rexecop 0.2.11a0

Regulated Execution Operations control-plane for profile-defined workflows bound to GovEngine and SCLite.

RExecOp

Regulated Execution Operations control-plane for profile-defined workflows, bound to GovEngine governance and SCLite auditable truth.

RExecOp (package name: rexecop) is the deterministic runner, orchestrator, and executor for domain profiles. It plans and runs declared workflow steps, enforces operational lifecycle mechanics, and projects completed work into SCLite-compatible artifacts — without becoming a policy engine or a parallel truth layer.

Status

Item	Value
Current source line	0.2.11a0
Maturity	alpha — operator evaluation with documented limits
Delivery	Published single supported alpha line; older PyPI releases are archived only
Tests	CI reruns the current suite
Latest PyPI	rexecop==0.2.11a0
Source dependencies	govengine==0.16.5, sclite-core==1.0.8 (see pyproject.toml)
Stack compatibility	docs/stack-contract-compatibility.md
Default posture	dry_run / read-only first; apply requires GovEngine allow

Project sentence

RExecOp runs profile-defined operations under GovEngine admission and records auditable outcomes through SCLite — profiles own meaning, GovEngine owns governance, SCLite owns proof, RExecOp owns execution mechanics.

Stack position

One operation crosses all layers. GovEngine owns policy and admission decisions; RExecOp enforces admitted neutral controls and executes the workflow; SCLite validates the proof bundle emitted after execution.

Profiles (tecrax, fixtures)
  intents, workflows, connector contracts, validation rules
        |
        v
RExecOp  plan -> GovEngine policy/admission -> lifecycle FSM
        |                  allowed | blocked | approval_required
        v
RExecOp  admitted controls -> step execution -> profile validation
        v
RExecOp  project runtime facts + GovEngine admission into SCLite artifact shapes
        |
        v
SCLite   validate schemas, ticket binding, review_bundle (truth authority)

Layer	Responsibility
Profiles	Intents, workflows, connector contracts, declarative validation rules
RExecOp	Runner: lifecycle, planning, step dispatch, pause/resume/retry, queue/lock; projects completed operations into SCLite bundles (does not decide policy)
GovEngine	Governance: admission and runner request/receipt contracts — does not execute steps or emit SCLite files
SCLite	Proof: auditable artifacts, scoped tickets, receipt-bounded evidence, review bundles

Tecrax ships as the tecrax package (rexecop.profiles:tecrax). Ravenclaw is legacy and out of scope for RExecOp.

What RExecOp includes now

• Deterministic operation state machine and OperationPlan runtime artifact
• GovEngine port: real GovEngineClient + bootstrap-only StaticGovEngineAdapter
• SCLite port: full GovEngine-integration bundle emission (scoped ticket v0.3, kernel guard, review pass)
• Profile resolution by path or rexecop.profiles entry point (tecrax)
• Declarative profile validation rules (YAML, not hardcoded domain logic in core)
• Domain-neutral runtime-fixture examples for lifecycle, policy and connector regressions; Tecrax product semantics live only in the external tecrax package
• Operational controls: approve, pause, resume, cancel, retry, rollback, queue, target lock, maintenance windows
• Runtime worker: rexecop worker run, rexecop queue --drain, rexecop trigger (host-owned scheduling)
• Connectors: mock, config-driven http_api (retry, pagination, error mapping), local_shell_readonly, ssh_readonly (temporary; bounded output + digests)
• Execution contracts: digest-bound ExecutionRequest / ExecutionReceipt in workflow shared_state (schema v0.2)
• GovEngine PolicyEngine when environment.policy_pack is set: plan admission, supported neutral controls, pre-execution drift validation, and per-connector invoke gate
• Operator target catalog and profile-derived operation catalog with deterministic applicability and start-time drift rejection; catalog compatibility never replaces GovEngine admission
• Storage: FileStore (default) or optional SqliteStore (REXECOP_STORAGE / --storage)
• Secrets port: REXECOP_SECRET_* and REXECOP_SECRETS_FILE (no plaintext secrets in git or .rexecop/)
• Operator CLI (rexecop); runtime data under .rexecop/ in the current working directory

What RExecOp does not include

• A policy engine (GovEngine is the governance authority)
• SCLite schema authority or long-term truth storage
• Domain profiles in core (no Tecrax/Ravenclaw operational logic in src/rexecop)
• Production cron/recurrence scheduler (host-owned worker + systemd/cron pattern only)
• Web UI or multi-tenant RBAC
• Unattended apply on critical infrastructure without operator and governance gates

