Set 10 Governance And Compilers Bundle

Four governance compilers run from copied bodies

Eleven governance and compiler mechanisms are copied into a public bundle and re-run against bundle-built inputs, with a result record for each that separates a computed failure from a fixture-read one. This component takes eleven governance and compiler mechanisms that run in the wider system, copies their source bodies into a public bundle, and re-runs a small source-faithful port of each one against inputs it constructs itself. It writes a result record for every mechanism: what source it came from, what the positive run produced, what each planted failure case produced, and whether the bundle computed that failure itself or only read it from a fixture.

One runner exercises all compiler fixtures

The problem is trust: a cold reader cannot confirm the system's own claims, so this re-runs the logic in the open and puts the computed value beside the expected one. The problem it solves is trust. When the system says a mutation gate blocks a write, or a finance horizon rejects a bad date, a cold reader has no way to confirm that from the outside. This component re-runs the logic in the open and records the computed value next to the expected one.

Compiler evidence stops before live governance

It exercises the batch10_governance_compilers_capsule component and grants no launch, public sharing, live-ledger, or source-file changes. It exercises batch10_governance_compilers_capsule in src/microcosm_core/organs/batch10_governance_compilers_capsule.py. It is not launch-scope decision, publishing-scope decision, live ledger truth, or source-file changes permission.

Purpose

Why a declared error code proves nothing

A fixture that names its own expected error code proves nothing, because the declaration can be right while the ported logic is broken or absent. A fixture that declares "this case should return error code X" proves nothing on its own. The declaration can be right while the ported logic is broken, or absent. A loose bundle would let a case grade itself green by assertion.

Labels are input, not verdict

Each case's on-disk label and error code are treated as input, recomputed in code and compared, and a case with no computed evidence raises fixture_verdict_echo_risk and blocks the run. This component refuses that. Every negative case carries a label and a stable error code on disk, but the bundle treats those as input, not verdict. For each case it recomputes the outcome in code and compares the computed value to the expectation. The result record marks each case fixture_role: negative_case_label_not_verdict_authority and stamps the verdict computed_by_batch10_governance_compilers_capsule_integrity_matrix. A case with no computed evidence raises fixture_verdict_echo_risk and blocks the run.

How it works

Two entry points over one evaluator

run and run_batch10_governance_compilers_bundle both feed _evaluate, which builds eleven mechanism matrices before _build_integrity_matrix writes one row each. run and run_batch10_governance_compilers_bundle are the two entry points; both hand _evaluate to a shared runner. _evaluate builds eleven mechanism matrices, then _build_integrity_matrix writes one row per mechanism.

Each compiler has a controlled matrix

Every governance mechanism uses its own matrix function to construct controlled input and assert the copied logic's behavior. Each mechanism has its own matrix function that constructs a controlled input and asserts the ported logic behaves.

How _source_evidence records each source

_source_evidence reads the manifest and records each mechanism as a verbatim copy or a source-faithful refactor, blocking the under-bound lane-width repair rather than presenting it as an import. Source evidence is resolved per mechanism by _source_evidence. It reads the bundle's source_module_manifest.json, looks up each mechanism's named source reference, and records what it finds. A verbatim copy carries its digest status and body-copied flag. A body that cannot ship as-is is recorded as a source-faithful public refactor with the original source digest, not a copy. publication_manifest_selector_contract_verifier is a refactor because its source carried a private home-path example. weighted_lane_width_apportionment_binding_repair is classified under_bound_binding_repair, so its integrity row is forced to current_action: block rather than presented as a Set 10 import.

Recomputing every negative case

_compute_negative_case_probe recomputes each case from its probe_input, and a missing computation, or fewer than ten copied source modules, turns into a blocking finding. Negative cases run through _compute_negative_case_probe. For each case it reads probe_input from the fixture, computes the observed value, and compares it to the binding's expected value. A row counts as proven only when the computed value matches. _build_integrity_matrix sets fixture_verdict_echo_risk on any mechanism whose cases are missing or uncomputed, and _evaluate turns any such count into a blocking finding. The run also requires exactly ten copied source modules; a thinned bundle raises BATCH10_SOURCE_MODULE_COUNT_INVALID and blocks. result_card projects the pass into a compact card with the mechanism count and passed-mechanism count.

flowchart TD Input["Public input dir or exported bundle"] Manifest["Validate source_module_manifest.json require 10 copied modules"] Matrices["Build 11 mechanism matrices each on bundle-constructed input"] Integrity["_build_integrity_matrix one row per mechanism recompute each negative case"] Echo["fixture_verdict_echo_risk? any uncomputed negative case"] Result["Result record: source evidence, computed outputs, scope limit body_in_receipt: false"] Input --> Manifest --> Matrices --> Integrity --> Echo Echo -->|no risk| Result Echo -->|risk found| Result

Negative cases

The eleven planted cases, each recomputed rather than trusted:

• mutation_status_intent_blocks_writes: a diagnostic message on an evolution route sets prohibit_file_writes to true.
• observe_apply_malformed_artifact_refused: an artifact with a non-list operations field yields no operations.
• reviewer_missing_boundary_detected: a missing boundary doc drops the safety persona to warn.
• release_toggle_no_go_fail_closed: a no-go toggle with one blocker is not operator-review-ready.
• publication_hard_exclude_rejected: private/raw_seed.md against a private/ hard-exclude is rejected.
• receipt_reuse_stable_input_changed: a changed stable digest counts one changed input.
• finance_invalid_horizon_rejected: the horizon not-a-date is rejected.
• session_failed_dependency_skips_child: node C is skipped when its dependency B failed.
• claim_parent_child_overlap_reported: a claim path inside an active scope is one conflict.
• dag_quality_error_not_overblocked: a quality error on an upstream probe is softened, not blocked.
• lane_width_binding_deferred_to_batch9: the lane-width repair resolves to under_bound_repair_deferred_to_batch9_claim.

Prior Art Grounding

Policy-as-code and supply-chain assurance

The design borrows the gate-and-compiler shape from Open Policy Agent, Kubernetes admission policies, and SLSA with OpenSSF Scorecard, staying fixture-bound evidence over copied or refactored source. The component follows policy-as-code, admission-control, and supply-chain assurance patterns: compile rules into deterministic checks, reject unsupported actions before they mutate state, and keep provenance for the decision. Honest anchors are Open Policy Agent, which separates policy decisions from enforcement and evaluates structured input against machine-readable rules; Kubernetes validating admission policies, which block, warn, or audit API requests before admission; and SLSA with OpenSSF Scorecard, which represent typed assurance levels, checks, and provenance for a software supply chain. This component borrows the gate-and-compiler shape for the eleven mechanisms above and stays fixture-bound evidence over copied or refactored source.

Validation Result record Path

Run from the microcosm-substrate/ public root:

What the two commands write and prove

The first command writes the result record, the second validates source and rows, and a pass means computed evidence and metadata-only records, not launch or whole-system correctness. The first command writes the integrity-matrix result record and sign-off JSON. The second validates the copied and refactored source, the source evidence, the positive and negative rows, and the scope limit fields. A pass means the mechanisms had computed source evidence, computed positive and negative rows, and metadata-only records; it does not mean launch or whole-system correctness.