REPORT — phase5-run-entry-fixes-4-review
STEP: phase5-run-entry-fixes-4 (Phase 5: the cancel-race disposal — F29–F32)
REV: 5711e48a57dcd9df9184083009be720bd20cd7bf   FINAL: 7f4381ad7f3a410f27831c02680f3daa1f9e1bcf
CHANGED:
  This report (docs/research/phase5-run-entry-fixes-4-review.md) and the review's committed probes
  tests/test_phase5_run_entry_fixes_4_review.py (five slow-marked probes: F34's named reproducer —
  RED at FINAL, the next step's pre-image per the report.txt convention — plus four green probes
  pinning the attacked faces: F33's four-follow-on breadth, the owner-payload branch's admission
  inaccessibility, the F33 residual, and F30's settle-twice count-exact drive). Scratch copies of
  REV/FINAL (git archive, src diff-verified before use) and every mutant lived under /tmp/kilo and
  are not in the tree.
REVIEW ACCEPTANCE: scripts/check-scope 5711e48a57dcd9df9184083009be720bd20cd7bf
  7f4381ad7f3a410f27831c02680f3daa1f9e1bcf docs/research/phase5-run-entry-fixes-4-brief.md →
  scope ok, tripped: PILOT-R1.

DECISION: F29–F32 verify fixed — every claim, red, and pin attacked in the answers below holds;
  F33's reading is the one conforming reading and its residual is disclosed and now pinned. ONE
  P2 remains (F34, ORIGIN: CODE, carried): the loader's documented fail-closed refusal does not
  hold for a YAML-unparseable spec file, driven through the documented CLI head with a
  reproducer, unpinned before this review, pre-existing since the run entry point's origin — so
  the loop's exit condition ("no P1 or P2 finding remains") does NOT hold and the fixes-4 step
  does not close out yet. The next step's brief absorbs the committed red probe green (an
  `except yaml.YAMLError` widening in `load_run_spec` + the doc's sentence then true as
  written) and closes out.

FINDINGS:

  F34 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  The run-entry loader's documented fail-closed face does not hold for a spec file the YAML
  decoder itself cannot parse. docs/run-entry.md (:12, the sentence this step's F21 narrowed):
  "a loader-refusable malformed spec is refused as a named `RunSpecError` before any store is
  opened or any event is admitted"; run_entry's module docstring (:7-9) and the
  `RunSpecError` docstring (:53-55, "the operator sees one named failure, never a run-time
  surprise") repeat it. `load_run_spec` (src/orchestrator/run_entry.py:265-272) catches only
  OSError, so `yaml.safe_load`'s errors escape raw. Measured through the documented CLI head on
  the delivered code: `python3 scripts/orchestrate.py start --spec BAD.yaml …` (BAD.yaml =
  "run_id: [unclosed\n  - oops\n") → exit 1, `yaml.parser.ParserError` traceback on stderr, NO
  JSON document, store file ABSENT, zero events. Zero events and no store hold — the half F21's
  narrowing claimed and measured — but the refusal is not "as a named
  `RunSpecError`". No committed pin drives `load_run_spec` at all (tests/test_run_entry.py and
  tests/test_phase5_run_entry_fixes_2_review.py reference validate_run_spec/freeze_target only;
  the clean-env pin feeds the CLI a VALID spec), so the file-level loader face — read, decode,
  OSError-refusal, decode-refusal — is unpinned. Pre-existing at the run entry point's own origin
  commit (dae836f, `except OSError` unchanged there and at REV), NOT a regression of this step.
  FIXED: none — carried. The next step's brief absorbs the committed red probe
  (tests/test_phase5_run_entry_fixes_4_review.py::test_review_f34_unparseable_spec_file_refused_as_a_named_run_spec_error)
  green: widen `load_run_spec`'s except to catch the YAML decode errors and wrap them as
  `RunSpecError` (the doc's sentence then holds as written, nothing to reword), keeping the
  OSError refusal as-is.

  Recorded disposition, not a finding (the review brief's question 1b asks for exactly this):
  F33's fail-closed clause — the brief's "a genuinely unknown `artefact_id` (never admitted
  anywhere in the log) still fails closed" — is TRUE in the reading's own sense (an id no
  terminal attempt owns; pinned by the delivered pin's unknown-id assertion and mutant-bound by
  this review) and FALSE in its literal parenthetical (a crafted `{terminal_attempt}-artefact`
  id with NO prior ARTEFACT_ADMITTED anywhere in the log is retained, pinned green by
  test_review_f33_residual_crafted_terminal_artefact_retained). The implementer's F33 filed,
  disclosed, and named this residual before this review (its FIXED and SHAPES); re-filing it
  would double-count F33's own content. NOTE FOR THE NEXT STEP'S PLANNER: the clause's literal
  form is unsatisfiable by any reading consistent with IN SCOPE (a pure `reduce(state, event)`
  cannot measure "never admitted anywhere" because retention writes no state record), so the
  clause's parenthetical should be corrected in the next committed brief (the record.md#observations
  close-form lesson: the close form follows where the text lives) — with it, the residual stops
  being a clause-reading question and becomes the recorded boundary this review pinned.

