REVIEW BRIEF — phase5-run-entry-fixes-6 (Phase 5: the loader face forced whole — F36)
REV: 9bb1d14181e34325820e0dedd3f2d43be1bd317f
FINAL: 8d219057a58df927edef10f91c43a01de1d07342
REVIEW ACCEPTANCE: scripts/check-scope 9bb1d14181e34325820e0dedd3f2d43be1bd317f 8d219057a58df927edef10f91c43a01de1d07342 docs/research/phase5-run-entry-fixes-6-brief.md
FOCUS: the face's completeness — one question above all: does any class inside the documented claim still escape `load_run_spec` raw? — then the wrap's honesty and the "loader-refusable" boundary the whole-face forcing draws.
SEVERITY SCALE: P0 blocks the step; P1 is serious; P2 is minor.
QUESTIONS TO ATTACK:

none — no `FINDINGS` entry and no `METHOD FRICTION` entry questions the brief (F36 is fixed as the whole-face widen prescribes, and `METHOD FRICTION: none`). The claims are attacked below.

1. The face's completeness — the one question. Re-drive the fixes-5 review's full 19-class corpus at `load_run_spec` and through the documented `start` head, plus the parser-resource and host-resource classes it did not name: 2000-deep block nesting, over-deep indent, a huge alias-expanded (billion-laughs-shaped) document, an over-long single-line scalar, a 5MB scalar, a truncated multi-byte tail, a `MemoryError`-shaped input if this host permits one, and any class your own reading of `yaml.safe_load` + `validate_run_spec` suggests. Ask of each: does a class inside `docs/run-entry.md`'s claim ("a loader-refusable malformed spec is refused as a named `RunSpecError` before any store is opened or any event is admitted") still escape `load_run_spec` raw? File a finding per escaping class. Then the boundary: the work commit declares "Host-resource failures outside the loader's own failure surface (e.g. `MemoryError`) stay outside 'loader-refusable'" — is that declaration evidenced (which words of the sentence exclude the host's failures from the loader's claim), or is it a silent re-scoping of a universal sentence (the F21 narrow-claim class in [record.md](../record.md#observations))? If a `MemoryError`-shaped input escapes raw and the sentence covers it, the narrowing is a finding; if the sentence does not cover it, name the words that exclude it.

