rexecop 0.2.7a0

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.7a0
Maturity	alpha — operator evaluation with documented limits
Delivery	Published B2/R4c alpha line (see CHANGELOG)
Tests	296 passed, 1 skipped (current local suite; CI reruns the current suite)
Latest PyPI	rexecop==0.2.7a0
Source dependencies	govengine>=0.16.1,<0.17, sclite-core>=1.0.5,<1.1 (see pyproject.toml)
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.7a0"
rexecop version

The published 0.2.7a0 wheel contains the full B2 enforcement path and R4c catalog. It requires the published GovEngine 0.16.x 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.7a0"
# 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)
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/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.