SHAPES: the delivered report's two named shapes verified real, disclosed, and not hidden (both
  probed here): the `_bind_acceptance` TOCTOU window (walked one order — below) and the F33
  residual (pinned). Shapes probed by this review that the suite does not build and no
  committed claim names:
- The launcher's in-memory cache diverges from the durable log inside the two-connection window:
  `store.admit` reduces every event against the connection's cached projection
  (src/orchestrator/store.py:214, `self._states.setdefault…`), and nothing resyncs a live
  connection's `_states` from disk once a second process has written. Inside the TOCTOU window
  the launcher's ARTEFACT_ADMITTED creates the candidate IN ITS CACHE while the durable log
  retains it (Exec F2's guard); the divergence persists until the process exits; every committed
  claim keys the RESULT document on `replay_fresh` (run_entry.py:597 and the settle-claim pins),
  so no committed assertion depends on cache freshness — measured, and worth its own lesson if a
  future surface ever reads `store.state` for a decision read (F20's discipline is exactly this).
- K3's coverage note: the two `evaluate_repeated_failure` emit sites of `NODE_MARKED_INFEASIBLE`
  (controller.py:2040, :2055) share the `infeasible-{node_id}` key with
  `mark_infeasible` (:2092); renaming ONLY the first two (the review brief's "all three emit
  sites" minus mark_infeasible's own) leaves the four F30 pins AND conformance 41 green — nothing
  committed binds the cross-route key identity. Harmless in effect (both routes carry the same
  terminal transition, so a double emission dedupes into one retained event), and the F30 shape
  claims `mark_infeasible`'s own facets (bound: the dedup facet reds under the per-emission-unique
  key mutant), so not a finding — a recorded coverage note.
- The stop-after-observation drive (`test_cancel_race_shape_stop_after_observation`) drives its
  stop through `run_entry.stop_run` on a second store connection (the documented stop WORKFLOW,
  not the documented `stop` CLI form), so it pins only the launcher's document; the stop
  process's exit code and JSON are pinned by `test_cancel_race_class_shape`. Together the two
  pins cover the brief's named drives; noted so no later reader expects the observation drive to
  carry the second process's CLI surfaces too.

METHOD FRICTION: none — the step and its report follow the report.txt form verbatim (the F33
  entry is ORIGIN: BRIEF, correctly NOT friction; every other entry names none).

INHERITED:

  Nothing received is still open. The received INHERITED (the fixes-3 report's: "none — every
  received INHERITED item F26/F27/F28 is fixed by that step; F29–F32 moved into this brief's
  body; nothing is carried") is consistent with what this review verified: F29–F32 are this
  step's brief-body items and are disposed here (their red evidence re-measured at this review's
  REV scratch, answers 3 and 7). Carried by THIS review: F34 (above), the pre-image for the next
  step's absorb. The F33 clause correction is a planner pointer, not a carried defect (F33's own
  residual, recorded in the disposition note above).

ATTACK ANSWERS:

Q1 — F33's reading, mechanism, and close form (scratch archive at REV diff-verified first):
- (a) The payload branch is dead through every store-validated surface; the suffix derivation is
  the only live face. The five artefact follow-on EventSpecs carry no `attempt_id` in required or
  optional fields (events.py: ARTEFACT_INTEGRATED (artefact_id, merge_info), PUBLISHED
  (artefact_id, publisher), REJECTED (artefact_id, reason), SUPERSEDED (artefact_id,
  replacement_artefact_id), VALIDATED (artefact_id, validator)), and `validate_event` rejects any
  field outside required|optional ("unexpected payload field", events.py:635) — driven:
  `store.admit` of an ARTEFACT_INTEGRATED payload carrying `attempt_id` → AdmissionError
  (committed probe ✓ green). `store.admit`, `_replay_all`, and `replay_fresh` ALL call
  `validate_event`, so no persisted event can carry the branch's input. Mint audit across
  src/scripts/tests: the only live mint feeding a follow-on is controller.py:1628
  `f"{attempt_id}-artefact"` (conformance.py:982 same shape); the conformance corpus's
  run-scoped ids (`f"{run_id}-artefact-{index}"`, lines 810/847) never end in the suffix and
  their own ADMISSIONS precede their follow-ons in the same run, so the retention branch is
  never consulted; no mismatched-`attempt_id` false retention exists (probe (ii)/(iii)). Dead
  branch, deliberate and harmless: reachable only by direct `reducer.reduce` calls.
- (b) Injection: `EventStore.admit` is a public API and accepts any schema-VALID payload —
  {"artefact_id": f"{terminal_attempt}-artefact", "merge_info": {}} passes `validate_event` —
  but no documented operator surface emits events (the CLI exposes start/inspect/stop only;
  the controller derives every id deterministically), so the crafted-id retention is reachable
  only by an experimenter or test code, exactly the residual F33 named. Clause verdict: TRUE in
  the brief's own sense ("an id no terminal attempt owns" — the delivered pin asserts it;
  always-retain mutant reds it), FALSE in the literal parenthetical sense — the shift is real,
  was DISCLOSED by F33 before this review, and is pinned by the residual probe. Recorded
  disposition above; no new finding.