2. The wrap's honesty. For every class in question 1's corpus that is refused: the `__cause__` chain is the real cause (never `None` for a decode/parse face), the message names the path (`cannot parse run-spec {path!r}: …` / `cannot read run-spec {path!r}: …`), the refusal happens before any store is opened (the store file ABSENT, not merely zero events) and before any event is admitted, and the documented CLI heads show no raw traceback (`start` on each malformed class — the documented JSON and exit form of a refused load, matched against `docs/run-entry.md`'s Commands section; `inspect` and `stop` against a refused-load run id — clean refusal or another class?). The `OSError` family's refusal is byte-for-byte the old one: diff `src/orchestrator/run_entry.py` at `9bb1d14` against `8d21905` (the report claims one line changed — verify, and verify `validate_run_spec` and the module/docstring sentences untouched).

3. The absorbed probe and the pin set. The F36 probe red→green with no test edit (`git diff 9bb1d14 8d21905 -- tests/` empty): re-measure its red at `REV`'s scratch form (diff-verified against `git show 9bb1d14:…`) — `tests/test_phase5_run_entry_fixes_5_review.py:31`'s `pytest.fail` translation, `Failed: F36: … RecursionError('maximum recursion depth exceeded')` — and its green at `FINAL`. Then the tuple's mutants as the boundary's evidence: drop `RecursionError` from the tuple (does the F36 probe go red?), drop `UnicodeDecodeError` (does F37's pin go red?), revert the parse clause to `OSError`-only (do the F34 and F36 probes and F37's pin all go red?). Each mutant on a scratch copy, diff-verified before use. Is the pin set's boundary exactly the tuple's inventory (the brief's "current inventory, not a wish list") — or does some class inside the tuple have no pin (a `SHAPES` entry waiting to happen)?

4. The whole-face forcing's reading and the report's forms (J-class). Was the fix order read as the GOAL forces (the face, not one more enumerated class) — and is any class silently declared outside the claim without evidence (question 1)? `FINAL`'s form: the work commit `8d219057a58df927edef10f91c43a01de1d07342` (expand; never the report commit `f0e1f3ca`). Every `VERIFIED` count re-measured: `--fast` 961/99 (account for 99), the four-module line 54 = 2 + 5 + 40 + 7 (account each module's collected count), static 104 rows and no new `B904`/`B90x` on the widened raise, docs 364/364 (and the counts at `FINAL` and at `REV`), `TRIPPED` from `scripts/check-scope`'s own line (the report claims `none`). `SHAPES` against the brief's two named shapes (rule 7 — the `OSError` face named unbuilt with its reason is the honest form; the Clause-restate shape's three faces named as the built pins). `INHERITED`'s `none` against the received set (rule 2/8 — the brief's two copied blocks and the two moved findings; verify nothing is open). Form-exhaustive (`report.txt`): every field filled and nothing outside it added. Standing battery: `scripts/check-tests` (your full run — record it in `VERIFIED`) and the held sets of the whole run-entry stream (the load and refusal shapes, the settle-claim interleave pins, the import matrix, `test_clean_env_cli_shape`'s documented forms, the F21 drift pin, the absorbed F27/F28/F30 pins, the cancel-race and stale-admission pins).

5. The Phase 5 exit gate as a whole — the loop's exit is at stake. The five operator classes as subprocesses against a real frozen repository (accept, failing-command refusal, wall-clock timeout, mid-run cancel, the injected-`ProtocolViolation` class): each a settled terminal outcome, the documented JSON and exit codes, no traceback, document == durable fresh outcome. Plus every documented head run as written (`docs/run-entry.md`'s Commands section — the `python3` forms). The loader's refusal face over question 1's corpus is the gate's input face. Report each guarantee as falsified-with-reproducer or attacked-and-not-falsified with the method. Whether anything remains open after this step is the loop's exit input — report findings and let the planner decide (cycle step 5).

--- BEGIN BRIEF UNDER REVIEW (copy of docs/research/phase5-run-entry-fixes-6-brief.md; the committed file is authoritative) ---
IMPLEMENTER BRIEF — phase5-run-entry-fixes-6 (Phase 5: the loader face forced whole — F36)

GOAL: F36 is disposed and the fixes-5 review's committed red probe is green — `load_run_spec` refuses a deeply-nested (parser-recursion-overflowing) spec file as a named `RunSpecError`, so `RunSpecError`'s "one named failure, never a run-time surprise" docstring and `docs/run-entry.md`'s fail-closed sentence hold for the whole face at once, not class by class. The face is forced whole in this step, not enumerated: every failure the loader's read+decode+parse can produce — the `OSError` read family (unchanged), the file-decode `UnicodeDecodeError`, the decoder's `yaml.YAMLError`, and the parse-depth `RecursionError` — is the named refusal before any store is opened or any event is admitted, each wrapped as `RunSpecError` raised `from` its cause with a message naming the path. F37's pin (`tests/test_phase5_run_entry_fixes_5_review.py::test_review_f37_invalid_utf8_spec_refused_as_a_named_run_spec_error`) and F34's absorbed probe stay green as maintained pins. No `tests/open_defects.yaml` registration rides (see CONTEXT).

CONTEXT: The fixes-5 step closed out (its review raises no P0 and no P1; [record.md](../record.md)'s row at REV `8adc6c5…`, Fixed 3 / Red 1 / Carried 1 / Declined 0 / Reviews 1). F36 (P2, ORIGIN: CODE, carried by the fixes-5 review) is the loop's last carried finding — the loop's exit condition ("no P1 or P2 finding remains", the `Carried` column) is what this step pays. F36's mechanism: `yaml.safe_load` overflows the parser's recursion on a deeply-nested document (2000+ nested flow sequences) and raises `RecursionError`, which the delivered `(yaml.YAMLError, UnicodeDecodeError)` tuple at `src/orchestrator/run_entry.py:270-273` does not catch — the raw `RecursionError` escapes `load_run_spec` and the documented CLI head dies on its traceback instead of the named refusal (zero events and the store-absent half hold; the named-failure face is what fails). Pre-existing since the run entry point's origin (dae836f), not a regression of fixes-5. The F35/F36 pair is the evidence for this brief's fix shape: the enumerated-class fix order ("catch the YAML decode errors", then one more class) keeps missing classes (F35's `UnicodeDecodeError` was filed and fixed at fixes-5; F36's `RecursionError` was found one review later), so the order here names the FACE — every failure the read+decode+parse can produce — and the except tuple is its current inventory, not a wish list. Two notes the review left that this brief settles in text: (1) the review's F36 `FIXED:` claims "The test needs registering in `tests/open_defects.yaml`" — that claim is falsified by `tests/test_open_defect_registry.py::test_every_bug_pin_is_registered_and_registered_pins_exist`, which asserts every registered node id starts with `test_bug_`: the probe is `test_review_*`, it needs no registration (F27's, F28's, and F34's probes rode the same way), it is absorbed green by this step's fix, and `tests/open_defects.yaml` is `OUT OF SCOPE`; (2) the review's judgment call on `docs/run-entry.md`'s quiet word "loader-refusable" resolves under the GOAL's forcing (F35's close: the sentence holds as written with nothing to reword), so no document is amended — host-resource failures outside the loader's own failure surface (e.g. `MemoryError`) are outside "loader-refusable", and the review's 19-class corpus found `RecursionError` as the only class inside the claim that escaped.

INHERITED:

From `docs/research/phase5-run-entry-fixes-5-implementer.md`, its `INHERITED` block verbatim:

  INHERITED:
  none — the received INHERITED carried exactly one open item, F34 (the fixes-4 review's carried P2, moved into this brief's body). It is fixed in this step (FINDINGS, F34); nothing is carried forward and nothing new is left open.

From `docs/research/phase5-run-entry-fixes-5-review.md`, its `INHERITED` block verbatim:

  INHERITED:
  none — the received INHERITED (the brief's two copied blocks and the moved F34 entry) carried exactly one open item, F34. It is fixed by the step under review (the implementer's FINDINGS, F34). F35 is disposed by the step under review. Two new findings are filed by this review: F36 (carried, above) and F37 (fixed, above). Nothing else is open.

The copied block's "(above)" references resolve to that report's `FINDINGS` entries; both are moved verbatim here so the brief is the actor's only input (the block leads `none` while F36 is carried — see `record.md#observations`):

  F36 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  A spec file whose YAML is deeply nested (2000+ nested flow sequences) raises `RecursionError` inside `yaml.safe_load`, which escapes `load_run_spec` raw — the delivered except catches `(yaml.YAMLError, UnicodeDecodeError)` but not `RecursionError`. The `RunSpecError` docstring's "the operator sees one named failure, never a run-time surprise" is falsified for this class (the operator sees a raw `RecursionError` traceback, not a named refusal). Whether `RecursionError` is inside `docs/run-entry.md`'s quiet word "loader-refusable" is a judgment call; the delivered clause's boundary falls at "YAML decode errors + file-decode errors", not at "loader-refusable", so one sentence needs a narrowing the fix did not make (a document amended is an OWNER commit). Pre-existing since the run entry point's own origin (dae836f), not a regression of this step. The alias-cyclic class does NOT escape (`yaml` composes the cyclic alias and `validate_run_spec` rejects the shape); the deep-nesting class does.
  FIXED: tests/test_phase5_run_entry_fixes_5_review.py::test_review_f36_deeply_nested_spec_refused_as_a_named_run_spec_error — at FINAL the named assertion fails at tests/test_phase5_run_entry_fixes_5_review.py:31: `Failed: F36: a deeply-nested spec file is refused as RecursionError, not the documented named \`RunSpecError\`: RecursionError('maximum recursion depth exceeded')` (`.venv/bin/python -m pytest tests/test_phase5_run_entry_fixes_5_review.py -v`, 1 failed). The test needs registering in `tests/open_defects.yaml` — registration left to the next implementer brief.

  F37 | SEVERITY: P2 | ORIGIN: CODE | STATE: fixed
  The `UnicodeDecodeError` face of the Loader-decode refusal shape had no committed pin: the absorbed probe drives the `ParserError` face only, and the drop-`UnicodeDecodeError` mutant leaves the committed suite green (52 passed) while the face escapes raw. The brief's `SHAPES` rule named the face as unbuilt, but the face is inside the documented sentence's claim and needs a pin.
  FIXED: tests/test_phase5_run_entry_fixes_5_review.py::test_review_f37_invalid_utf8_spec_refused_as_a_named_run_spec_error — no regression test (the face was working at REV and at FINAL; the pin asserts the `UnicodeDecodeError` face is refused as a named `RunSpecError` and goes red under the drop-`UnicodeDecodeError` mutant). Green at FINAL in the 2-collected probe run.

IN SCOPE: src/orchestrator/run_entry.py

RESIDUALS:

none — rule 3 selection for this brief's `IN SCOPE`: no `docs/residuals.md` trigger glob matches `src/orchestrator/run_entry.py` (the ten `PILOT-R*` triggers name `planning_pilot.py`, `controller.py`, `reducer.py`, `decomposition.py`, `model.py`, and `derive_obligations.py`; the store is byte-verified against `docs/residuals.md` before this brief's commit, rule 2). No residual row rides, so the residual half of `scripts/check-scope` has nothing to carry here and it prints `tripped: none` — the line your report's `TRIPPED` field copies.

OUT OF SCOPE:
- Editing this brief file (`docs/research/phase5-run-entry-fixes-6-brief.md`). A committed brief is never modified; a re-cut is a new file.
- Every committed pin and probe of the earlier steps: `tests/test_phase5_run_entry_fixes_5_review.py` (the F36 probe turns green from the fix alone; the F37 pin stays green), `tests/test_phase5_run_entry_fixes_4_review.py`, `tests/test_run_entry.py`, and `tests/test_phase5_run_entry_fixes_2_review.py` are read-only here. If a pin would have to change for acceptance to pass, stop and report `IN SCOPE` as insufficient.
- `tests/open_defects.yaml` and the registry's meta-tests: no registration rides (CONTEXT note 1 — the meta-test asserts every registered pin is `test_bug_*`, and this brief's absorbed probe is `test_review_*`).
- `validate_run_spec`, `freeze_target`, `start_run`/`_bind_acceptance`, the controller stack, the store, the experiment harness, `scripts/orchestrate.py`.
- `docs/run-entry.md`, the module docstring, and the `RunSpecError` docstring: the fix makes their sentences true as written — nothing is reworded, narrowed, or widened (CONTEXT note 2 settles "loader-refusable" under the GOAL's forcing). If you find a sentence the fix cannot make true, stop and report rather than reword it (a document amended is an OWNER commit, rule 5).
- No `docs/tables/*` change and no table regeneration, no `docs/event-catalogue.md` change and no new event type, no `docs/control-plane.md` edit, no `docs/residuals.md` or `docs/record.md` edit, no `docs/self-host.md` edit, no `docs/method.md` or `docs/templates/` edit.
- The fixes-5 review's remaining `SHAPES` disclosures stand as disclosed and are not built here: the `OSError` face's unpinned-but-unchanged status (hand-probed; no pin owed) and the Clause-restate shape's faces (the residual pin, the unknown-id assertion, and the live-attempt face in `test_review_f33_owner_payload_branch_is_admission_inaccessible` — all green pins, none touched).
- Registry and control files: `tests/counterexamples.yaml`, `tests/guard_mutation_matrix.yaml`, `tests/fixture_fidelity.yaml`, `tests/verifier_registry.yaml`, `tests/spend_paths.yaml`, `tests/invariants.py`, `tests/helpers.py`, `pytest.ini`, tool configuration. No test file changes and no new test file — the standing `tests/test_phase3_project_oracle.py` line is therefore not owed (it is named only for a brief that adds a file under `tests/` or `scripts/`).
- No new dependencies, no tooling configuration, no reformatting. No new exception class (`RunSpecError` is the named failure) and no `*Executor`/`*ModelClient` class or provider-registry registration.
- Name no test `test_bug_*` (the open-defect registry would then own it).

ACCEPTANCE: Commands (run every one and paste what each prints into `VERIFIED`; expected result is green, exit 0, for each):

    scripts/check-tests --fast
    .venv/bin/python -m pytest tests/test_phase5_run_entry_fixes_5_review.py tests/test_phase5_run_entry_fixes_4_review.py tests/test_run_entry.py tests/test_phase5_run_entry_fixes_2_review.py
    scripts/check-static
    scripts/check-docs
    scripts/check-scope 9bb1d14181e34325820e0dedd3f2d43be1bd317f <FINAL> docs/research/phase5-run-entry-fixes-6-brief.md

Every `pytest` line names `.venv/bin/python -m pytest` deliberately (F17's carried correction: the bare `pytest` on PATH has no `pytest-timeout` and `pytest.ini`'s `strict_config = true` rejects it on this host — run these lines exactly as written and claim them under these names). The four modules are the loader's whole committed battery: the fixes-5 probes (F36 absorbed green, F37 still green), the fixes-4 probes, and the run-entry/fixes-2 batteries that must not regress. Never put a full run in `ACCEPTANCE`; the reviewer runs `scripts/check-tests`. `REV` below names the step's base — the parent of this brief commit — and is not claimed to be `FINAL`'s parent (F4's lesson).

