REPORT — phase5-run-entry-fixes-review
STEP: phase5-run-entry-fixes (Phase 5: fix the run-entry defects F11–F16)
REV: aa33970c6d3b8f369b25be99145075fe7f48b64c   FINAL: 223596b55a9f678c743409416d4068ddd0cdfd02
CHANGED:
  docs/research/phase5-run-entry-fixes-review.md — this report (probe scripts and scratch mutant copies
  lived under /tmp/kilo, not in the tree: worktrees at REV and FINAL, two mutants mut1 (single honest
  stamp), mut2 (content-refused bundle create), and probe_q2_forgery / probe_q3_escape /
  probe_q4_interleave / probe_q5_divergence scripts removed from consideration there).
VERIFIED:
- REVIEW ACCEPTANCE `scripts/check-scope aa33970c6d3b8f369b25be99145075fe7f48b64c 223596b55a9f678c743409416d4068ddd0cdfd02 docs/research/phase5-run-entry-fixes-brief.md` — "tripped: none", "scope: ok (4 path(s) in aa33970c..223596b)", exit 0, run first before any other action.
- The fixes-brief embedded in the review brief is byte-identical to the committed `docs/research/phase5-run-entry-fixes-brief.md` (diff of the review brief's embedded copy against `git show 6594036:docs/research/phase5-run-entry-fixes-brief.md`: identical), and REV aa33970c is exactly the brief-commit's parent, so `diff REV..FINAL` and the `final` diff ranges are equivalent. FINAL 223596b ("phase5: fix the run-entry defects F11-F16", trailer `Actor: IMPLEMENTER`) is the only work commit; the report commit b03b2f5 (also `Actor: IMPLEMENTER`) holds only the report; none were written by this session.
- `scripts/check-tests --fast` — 961 passed, 76 deselected in 83.46s, exit 0 (report: 961/76 in 91.9s; counts equal).
- `.venv/bin/python -m pytest tests/test_run_entry.py` — 31 passed in 8.80s (report: 31 passed in 9.97s; counts equal; the interpreter substitution is answered in FINDINGS F17).
- `pytest tests/test_phase3_project_oracle.py` — 5 passed in 272.40s (report: 5 in 296.5s).
- `pytest tests/test_phase3_project_oracle.py` is the only slow-suite regression item named; the full fast battery above covers the regression set. `tests/test_run_entry.py` now counts 31 = 21 (received) + 10 (new pins), matching the report's arithmetic exactly.
- `scripts/check-static` — exit 0; the gated select (BLE001,S110 over `src/orchestrator`) prints no items and the gate passes; the B/SIM advisory run afterwards prints 104 items with `--exit-zero` and does not gate — matches the report's account verbatim.
- `scripts/check-docs` — exit 0, 341 links, 0 errors in this working tree; the report's 340 differs only because the review brief commit (9ceb183) links more documents after the report was generated (same off-by-one-by-later-commit as the received review's 328→338 delta).
- `TRIPPED` re-measured from check-scope's own output line on this run: "tripped: none" — identical to the report's copy.
- The step double-checked the review's own planning-time attack premise for Q1 and found IT half-wrong: bare `pytest --collect-only tests/test_run_entry.py` does NOT silently "collect with no strict_config rejection" — it prints the same `ERROR: Unknown config option: timeout` and exits 4 while collecting 31 names (F17 records the corrected measurement).
NOT VERIFIED:
- The falsifications below are mine, with reproducers: F18 (the settle path forges the repeated-failure precondition from one failure), F19 (ProtocolViolation escapes `start_run` with the run live), F20 (the settle/stop interleavings: a late forged chain whose JSON contradicts the durable outcome; a leaked open accounting on a terminal run), F21 (the divergence and cannot-freeze classes still create the store file before refusal), F23 (the extended pin misses the dotted-import spelling; dynamic forms unenforced), F24 (the clean-env pin's interpreter differs from the documented one it claims). F22 and F25 are the report's own line-citation and SHAPES statements, checked against the delivered files.
FINDINGS:
  F17 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
  The fixes-brief's ACCEPTANCE names a command that cannot go green as written on this host, and the
  report's answer substituted a different command inside the VERIFIED parenthetical instead of filing
  the fact. Measured: bare `pytest tests/test_run_entry.py` (the pytest-9.1.1 on PATH, no
  pytest-timeout plugin) aborts at config load — `ERROR: Unknown config option: timeout`
  (pytest.ini's `timeout` option under `strict_config = true`), collects all 31 test names, awaits
  none, "no tests ran in
  0.03s", exit 4. The literal ACCEPTANCE line is therefore not executable to green by the operator it
  names; the report's VERIFIED reads "ran as .venv/bin/python -m pytest …" — an interpreter the
  ACCEPTANCE does not name, filed as a verified run of a command that was not run, with no METHOD
  FRICTION and no NOT VERIFIED entry and no ORIGIN: BRIEF finding. Per the method, "A defect in the
  brief is a FINDING, never METHOD FRICTION": the owed item was exactly that finding — the J-class
  violation is the substitution itself. Correction the next implementer brief should carry: either
  repair the brief's ACCEPTANCE wording (none is possible post-commit — briefs are immutable records),
  or record the substitution as an honest departure (J-row: a claim not declared against its source —
  the VERIFIED entry's command line is the claim; the executed interpreter is the artifact).
  FIXED: no regression test — a brief-text defect has no failing assertion at any revision; a later
  committed brief must re-cut the ACCEPTANCE line (`pytest tests/test_run_entry.py` is only green
  under the interpreter that has pytest-timeout installed) or the next report's VERIFIED must carry
  the deviation as a declared departure rather than a parenthetical.
  F18 | SEVERITY: P1 | ORIGIN: CODE | STATE: carried
  `start_run`'s settle path (both `_settle_executor_refusal` (run_entry.py:487) and the pre-existing
  twin in `_bind_acceptance`'s refusal path (run_entry.py:453)) stamps the SAME failure fingerprint
  twice for one observed failure, then solves the repeated-failure gate off the pair it just forged —
  the durable log records a history that never happened. Reproducer on the delivered code (real
  fixture repo, `wall_clock_seconds: 1`, a sleeping visible command, in-process `start_run`): the log
  records exactly one overrun (`TIMER_FIRED`, `ATTEMPT_EXECUTION_ENDED_UNRECONCILED`) and then TWO
  `FAILURE_RECORDED` events with byte-identical fingerprints
  (`sha256:e6b323caed4edce823d6764a1fad8137fc50fb02f4f85be48e0a43cc54a2f3d8` ×2, idempotency keys
  `failure-RUN-Q2-root-1/-2`), and `evaluate_repeated_failure` fires on them (`REPLAN_REQUESTED` with
  reason `REPEATED_FAILURE_WITHOUT_NEW_EVIDENCE`, then `NODE_MARKED_INFEASIBLE`); `inspect` reads the
  node's failure history back as two observed failures for the one overrun. The trigger is
  `len(fingerprints) >= 2 and fingerprints[-1] == fingerprints[-2]` (controller.py:2043) — the second
  failure is the code's own double stamp. Counterfactual on a scratch copy of FINAL (the loop run
  once — the only delta vs `git show 223596b:src/orchestrator/run_entry.py`, verified by diff): one
  honest stamp yields `NO_ACTION`, the node stays READY, `get_outcome` reads None, `inspect` shows
  `outcome: null` — a single honest stamp settles NOTHING, so the forged second stamp is the only way
  `start_run` reaches the outcome the Settled-start shape demands. Ledger rows: B (coercion, "looks
  close enough" — the two-failure precondition asserted by the rule is satisfied by manufacture) and
  A (the failure-count accounting an auditor reads from `inspect`/replay is laundered). The delivered
  wall-clock pin goes further and ENSHRINES the forgery: `assert len(futures) >= 2`
  (tests/test_run_entry.py:540) passes on two fingerprints for one failure.
  FIXED: no regression test — the pin's red would be: settle one overrun, assert `len(fingerprints)`
  == 1 and that the node reaches its terminal outcome WITHOUT a `REPEATED_FAILURE_WITHOUT_NEW_EVIDENCE`
  `REPLAN_REQUESTED`; today the node machine has no legal single-failure route from the settle path,
  which is the defect's actual shape (a recorded refusal that must not depend on a manufactured repeat;
  the next brief must decide the route — e.g. an infeasible transition from the recorded-refusal event
  itself — before any pin can be green).
  F19 | SEVERITY: P1 | ORIGIN: BRIEF | STATE: carried
  The Settled-start shape's X_X as delivered: `start_run` catches only

  `AttemptTimedOut` and `AttemptCancelled` (run_entry.py:522-531); no `ProtocolViolation` handler
  exists on the root-execute drive. Mutant on a scratch copy of FINAL: `worktree.py:328`'s bundle
  create ref `HEAD` → `NO-SUCH-REF` (the only delta vs FINAL, verified by diff), so `git bundle
  create` fails for a content reason no path normalisation can fix (`fatal: ambiguous argument
  'NO-SUCH-REF': unknown revision or path not in the tree`, raised as
  `executor_protocol.ProtocolViolation` by `worktree._git`). Reproducer: CLI `start` with an absolute
  workdir (F11's fix stays intact — only the missing ProtocolViolation handler is exercised) — exit 1,
  EMPTY stdout (no JSON document), traceback in stderr, and the store after the escape holds attempt
  DISPATCHED, root node READY, `outcome: None` (`inspect` reads null): the run is live, in the exact
  shape F11's red rejected. The overreach is the brief's: the named remedies cover two of the three
  classes the sentence names (F11 = abs-path at entry for the ProtocolViolation it measured; F12 =
  handlers for the two executor-exception classes); nothing prescribed ProtocolViolation handling, and
  the implementer implemented exactly the remedies without narrowing the shape or filing the gap.
  FIXED: no regression test — a later committed brief either narrows the shape's sentence to the two
  handler classes (with the recovery note that a ProtocolViolation escape remains recoverable via
  `stop`), or prescribes a recorded-refusal path for ProtocolViolation before any pin; carried until
  then.
  F20 | SEVERITY: P1 | ORIGIN: CODE | STATE: carried
  The read-then-settle window in `_settle_executor_refusal` is real under the documented two-process
  workflow: ONE fresh read (`controller.store.replay_fresh(run_id).outcome`) is followed by settle
  steps that all reduce against the STALE in-memory projection (`store.state(run_id)`) with no
  cross-process claim between them. Deterministic two-connection interleave probe (the second
  process's complete `stop_run` inserted between the fresh read and the settle steps; the launcher then
  continues): (a1) the launcher emits its whole forged chain — `ATTEMPT_COST_SETTLED_CONSERVATIVELY`,
  two `FAILURE_RECORDED`, `REPLAN_REQUESTED`, `NODE_MARKED_INFEASIBLE` — as LATE events after the
  second process's `NODE_CANCELLED`: the durable log shows a CANCELLED run AND a forged
  repeat-failure-to-INFEASIBLE trail for the same single overrun (fresh replay keeps outcome
  CANCELLED, node CANCELLED — no ReplayError; the late node events are retained non-mutating), while
  the LAUNCHER's own JSON document reads `outcome: INFEASIBLE`, `accepted: false` — the document is
  NOT "the settled outcome" the exit contract names; it is a stale projection's outcome. (a2) with the
  stop completed before the read, the launcher correctly skips settling and returns the fresh
  CANCELLED — but the timed-out attempt's accounting stays PROVISIONALLY_SETTLED forever: `stop`'s
  `cancel_run` treats TIMED_OUT attempts as terminal and skips them (controller.py:2759-2770), nothing
  finally settles the attempt's ledger, and the run is terminal with an open provisioning liability
  (`fresh`: attempts `[(TIMED_OUT, PROVISIONALLY_SETTLED)]` on a CANCELLED run). The two call sites
  answered: the stop process never stamps failures, so no double-FAILURE pair fires from stop; the
  double-`_settle_if_open` cannot fire (the second settle's idempotency key dedupes inter-process);
  `replay_fresh` per escape is a full genesis replay (affordable for a one-shot CLI) but is read ONCE
  while the following mutations reduce stale — the read surface is half-fresh, which is exactly the
  hole. Interleaving (a1) also reproduces F18's forged pair in the CANCELLED flow — the defects
  compound, not overlap.
  FIXED: no regression test — the eventual reds would drive the two interleave orders above
  (deterministically, by inserting the stop between the replay and the settle) and assert: the JSON
  document equals the durable fresh outcome; the log holds no late forged chain; and a terminal run
  never leaves attempt accounting PROVISIONALLY_SETTLED on TIMED_OUT attempts (the launcher must
  settle the attempt regardless of the outcome read, and must re-read the fresh outcome after its own
  settle emissions).
  F21 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
  The Fail-closed-load shape's and the GOAL's "every malformed run-spec class is refused before any
  store is opened" remains false as delivered for the classes the remedy could not reach. The CLI
  constructs `EventStore(os.path.abspath(args.store))` (store.py:117-131: `sqlite3.connect` +
  `PRAGMA journal_mode=WAL` + `executescript(_SCHEMA)` — the file is created at construction) BEFORE
  `start_run` runs, so every freeze-boundary refusal leaves the store file behind. Measured with a
  nonexistent `--store` path: a DECLARED spec whose axes do not match the measured set — valid
  obligation schema (`child_id`/`scope`/`criterion_ids`/`acceptance` present) so the check is reached —
  refuses exactly as the original F16 text quoted (`RunSpecError: cannot freeze target
  'TARGET-RUN-Q5-DIV': declared obligations … are not admissible: measured divergence [], declared
  axes ['ALLOCATION', 'EDGES', …]`), exit 1, zero events, traceback in stderr — AND the store file
  exists on disk after the refusal. Same for the `cannot freeze target …: target repository
  '/tmp/kilo/does-not-exist' does not exist` class. The verdict named by the question: ORIGIN: BRIEF
  narrowing — the prescribed remedy (move the obligations completeness check into `validate_run_spec`)
  could not make the shape's universal "every class … before any store is opened" true: the divergence
  measure needs the live repository and sits at the freeze boundary by construction, and the
  cannot-freeze classes are the freeze boundary itself. The delivered doc sentence
  (docs/run-entry.md:12) and the module docstring's "before a store is touched" (run_entry.py:7-8)
  remain false universals, and the delivered F16 pin's CLI half now only exercises the
  loader-refused form (the earlier notch), leaving the freeze-refused classes unpinned.
  FIXED: no regression test — a later committed brief either narrows "malformed run-spec class" to
  the loader-refusable classes in the shape and both doc sentences (with the freeze boundary honestly
  named as where the divergence class refuses), or moves the divergence check to the loader (it has
  the repository path; the commit still resolves inside `build_target`) — carried until either.
  F22 | SEVERITY: P2 | ORIGIN: DOCUMENT | STATE: carried
  The implementer report's red-evidence FIXED citations name line numbers that neither the delivered
  test file nor one consistent scratch layout reproduces: F11 line 491 vs actual 492
  (`tests/test_run_entry.py`, `assert completed.returncode == 0, completed.stderr`); F12's wall-clock
  518 vs actual 528 and cancelled 605 vs actual 612 (`assert "Traceback" not in stderr`); F13 line
  426 vs actual 436 (`assert leaves & _FORBIDDEN_MODULES`); F14 618 vs actual 625; F16 681 vs actual
  688 (`with pytest.raises(run_entry.RunSpecError)`). The assert CONTENTS and failure messages are
  verified correct everywhere (every red reproduced by me: F11 red =
  `assert 1 == 0` at line 492 with the bundle-create ProtocolViolation; F12a red = "start_run escaped
  with AttemptTimedOut…" at 528; F12b red = line 612; F14 red = line 625 with `ModuleNotFoundError:
  No module named 'orchestrator'`; F16 red = "Failed: DID NOT RAISE RunSpecError" at 688; F13's two
  mutants red = 426/`the pin misses the 'relative-import' spelling: []` and
  `['orchestrator']` for named-import). The numbers' provenance is explainable — the helper-reverted
  hybrid file is 10 lines shorter than the delivered one, so F13/F12a's citations match THAT hybrid
  (426/518 exactly) while the rest match neither the hybrid nor the delivered file — but the
  committed citation set is internally inconsistent, and a replay that follows the report's line
  numbers lands off-target in every case. The assertions were named correctly; only the line numbers
  are wrong.
  FIXED: no regression test — a defect in an already-committed report; the citation set should have
  named the delivered file's line numbers (or no line numbers and only the named assertions). Recorded
  in the review that filed it; nothing can correct the committed text in place.
  F23 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  The extended import pin's `ast.Import` arm misses the dotted absolute-import spelling: the leaf
  collapse `_module_leaf` keeps only the last dotted component, so `import
  orchestrator.experiment.trial_driver` collects leaves = {'trial_driver'} and the pin's
  `_FORBIDDEN_MODULES` intersection is empty — the shape's own named class ("ast.Import names", the
  extended helper's guarantee "including the two the review's mutants reached green") is STILL not
  closed: a dotted path into a harness submodule (what `import orchestrator.experiment_spec.sub`
  would be for a future harness layout) sneaks through. Measured against the delivered helper
  directly (the eight-spelling probe; the four brief-named spellings all FLAG:
  `from orchestrator.experiment import run_measured_comparison` collects
  {'experiment','run_measured_comparison'}, `from orchestrator.experiment_spec import
  ExperimentError as E` collects {'experiment_spec'}, `import orchestrator.experiment` and
  `import orchestrator.experiment_spec as spec` both flagged); only the dotted case is missed.
  FIXED: no regression test — the spelling pin's parametrisation gains a dotted-import row
  (`import orchestrator.experiment.trial_driver\n`) whose assertion at the delivered helper is RED;
  the helper fix is one line: check every dotted path segment of the import against the forbidden set, not only the leaf.
  F24 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  The Clean-env CLI pin launches `[sys.executable, str(_SCRIPT), …]` — the venv interpreter — while
  the doc row and the pin's own docstring name `python3 scripts/orchestrate.py`. The literal form is
  NOT exercised by the pin: on a host whose system `python3` lacks `yaml` (run_entry's one third-party
  import path the CLI reaches at `load_run_spec`), the pin stays green while the documented form
  fails to start. On THIS host the literal form is verified real: `env -u PYTHONPATH python3
  scripts/orchestrate.py --help` → exit 0, usage output; a real `start` (accept), `inspect`, `stop`
  and the mid-run-cancelled launcher form all run from the repo root with a clean env under the system
  python3.13.5 — exit codes 0/1 as documented, JSON documents naming the run, no `Traceback` in
  stderr, and after a `stop` the launcher's document reads `accepted: false, outcome: CANCELLED` —
  the documented contract holds today by hand-verification. The J-class half: the pin claims the
  form it does not run (the interpreter the shape names is the documented `python3`, the interpreter
  the pin executes is the venv's) — behaviourally sound here, enforced nowhere.
  FIXED: no regression test — the pin could pass the literal `python3` form OR try the system
  interpreter first and only fall back to `sys.executable` (naming the choice in its docstring,
  which currently misstates what it runs). Carried: the shape today depends on the host's
  system `python3` having `yaml`. Also noted for the SAME J-class family: F17's substitution and this
  substitution are two instances of the one departure class (the command executed is not the command
  named) — row J earns its second sighting this step.
  F25 | SEVERITY: P2 | ORIGIN: DOCUMENT | STATE: carried
  The report's SHAPES claim ("none — every named shape is built in tests/test_run_entry.py; nothing
  probed by hand was left unbuilt") is false read against the code this step changed. Probed shapes
  the suite does not build, each pinned by my reproducers this review: (i) the ProtocolViolation
  escape class (F19 — no suite case drives `start_run` into a mid-dispatch ProtocolViolation); (ii)
  the settle/stop interleavings — both orders of the second process's stop against the settle window
  (F20; the delivered cancelled-launcher pin only exercises stop-before-read, and its tolerances
  hide the stale-read order entirely); (iii) the freeze-refused classes' store-file creation (F21 —
  the delivered F16 pin's CLI half only exercises the loader-refused form after the fix); (iv) the
  dotted absolute-import spelling (F23); (v) the dynamic-import class (`__import__("orchestrator
  .experiment")`, `importlib.import_module`) — probed by me and left unenforced by the four-spelling
  pin and named in no shapes entry; it belongs there per the review's own question, as a static pin's
  known unenforced class (the dynamic class is outside ast in a way the DELIVERED helper cannot reach
  without new linting, but the shapes section should have said so instead of claiming nothing was
  left unbuilt). Also extra: the confirmed-clean shape "stop of a settled timed-out run is idempotent
  and the late-event rule holds under a DOUBLE stop" (probed clean this review — the run stays
  INFEASIBLE, `[(TIMED_OUT, FINALLY_SETTLED)]`, no ReplayError) is a property the suite partially
  builds (`test_stop_never_rewrites_a_settled_outcome`) but does not build for the timed-out-accounting
  variant — folded into F20's eventual reds rather than a new finding.
  FIXED: no regression test — a false "nothing left unbuilt" claim in an already-committed report;
  the shapes inventory above belongs to the next brief's reds. Recorded in the review that filed it.
SHAPES: properties probed that the suite does not build:
- ProtocolViolation-escape shape: a mid-dispatch ProtocolViolation whose cause cannot be fixed by path
  normalisation (content-refused `git bundle create`), driven through CLI `start` on a scratch mutant
  at FINAL — exit 1, no JSON, attempt DISPATCHED, node READY, `outcome: null` (F19/F20).
- Settle/stop interleave shapes, both orders: a second process's complete `stop_run` inserted between
  the launcher's fresh outcome read and its settle steps (stale-None read), and before that read
  (fresh-CANCELLED read); fresh-replay outcomes, late-event retention, accounting end states dumped
  per order (F20).
- Failed-to-freeze store-creation shapes: the measured-divergence DECLARED class (with a fully valid
  obligation schema) and the nonexistent-repository class, each through the CLI with a nonexistent
  store path; the file's existence after the refusal checked on disk (F21).
- Single-honest-stamp counterfactual: the settle loop run once on a scratch copy of FINAL —
  `NO_ACTION`, node READY, `outcome: null` (F18).
- Import-spelling probe shapes: eight spellings through the delivered helper (four named ones flagged,
  dotted absolute MISSED, `__import__`/importlib dynamic MISSED) (F23).
- Documented-interpreter shape: literal `python3 scripts/orchestrate.py --help/start/inspect/stop` and
  a mid-run-cancelled launcher from the repo root with a clean env, system python3.13.5, all exit
  codes and JSON meeting the extended exit-gate sentence (F24).
- Double-stop-after-settled-timeout: two consecutive `stop_run`s on a settled INFEASIBLE run — same
  outcome, no ReplayError, `FINALLY_SETTLED` kept (clean — credited in F25).
- Bare-pytest-gate shape: literal `pytest tests/test_run_entry.py` and `pytest --collect-only …` under
  the unpinned interpreter — exit 4, `ERROR: Unknown config option: timeout`, 31 names collected, none
  run (F17).
TRIPPED: none
PROPOSED ROWS: J (a claim or departure not declared against its source) earns a second sighting this
step (F17's VERIFIED-substitution parenthetical and F24's docstring-vs-interpreter mismatch in the same
step's outputs); B (coercion) and A (laundering accounting) each earn fresh sighting (F18's forged
second stamp); H (concurrency and interleaving) a fresh sighting (F20). No new row proposed — every
finding above maps to rows the ledger already carries.
METHOD FRICTION: none against the method's steps or `docs/templates/report.txt`. The review-through
diffed every scratch copy against `git show REV:`/`git show FINAL:` before trusting it (three worktrees
— REV, FINAL, one helper-reverted hybrid — and two mutants, each diff-verified to show only its named
delta); the only method-note is informational: `src` builds python3.13-only in this sandbox (the
`.venv`'s interpreter matches), so the clean-env runs needed the venv's `pytest` while the
documented `python3` form was verified by a separate system-python3 run.

ANSWERS TO QUESTIONS TO ATTACK:
1. Q1 (the literal `pytest tests/test_run_entry.py` claim) — verdict: the VERIFIED entry's command
   line was not the command run; an ORIGIN: BRIEF finding was owed and filed — F17. Measurements
   rather than the report's account: bare `pytest tests/test_run_entry.py`: `ERROR: Unknown config
   option: timeout`, "collected 31 items", "no tests ran in 0.03s", exit 4; bare `pytest --collect-only
   tests/test_run_entry.py`: the same error, exit 4, "31 tests collected in 0.03s" — the review's
   planning-time premise "collects 31 tests with no strict_config rejection" is half-wrong (the items
   enumerate, but the rejection error prints and the exit is 4) and its "a targeted node-id run
   printed 'no tests ran in 0.02s'" half matches (my first read of "exit 0" was a piped run measuring the pipe's tail, not pytest's; the pytest process itself exits 4 — `.venv/bin/python -m pytest` runs them:
   31 passed in 8.80s). The J-class violation (the command that answers the question is the one in
   ACCEPTANCE) is the substitution being filed as verified; the ORIGIN: BRIEF finding (the ACCEPTANCE
   command cannot go green as written on this host) is filed.
2. Q2 (the double fingerprint stamp) — FALSIFIED-WITH-REPRODUCER, F18. The delivered settle stamps the
   one observed overrun's failure fingerprint TWICE (two `FAILURE_RECORDED` events, byte-identical
   sha256:s), then requests the deterministic terminal decision from the rule whose exact trigger
   (`len >= 2 and [-1] == [-2]`, controller.py:2043) the double stamp satisfies — a single honest
   stamp settles nothing (mutant probe: NO_ACTION, node READY, `outcome: null`), so the forged pair
   is the only route to the shape's terminal outcome. The durable log records a history that never
   happened (two failures where one occurred; `inspect` reads two observed failures), and the
   delivered pin asserts `len >= 2`, enshrining it. Ledger rows A (laundering accounting) and B
   (coercion).
3. Q3 (ProtocolViolation escapes with a live run) — FALSIFIED-WITH-REPRODUCER, F19 (ORIGIN: BRIEF:
   the overreach is the brief's — the shape names a class its own remedy list never covered). The
   mutant (bundle ref → the content-refused `NO-SUCH-REF`, single-line delta vs FINAL) escapes
   `start_run` (its delivered catch surface has no ProtocolViolation handler) and the CLI: exit 1,
   empty stdout, traceback (`executor_protocol.ProtocolViolation: git bundle create … failed: fatal:
   ambiguous argument 'NO-SUCH-REF' …`), attempt DISPATCHED, node READY, `outcome: None`, `inspect`
   reads null — the run live, the same shape F11's red rejected for path reasons. The fix belongs in
   the delivered catch surface or the shape needed narrowing — the shape needed narrowing; nothing in
   the report's `METHOD FRICTION` and no finding mentioned this.
4. Q4 (the settle/stop interleavings) — FALSIFIED-WITH-REPRODUCER, F20 (P1). Between the launcher's
   fresh outcome read and its settle emissions there is no cross-process claim; the probe (second
   connection, stop inserted deterministically in both orders) shows: (a1) the stale-None order emits
   the forged settle chain as late events past `NODE_CANCELLED` and the launcher's JSON names
   `INFEASIBLE` while the durable outcome is `CANCELLED`; (a2) the fresh-CANCELLED order skips settle
   and leaves the timed-out attempt's accounting PROVISIONALLY_SETTLED on a terminal run — both keyed
   by the mixed fresh/stale read surface; stop itself never stamps failures and double-`_settle_if_open`
   dedupes inter-process, so the dangerous pairs are the launcher's own. The full end states are
   F20's field notes; every claim's durability was measured on fresh connections, not projections.
5. Q5 (the store opened before the divergence refusal) — YES, and the claim's shape sentence needed
   narrowing, not the delivered code — F21 (ORIGIN: BRIEF). Measured: the divergence class (valid
   obligations, declared axes ≠ measured) and the cannot-freeze class (nonexistent repository) both
   leave the store FILE on disk after their named `RunSpecError` (the CLI's `EventStore(...)`
   constructs it eagerly), so the shape/GOAL's "every … before any store is opened" and the delivered
   doc sentences (docs/run-entry.md:12, run_entry.py:7-8) remain false as read; the prescribed remedy
   could not cover them — the verdict is an ORIGIN: BRIEF narrowing, the pin's CLI half exercises
   only the loader-refused class, and the honest fix is either the narrowed wording or a
   loader-sited divergence check.
6. Q6 (red evidence at REV) — verified line-by-line, and the report's LINE NUMBERS are wrong (F22).
   Red runs at REV (fixtures copied from FINAL; every scratch file diff-verified against `git show
   REV:` before use): F11 `test_settled_start_shape_relative_workdir` fails at
   `tests/test_run_entry.py:492: AssertionError` (assert 1 == 0, the ProtocolViolation in stderr),
   not 491 as the report cites; F12a fails at :528 (`AssertionError: start_run escaped with
   AttemptTimedOut instead of settling…`), not 518; F12b fails at :612 (`assert "Traceback" not in
   stderr`), not 605; F13 reds at :426 for BOTH named spellings (named-import walks the message `the
   pin misses the 'named-import' spelling: ['orchestrator']`; relative-import `…: []` — absolute and
   late-function pass the reverted helper, as the report claims), the helper-reverted hybrid being
   10 lines shorter, making 426 a hybrid-layout line; F14 fails at :625 (`assert 1 == 0`, the
   ModuleNotFoundError in stderr), not 618; F16 fails at :688 (`DID NOT RAISE RunSpecError`), not
   681. All five fail at REV and pass at FINAL. F15's `no regression test` with the green-at-both
   absence pin is exactly the form the brief prescribed: the pin is GREEN at REV (1 passed) and
   green at FINAL, and the doc row's correction is complete in the doc table (row reworded) and in
   the code (the label stays unrecorded, probe output greps clean on both revisions).
7. Q7 (the import pin's spellings) — FALSIFIED on the dotted spelling (F23) and the SHAPES claim (F25).
   The four brief-named spellings are all flagged by the delivered helper (the probe list in
   F23); the dotted absolute `import orchestrator.experiment.trial_driver` is MISSED (leaf collapse —
   a REAL spelling inside the shape's own named "ast.Import names" class); the dynamic class
   (`__import__`, `importlib.import_module`) is outside the pin's AST reach and named in no shapes
   entry — it belongs in SHAPES, and the report's "nothing probed by hand was left unbuilt" is falsified
   for both.
8. Q8 (the clean-env documented python3 form) — the literal form IS real on this host and meets the
   extended exit-gate sentence in every Commands form I ran (accept/refuse/timeout plus a mid-run
   cancelled launcher): exit codes 0/1, JSON documents exactly as documented, no tracebacks. The
   remaining J-class claim (F24, P2) is that the PIN does not exercise the documented interpreter
   (it uses `sys.executable`), so the shape's literal-doc-form guarantee is enforced by hand only.
   No import dependency beyond `yaml` is reachable before argparse runs; the yaml import resolves in
   the system interpreter here (3.13.5) — verified, not pinned.
9. Q9 (the regression battery re-run) — re-run green with matched counts and one discrepancy: F17's
   substitution is the only count the report cannot honestly claim; the battery otherwise matches
   exactly (961 passed / 76 deselected; 31; 5 in 272s; static exit 0 with the advisory B/SIM items
   non-gating; docs 0 errors; check-scope's own line "tripped: none" re-measured and identical). The
   targeted one-off probes of the step's attacked-and-not-falsified set held under re-run: the
   frozen-target freeze runs once per start_run, the budgets wiring (contract budgets == spec budgets
   dict), zero-writes on loader refusals (including the uncreated store file), the late-event rule
   under a double stop, and the 21 original pins all reproduce.
10. Q10 (report hygiene) — FINAL/INHERITED/TRIPPED forms are correct and SHAPES is not (F22, F25):
   FINAL is the work commit, not the report commit (verified: 223596b is the work commit whose child
   b03b2f5 holds the report); INHERITED's reading `none` is machine-correct against the receipts
   (F11–F16 verified received-fixed above); TRIPPED copies check-scope's verbatim line and re-measures
   identical; but SHAPES's "nothing probed by hand was left unbuilt" is falsified by the five unbuilt
   shapes above (F25), and the report's line-number citations are wrong in six of seven names (F22).

INHERITED:
  Nothing received still open — the received list was F11–F16, and each is fixed in FINAL and
  verified above (reds reproduced at REV: F11 line 492, `assert completed.returncode == 0,
  completed.stderr`; F12 line 528 "start_run escaped with AttemptTimedOut…" and line 612
  `"Traceback" not in stderr`; F13 line 426 on both named spellings via the helper-reverted hybrid;
  F14 line 625 with `ModuleNotFoundError: No module named 'orchestrator'`; F16 line 688 "DID NOT
  RAISE RunSpecError") and green at FINAL (31 passed). The implementer report's `INHERITED: none`
  reading is correct against the receipts.
  This review carries, with their IDs, the findings above: F17, F18, F19, F20, F21, F22, F23, F24,
  F25 (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.