- (c) Forced, yes — and the missing mechanism IS the brief's own defect, which F33 correctly
  files ORIGIN: BRIEF: `reduce(state, event)` sees no log; the state carrier would live in
  `model.py` (OUT OF SCOPE; a tombstone field addition) or `store.py`'s replay loop (OUT OF
  SCOPE; the log-reading face — the exclusion's real cause, as the review brief suspects).
  Abusing in-scope state (`state.artefacts` tombstones) contradicts the "retained, never
  created" guard and the delivered pin's `artefact_id not in fresh.artefacts` assertion, so
  the id-shape-plus-attempts lookup is the ONLY signal a conforming reading can use — F33's
  recorded reading is the one conforming choice.
- (d) Close form: honest — with the imprecision recorded in the disposition note. The rule
  ("a later committed brief corrects the text") governs a finding whose fix is the text's
  change; F33 asserted no text fix is owed because the reading is the brief's own requirement —
  which this review verifies for the shape's operative sentence. Where the rule DOES bite is the
  residual clause's literal parenthetical: recorded for the next committed brief rather than as
  a new finding (F33 already owns it, disclosed before this review).

Q2 — the stale-admission pair's every face:
- Red reproduced first, in the report's exact scratch form: REV archive (reducer.py and
  tests/test_run_entry.py diff-verified against `git show 5711e48:…`), the delivered test files
  overlaid → `.venv/bin/python -m pytest tests/test_run_entry.py -q -k "cancel_race or
  stale_admission"` → 3 failed, 37 deselected in 7.76s, at exactly the named lines (answer 3d).
  The two candles in the dark both real: the class shape red (launcher exit 0 under a cancelled
  run) and the observation drive red (accepted True pre-fix).
- (a) Verified deeper than the no-assert: the delivered pin asserts `artefact_id not in
  fresh.artefacts` (tests/test_run_entry.py:1213) — the candidate never EXISTS in replay state,
  so it can never advance to INTEGRATED/VALIDATED/PUBLISHED; the committed breadth probe shows
  every follow-on event type yields `late_event_retained` with the artefact still absent.
- (b) NO breadth gap exists: ALL five artefact follow-on event types route through
  `_on_artefact_integrated` (reducer.py:1207-1212's dispatch table — no other handler admits an
  artefact-machine event), so the retention branch covers validated/rejected/superseded/published
  too. Driven (committed probe, all four types → retained, artefact absent). The CONTEXT's
  breadth claim is any-artefact-follow-on and it is TRUE; claim-narrowing is not needed.