Red evidence at `REV` `9bb1d14181e34325820e0dedd3f2d43be1bd317f` (command `.venv/bin/python -m pytest tests/test_phase5_run_entry_fixes_5_review.py`; each unit must be replayable): the previous review's own committed probe is red at `REV` as committed — `tests/test_phase5_run_entry_fixes_5_review.py::test_review_f36_deeply_nested_spec_refused_as_a_named_run_spec_error` — the named failing assertion at `REV` being its `pytest.fail` translation at tests/test_phase5_run_entry_fixes_5_review.py:31: `Failed: F36: a deeply-nested spec file is refused as RecursionError, not the documented named \`RunSpecError\`: RecursionError('maximum recursion depth exceeded')` (measured at `REV`: 1 failed, 1 passed — the F37 pin green beside it). The fail shape is the same adjudicated translation form as F34's (named, message-full, the class that escaped), and that red is this step's red evidence, already in the tree; `FIXED` names the node id, the command, that failing message, and the delivered file's line numbers or none (F22's lesson). The probe turns green at `FINAL` with no test edit. Other gates measured at `REV`: `scripts/check-tests --fast` 961 passed, 99 deselected, 81.20s; `scripts/check-static` exit 0 (104 advisory rows); `scripts/check-docs` 363 total, 360 OK, 0 errors; `scripts/check-tests` at the fixes-5 report tree — 1 failed (exactly that node), 1059 passed, 570.86s (the review's full run; this brief's base is docs-only past it).

Slow-mark convention: the probe's module stays slow-marked by its existing `pytestmark = pytest.mark.slow` (`src/orchestrator/project_oracle.py:731`'s internal gate runs `scripts/check-tests --fast`, and the pre-commit hook deselects the same way); no new module is needed and no test file is edited.

