Work Landing Control Spine

With many agents editing at once, the hard problem is landing one finished commit without sweeping up a neighbour's half-done edits, solved by internal control modules copied into a public bundle. The larger source project this public folder draws from is edited by several agents at the same time. Its hardest everyday problem is dull: how does one agent land a small, finished commit without sweeping up a neighbour's half-done edits in the same files, and without claiming more than it actually did. The answer lives in a handful of internal control source modules. A separate import step copies those bodies, non-secret, into a public bundle so a reader can inspect the real mechanics instead of taking a description on trust.

work_landing_control_spine guards that copy, confirming five copied modules are exact, their load-bearing logic is present, the contract claims no live authority, and nothing secret leaked. work_landing_control_spine is the check that guards that copy. It reads a bundle of five copied source modules plus the manifests and runtime contract that describe them, confirms the copies are exact, confirms the load-bearing logic is still present, confirms the runtime contract claims no live authority, and confirms nothing secret leaked in. It then writes one result record.

It is a witness over copied source, not a runner.

Purpose

A described control plane is easy to fake

A prose description of a control plane is easy to fake, so this component copies the actual bodies and asks whether they are genuine, load-bearing, and within their limits. A description of a control plane is easy to fake. A reader cannot tell whether "we validate scoped commits" means the real actuator or a paragraph of prose. So this component copies the actual bodies into the public bundle and then answers one narrow question: are these copied bodies the genuine ones, is their load-bearing logic still present, and does the bundle stay inside its stated limits.

The copied set is five modules:

• tools/meta/control/work_landing.py (the command parser and admission gate)
• system/lib/work_landing_status.py (controller action order and finalizer policy)
• tools/meta/control/mission_transaction_preflight.py (owned-path preflight)
• system/lib/mission_transaction_landing_preflight.py (shared-index quarantine)
• tools/meta/control/scoped_commit.py (the private-index scoped-commit actuator)

Scoped commit and controller ordering

Two ideas matter: scoped_commit.py commits from a throwaway private index that never touches a neighbour's changes, and work_landing_status.py fixes the controller action order. Two ideas in that source are worth a reader's attention. One is the scoped commit: scoped_commit.py builds a throwaway Git index from the current HEAD, stages only the exact paths an agent declares it owns, writes a tree from that private index, and commits against the captured parent with a compare-and-swap on the branch ref. The shared .git/index is never written. An agent cannot pick up a neighbour's dirty changes, because those changes were never in the index it committed from. The other is ordering: work_landing_status.py fixes a sequence of controller actions so claims launch only after the session is finalised and convergence recomputes only after claims launch. The check confirms both are still present in the copied bodies, which is what separates an honest copy from a stale bag of hashes.

How it works

The validate_work_landing_control_bundle entry point

validate_work_landing_control_bundle runs the stages in order and returns one result record, wrapped by main and leaning on shared JSON, result record, and secret-scan helpers. The check lives in src/microcosm_core/macro_tools/work_landing_control_spine.py. The entry point is validate_work_landing_control_bundle, which runs the stages below in order and returns a single result record. main and build_parser wrap it for the command line. It depends on three shared helpers: the strict JSON reader in microcosm_core.schemas, the atomic record writer in microcosm_core.receipts, and the secret scanner in microcosm_core.secret_exclusion_scan.

The stages run in this order.

Loading the three JSON inputs

First _load_json_input reads the bundle manifest, source manifest, and runtime contract, turning a missing file or non-object JSON into a finding rather than a crash. First it loads the three JSON inputs with _load_json_input: the bundle manifest, the source module manifest, and the runtime contract. A missing file or non-object JSON becomes a finding, not a crash.

_source_manifest_summary checks copy fidelity

_source_manifest_summary recomputes a SHA-256 and line count for each of the seven required inputs against the manifest, and confirms every material and import class. Then _source_manifest_summary checks copy fidelity. For each of the seven required inputs (five source bodies plus the two JSON files, named in REQUIRED_INPUTS) it computes a SHA-256 with _file_sha256 and a line count with _line_count, then compares them against the manifest's expected values. It also confirms each row's material_class is one of ALLOWED_MATERIAL_CLASSES and that each source body is classified copied_non_secret_macro_body (SOURCE_IMPORT_CLASS).

_anchor_summary confirms load-bearing anchors

