REPORT — phase5-run-entry-fixes-2-review
STEP: phase5-run-entry-fixes-2 (Phase 5: the settle-route fixes — F17–F25)
REV: 544a0bf0ae130d7391d5215054c78ca60bebd81d   FINAL: b98310d4f6df56f98c35aefc5bdcbfccd390ee70
CHANGED:
  docs/research/phase5-run-entry-fixes-2-review.md — this report. New test file
  tests/test_phase5_run_entry_fixes_2_review.py (three slow-marked probes: the two findings' named
  reproducers and the walked residual's green pin). Probe scripts, scratch copies of REV/FINAL
  (git archive, src diff-verified before use), the leaf-collapse mutant, and the worktree
  bundle-create mutant all lived under /tmp/kilo and are not in the tree.
VERIFIED:
- REVIEW ACCEPTANCE `scripts/check-scope 544a0bf0ae130d7391d5215054c78ca60bebd81d
  b98310d4f6df56f98c35aefc5bdcbfccd390ee70 docs/research/phase5-run-entry-fixes-2-brief.md` —
  "scope: ok (5 path(s)) in 544a0bf..b98310d", "tripped: PILOT-R1 PILOT-R10", exit 0, run first
  before any other action.
- The fixes-2 brief embedded in the review brief is byte-identical to the committed
  `docs/research/phase5-run-entry-fixes-2-brief.md` (diff of the BEGIN/END-marked copy against the
  file at HEAD 49ae622: identical). REV is exactly the brief commit 3375429's parent. The step is
  one work commit: FINAL b98310d "phase5: settle the run-entry refusals honestly (F18-F25)",
  trailer `Actor: IMPLEMENTER`; the report commit 6175335 adds only the report; none were written
  by this session. Working tree at review start: clean.
- `scripts/check-tests --fast` — 961 passed, 82 deselected in 92.52s (the report's 100.8s counts
  equal; the battery re-run in this review also at 97.56s after this review's test file existed,
  961 passed / 85 deselected — the three review probes are slow-marked and the fast gate is
  undisturbed).
- `.venv/bin/python -m pytest tests/test_run_entry.py` — 37 passed in 15.56s (report: 15.9s;
  counts equal). Arithmetic: 31 received + the dotted-import row (4→5 spellings) + five new cases
  (protocol-violation, the three settle-claim shapes, the freeze-boundary drift pin) = 37.
- `pytest tests/test_milestone2_conformance.py` — 41 passed in 0.28s; the settle still emits only
  the existing transition (`NODE_MARKED_INFEASIBLE` on `any_non_terminal` to `INFEASIBLE`,
  docs/tables/node-lifecycle.yaml; catalogue row at docs/event-catalogue.md:30, emitter
  Controller) — no new event type, no table change (the step's own claim, re-checked against
  `git diff 544a0bf..b98310d`, whose only controller additions are the `mark_infeasible` body and
  its docstring; `evaluate_repeated_failure` is byte-identical between REV and FINAL).
- `pytest tests/test_phase3_project_oracle.py` — 5 passed in 313.72s (report: 296.5s; counts equal).
- `scripts/check-static` — exit 0 (gated BLE001/S110 over src/orchestrator: no items; the B/SIM
  advisory run prints and does not gate, as the report says). `scripts/check-docs` — exit 0, 346
  links, 0 errors, re-run in a pristine FINAL scratch (this working tree reads 348 only because
  the two research files committed after FINAL link from the docs tree).
- TRIPPED re-measured from check-scope's own output on this run: "tripped: PILOT-R1 PILOT-R10" —
  identical to the report's copy.
- F26's mechanical verification and Q5's red evidence were reproduced with scratch copies of REV
  (git archive + the delivered tests file copied in; src diff against the archive verified before
  each run — the only expected deltas are the four delivered hunks).
NOT VERIFIED: none — every claim is covered by a run named below or a replay above. The two
  findings are new defects filed this review (both red at FINAL by assertion, not by error).

FINDINGS:
  F27 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  The new `Controller.mark_infeasible` surface admits a terminal decision with its only guard
  (`docs/tables/node-lifecycle.yaml`: "Deterministic infeasibility policy passes") evaluated
  nowhere; the guard lives in prose inside the docstring's caller contract ("The caller has already
  recorded the observed failure(s)", controller.py:2061-2078). Measured on the delivered code:
  `build_run` → `controller.mark_infeasible(run_id, root)` on a READY root with ZERO recorded
  failure fingerprints admits `NODE_MARKED_INFEASIBLE` (key `infeasible-RUN-Q2A-root`); the node
  goes READY → INFEASIBLE and, because the node is the root with no outcome yet, the machine drives
  the whole run's outcome to INFEASIBLE from `state.outcome is None` — a false policy pass, both
  cached and under fresh replay. The other probes: on an ACCEPTED root (run TERMINAL) and on a
  CANCELLED root the same call is retained as a LATE event (`late_event_retained`): no
  ReducerError, no outcome rewrite, node and outcome unchanged, history grows by one; called twice
  in a row the second call deduplicates (history grows by 0 — the node-wide
  `infeasible-{node_id}` key shared with `evaluate_repeated_failure`'s own infeasible emission is
  benign, a node can reach INFEASIBLE once). The check belongs inside the surface: a mechanical
  precondition is available (`state.failure_fingerprints[node_id]` non-empty — the same state the
  settle paths build their stamp on). The trusted-caller risk is the PILOT-R10 family in kind, but
  this is an ordinary public emitter beside `record_failure`/`cancel_run`, not a capability path,
  so it is P2 not P1; the run-entry callers themselves do observe a real refusal before calling.
  FIXED: no regression test — the finding is carried for the next brief; its named reproducer is
  committed red by this review at
  `tests/test_phase5_run_entry_fixes_2_review.py::test_review_f27_mark_infeasible_requires_no_failure_history`
  (assertion red: "F27: mark_infeasible admitted a terminal decision for a lineage with zero
  recorded failures … assert 'INFEASIBLE' != 'INFEASIBLE'").
  F28 | SEVERITY: P2 | ORIGIN: DOCUMENT | STATE: carried
  `docs/run-entry.md`'s Commands section shows the bare `scripts/orchestrate.py …` forms, but the
  delivered script is mode 100644 with only a shebang (`#!/usr/bin/env python3` present, no
  executable bit — `git ls-tree` reports 100644 already at REV, so this is not a work-commit
  regression). Measured literally on this host: `scripts/orchestrate.py --help` → PermissionError
  (Errno 13, cannot exec); `python3 scripts/orchestrate.py --help` → exit 0 (system python3 3.13.5
  with PyYAML 6.0.2 present). The doc names neither the executable-bit (or `python3` prefix)
  requirement nor the system-interpreter prerequisite (its `python3` must resolve `yaml` for the
  documented form to start). This is the J-class row of F24's own carried note ("the shape today
  depends on the host's system python3 having yaml") transplanted onto the doc's Commands section,
  which F24's fix left unchanged. Next brief: either set the bit (`git add --chmod=+x` — shebang
  already present) and name the `python3`-must-have-`yaml` prerequisite in the Commands section, or
  rewrite that section's command heads as `python3 scripts/orchestrate.py …`.
  FIXED: no regression test — the finding is carried for the next brief; its named reproducer is
  committed red by this review at
  `tests/test_phase5_run_entry_fixes_2_review.py::test_review_f28_documented_bare_command_is_executable`
  (assertion red: "F28: docs/run-entry.md's Commands section documents `scripts/orchestrate.py
  start/inspect/stop` as runnable bare forms …").

SHAPES: The suite now pins the three settle classes, the settle-claim interleave orders, and the
  import spellings as assertions; what the suite still does not build and this review probed or
  walked by hand:
- The unguarded mark_infeasible surface under a synthetic caller (F27 above; the implementer's
  SHAPES does not name it — its inventory claims the same-instant race and the dynamic-import class
  only, honestly, but this shape is a real probed shape outside both).
- The `_bind_acceptance` route's node-machine semantics: whether the refusal ever walks the
  machine's VALIDATION_FAILED family. Measured: it never does, at either revision — the refusal
  fires at authorise_acceptance's result-bound precondition (`_assert_result_bound`) because the
  failing command's result was RESULT_REJECTED (attempt FAILED) before any `VALIDATION_STARTED`.
  The delivered chain (measured): RESULT_REJECTED → EVIDENCE_ADMITTED → FAILURE_RECORDED ×1 →
  NODE_MARKED_INFEASIBLE (end state INFEASIBLE, node READY → INFEASIBLE, no REPLAN_REQUESTED). At
  REV the same route stamped FAILURE_RECORDED ×2 and interpolated REPLAN_REQUESTED
  (REPEATED_FAILURE_WITHOUT_NEW_EVIDENCE) with the same end state. No consumer depends on the old
  shape: inspect displays the history, recovery short-circuits on the terminal outcome, fresh
  replay equals the cached projection (measured), the conformance suite passes, and the trial path
  cannot import run_entry (pinned).
- The settle's same-instant residual beyond the pinned orders: a second process's complete `stop`
  committed between the point-of-emission fresh read and the settle's own emissions. Walked as an
  executable pin committed green at FINAL
  (`test_review_settle_gap_adversarial_order_keeps_document_fresh`): the returned document still
  names the durable fresh outcome (CANCELLED), the attempt stays TIMED_OUT/FINALLY_SETTLED via the
  settle's unconditional first-move accounting settle, and the gap appends exactly the late
  node-level chain SHAPES names — FAILURE_RECORDED (`failure-{node}-1`) then NODE_MARKED_INFEASIBLE
  (`infeasible-{node}`) after the second process's NODE_CANCELLED; `_on_failure_recorded` even
  appends into the fresh fingerprint history (one honest overrun's fingerprint on the cancelled
  node — a real observation, retained, non-mutating for the machines). The implementer's SHAPES
  wording is honest against this measurement and sufficient. What the inter-process idempotency
  keys buy in that gap: event-level idempotency only — crash-retry and stale-cache re-fire
  deduplication (`settle-conservative-{attempt}`, `infeasible-{node_id}`, `failure-{node}-{n}`);
  they buy no cross-process serialisation of the decision (the triple fresh-read discipline, not
  the keys, keeps the document honest).
- The ProtocolViolation exit class leaves the attempt in non-terminal DISPATCHED with
  FINALLY_SETTLED accounting on the terminal run (measured in the exit gate below): no
  attempt-machine terminal event is emitted on this path (the timeout/cancellation classes drive
  the attempt machine to TIMED_OUT/CANCELLED). Cancellable afterwards, no liability (FINALLY
  settled); noted as a residue, not pinned by either revision's pins.

TRIPPED: PILOT-R1 PILOT-R10
PROPOSED ROWS: none — F27 is a new residual-code row for the ledger's open set (the unguarded
  terminal-decision surface) at the next brief's hand; F28 is the doc claim-jrow re-cut for the
  same brief; nothing else is unrowed.
METHOD FRICTION: none against the method or docs/templates/report.txt.
INHERITED:

  Nothing received is still open. The received INHERITED (the review brief's F17–F25 blocks) all
  closed with this step and were re-verified here: F17 fixed by the ACCEPTANCE re-cut in the brief
  commit 3375429 (its ACCEPTANCE lines name `.venv/bin/python -m pytest …`, measured green),
  F18/F19/F20/F23 fixed with red evidence re-measured at REV (answer 10 below), F21/F24 as the
  narrowed claims / the honest pin (answers 8 and 9), F22/F25 fixed-recorded in
  docs/research/phase5-run-entry-fixes-review.md (that file is committed and is where those
  findings live). The received carried finding is:

  F26 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
  A later committed brief has not yet corrected the fixes-2 brief's GOAL: at this commit the only
  later commits are the implementer report (6175335) and this review's brief (49ae622), and neither
  corrects the named dotted-import row. Carried verbatim from the implementer report:
  "F26 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried — the brief names
  `import orchestrator.experiment.trial_driver` as a dotted-import row "red at the delivered
  helper", but that leaf is already forbidden, so the row is green; the reading taken is the
  brief's own red form `import orchestrator.experiment_spec.sub`. A later committed brief should
  correct the named row."
  This review adds two carried findings (F27 above, F28), because after examining the settled code
  both defects are real and are the next brief's work.

=== ANSWERS TO THE QUESTIONS TO ATTACK ===

Q1 — F26 grounded and mechanical (scratch copy of the pristine REV helper
`_module_leaf` + REV `_FORBIDDEN_MODULES` = {experiment, experiment_spec, experiment_phases,
trial_driver, smoke_run}):
- `import orchestrator.experiment.trial_driver` (the GOAL's named row): the REV leaf-only helper
  flags it (leaf `trial_driver` in the set) — mechanically `REV-helper flags=True` — so the new pin
  row asserting "the pin flags this" is GREEN at the delivered helper. It cannot be red evidence
  and cannot demonstrate the fix. The brief's GOAL is wrong exactly as F26 says.
- `import orchestrator.experiment_spec.sub` (the brief's INHERITED-F23 prose form): the REV helper
  does NOT flag it (leaf `sub` is not forbidden; the forbidden module `experiment_spec` is an
  interior segment) — mechanically `REV-helper flags=False`, reproduced as the exact raise
  `AssertionError: the pin misses the 'dotted-import' spelling: ['sub']`; the delivered
  `_module_segments` flags it (segments {orchestrator, experiment_spec, sub}). This is the only
  reading consistent with the brief's red-evidence requirement ("red at the delivered helper") and
  its own red-form prose — the single consistent one.
- Close form: F26's `ORIGIN: BRIEF` + `FIXED: no regression test — a later committed brief should
  correct the named row` is the right rule-8 shape, and at this commit no later committed brief has
  corrected the GOAL text (6175335 is the report; 49ae622 is this review's brief), so carrying
  F26 in INHERITED is correct.

Q2 — `Controller.mark_infeasible`'s surface attacks (probe script against the delivered code;
full measurements in F27):
- Zero recorded failures (a READY, never-dispatched root): the guard is evaluated nowhere; the
  event is admitted, the node reaches INFEASIBLE and the run's outcome is rewritten to INFEASIBLE
  (fresh replay agrees). A public surface that admits a terminal decision with the guard only in
  prose is NOT the right shape for the catalogue's emitter — the policy check belongs inside (a
  ≥1-recorded-failure precondition on the lineage). FINDING F27.
- ACCEPTED node: retained late (no ReducerError, no outcome rewrite — node stays ACCEPTED,
  outcome ACCEPTANCE_CLAIMED, history +1, fresh replay unchanged).
- CANCELLED node (cancelled while live): retained late identically (outcome stays CANCELLED).
- Twice in a row: the second call deduplicates against the same node-wide
  `infeasible-{node_id}` key (history grows by 0). The key's sharing with
  `evaluate_repeated_failure`'s emission is benign (a node is admitted infeasible once).

Q3 — `_bind_acceptance`'s refusal route semantics (chain shapes printed for both revisions; the
grounding runs in the Q3 probe and the SCRATCH replay):
- The VALIDATION_FAILED family is not "now bypassed": it never walked this route at either
  revision. The refusal is the result-bound precondition (the failing command's own RESULT_REJECTED
  / attempt-FAILED is recorded first), `authorise_acceptance` raises `AcceptanceRefused` before
  any `VALIDATION_STARTED`, and the node reaches INFEASIBLE from READY through the legal
  `NODE_MARKED_INFEASIBLE` transition (`any_non_terminal`).
- Is a normal visible-validation failure "deterministic infeasibility"? Under the operator run's
  own frozen contract (`retry_prohibited: true` — "a failing command is a recorded refusal, never
  a retry loop", run_entry.py:326-328) no material repair exists inside the run, so the
  deterministic terminal is INFEASIBLE; the observed failure is stamped exactly once and the
  terminal decision rides the catalogue's documented emitter (event-catalogue.md:30). The
  alternative machine reading (VALIDATION_FAILED → REPLAN_REQUIRED) is skipped only because the
  refusal never enters the validation machine at all — the machine's own recorded step for the
  failing command is RESULT_REJECTED, which this route honours.
- Consumers of the old chain shape: none (inspect projects history display-only; recovery
  short-circuits on the terminal outcome; fresh replay is deterministic and equals the cache;
  the milestone-2 conformance suite passes 41/41; the trial path cannot import run_entry — pinned).
- The "no `REPLAN_REQUESTED` of reason `REPEATED_FAILURE_WITHOUT_NEW_EVIDENCE`" claim is pinned on
  BOTH routes: the bind pin's lines 299-304 and the wall-clock pin's lines 588-593 of the delivered
  tests file exist and run green at FINAL.

Q4 — the interleave pins' red/green reproduction and the adversarial walk:
- At the REV scratch (delivered FINAL tests running against REV code): the stale-order pin goes
  RED at `tests/test_run_entry.py:762` with
  `AssertionError: assert 'INFEASIBLE' == 'CANCELLED'` — exactly the report's named failing
  assertion and line (the launch returned the launcher's own stale in-memory projection after the
  late node-level chain mutated it); the fresh-order pin goes RED with
  `AssertionError: assert 'PROVISIONALLY_SETTLED' == 'FINALLY_SETTLED'`; the accounting had been
  moved to PROVISIONALLY_SETTLED by the timeout machinery's
  `ATTEMPT_EXECUTION_ENDED_UNRECONCILED` (accounting-lifecycle.yaml: OPEN → PROVISIONALLY_SETTLED)
  and the REV settle skipped `_settle_if_open` when the fresh read saw a terminal outcome.
- Both pins and the double-stop variant are GREEN at FINAL (the battery's 37, and the six named
  pins re-run individually — 11 passed).
- The double-stop variant built green at BOTH revisions, as the report's VERIFIED claims (REV
  scratch run + FINAL run, measured).
- The stale-order monkeypatch faithfully drives the same order the prior review drove: the second
  process's complete `stop` after the decision read — at REV that lands between the single read and
  the settle steps (the prior review's exact order); at FINAL between the decision read and the
  point-of-emission read (the pin's docstring states precisely this).
- The adversarial same-instant order (stop committed between the point-of-emission read and the
  emissions — the gap SHAPES names) walked with a dedicated instrumented run: durable end state
  from fresh replay = run CANCELLED, root CANCELLED, attempt TIMED_OUT + FINALLY_SETTLED; the log
  holds the late node-level chain [FAILURE_RECORDED, NODE_MARKED_INFEASIBLE] after NODE_CANCELLED;
  the returned document names CANCELLED (durable fresh). SHAPES' naming ("a stop committed in that
  sub-step gap can still append a late node-level chain, because there is no cross-process lock")
  is honest and sufficient against what I measured, and the equal-or-better property (document =
  fresh, accounting settled) held in the same walk. The keys' purchase is dedupe only (FINDINGS
  SHAPES bullet 3).
- The settle path re-reads 3× in the settle phase (decision, point of emission, post-admission —
  traced and pinned in the committed gap walk via the settle-phase read signature).

Q5 — red evidence at REV, all reproduced (REV scratch = archived REV src + the delivered tests,
src diff-verified; every case is a failing ASSERTION, none an error):
- F18 wall-clock: RED at `tests/test_run_entry.py:585` — `AssertionError: assert 2 == 1`
  (`assert len(fingerprints) == 1`), the forged byte-identical pair printed in the failure
  (`sha256:e6b323caed4edce823d6764a1fad8137fc50fb02f4f85be48e0a43cc54a2f3d8` twice). Line and
  message match the report exactly.
- F18 bind: RED at `:298` — `AssertionError: assert 2 == 1`
  (`assert types.count("FAILURE_RECORDED") == 1`) — exactly as named (the earlier assertions in
  the pin — no `ACCEPTANCE_AUTHORISED`, no `VALIDATION_PASSED` — pass at REV, so the first failing
  line is the count, as the report says).
- F19: RED — `ProtocolViolation` escapes `start_run` and the pin's named
  `raise AssertionError("start_run escaped with ProtocolViolation instead of settling the run
  through the recorded-refusal path")` fires; pytest frames the raise statement at `:632`, the
  report names `:633` (the message line inside the statement).
- F20 stale: RED at `:762` — `assert 'INFEASIBLE' == 'CANCELLED'` — exactly as named.
- F20 fresh: RED — `assert 'PROVISIONALLY_SETTLED' == 'FINALLY_SETTLED'` — pytest frames the
  multi-line assert at `:804`; the report names `:806` (the comparand line inside the statement).
- F23: RED at the delivered REV leaf-only helper (scratch probe with the pristine helper):
  `AssertionError: the pin misses the 'dotted-import' spelling: ['sub']` — exactly the report's
  named failing assertion and message.
- All six are failing assertions (no errors, no collection failures) and all are green at FINAL.
- Line-number residue under F22's lesson: every citation names the delivered file's failing
  assertion and a replay following any number lands on it; two multi-line statements are cited by
  their interior line (633 in the 632-635 raise; 806 in the 804-807 assert) rather than the
  statement's first line (632/804). Content and target are right in both cases — noted, no
  finding.
- Close forms: F17 (ORIGIN: BRIEF → fixed by this step's brief commit 3375429 re-cutting the
  ACCEPTANCE to `.venv/bin/python -m pytest …`) is the right rule-8 form and the re-cut is
  measured green; F21 and F24 (no regression test + green drift guards) are the right forms and
  both drift guards measure green at REV scratch and FINAL (the F21 freeze-boundary drift pin ran
  in the REV scratch batch — 3 passed; the F24 clean-env pin too); F22 and F25 (fixed: recorded in
  docs/research/phase5-run-entry-fixes-review.md) — that file is committed and holds them.

Q6 — F21's narrowed wording against measured behaviour (both classes + one loader-refusable class
driven through the CLI by hand, the store file opened on disk rather than trusting the pin):
- Loader-refusable (empty `budgets`): exit 1, `orchestrator.run_entry.RunSpecError: budgets must be
  a non-empty mapping is invalid: {}` named in the stderr traceback, store file ABSENT, zero
  events (none could exist — no store was opened). Matches "refused … before any store is opened
  or any event is admitted" exactly.
- Freezing-domain classes through EventStore-in-CLI: DECLARED divergence (fully valid obligation
  schema with mandatory acceptance + `non_derivable_axes`/`non_derivable_reason`): exit 1,
  RunSpecError "cannot freeze target 'TARGET-RUN-Q6-DIV': declared obligations … not admissible:
  measur[ed divergence …]", store file CREATED, ZERO events (empty history, root_node_id None).
  Unfreezable repository (nonexistent path): exit 1, RunSpecError "cannot freeze target …
  does not exist", store file CREATED, ZERO events.
- Both doc sentences state EXACTLY the measured behaviour (docs/run-entry.md:12-15 and
  run_entry.py:7-12's module docstring): loader-refusable → before any store is opened; freeze-
  boundary → zero events but the store file may already have been created. Nothing in the measured
  classes contradicts either sentence; the narrowing is faithful (the loader classes admit zero
  events AND no file; the freeze classes admit zero events WITH the file created). The one
  unmatched cosmetic: the CLI surfaces the refusal as an uncaught traceback (exit 1, RunSpecError
  named) rather than a JSON document — exit 1 holds as documented; the doc's "named RunSpecError"
  wording holds.

Q7 — F24's `_documented_interpreter` (a yaml-less `python3` stub driven first on PATH in a FINAL
scratch; the pin then run under that PATH; a scratch CLI mutant used to force a real assertion
failure):
- Fallback branch: with a `python3` that cannot import `yaml`, `_documented_interpreter()` returns
  `sys.executable` (the venv interpreter) — the fallback drives and the pin STAYS GREEN silently.
- Does the failure output name which interpreter ran? No assertion or message names or labels it;
  on a genuine failure the acting interpreter appears only incidentally inside pytest's
  `where 1 = CompletedProcess(args=[<interpreter>, …])` print (measured against a scratch mutant
  that broke the CLI's output). The docstring is the record of the substitution — exactly the form
  the brief's remedy prescribed ("naming the choice in its docstring"), delivered verbatim. An
  output labelling is not demanded by the remedy at any revision; the residual host dependency is
  F28's finding now anchored on the doc's Commands section.
- Row J on the doc: measured literally. `python3 scripts/orchestrate.py --help` → exit 0
  (usage printed); the bare `scripts/orchestrate.py --help` → PermissionError — the shebang is
  true but the executable bit is absent (mode 100644 at both REV and FINAL). FINDING F28 covers
  the claim gap.

Q8 — the import pin spelling matrix at FINAL + the mutant + spellings beyond the five:
- FINAL: all five rows green (the parametrised `test_import_spelling_shape` inside the battery's
  37 and re-run alone); `test_no_harness_import_shape` re-walks `run_entry` and `orchestrate` with
  `_module_segments` and stays green; the dynamic-import class (`__import__`,
  `importlib.import_module`) is named in `_module_segments`' docstring (delivered
  tests/test_run_entry.py:429-433) rather than silently claimed.
- Mutant (leaf collapse — scratch diffed against `git show b98310d:tests/test_run_entry.py`: the
  ONLY delta is the helper body + docstring): exactly the `dotted-import` row goes RED
  (`AssertionError: the pin misses the 'dotted-import' spelling: ['sub']`,
  `assert ({'sub'} & {…})`), the other four rows stay green, and `test_no_harness_import_shape`
  stays green — no other row's behaviour changes.
- Spellings beyond the five, measured against the delivered helper: `from .. import experiment` —
  collected name `..experiment`, segments {'experiment'} → FLAGGED; and
  `import orchestrator.experiment_spec.sub.sub2` — segments include `experiment_spec` → FLAGGED.
  Both deeper/star spellings land flagged.

Q9 — regressions (every command re-run in this review, counts against the report):
- check-tests --fast 961/82 ✓; test_run_entry 37 = 31+1+5 ✓; milestone2 conformance 41 ✓ (the
  settle's new emission is the existing `NODE_MARKED_INFEASIBLE` any_non_terminal→INFEASIBLE
  transition — no conformance entry owed); phase3 project oracle 5 ✓; check-static 0 ✓; check-docs
  0 (346 links/0 errors at the pristine FINAL scratch; the report's count matches) ✓; check-scope
  re-run "scope: ok (5 path(s))", "tripped: PILOT-R1 PILOT-R10" ✓.
- The residual rows' constraints hold: PILOT-R1 ("the brief's path never admits a decomposition")
  — the run-entry paths admit none (the exit-gate histories contain no DECOMPOSITION_* event), so
  no admitted payload exists to mutate; PILOT-R10 is not claimed closed by the report (its column
  says exactly that) and this review did not close it: the in-process admission capability is
  still canonical for in-process callers, and F27 is a new sibling risk in the same trusted-caller
  family, now with its own emitter clause.

Q10 — the Phase 5 exit gate as a whole (five classes, subprocesses against a real repository;
`inspect` re-read from a separate subprocess; fresh projection compared):
1. Accepting run: exit 0, JSON `accepted: true`, outcome ACCEPTANCE_CLAIMED, no traceback;
   inspect exit 0, outcome ACCEPTANCE_CLAIMED, fresh == document.
2. Failing-command refusal: exit 1, JSON `accepted: false`, outcome INFEASIBLE, no traceback;
   fresh == document (INFEASIBLE).
3. Wall-clock timed out: exit 1, INFEASIBLE, no traceback; fresh == document (INFEASIBLE).
4. Mid-run cancelled (second process's documented `stop` against a live launcher): stop exit 0,
   outcome CANCELLED; launcher exits 1 with JSON `accepted: false`, outcome CANCELLED, no
   traceback; fresh == document (CANCELLED).
5. Injected ProtocolViolation (scratch copy with `worktree.py:328`'s `bundle create … HEAD`
   mutated to a nonexistent ref — the F19 injection family): exit 1, INFEASIBLE, no traceback;
   fresh replay: outcome INFEASIBLE, root node INFEASIBLE, attempt accounting FINALLY_SETTLED;
   fresh == document.
- All five settle to terminal outcomes with the documented JSON and exit codes, never a traceback
  with a live run, and the document's outcome is always the durable fresh one. The one measured
  residue is the DISPATCHED-attempt note in SHAPES above (no attempt-machine terminal on the PV
  path) — it changes nothing in the gate's demanded properties.

Q11 — report hygiene:
 Counts: every number re-measured equal (see VERIFIED). SHAPES: a positive, honest inventory
 (the same-instant race + the dynamic-import class) — the implementer's unprobed shapes (the
 unguarded mark_infeasible surface, the bind route's validation-machine semantics) are not CLAIMED
 probed anywhere in the report, and my report names them (SHAPES bullets 1-2); the walked
 same-instant residual is measured and committed as a green pin. INHERITED: the implementer's
 statement ("nothing received is still open … adds one carried finding") is correct: F17 moved
 fixed via the brief's rule-8 commit, F18-F23/F25 moved fixed with their red evidence re-measured
 at REV, and F26 stays carried with the wide row the next brief must correct. FINAL names b98310d
 (the work commit), not 6175335 (the report commit). The trailer `Actor: IMPLEMENTER` is on both
 step commits. Two hygiene residues were found but nothing false: the F19/F20-fresh citations
 name interior statement lines (recorded, no finding), and the report's check-docs count (346)
 drifts +2 against this working tree purely because the two research files committed after FINAL
 add links (re-verified in the pristine scratch — no defect).

--- when CLOSE OUT is yes, the PLANNER appends this to the step's LAST report only, copying and
    adding no judgement: ---
CLOSEOUT
DECLINED: none
DIVERGENCES CLOSED: none