Named shapes to build — the list of shapes, not the number of tests. One shape needs at least one test, and every named shape needs one:

- `Loader-refusal face` (F36's whole-face forcing): the face's three pinned classes are the absorbed probe (the parse-depth `RecursionError` class — this step's red, green at `FINAL`), `tests/test_phase5_run_entry_fixes_4_review.py::test_review_f34_unparseable_spec_file_refused_as_a_named_run_spec_error` (the `ParserError` class), and `tests/test_phase5_run_entry_fixes_5_review.py::test_review_f37_invalid_utf8_spec_refused_as_a_named_run_spec_error` (the `UnicodeDecodeError` class) — all green at `FINAL`, none edited. The `OSError` read family is unchanged behaviour, kept as-is, and is not a named shape here (no pin owed; the fixes-5 review hand-probed it — missing path, directory, symlink loop → `RunSpecError("cannot read run-spec …")`); if your work probes it and the suite does not build it, name it in `SHAPES` rather than claiming it covered.
- `Clause-restate shape` (F33's boundary): no new test and no change — its faces stay the already-built green pins named in the brief under review (`test_review_f33_residual_crafted_terminal_owned_artefact_retained`, `test_stale_admission_race_log_replays`'s unknown-id assertion, and the live-attempt face in `test_review_f33_owner_payload_branch_is_admission_inaccessible`). The shape entry exists so the untouched surface is not hidden as prose-only work.

REV: 9bb1d14181e34325820e0dedd3f2d43be1bd317f
CLOSE OUT: yes
DIVERGENCES: none
REVIEW: one session — attack the face's completeness once more over the full hostile corpus (the fixes-5 review's 19 classes plus parser-resource and host-resource failures — a huge alias-expanded document, an over-long line, an over-deep indent, a `MemoryError`-shaped input if this host permits) asking one question: does any class inside the documented claim still escape raw? Then the wrap's honesty (`__cause__` chains, message form, store-absent and zero-events halves, no traceback through the CLI heads), the absorbed probe's red→green with no test edit and the F37 pin's still-green, the whole-face forcing's reading (was any class silently declared outside "loader-refusable" without evidence?), and the report's counts and forms (J-class). Report each guarantee as falsified-with-reproducer or attacked-and-not-falsified with the method.

You implement one brief. You do not plan, re-scope, or decide what the work is. Read every file
in IN SCOPE before editing it; if what you find contradicts the brief, report that instead of
guessing. Modify only what IN SCOPE names. If you find uncommitted changes in the tree, stop and say
so. Stop and report rather than improvise when IN SCOPE is
insufficient, the brief contradicts the code, you have already failed twice at this goal, or the
requirement is ambiguous and no single reading is consistent with the rest of the brief. If exactly
one reading is consistent, take it and file a FINDING with ORIGIN: BRIEF that names the reading you
took. No new dependencies, no tooling configuration, no reformatting. Run every ACCEPTANCE command;
fix what is in scope and report what is not.

A defect in the brief is a FINDING, never METHOD FRICTION. METHOD FRICTION is only for the method and
its templates: any place you deviated from them, found them ambiguous, or found them silent. Report
friction you worked around — that is the section the method learns from.

Commit your own work. When ACCEPTANCE passes, commit the files you changed, and only those, in one
commit whose message ends with the trailer `Actor: IMPLEMENTER`. That commit's full sha is FINAL.
Then append docs/templates/report.txt verbatim, fill it in, write it to
docs/research/<phase>-<subject>-implementer.md, and commit it in a second commit with the same
trailer. Do not amend the first commit to add the report: FINAL must not change after the report
names it. If you cannot commit, stop and say so; do not leave work uncommitted for someone else to
commit.

# report.txt

REPORT — <phase>-<subject>-<role>
STEP: <implementer brief subject>
REV: <copied from the brief's REV — the step's base, not FINAL's parent>   FINAL: <implementer: sha of your work commit, never the commit that holds this report;
  reviewer: the sha under review, copied from the review brief>
CHANGED: <files, one line each>
VERIFIED: <command, duration, counts>
         Every VERIFIED and ACCEPTANCE claim names the command that actually ran — never a
         substituted interpreter, wrapper, or narrowed form. If the documented form cannot run in
         your environment, record both commands and the documented form's separate check.
NOT VERIFIED: <why, or none>
FINDINGS: none | one block each:
  ID | SEVERITY: P0|P1|P2 | ORIGIN: BRIEF|CODE|DOCUMENT | STATE: fixed|declined|carried
  <root cause, one line>
  FIXED: <node id, command, and the named failing assertion at REV — or "no regression test">
         An error or a collection failure is not red. The assertion has to be the thing that
         failed; a run that merely crashed proves nothing.
  STATE means: fixed (above); declined = not a defect, with the reason; carried = a real defect
  left unfixed, passed on in INHERITED. A defect you will not fix now is carried, never declined.
  An ORIGIN: BRIEF finding is fixed once a later committed brief corrects the text: FIXED: names
  that brief's commit and reads "no regression test". Carried means a future actor has something to
  do with it; at closeout a finding with no possible next action is closed — a defect in an
  already-committed report reads FIXED: recorded in the review that filed it, and an authoring
  lesson from a finished brief goes into record.md's Observations.
SHAPES: <shapes probed that the suite does not build, or none with a reason>
        Every shape this report names needs a test or an entry here: a hand measurement is not a
        test. A facet claimed unchanged is re-driven at FINAL when your fix touches its surface.
        SHAPES: none claims nothing probed is left unbuilt — never that unbuilt probes were left
        unnamed.
TRIPPED: <copied from check-scope's tripped: line>
PROPOSED ROWS: <ledger rows, or none>
METHOD FRICTION: none | <where you deviated from the method or its templates, misread them, or
  found them silent. A defect in the brief is a FINDING, not friction. This form is exhaustive:
  every field is filled and nothing outside it is added. A departure from the form is friction
  even when it changes no outcome — silence is not compliance.>
INHERITED:
<<every INHERITED item you received that is still open, copied verbatim; then each
  finding you marked carried, with its ID>>
Rule 2 governs the planner's copy of this block. What goes in it is yours: an implementer or
reviewer who received an obligation, finding, entry or trigger carries it forward verbatim, and
adds anything new that is still open. A block reading `none` is correct only when nothing came in
and nothing is open. INHERITED never carries residual rows; they are re-selected from the store per
brief.
--- END BRIEF UNDER REVIEW ---

You did not write this code and you will not fix it; a finding is output, not an action. The step's
decision is the planner's (cycle step 5): report findings, never decisions. The commits under review
carry the trailer `Actor: IMPLEMENTER`; if your session wrote any of them, stop and say so. Run
REVIEW ACCEPTANCE first: it is the method's only gated check. The ACCEPTANCE lines inside the brief
under review are the implementer's; re-run them to verify the delivery, and run `scripts/check-tests`
as your standing battery — the full suite is your falsification ground — recording both in `VERIFIED`.
The embedded brief is a convenience copy: if the
standalone file it names differs, file a FINDING with ORIGIN: BRIEF and review against the committed
file.

You may create new test files to prove a finding, and modify nothing else. If a failing test would
need registering in tests/open_defects.yaml, say so in the report and leave the registration to the
next implementer brief rather than editing that file. Read pre-images with git show <rev>:..., not
the implementation's account of them. Run every mutant on a scratch copy of the tree, and diff each
mutant against git show <rev>:... before trusting its result. Attempt to falsify the brief, not only
the code: a finding that the brief was wrong is a finding, and so is a defect the implementer filed
only as friction. Answer every item under QUESTIONS TO ATTACK. An added review's QUESTIONS TO
ATTACK come only from the implementer's report — never from another review's findings. Enumerate
the shapes you probed that
the existing suite does not build, as a list; zero with a stated reason is legitimate. Report each
guarantee as falsified-with-reproducer or attacked-and-not-falsified with the method.

Commit your own work: your new test files and your report, together, in one commit whose message
ends with the trailer `Actor: REVIEWER`. Append docs/templates/report.txt verbatim, fill it in, and
write it to docs/research/<phase>-<subject>-review.md. If you cannot commit, stop and say so.
