REPORT — phase5-run-entry-review
STEP: phase5-run-entry (Phase 5: the run-spec over an arbitrary repository, the operator start/inspect/stop CLI, and the evidence-policy binding)
REV: a13aacfe2219e3dbd1b6207a28bbe0f980c78b2c   FINAL: dae836f9bee9c03a7708d4364f381658be70caf1
CHANGED:
  docs/research/phase5-run-entry-review.md — this report (probe scripts lived under /tmp/kilo, not in the tree; one scratch mutant worktree at FINAL was removed after use).
VERIFIED:
- REVIEW ACCEPTANCE `scripts/check-scope a13aacfe2219e3dbd1b6207a28bbe0f980c78b2c dae836f9bee9c03a7708d4364f381658be70caf1 docs/research/phase5-run-entry-brief.md` — "tripped: PILOT-R1 PILOT-R10", "scope: ok (8 path(s) in a13aacfe2219e3dbd1b6207a28bbe0f980c78b2c..dae836f9bee9c03a7708d4364f381658be70caf1)", exit 0, run first before any other action.
- The brief embedded in the review brief is byte-identical to the committed `docs/research/phase5-run-entry-brief.md` at FINAL (diff via git show: only the review file's `--- END BRIEF UNDER REVIEW ---` marker differs), so no FINDING on the copy.
- Work commit measured: dae836f ("phase5-r4: operator run entry point") is the only `Actor: IMPLEMENTER` work commit; its child 5da0516 adds the implementer report and this review's brief 1be5eae came after. dae836f is not a commit of my session.
- `scripts/check-tests --fast` — 961 passed, 66 deselected, 71.45s, exit 0 (report: 961/66 in 69.50s; counts equal).
- `pytest tests/test_run_entry.py` — 21 passed in 1.44s (report: 21 in 1.60s).
- `pytest tests/test_harness_schemas.py tests/test_boundary_mutations.py tests/test_categorical_completeness.py` — 47 passed in 0.27s (report: 47 in 0.20s).
- `pytest tests/test_phase3_project_oracle.py` — 5 passed in 264.51s (report: 5 in 212.02s).
- `scripts/check-static` — exit 0, "All checks passed!" on the gated BLE001/S110 select; the B/SIM advisory items printed afterwards do not gate (matches the report's account).
- `scripts/check-docs` — exit 0, 338 links, 0 errors. The report says 328: re-run at the report's own commit 5da0516 prints exactly "328 Total ... 328 OK 0 Errors"; the +10 delta is the review brief commit (1be5eae) adding links after the report — no misstatement.
- Slow-split arithmetic: `--collect-only -m slow` = 66 of 1027; ignoring tests/test_run_entry.py = 45 of 1006 — 66 = 45 + 21 exactly as the report claims.
NOT VERIFIED:
- None of the implementer's counts. All seven ACCEPTANCE commands were re-run by me with equal counts (durations differ as expected). The items below are falsifications with my own reproducers, in FINDINGS.
FINDINGS:
  F11 | SEVERITY: P1 | ORIGIN: CODE | STATE: carried
  A relative `--workdir` makes `start` crash and the run stay live, on both the accepting and the refusing path. `run_entry.build_command_executor` passes the CLI's `--workdir` value through verbatim into `CommandExecutorConfiguration` roots, so the candidate-bundle artefact path is relative to the sandboxed worktree's own directory; `git bundle create` fails inside the executor and the raise escapes `dispatch_attempt` ("substrate that dies on contact" form), out of `start_run`, and out of the CLI. Reproducer (CLI subprocess at FINAL, real fixture repo): `start --spec spec-accept.yaml --workdir W-REL --store SREL.db` — exit 1, empty stdout, no JSON, `orchestrator.executor_protocol.ProtocolViolation: git bundle create W-REL/artefacts/WT-RUN-OP-ACCEPT-....candidate.bundle HEAD failed: fatal: Unable to create '<worktree>/W-REL/artefacts/....bundle.lock'`; the store then holds 8 admitted events (`NODE_PROPOSED..TIMER_SCHEDULED`), attempt DISPATCHED, `inspect` shows `outcome: null`, node READY. Same crash on the refusing spec (`--workdir W2`, spec-fail): no recorded refusal. With an absolute workdir the same spec accepts end to end (`accepted: true`, `outcome: ACCEPTANCE_CLAIMED`, exit 0), so this is exactly the relative-path hazard. `docs/run-entry.md` says "`--workdir DIR` — scratch directory for worktrees and artefacts" with no absolute-path requirement, and the brief's Start shape is unconditional: "drives the run's root execution to a settled attempt and an evidence-bound acceptance claim or recorded refusal". A crash that leaves the run live (root READY, no outcome, no refusal) satisfies neither branch. Recovery exists (`stop` on the live store settles it to CANCELLED), which is why this is not P0.
  FIXED: no regression test — the deliverable has no assertion over CLI workdir forms; the eventual pin's red would name a subprocess start with a relative workdir asserting a settled run (or a refusal) instead of a traceback.
  F12 | SEVERITY: P1 | ORIGIN: CODE | STATE: carried
  A wall-clock overrun of the root's visible command is neither an acceptance claim nor a recorded refusal: `start` crashes and the run stays live. With `limits.wall_clock_seconds: 5` and a `sleep(120)` visible command (both documented run-spec fields), `CommandExecutor` raises `AttemptTimedOut`; `dispatch_attempt` catches it, emits `TIMER_FIRED` plus `ATTEMPT_EXECUTION_ENDED_UNRECONCILED`, and re-raises; `run_entry.start_run` has no handler and the exception escapes to the CLI (exit 1, traceback, no JSON). Store state after the escape: attempt TIMED_OUT with accounting PROVISIONALLY_SETTLED (not finally settled), root node READY, `outcome: None` — `Controller.get_outcome` reads None, failing the Start shape's "The run reaches a terminal Run outcomes value that `Controller.get_outcome` reads" for a reachable, documented configuration. `inspect` shows the run as live (`outcome: null`, node READY) long after the command died; `stop` afterwards settles it to CANCELLED, so recovery is operable — not P0. The same escape also surfaces in the two-process workflow: after a mid-run `stop`, the launcher process dies with an unhandled `AttemptTimedOut`/`AttemptCancelled` (exit 1, traceback, no JSON) while the store is fine (CANCELLED) — the documented "start exits zero ... non-zero" holds for exit codes but the run's own termination is reported only as a stack trace.
  FIXED: no regression test — no suite case drives a timing-out visible command through `start_run` (the timeout path in tests lives at the executor/recovery layer); the eventual red would be `start_run` with `limits.wall_clock_seconds` under the command's runtime asserting a settled run outcome (or a recorded refusal).
  F13 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  The `No-harness-import shape`'s pin misses two import spellings. The AST helper collects module-path strings only from `ast.Import` alias names; for `ast.ImportFrom` it reads `node.module` and ignores `alias.name` and relative imports (`node.module is None` skips entirely). Mutants on a scratch copy of FINAL: adding `from orchestrator import experiment` or `from . import experiment` (extending `run_entry.py`'s own existing `from . import acceptance_checks, events, glossary, numeric, schemas` line — the most idiomatic future drift spelling in this file) leaves `pytest tests/test_run_entry.py -k harness_import` GREEN on both — the shape's guarantee is unenforced for named import statements; `import orchestrator.experiment_spec` is red as expected. The pin fails open exactly where the named guarantee ("the import surface names none of ...") is about to drift.
  FIXED: no regression test — the pin itself is the named regression guard and its assertion must-but-does-not fire on the mutants above; the next brief's red is: with the helper extended to `alias.name` (and to relative levels via the containing module), the same two mutants go red.
  F14 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  `scripts/orchestrate.py` does not import without putting `src` on the path, so the documented invocation fails before argparse runs: plain `python3 scripts/orchestrate.py …` (the only form `docs/run-entry.md`'s Commands section shows) dies with `ModuleNotFoundError: No module named 'orchestrator'` because the repo has no packaging metadata (no pyproject/setup.py, package not installed in .venv) and the CLI lacks the `sys.path.insert(REPO_ROOT/"src")` bootstrap that sibling operator scripts have (`scripts/smoke_run.py:111`, `scripts/stress_run.py:62`). My subprocess runs needed `PYTHONPATH=src` explicitly. The exit-gate workflow is real once the path is set, but as documented the operator's whole interface does not start.
  FIXED: no regression test — an environment-shape claim (the script is runnable by its documented invocation from the repo root with a clean env) has no failing assertion at REV; the eventual pin would run a clean-env subprocess and assert a non-ModuleNotFoundError result.
  F15 | SEVERITY: P2 | ORIGIN: DOCUMENT | STATE: carried
  `docs/run-entry.md`'s field-table row for `executor_profile` ("The executor label recorded on the run") is false against the loader. The label is required by the `RunConfiguration` schema and validated, and then recorded nowhere: J-run on a real run at FINAL — the full event log JSON never contains the probe label (not in NODE_PROPOSED's contract, not in the `run_specification` binding, not in any event payload), the inspect document never contains it, and grep over `src/` shows no other sink (`executor_profile` appears only in run_entry/spec-bearing files). "Recorded on the run" is a normative claim an auditor cannot observe — the honest row would say it is a schema-required label only, with executor selection separate work.
  FIXED: no regression test — a doc-wording defect has no failing assertion at REV; the eventual pin would assert the label is absent from the store (if the doc is corrected) or present (if recording is ever added).
  F16 | SEVERITY: P2 | ORIGIN: DOCUMENT | STATE: carried
  `docs/run-entry.md`'s loading header overclaims: "Loading is fail-closed: a malformed spec is refused as a named RunSpecError before any store is opened or any event is admitted." Falsified for the obligations class the same table names ("when present, non_derivable_axes and non_derivable_reason must also be supplied"): a CLI `start` of an obligations-without-axes spec passes `load_run_spec`, the store file IS created (a fresh `axes.db` exists after the refusal), and only then does the freeze boundary refuse (`RunSpecError: cannot freeze target 'TARGET-AXES': a DECLARED target must name the axes it cannot derive…`), exit 1, zero events admitted. The zero-events half is true everywhere (see answer 4), and the class's fail-closed behaviour is real — but "before any store is opened" is false for this malformed class: the refusal happens at the freeze boundary inside `start_run`, after the CLI opens the store.
  FIXED: no regression test — a doc claim has no failing assertion at REV; the eventual check either narrows the doc sentence to "before any event is admitted" or moves the axes check into `validate_run_spec` (pin: CLI start of the class with a nonexistent store path, asserting the path is absent after the refusal).
SHAPES: properties probed that the suite does not build:
- CLI subprocess shape: `orchestrate.py start/inspect/stop` as real subprocesses (exit codes, JSON output documents, absolute and relative workdirs, malformed-spec store-file creation). Built across answers 8 and 10.
- Wall-clock timeout shape: a visible command that outlives its documented limit, with no stop involved (answer 10/F12).
- Mid-flight stop shape: cancelling a run whose root attempt is truly DISPATCHED (in-flight executor I/O), from a second connection, and the launcher process's behaviour afterwards (answers 7 and 10).
- Import-pin mutant shape: the three import spellings as mutants against the pin (answer 8/F13).
- Double-boundary mutation shape: the unknown-budget-dimension refusal with each of the three validating layers mutated away (answer 4).
- Digest sensitivity shape: contract digest stability across reloads and its per-field sensitivity (seven spec variants) beyond the suite's same-spec assumption (answer 3).
- Declared-obligations admissibility shape: a DECLARED-obligations run-spec through `start_run` (measured-divergence gate, axes-missing refusal) that the suite reaches only at the seam level (answer 4 and 9).
TRIPPED: PILOT-R1 PILOT-R10
PROPOSED ROWS: none
METHOD FRICTION: none against the method's steps or `docs/templates/report.txt`. One confirmation, not friction: the implementer report's METHOD FRICTION informational note about `experiment_target.build_target`'s `budgets` keyword was reproduced verbatim by running it (`build_target(..., budgets={"MODEL_COST": 10.0})` raises `ExperimentError: cannot derive obligations for 'S-B': budget names no declared component: ['MODEL_COST']; components are ['core']`), and the note's account (run budgets reach the configuration directly; `freeze_target` forwards none) matches the code.
ANSWERS TO QUESTIONS TO ATTACK:
1. F10's `fixed` claim — attacked-and-not-falsified; the FIXED form is right. `git show a13aacfe2219e3dbd1b6207a28bbe0f980c78b2c:src/orchestrator/controller.py` vs FINAL: the range's entire delta in the file is nine added/ two removed docstring lines inside `AdmissionCapability` plus the `run_specification` binding addition in `submit_run` — nothing else in the class (slots, `__init__`, the mint guard) changed. The clause is replaced as claimed: new text "data-only construction is refused, matching the Capability shape's 'a caller holding only data cannot construct one'", retaining "not reconstructible from data" and "Exactly two mint points exist … In-process trusted-code circumvention is outside this threat model (PILOT-R10)" — each of those quotes measured, not assumed. J-probe of the fixed form: all three data-only constructions refuse (`AdmissionCapability()`, `AdmissionCapability(bound_digest="…")`, class-called with a dict) — `WorkflowError("an admission capability cannot be constructed from data…")`; a fresh `__new__` instance is non-functional (`admits` raises AttributeError); `copy.copy` of a minted capability still admits True — an in-process trusted-code act outside the data-only model, exactly as the new wording scopes things (it claims nothing about copying, and the F10 falsification only fired against the OLD "construction without the mint nonce is refused" sentence, now gone). No other tree text makes the old claim: grep over `src/` and `docs/` at FINAL shows the plain "without the mint nonce is refused" sentence only inside committed brief/report records (historical documents), never in live code or normative docs; `PILOT-R10` stays accepted. FIXED form: R8's ruling (docs/record.md#owner-rulings) split F10 — "its brief-wording half has no possible action and closes … the docstring half … is live code and stands as the only carried item". Rule 8's "a later committed brief corrects the text" close governs defects whose text lives in a committed (immutable) brief. After R8, the carried item's text lived in the C shape of live code — its correct close is a code edit, performed by the later committed implementer brief (43c5a61) that directed it ("F10's docstring half (INHERITED) is fixed in `AdmissionCapability`'s docstring") and executed at dae836f. A pure wording fix cannot have a failing assertion at REV, so "no regression test" is the honest form, and the FIXED line names the node and the commit it made. No further wording claim beyond the data-only threat model was introduced, so nothing invites a third-mint closure the threat model does not buy. No finding.
2. Budgets wiring — attacked-and-not-falsified (all four sub-claims) by running the wiring, not the report's account. (a) spec budgets reach the code path: a raw run-spec with `budgets: {"WALL_CLOCK": 7.0, "MODEL_COST": 3.0}` yields `run_configuration` `budgets` `{"WALL_CLOCK": 7.0, "MODEL_COST": 3.0}` and the ADMITTED root contract's `budgets` record equals it — same dict, not a projection (J-probe on a real frozen target over a real repository). (b) The commitment path keys on the first catalogue dimension (`_budget_dimension`) — the allocation is per-attempt and consistent with contract budgets. (c) Unknown budget dimension fails closed at load with no store writes: `RunSpecError: budget dimension 'NOT_DIM' is not catalogued is invalid: 'NOT_DIM'` before any freeze; `store.history(run_id) == []` AND the sqlite file's events table row count is 0 total (opened directly, not via the API). (d) The METHOD FRICTION note is reproduced: `build_target(..., budgets={"MODEL_COST": 10.0})` raises `ExperimentError: cannot derive obligations for 'S-B': budget names no declared component: ['MODEL_COST']; components are ['core']` — the per-component derivation allocation refuses run-budget dimensions loudly; nothing is silently absorbed. Also correct: `contract["run_limits"]` carries the limits dict, and the contract's `owned_scope` matches.
3. `Run-spec load shape` — attacked-and-not-falsified. Real fixture repo + real spec, J-runs at FINAL: exactly ONE `build_target` freeze per `start_run` (wrapper counter = 1); `run_configuration` + `Controller.submit_run` admits (NODE_PROPOSED/NODE_ADMITTED land; run disposable). The admitted root contract carries the configured `owned_scope`, `budgets`, `run_limits` (`limits` mapped to `run_limits`), and the frozen `run_specification` binding carries `policy_version` and the `evidence_policy` reference beside it (values exactly the configured ones — see answer 9). The filled references match CONTEXT's stated reading: `project_kernel.repository_commit` = the named repository commit (the fresh commit of the frozen repo, verified byte-identical between config and `git rev-parse HEAD`), and `experiment_manifest.manifest_hash` = `target.contract_hash` — the run-spec's own digest as the frozen target contract computes it: it is stable across reloads (two identical freezes → equal `contract_hash`, `sha256:7578…`), and it changes with every contract-bearing field (acceptance criteria, task statement, owned scope, the last/acceptance visible command, components, snapshot_id — each a controlled variant changing the digest; snapshot_id rides because the derived obligations' descriptions embed it) while run-level fields outside the contract (run_id, budgets, limits, project_kernel, other visible commands, executor_profile) leave it unchanged — consistent with the stated reading if the frozen contract is the content being digested. No finding against that reading.
4. `Configuration refusal shape` — coverage and zero-writes verified; the mutation attack produces a red. The twelve parameterised IDs exactly cover the brief's named list: `empty/missing-repository`, `empty/missing-base-commit` (4), `unknown-evidence-level` (level outside [Evidence policy levels](../glossary.md#evidence-policy-levels) — my CLI probe reproduces the refusal text verbatim: `RunSpecError: evidence_policy.level 'NOT_A_LEVEL' is not one of ['LOW', 'MEDIUM', 'HIGH', 'CRITICAL']`), `non-positive-evidence-version` (0) and its `string` variant, `unknown-budget-dimension`, `empty-budgets`, `mismatched-policy`, `empty-executor`, `empty-run-id` (12), plus `test_run_configuration_schema_is_a_second_boundary` for the schema-rejected `RunConfiguration` — every named item present. Zero store writes verified by opening the sqlite file, not the API: after an unknown-dimension refusal the events table has 0 rows total; for the CLI path a malformed spec that the loader rejects (unknown evidence level) leaves the store FILE uncreated (`SB.db not created`) — see F16 for the class where it is created. Mutation attack on a scratch copy of FINAL: removing the run-spec-level catalogue check alone leaves the case green (the `RunConfiguration` schema's `_budgets` validator refuses the same class); removing that schema-level check as well turns the case red — the deepest layer (the reducer's ledger budget-dimension check at commitment creation) refuses with a `ReducerError` (a different error type than the refused spec shape asserts), so the pin's assertion fails loudly rather than silently passing an unvalidated shape. The shaped check can fail; defence in depth is real (three independent layers: run-entry validator, schema validator, reducer/ledger check) with the same zero-events guarantee holding at the deepest layer too.
5. `Start shape` — attacked-and-not-falsified on both sub-questions; every attack refusal reproduced by hand at FINAL on a real repo. The happy path is bound exactly: plan → `dispatch_attempt` over the spec's visible commands → `admit_observation_and_result` → `admit_evidence` with a `VisibleAcceptanceChecker` running the attempt's own response observations (check class VISIBLE, id `{root}-visible-evidence`) → `authorise_acceptance` with the node's own result id. Attacks: (a) evidence id never admitted ("ghost-evidence") → `AcceptanceRefused: unknown evidence ids`; (b) a fabricated result id → `AcceptanceRefused: result '…-fabricated-result' does not exist for node 'RUN-ATTACK-root'` (R09's refusal surface asserts the result belongs to the node's attempt set); (c) evidence for a node that never existed — the REDUCER refuses the EVIDENCE_ADMITTED event (`ReducerError: EVIDENCE_ADMITTED: unknown node_id 'phantom-node'`), so no evidence can even be placed off-note for authorisation to chase, and authorise's own foreign-node check then refuses with `unknown evidence ids` — evidence not admitted through `admit_evidence` cannot authorise: `state.evidence` is populated only by `EVIDENCE_ADMITTED`, and run_entry only calls `admit_evidence` (the other inline-evidence sites live in pre-existing `validate_and_accept`/`accept_parent`/`resume_deferred_acceptance`, none on this path, all sharing the `_assert_result_bound` surface). (d) A result id from a different (nonexistent) attempt is refused by the same surface. Failing visible commands are a real refusal (in-process J-run with a `SystemExit(1)` command): `accepted=False`, `outcome=INFEASIBLE` (terminal in [Run outcomes](../glossary.md#run-outcomes), `get_outcome` readable), failing checks recorded in the admitted visible evidence (1 witness with `passed: False`), `ACCEPTANCE_AUTHORISED` NOT in the event log, and the run reaches its terminal outcome through the specified branches. The two observed early-exit exceptions that DO appear on other inputs are the F11/F12 findings, outside both named branches.
6. `Observe shape` — attacked-and-not-falsified. A second `EventStore` connection over the same sqlite file drains the same audit; the event log is byte-identical before and after `inspect` (19 → 19 events, (idempotency key, event id) tuples compared, and the sqlite row count independently verified = 19). All milestone-1 retrieval fields are printed by `inspect` from the store alone: `status` (with `node_state` READY/ACCEPTED as appropriate), `outcome` (None / ACCEPTANCE_CLAIMED / CANCELLED), `candidate_reference`, `evidence` (VISIBLE evidence listed), `costs` (six ledger keys: by_attempt, open_commitments, open_reservations, overruns, total_charged, total_overrun), `policy_version` (1), `evidence_policy` (level/schema_version/version), and `event_history` (19 entries, first NODE_PROPOSED, last ACCEPTANCE_AUTHORISED). Functional on a run started by ANOTHER `Controller` over one `EventStore`: my probe opens a second connection after the first one is closed — the audit reads a run it never drove.
7. `Stop shape` — attacked-and-not-falsified, including the settled case. J-runs at FINAL: (a) a planned-but-not-dispatched attempt (the suite's case) plus my harder case — a TRULY in-flight run (attempt DISPATCHED, the sandboxed command executing) observed mid-run from a second connection (`outcome None`, attempt DISPATCHED) and then cancelled from there: `stop` returns CANCELLED: `NODE_CANCELLED` is admitted; the DISPATCHED attempt settles (final attempt state CANCELLED — the attempt machine accepts the late cancellation), attempt costs settled (`ATTEMPT_COST_SETTLED_CONSERVATIVELY`), and NOTHING live remains (all attempt states terminal after the settle). (b) double `stop`: second call returns CANCELLED, event count unchanged (9 → 9; the NODE_CANCELLED dedupes on the idempotency key). (c) `stop` after acceptance: the run stays ACCEPTANCE_CLAIMED — and the report's own wording is exactly right about the mechanism: a `NODE_CANCELLED` event IS added (19 → 20) and is retained-but-non-mutating by the REDUCER's late-event rule (`_apply_node_event` returns `late_event_retained` against a terminal node; the run outcome, once admitted, is never rewritten) — the pin goes through the reducer's rule, NOT a CLI-side guard (`run_entry.stop_run` has no early outcome check). One defect surfaces under this shape via my mid-flight subprocess variant (F12's second paragraph: the LAUNCHER process crashes after the cancellation), and the run itself stays consistent — a process shape, not a store or reducer defect.
8. `No-harness-import shape` — pinned, tested, and F13 filed for the exact question: `import orchestrator.experiment_spec as x` IS caught (leaf match on `ast.Import` alias names — mutant 3 goes red); a late function-level import IS caught (`ast.walk` descends into function bodies); `from orchestrator import experiment` and `from . import experiment` are NOT caught (both mutants stay green) — F13. Subprocess half: `scripts/orchestrate.py` end-to-end as subprocesses recorded against `docs/run-entry.md`: `start` (absolute workdir, accepting) exit 0 with the JSON document naming run_id=root_node_id, attempt_id, evidence_id, 'outcome: ACCEPTANCE_CLAIMED'; `inspect` exit 0 (the JSON document prints status/outcome/policy_version/evidence_policy and the full sets) — the claim "start exits zero on acceptance and non-zero on refusal" holds for both named paths (the loader-refusal path exit 1 with a named `RunSpecError`, the store not created); WITH a relative workdir the rejecting case exists but is NOT a graceful refusal — F11 (crash + live run) — and without `PYTHONPATH=src` the CLI does not import at all — F14 (the report's subprocess caveat was correct; the subprocess runs are henceforth under my reproducers, since the suite builds the shapes in-process).
9. `Evidence-policy shape` — attacked-and-not-falsified on the binding; two field-table rows are falsified (F15, F16). The `{level, version}` pair is validated ONLY by the catalogue accessors — `run_entry._require_evidence_policy` reads `glossary.evidence_policy_levels()` directly and `RunConfiguration`'s schema validates `evidence_policy.level` through the same accessor from the catalogue; grep confirms no LOW/MEDIUM/HIGH/CRITICAL literal lists in `src/` (no local redefinition). The pair is recorded beside the control-policy version in the frozen `run_specification` binding (J-probe: binding `{policy_version: 1, evidence_policy: {…}}`) and read back through `inspect` (`policy_version` and `evidence_policy` fields, HIGH in the suite, MEDIUM/LOW in my probes). The normative-marker question: attacked-and-not-falsified. The api-shape deferral ("no docs/control-plane.md or other normative freeze of the shape") was about freezing the R1 shape into an EXISTING catalogue doc, and OUT OF SCOPE declined it for that purpose only; this brief's GOAL itself makes "a documented run-spec" the deliverable and `docs/run-entry.md` the only docs/ file it authorises, so marking the new deliverable `<!-- normative -->` is the brief's own act, not a skipped OWNER freeze step. Row-J: every documented field was run against the loader — `run_id: {run_id}-root` (observed `RUN-OP-ACCEPT-root`); `repository` exists and contains the base commit (a named `RunSpecError` on a missing or empty one, four cases); `snapshot_id` rides the obligations' derivations and the manifest id; `project_kernel` is required non-empty and maps from the frozen target (the binding's separate `kernel` slot is None for run-entry runs — pre-existing `submit_run` keying, with the reference itself alive on the config — see answer 3); `visible_commands` (order recorded and dispatched in order); `components` (name, scope) feed derivation; `owned_scope` globbing exercised at the run-spec and worktree level; `acceptance_criteria` and the last visible command feed the acceptance checks; `budgets` catalogued and positive (answer 2); `limits` (`actions`, `wall_clock_seconds` each read by the loader); `policy_version` refusing a mismatched one (named `RunSpecError` for 999); `evidence_policy` mapped above; `executor_profile` validated-but-unrecorded (F15); `obligations` exercised at the freeze boundary: a DECLARED spec without `non_derivable_axes` is refused ("a DECLARED target must name the axes it cannot derive"), and a DECLARED spec whose obligations are not measured divergence is refused ("declared obligations … are not admissible: measured divergence") — both zero events. The two falsified rows are F15 (`executor_profile` "recorded on the run") and F16 ("before any store is opened" for the obligations class).

10. Exit gate as a whole — most guarantees closed end-to-end; three falsified-with-reproducer (F11, F12, F14). Without importing the harness (subprocess, `PYTHONPATH=src` for module resolution), a real fixture repository operates: `start` (absolute workdir) → exit 0, JSON document with accepted/attempt/evidence ids and `outcome: ACCEPTANCE_CLAIMED`; `inspect` over the same store from a second subprocess → exit 0, correct JSON audit (live states, evidence, costs, event history, policy pair); `stop` mid-run from a second subprocess while the launcher drives a sleeping sandboxed command → exit 0, `{"outcome": "CANCELLED", …}`, the in-flight attempt settled (`ATTEMPT_COST_SETTLED_CONSERVATIVELY`, attempt CANCELLED), `ACCEPTANCE_AUTHORISED` absent, double stop idempotent; the launcher process itself then dies with an unhandled executor exception (F12's second paragraph) while the store stays consistent and operable; `start` of a malformed spec is refused (exit 1, named `RunSpecError`, no store file — verified for the levels class; F16's obligations class opens the store first). The gate's falsifications, in operator terms: (F11) a relative `--workdir` crashes `start` on BOTH branches, leaving a live run with no JSON and no recorded refusal; (F12) a `wall_clock_seconds` overrun crashes `start` with the run live (`outcome None`, root READY); (F14) the CLI is not runnable outside pytest's `pythonpath` configuration without setting `PYTHONPATH` first, which the doc does not document. In all three cases recovery through a second process is still possible (`inspect`/`stop` are store-only), but the gate's "start" half fails for the documented forms and the Start shape's unconditional sentence is false under F11/F12. "An operator can start, observe, and stop a run on an arbitrary repository without importing the experiment harness" — with the harness import boundary itself holding (the CLI imports only run_entry + the controller stack, verified by the mutant probe as far as the pin reaches).
11. Report hygiene — verified line-for-line. (a) The implementer's VERIFIED counts all match my independent re-runs (961/66 fast; 21; 47; 5; static exit 0; docs 328-at-their-commit/338-at-mine; check-scope tripped line identical — the check-docs gap is exactly the review brief's own ten links). (b) `TRIPPED` copies check-scope's verbatim line ("tripped: PILOT-R1 PILOT-R10"). (c) The shape map: ten functions reported, twenty-one cases (`collect-only` confirms 21 cases under 10 `def test_` names — test_run_spec_load_shape, test_configuration_refusal_shape[12], test_run_configuration_schema_is_a_second_boundary, test_start_shape_authorises_acceptance, test_start_shape_records_a_refusal_without_authorising, test_observe_shape_is_read_only, test_stop_shape_settles_live_attempts, test_stop_never_rewrites_a_settled_outcome, test_no_harness_import_shape, test_evidence_policy_shape_binds_the_run); every case is slow-marked by the module-level `pytestmark = pytest.mark.slow` (single mark point, module-wide, so the map's "every case slow-marked" holds mechanically), and the split is exactly 45 + 21 = 66 fast-deselected (both collect runs directly measured). (d) `INHERITED: none` against the received materially — F10 (docstring half) is FIXED (its STATE reads fixed and verified above in answer 1), and nothing else was open at the received step; the block reading `none` follows the receipt (nothing still open). Rule 2 governs the planner's copy: nothing of mine re-carries earlier findings — this review's carried set is the six findings above (F11–F16).
INHERITED:
Nothing received still open — the implementer brief's INHERITED (F10 docstring half) is fixed in FINAL and verified in answer 1. This review carries, with their IDs, the findings above: F11, F12, F13, F14, F15, F16 (all carried, per the template's rule "a defect you will not fix now is carried, never declined").

Rule 2 governs the planner's copy of this block. What goes in it is mine: an implementer or reviewer who received an obligation, finding, entry or trigger carries it forward verbatim if still open, and adds anything new that is still open. INHERITED never carries residual rows; they are re-selected from the store per brief.