_anchor_summary confirms every required anchor string in REQUIRED_SOURCE_REFS still survives in each copied body, counting any missing anchor rather than dropping it. Then _anchor_summary reads each copied body and confirms every required anchor string is still in the text. The anchors are declared in REQUIRED_SOURCE_REFS, keyed by module. For example work_landing.py must still contain build_parser, admission-check, and begin; scoped_commit.py must still contain perform_scoped_commit, private-index scoped commit, and the line stating it never invokes git commit against the shared index. A missing anchor is counted, not silently dropped.

_contract_summary checks the scope limit

_contract_summary requires all thirteen FALSE_AUTHORITY_FLAGS to be exactly False, treating any other value as an overclaim, and confirms the required import classifications. Then _contract_summary checks the scope limit. Every flag in FALSE_AUTHORITY_FLAGS (thirteen of them, from live_git_mutation_authorized through publication_authorized and release_authorized) must be exactly False in the contract. Any flag that is not False is an overclaim. The same stage confirms the contract declares the required import classifications (REQUIRED_CLASSIFICATIONS).

scan_paths runs the secret scanner

scan_paths runs the shared secret scanner over all seven inputs, turning any blocking hit into a finding. Then scan_paths runs the shared secret scanner over all seven inputs. Any blocking hit is a finding.

Assembling the metadata-only result record

Finally the record is assembled, pass only when there are no findings, carrying digests, anchor and authority rows, and body_in_receipt: false so no body is copied out. Finally the record is assembled. status is pass when there are no findings and blocked otherwise. The record carries refs, digests, line counts, anchor rows, authority rows, material-class counts, and findings, and it sets body_in_receipt: false so no source body is copied into the output. The record is written atomically as exported_work_landing_control_bundle_validation_result.json and also printed to stdout.

flowchart TD A["Copied bundle 5 bodies + manifest + contract"] --> B["Load JSON inputs _load_json_input"] B --> C["Copy parity _source_manifest_summary"] C --> D["Anchor scan _anchor_summary"] D --> E["Scope limit _contract_summary"] E --> F["Secret scan scan_paths"] F --> G["Result record status pass or blocked"]

Negative cases

Five rejections from one-field mutations

The focused tests drive five rejections by mutating one field at a time, each producing a blocked status with a stable finding code, and the same shape covers other drifts. The focused tests drive five rejections from the accepted bundle by mutating one field at a time. A digest changed in the manifest gives status blocked with SOURCE_DIGEST_MISMATCH. A source body relabelled to a private material class gives MATERIAL_CLASS_NOT_ALLOWED. A body reclassified away from copied_non_secret_macro_body gives SOURCE_IMPORT_CLASS_MISMATCH. Dropping secret_exclusion from the contract's required classifications gives CLASSIFICATION_FLOOR_MISSING. Setting live_git_mutation_authorized to True in the contract gives AUTHORITY_CEILING_OVERCLAIM. The check emits the same shape of finding for a missing anchor (SOURCE_ANCHOR_MISSING), a missing input (MISSING_REQUIRED_SOURCE_INPUT), a line-count drift (SOURCE_LINE_COUNT_MISMATCH), and a secret hit (SECRET_EXCLUSION_BLOCKING_HIT).

Prior Art Grounding

Git index and durable-workflow ancestry

The mechanics come from Git's index separating selected changes and from durable-workflow action ordering, imported here as an auditable public check with no power to act. The mechanics copied here come from ordinary version-control and workflow engineering. Git's index already separates the changes you have selected from the rest of a dirty worktree, which is the practical ancestor of scoped path ownership. Durable-workflow systems show the value of a recorded action order and deterministic replay for long-running work. This component imports those ideas as a public check: digest parity, anchor presence, a no-live-mutation contract, and a secret scan make the copied control plane auditable without granting it any power to act.

• Git staging and index workflow: https://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository
• Durable workflow event history and replay: https://docs.temporal.io/workflows

Validation Result record Path

Run from microcosm-substrate/:

PYTHONPATH=src ../repo-python -m microcosm_core.cli work-landing-control-spine \
  validate-control-bundle \
  --input examples/work_landing_control_spine/exported_work_landing_control_bundle \
  --out receipts/first_wave/work_landing_control_spine

What a pass writes and means

A pass writes the validation result record and means the copied bodies matched the manifest, every anchor was present, all authority flags stayed false, and the secret scan found nothing. A pass writes receipts/first_wave/work_landing_control_spine/exported_work_landing_control_bundle_validation_result.json and means the copied bodies matched the manifest, every required anchor was present, all authority flags stayed false, and the secret scan found nothing. The focused regression suite that pins the pass case and the four rejections above is:

PYTHONPATH=src ../repo-python -m pytest -p no:cacheprovider \
  tests/test_work_landing_control_spine.py -q