Installation

Published alpha package:

python -m pip install "rexecop==0.2.11a0"
rexecop version

The published 0.2.11a0 wheel contains the full B2 enforcement path, R4c catalog, watchdog decision truth path, and manual recovery record path for the single supported alpha stack line.

See docs/distribution.md for Tecrax extra, wheels, Git URL, and private index notes.

From source (development):

git clone https://github.com/rozmiarD/RExecOP.git
cd RExecOP
python -m venv .venv && source .venv/bin/activate
git clone https://github.com/rozmiarD/GovEngine.git ../govengine
pip install -e ../govengine
pip install -e ".[dev]"

With the Tecrax profile package:

pip install "rexecop[tecrax]==0.2.11a0"
# or, for coordinated development: pip install -e /path/to/tecrax

CI also checks out tecrax for integration tests.

Quick start

rexecop version

rexecop plan \
  --profile examples/profiles/runtime-fixture/profile.yaml \
  --env examples/environments/runtime-fixture.example.yaml \
  --intent inspect_fixture_state \
  --target fixture-target \
  --mode dry_run

rexecop start --operation <operation-id>
rexecop status --operation <operation-id>
rexecop validate --operation <operation-id>

• With tecrax installed, --profile tecrax resolves via entry point.
• For offline tests without a domain package, use examples/profiles/runtime-fixture/profile.yaml.
• Staging http_api template: examples/environments/runtime-fixture.staging.example.yaml

Runtime artifacts live under .rexecop/ (gitignored): operations, evidence, SCLite bundles, receipt exports.

CLI commands

Command	Purpose
plan	Create operation + plan; evaluate configured PolicyEngine and mutating admission gates
approve	Manual approval after approval_required
start	Execute workflow (queues when lock/capacity busy)
pause / resume	Pause only at pause_safe workflow steps
cancel	Abort before completion
retry	Operator retry when profile policy allows
rollback	Run explicit workflow rollback steps after failure
validate	Re-run declarative profile validation
escalate	Build operator escalation package
queue	Inspect FIFO run-now backlog; queue --drain processes pending starts
worker run	Poll queue and start approved operations (--once, --poll-interval, --watch-inbox, --watchdog, --inbox-retry-budget)
trigger	Create operation from JSON stdin or CLI flags (webhook-friendly)
targets list / targets show	Query bounded descriptors from a private target catalog
operations list / operations explain	Query profile-owned operations and target applicability
status / history	Operation state and evidence history
version	Package version

Global option: --storage file|sqlite selects the runtime storage backend.

Development

pip install -e /path/to/tecrax -e ".[dev]"
python scripts/validate_public_truth.py
ruff check .
mypy src/rexecop
python -m build && python -m twine check dist/*
pytest

GitHub Actions runs on every push and pull request: install tecrax, public truth validation, ruff, mypy, core boundary grep, secret scan, pytest, and a package-dry-run job (build + twine check).

Documentation

• Deterministic reaction interpreter

Document	Topic
docs/architecture.md	Layer boundaries and execution path
docs/stack-contract-compatibility.md	Cross-repo contract matrix and readiness labels
docs/operation-lifecycle.md	States, CLI orchestration, queue/lock
docs/operator-scheduler-pattern.md	Host-owned scheduling with worker/systemd
docs/govengine-integration.md	Governance port and apply gating
docs/sclite-integration.md	Artifact emission and authority model
docs/evidence-model.md	Internal events vs SCLite truth
docs/profile-contract.md	Profile layout and entry points
docs/connector-contract.md	http_api, secrets, error taxonomy
docs/execution-contract.md	ExecutionRequest/Receipt, bounded output
docs/environment-contract.md	Target, group, and connector semantics
docs/operator-catalog.md	Target catalog, operation projection, applicability and drift binding
docs/storage-backends.md	File vs SQLite boundaries
docs/safety-model.md	Hard safety rules and operator posture
docs/known-limitations.md	Alpha scope and explicit non-claims
docs/distribution.md	Wheels, Git install, private index
OPERATOR_LAB_RUNBOOK.md	Lab checklist and E2E walkthrough
OPERATOR_RUNBOOK.md	Installation, secrets, workflows, troubleshooting
CHANGELOG.md	Release history

Related repositories

Repository	Role
GovEngine	Governance kernel and admission contracts
SCLite	Auditable contract lifecycle and review bundles
tecrax	Tecrax domain profile and local-fixture package

License

MIT — see LICENSE.