- (c) Both mutants run on separate FINAL scratch copies (each diff-verified: only
  src/orchestrator/reducer.py changed):
  always-retain (`return True` as the body's first statement, :919) → the unknown-id fail-closed
  assertion red: `Failed: DID NOT RAISE ReducerError` inside the pin's pytest.raises block
  (:1226); never-retain (`return False` there) → `test_stale_admission_race_log_replays` red via the
  :1211 translation (`Failed: F29: the durable race log did not replay: ReducerError(...)`).
  Under both mutants the committed probes red in the matching direction (breadth probe reds only
  under never-retain; the payload probe reds under both), so both levers are pinned.
- (d) Live face: the two-connection ARTEFACT_ADMITTED replay face retains (the Exec F2 guard,
  :884-892) — driven by the fixture's own new-connection replay. On the ADMIT face the event
  reduces against the connection's CACHED projection (store.py:214), which never resyncs
  after another process writes, so inside the TOCTOU window the live cache CREATES where the
  durable log retains — "the cached projection end equals replay_fresh" is FALSE for that
  window; no committed claim asserts cache equality (the document contract keys on
  `replay_fresh`), and the divergence cannot change the durable outcome. Recorded in SHAPES.

Q3 — the class pin and document == durable fresh outcome:
- (a) Every guarantee sentence asserted inside the pin: JSON accepted false + outcome CANCELLED
  (:1078-1079), launcher exit non-zero (:1064), no Traceback in EITHER process's stderr
  (:1065/1074 + :1066), the stop's documented-form exit 0 (:1069-1070), the inspect head clean
  (rc 0, no Traceback, :1071-1077), and inspect's outcome equal to a brand-new connection's
  `replay_fresh` (:1077-1081). Re-verified by hand in this review's drive: a real repo, the
  documented three heads, empty stderrs everywhere, stop mid-run → the launcher dies exit 1
  with the CANCELLED document (see Q5/6 drives).
- (b) The TOCTOU order walked: the stop landing between `_bind_acceptance`'s re-read
  (run_entry.py:447) and `authorise_acceptance` (committed probe). The durable log takes the
  chain's remainder AFTER the stop: REOPENING replays clean (no new ReducerError face), the late
  ACCEPTANCE_AUTHORISED binds only resolvable evidence (EVIDENCE_ADMITTED is admitted before the
  stop; `fresh.evidence` resolves the binding), the outcome stays CANCELLED, and the document
  keys the durable outcome (accepted false, CANCELLED). The `_cancel_attempt` claim verified
  directly at controller.py:617-622: a RESULT_PRODUCED attempt returns before any
  CANCELLATION_CONFIRMED, so the bindings' result record is untouched and the late pair
  resolves. The report's sentence measured true in both directions probed.
- (c) The observation drive binds only the launcher's document (it stops via a second
  connection through `run_entry.stop_run`, the documented WORKFLOW, not the CLI form); the
  stop process's exit code and JSON are bound in the class drive. Noted in SHAPES; the two
  together cover the brief's named drives, so not a finding.
- (d) The line numbers land at FINAL: :1064 `assert launcher.returncode != 0, (…F29…)` renders
  `assert 0 != 0`; :1111 `assert result.accepted is False` renders `assert True is False`;
  :1211 is `pytest.fail(f"F29: the durable race log did not replay: {error!r}")`. All three red
  at the review's REV scratch (measured), all three green at FINAL (the delivered battery).
  :1211's `pytest.fail` is NOT a raw assert — it is the deliberate translation of the
  reducer's ReducerError raise, the only honest failure shape for an unreachable read (the
  pin's own read raises; there is no later assert to fail), named and message-full, not a
  collection error or a crash; the report disclosed it as exactly that. Accepted as red with
  this review's verdict recorded here; the never-retain mutant red would use the same face.

Q4 — F30's pins and the guard mutant (each on its own FINAL scratch, diffs verified):
- Key mutant, the fixes-3 form (the shared key consistently renamed at ALL THREE sites —
  controller.py:2040, :2055, :2092): the four pins stay green — they bind the dedup/share
  INVARIANT, not the literal string; that is why the fixes-3 key mutant measured 40/40 and was
  the coverage evidence for F30.
- Key mutant, per-emission-unique at mark_infeasible's own site (uuid suffix): the DEDUP facet
  reds (`test_review_f30_duplicate_mark_infeasible_dedupes_the_shared_key` at :322, history +1)
  and this review's settled-lineage settle-twice probe reds with it. So the settle-once claim is
  enforced by the shared deterministic key's idempotency AND count assertions, and the dedup
  facet catches a key that stops being deterministic-per-logic-emission.
- Key mutant, cross-surface only (the first two sites minus mark_infeasible's): the four pins AND
  conformance stay green — recorded as a coverage note in SHAPES; the shape's claims are
  mark_infeasible's facets, and the cross-route unsharing's effect is a deduped no-op, so not a
  finding.
- Guard mutant (the F27 precondition forced to always pass): `DID NOT RAISE WorkflowError` on
  the zero-fingerprint pin's pytest.raises (:365-377) — red ✓. The refusal's shape is asserted
  as the SPECIFIC WorkflowError class plus node ACCEPTED, outcome ACCEPTANCE_CLAIMED, and
  history unchanged after the raises block (a ReducerError would not satisfy the raises clause;
  the pre-admission property is bound, not the prose).
- The settle-twice drive on the accepted lineage (committed probe): record_failure + two
  mark_infeasible calls → exactly ONE NODE_MARKED_INFEASIBLE in the history, +0 on the second
  call, node/outcome unchanged. The late-retention facet asserts retention, not merely
  non-raise: NODE_MARKED_INFEASIBLE present (:339+), node ACCEPTED, outcome CLAIMED — and the
  count-exact coverage this review's probe pins is exactly history +1 with no rewrite.

Q5 — claim hygiene:
- (a) The renamed id names the enforced property exactly (the `python3 scripts/orchestrate.py`
  heads, no bare head, the prose prerequisite, the form run); the old name
  (`test_review_f28_documented_bare_command_is_executable`) remains only in committed historical
  reports/briefs that correctly describe the old state; the module docstring reference is
  updated (tests/test_phase5_run_entry_fixes_2_review.py:12, the node at :175). No live stale
  reference.
- (b) All three mutants red the SAME assertion (:194): the json-name, the deletion, and the
  report-unnamed move-into-fence (the surrounding prose loses `yaml` entirely once the
  prerequisite sentence sits inside the block — the wall prose keeps only the interpreter/mode
  sentences, so the pin refuses vacuousness; NOT row-I's class). The pre-fix word-presence form
  measured True under all of them (the vacuous-truth class demonstrated: `("yaml" in section…,
  "python3" in section…)` → (True, True) for the fin doc and both mutants).
- (c) Row J: system python3 (/usr/bin/python3, 3.13.5) resolves yaml (6.0.2) — the prerequisite
  sentence TRUE on this host. Every documented head driven AS WRITTEN with full forms (system
  python3, repo-root cwd): start (accept scenario: exit 0, accepted true, empty stderr;
  cancel scenario: exit 1 with the CANCELLED document + the documented stop head mid-run exit 0
  with its JSON), inspect (both: exit 0, JSON, zero stderr) — no traceback anywhere; fresh
  equality matched every returned outcome (ACCEPTANCE_CLAIMED / CANCELLED).

Q6 — the Phase 5 exit gate as a whole (each class measured against a real frozen repository):
- ACCEPT: `start` exit 0, JSON accepted true / ACCEPTANCE_CLAIMED, zero stderr; `inspect` exit 0
  clean; document == replay_fresh.
- FAILING-COMMAND REFUSAL: `start` exit 1, JSON accepted false / INFEASIBLE, zero stderr;
  `inspect` clean; fresh == INFEASIBLE.
- WALL-CLOCK TIMEOUT: `start` exit 1, INFEASIBLE document, zero stderr; `inspect` clean;
  fresh == INFEASIBLE (the delivered shape + this review's subprocess drive).
- MID-RUN CANCEL: the delivered class drive (subprocess stop form mid-run, the launcher's
  document, the inspect head, the fresh connection) + this review's drive — exit codes, JSON,
  no traceback on either side, document == fresh == CANCELLED.
- INJECTED-PROTOCOLVIOLATION: the delivered pin (in-process — the only honest injection face
  for that class, since a real CommandExecutor violation is an executor defect); settled refusal,
  FINALLY_SETTLED, node INFEASIBLE, no escape.
- Every documented head run as written (answer 5c). VERDICT: all five classes
  attacked-and-not-falsified. The one falsified guarantee this review found (F34) is outside the
  five classes but on the same head's input face and inside the loop's guarantee set.

Q7 — regressions over the whole stream (every count re-measured at the delivered tree):
- check-tests --fast: 961 passed, 92 deselected (98.36s) — matches the report exactly.
- The two in-scope modules: 47 passed (tests/test_run_entry.py 40 = 37 at REV + 3 new;
  tests/test_phase5_run_entry_fixes_2_review.py 7 = 3 at REV + the 4 new F30 pins; 40+7=47, and
  the battery's deselected delta 85 → 92 is exactly the step's seven new slow-marked cases).
  Re-run including this review's committed probes: both modules green.
- test_milestone2_conformance.py: 41 passed. test_phase3_project_oracle.py(the report names the
  file explicitly): 5 passed (278.90s — the report's clock said 224.47s; duration, not a count).
- scripts/check-static: exit 0 with 104 advisory rows (Found 104 errors — the advisory-only
  enum) — matches.
- scripts/check-docs: 353/353 OK, 0 errors at the report's own tree (b87be69, tracked down via
  a symlinked-venv archive run because the count grows with every committed docs/research file —
  it reads 355/355 at the current HEAD after the review brief's links; no missing-link error at
  either tree).
- TRIPPED re-measured from check-scope's own line: PILOT-R1 (the acceptance line above).
- Held sets: the battery + the review modules (47) + the committed probes cover the load and
  refusal shapes, the F20 settle-claim interleave pins, the import matrix,
  test_clean_env_cli_shape (still executing the doc's form — `--help`, a real start, inspect,
  and a stop against the SETTLED run, never a rewrite), the F21 drift pin, and the absorbed
  F27/F28 pins. The --fast battery deselects all 92 slow nodes; of those, 47 were re-measured by
  the two-module line and 5 by the oracle, so 40 pre-existing slow nodes were NOT re-run at this
  step's FINAL until the full battery below (this review's standing privilege).

Q8 — report hygiene:
- Counts re-measured (answer 7): 961/92 ✓, 47 = 40+7 with each new case accounted ✓, 41 ✓,
  5 ✓, 104 ✓, 353/353 at the report's tree ✓.
- FINAL form: the short 7f4381a expands to 7f4381ad7f3a410f27831c02680f3daa1f9e1bcf — the WORK
  commit (the diff under review), never the report commit b87be69 ✓.
- Red-evidence honesty: :1064 and :1111 are real failing asserts (replayed at the scratch —
  `assert 0 != 0`, `assert True is False`); :1211's pytest.fail is the named deliberate failure
  translating the reducer's raise, disclosed by the report as such — not a crash, not an error
  outcome; accepted (answer 3d).
- SHAPES vs the brief's four shapes: the cancel-race class shape and the stale-admission replay
  shape are pinned by the delivered suite (the three new test_run_entry cases, plus the probes);
  the TOCTOU window and the F33 residual are the delivered report's SHAPES entries — named,
  not hidden, exactly as the brief's discipline requires — and this review's probes close the
  named-shape/untested gap for both (the stop-cache-divergence window walked in answer 3b; the
  residual pinned green in the committed probes file) ✓.
- INHERITED vs the received set and rule 8: the received set was "none; F29–F32 moved into the
  brief body" — consistent with the stream's record (the fixes-3 report's INHERITED and the
  brief carrying F29–F32 in its GOAL body); re-verified, nothing received open ✓.
- METHOD FRICTION: the template's field verified — nothing deviated; the one brief-questioning
  entry is F33 (ORIGIN: BRIEF, not friction) ✓.
- The full scripts/check-tests (the standing reviewer battery): the previously unre-run
  pre-existing slow nodes now measured at FINAL (1057 passed, 1 failed — exactly the committed
  F34 probe) — see the battery line below.

FULL BATTERY LINE (measured): scripts/check-tests → 1057 passed, 1 failed
  (test_phase5_run_entry_fixes_4_review.py::test_review_f34_unparseable_spec_file_refused_as_a_named_run_spec_error —
  the committed red probe, its Failed: message naming F34 exactly), 477.01s, no errors
  elsewhere: the full node set (fast 961 + slow 92 + this review's five probes) ran, and the 40
  pre-existing slow nodes --fast deselects (and the two-module/oracle lines do not cover) all
  pass at FINAL. The next step's REV absorbs the red probe green and re-measures the battery as
  1058 passed.

--- 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
