REVIEW BRIEF — phase5-run-entry-fixes-3 (Phase 5: the last run-entry fixes — F26–F28)
REV: 6ad098906d6e180e4bff3a5362f1c030ba42230b
FINAL: 010142264aeaadbfdee24b61131a15956e6ffc94
REVIEW ACCEPTANCE: scripts/check-scope 6ad098906d6e180e4bff3a5362f1c030ba42230b 010142264aeaadbfdee24b61131a15956e6ffc94 docs/research/phase5-run-entry-fixes-3-brief.md
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 (F26–F28 are fixed as prescribed, and `METHOD FRICTION: none`). The claims are attacked below. This review decides whether the loop's exit condition holds ("no P1 or P2 finding remains") and whether the fixes-3 step closes out.

1. F26's rule-8 close: does the fixes-3 brief's `GOAL` (committed at `93044848c0ce2eb1ab2f0706cb5797830602b749`) carry the later committed correction of the named row, and is `no regression test` naming that commit the right form for an `ORIGIN: BRIEF` close? Verify the correction's mechanics once more against the pristine REV helper (the fixes-2 review's Q1): `import orchestrator.experiment.trial_driver` green at a leaf-only helper (leaf `trial_driver` forbidden), `import orchestrator.experiment_spec.sub` red at it (interior `experiment_spec`, leaf `sub` not forbidden).

2. F27's guard. Reproduce the red first: the absorbed probe as committed at `66e047b` against REV `6ad0989` code (its original `assert 'INFEASIBLE' != 'INFEASIBLE'` at the report's named line 112) and the RESHAPED probe against REV code (the `pytest.raises(WorkflowError)` form must go red at REV — `DID NOT RAISE`). Then attack the guard itself. (a) The read surface: `self.store.state(run_id)` is the cached projection — can a second connection's `record_failure` be invisible here (a false refusal), and is that the right trade (fail-closed) or the F20 lesson unlearned? Walk one two-connection order and record the outcome. (b) Every emitter: `evaluate_repeated_failure`'s two internal `NODE_MARKED_INFEASIBLE` sites still emit directly, past the new surface — is the policy enforced at every emitter or assumed by construction there (mutant: drive the `REPLAN_REQUIRED` branch with zero fingerprints — possible?)? (c) The policy's meaning: the guard is "Deterministic infeasibility policy passes" and the enforced precondition is ≥1 recorded fingerprint on the node — is one older failure fingerprint from an unrelated refusal sufficient for a terminal decision with no new observed failure (drive it: record one failure, then mark the node infeasible with no new attempt)? Name a finding if the enforced policy is weaker or stronger than the guard's words.

3. F28's absorbed pin and doc. (a) The node id still reads `test_review_f28_documented_bare_command_is_executable` while the property it pins is "no bare head is documented and the documented `python3` form runs" — the node id is the claim (row J): does the misnamed id misstate the enforced property? File it either way. (b) The prerequisite assertion (`"yaml" in section and "python3" in section`) binds word presence, not the claim "the system `python3` must resolve `yaml`" (row I's vacuous-truth class): mutant the section — a prerequisite sentence naming only `json` while the heads keep `python3` — does the pin stay green? (c) Row J on the prose: run every documented head as written (each full form, not only `--help`) on this host and check the two new sentences ("no bare `scripts/orchestrate.py …` head is documented as runnable"; the `yaml` prerequisite) against the artefact.

4. Red evidence at `REV` `6ad098906d6e180e4bff3a5362f1c030ba42230b`: the two committed probes as committed at `66e047b` (scratch or `git show` — diff-verify before trusting) — the named assertions at the report's named lines 112 and 128 (F22's lesson: do the line numbers land?), each a failing assertion at REV (an error is not red) and green at FINAL. Is F27's `FIXED` citing the reshaped pin's REV red honest about the reshape (the committed-at-REV probe's assertion text is the original)?

5. The `Guarded-surface shape`'s other facets: accepted-lineage settle-once, duplicate-call dedup against the shared `infeasible-{node_id}` key, and terminal-run late retention. The report's `SHAPES: none` claims these are "unchanged as measured by the fixes-2 review" — hand measurement, not a built test. The brief's shape named all three facets and every named shape needs a test. Mutant: change the idempotency key (or emit twice) — does any committed test go red? If the facets are pinned, say where; if not, `SHAPES: none` is F25's class again and the facets belong in `SHAPES` (file the finding against the report or the brief's shape breadth).

6. The Phase 5 exit gate as a whole — the loop's exit is at stake. The five operator classes as subprocesses against a real 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. Report each guarantee falsified-with-reproducer or attacked-and-not-falsified.

7. Regressions over the whole stream: the battery (961 passed / 85 deselected; 40 = 37 + 3 across the two modules; conformance 41; oracle 5; static; docs) and the held sets of the run-entry, fixes, and fixes-2 steps — the load and refusal shapes, the one-stamp pins, the settle-claim interleave pins, the import matrix (five rows), `test_clean_env_cli_shape` (still executing the form the doc now names?), the F21 drift pin, and the budgets/`run_specification`/late-event guarantees. Re-measure `TRIPPED` from `scripts/check-scope`'s own line (the report claims `PILOT-R1 PILOT-R10`).

8. Report hygiene (J-class): every `VERIFIED` count re-measured; `SHAPES: none` against question 5; `INHERITED: none` against the received F26–F28 and rule 8; `FINAL`'s form (the work commit `0101422`, never the report commit `73a90d1`); the one-line `METHOD FRICTION: none` against the template's field; and the `FIXED` line numbers against the delivered files.

--- BEGIN BRIEF UNDER REVIEW (copy of docs/research/phase5-run-entry-fixes-3-brief.md; the committed file is authoritative) ---
IMPLEMENTER BRIEF — phase5-run-entry-fixes-3 (Phase 5: the last run-entry fixes — F26–F28)

GOAL: F26–F28 are disposed and the loop can exit on the next clean review. F26 closes with this brief's commit (rule 8's ORIGIN: BRIEF form, `no regression test` naming this brief): the dotted-import row is `import orchestrator.experiment_spec.sub` — a dotted path whose forbidden module is interior and whose leaf is not — and `import orchestrator.experiment.trial_driver` (the fixes-2 brief's GOAL example) is green at a leaf-only helper because its leaf `trial_driver` is already forbidden; this sentence is the later committed brief's correction of that row. F27: `Controller.mark_infeasible` enforces its guard — a lineage with zero recorded failure fingerprints is refused with a named `WorkflowError` before any event is admitted — so a terminal decision can never pass on prose alone; the accepted-lineage and duplicate-call behaviour the fixes-2 review measured (one `NODE_MARKED_INFEASIBLE` per node via the shared `infeasible-{node_id}` key; late retention on terminal runs, no outcome rewrite) stays as measured. F28: `docs/run-entry.md`'s Commands section names forms that run — the heads read `python3 scripts/orchestrate.py …` (the form `test_clean_env_cli_shape` actually executes) with the system-interpreter prerequisite named (`python3` must resolve `yaml`) — and no bare `scripts/orchestrate.py …` head is documented as runnable (the script is mode 100644 and stays so). The two probes the fixes-2 review committed red are absorbed as maintained pins of the enforced properties and pass.

CONTEXT: The fixes-2 step closed out (its review raised no P0 and no P1); F26–F28 are its survivors and this step disposes them — the loop's exit condition is "no P1 or P2 finding remains", so the step after this one exits on a clean review. Red at this brief's `REV` is the previous review's own committed probes: `tests/test_phase5_run_entry_fixes_2_review.py::test_review_f27_mark_infeasible_requires_no_failure_history` and `tests/test_phase5_run_entry_fixes_2_review.py::test_review_f28_documented_bare_command_is_executable`, both red at `REV` as committed and both absorbed green here. The F27 pin's assertion reshapes to the enforced refusal (`pytest.raises(WorkflowError)` plus node and outcome unchanged): the fix's failure mode is a raise, the controller's existing refusal style is the bare `WorkflowError` family (`controller.py` raises bare `WorkflowError` at its capability seams — no new exception class, no subclass). F28's fix is prescribed as the doc rewrite, not the mode bit: the documented head must be the head the pins run (F24's lesson — "the command executed is not the command named", whose second sighting already owes the OWNER a rule in `record.md#pending-for-the-owner`), so `python3 scripts/orchestrate.py …` heads plus the named `yaml` prerequisite keep the doc, the pins, and the artefact on one form; the absorbed F28 pin reshapes to the documented-form property (its `os.access(_SCRIPT, os.X_OK)` assertion is the mode-bit route's property, which this reading declines). F27's precondition is the fixes-2 review's named mechanical one: `state.failure_fingerprints[node_id]` non-empty — the same state the settle paths build their stamp on. `REV` names the step's base — the parent of this brief commit — and is not claimed to be `FINAL`'s parent (F4's lesson).

INHERITED:

From `docs/research/phase5-run-entry-fixes-2-implementer.md`:

  Nothing received is still open — the received set was F17–F25, and each is fixed by this step (F17 via the ACCEPTANCE re-cut in this brief's commit 3375429; F18, F19, F20, F23 with red evidence; F21 and F24 as narrowed claims / an honest pin; F22 and F25 as recorded in docs/research/phase5-run-entry-fixes-review.md). This step adds one carried finding:
  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.

From `docs/research/phase5-run-entry-fixes-2-review.md` — its `INHERITED` block, then each carried finding's block from its `FINDINGS` section (the block's own "above" pointer), moved verbatim, preceded by the implementer's full F26 block from its `FINDINGS`:

  F26 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
  This brief's GOAL names `import orchestrator.experiment.trial_driver` as a dotted-import row "red at the delivered helper", but that path's leaf `trial_driver` is in `_FORBIDDEN_MODULES`, so the delivered leaf-only helper already flags it (green) and it cannot demonstrate the fix; the brief's own prose names the genuinely-red form `import orchestrator.experiment_spec.sub` (a dotted path into a harness submodule). Reading taken: the dotted row is `import orchestrator.experiment_spec.sub`, whose forbidden module is interior and which is red at the delivered helper.
  FIXED: no regression test — a later committed brief should correct the named row to a leaf-non-forbidden dotted path; carried until then.

  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.

  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 …").

IN SCOPE: src/orchestrator/controller.py, docs/run-entry.md, tests/test_phase5_run_entry_fixes_2_review.py

RESIDUALS:

Rule 3 selection for this brief's `IN SCOPE`, copied verbatim from `docs/residuals.md` and byte-verified against it (fenced so the store's relative evidence links are not re-resolved from this directory): `IN SCOPE` matches `PILOT-R1` and `PILOT-R10` trigger globs (`src/orchestrator/controller.py`); `PILOT-R2`–`PILOT-R9` (`decomposition.py`, `planning_pilot.py`, `model.py`, `derive_obligations.py`) do not match and do not ride.

```
| ID | State | Trigger | Risk | Rationale | Evidence |
| --- | --- | --- | --- | --- | --- |
| `PILOT-R1` | accepted | `src/orchestrator/planning_pilot.py`, `src/orchestrator/controller.py`, `src/orchestrator/reducer.py` | mutable admitted payload (wiring constraint): the caller holds a mutable reference to the admitted payload, and a post-return mutation of a child's scope survives the reducer's re-validation. Any integration must therefore not mutate a payload between the guard and event admission. | the admitted payload is mutable; the reducer's re-derivation runs at admission and on replay, so the guard's result is only as safe as the wiring keeps it | [pilot re-review 3](research/phase4-recursive-planning-pilot-re-review-3.md) |
| `PILOT-R10` | accepted | `src/orchestrator/controller.py`, `src/orchestrator/planning_pilot.py` | in-process trusted-code circumvention of the admission capability: the capability is not reconstructible from data, but trusted code running in-process can hold or mint one and admit anything — if untrusted code is ever loaded in-process, the capability boundary does not hold | R1's prevention-shape ruling: the capability's threat model is data-only reconstruction, and trusted-code circumvention is recorded here rather than claimed solved | [owner rulings](record.md#owner-rulings) (R1) |
```

A tripped trigger is a finding: fixed with red evidence, or carried into the closeout with its reason. `scripts/check-scope` prints the `tripped: <ids>` line your report's `TRIPPED` field copies. Both rows stay accepted: this brief's path never admits a decomposition (so no admitted payload exists to mutate), and `PILOT-R10` is not closed — F27's fix narrows one trusted-caller risk but does not claim the in-process boundary solved.

OUT OF SCOPE:
- Editing this brief file (`docs/research/phase5-run-entry-fixes-3-brief.md`). A committed brief is never modified; a re-cut is a new file.
- The controller stack beyond `mark_infeasible`'s precondition: `src/orchestrator/controller.py` otherwise unchanged (the settle callers already record one failure first and are not re-touched), and `reducer.py`, `store.py`, `executor.py`, `executor_protocol.py`, `command_executor.py`, `acceptance_checks.py`, `schemas.py`, `glossary.py`, `experiment_target.py`, `derive_obligations.py`, `scripts/orchestrate.py`, and the experiment harness (`experiment.py`, `experiment_spec.py`, `experiment_phases.py`, `trial_driver.py`, `hidden_oracle.py`, `scripts/smoke_run.py`, `scripts/stress_run.py`). If one of these must change, stop and report `IN SCOPE` as insufficient.
- No mode-bit change to any file: `git add --chmod=+x` is declined by this brief's F28 reading (the documented head becomes the `python3` form instead). `tests/test_run_entry.py` is untouched: the absorbed pins stay in their committed home.
- `evaluate_repeated_failure`, the repeated-failure rule's semantics, and `record_failure`'s fingerprint material stay unchanged (F27's precondition reads the state they already maintain).
- Any `docs/` file except `docs/run-entry.md` and your report: 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 (the status concern is already in `record.md#pending-for-the-owner`).
- Model-produced candidates and recursive decomposition driving (unchanged): `start` drives the root's execution only.
- Registry and control files: `tests/open_defects.yaml`, `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 new dependencies, no tooling configuration, no reformatting. No new exception class or `*Executor`/`*ModelClient` class and no provider-registry registration. No new arm and no `docs/tables/limits.yaml` change.
- Name no test `test_bug_*` (the open-defect registry would then own it).
- Do not mutate an admitted payload between the guard and event admission.

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_run_entry.py tests/test_phase5_run_entry_fixes_2_review.py
    .venv/bin/python -m pytest tests/test_milestone2_conformance.py
    .venv/bin/python -m pytest tests/test_phase3_project_oracle.py
    scripts/check-static
    scripts/check-docs
    scripts/check-scope 6ad098906d6e180e4bff3a5362f1c030ba42230b <FINAL> docs/research/phase5-run-entry-fixes-3-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). `tests/test_milestone2_conformance.py` is named because `mark_infeasible`'s emission surface changes. `tests/test_phase3_project_oracle.py` is named under the standing rule for `tests/` changes. 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` `6ad098906d6e180e4bff3a5362f1c030ba42230b` (command `scripts/check-tests`; each unit must be replayable): the red is the previous review's own committed probes, replayable at `REV` without any scratch work — `tests/test_phase5_run_entry_fixes_2_review.py::test_review_f27_mark_infeasible_requires_no_failure_history` (red at the assertion naming F27: `mark_infeasible` admits the emission and drives the node `READY → INFEASIBLE`) and `tests/test_phase5_run_entry_fixes_2_review.py::test_review_f28_documented_bare_command_is_executable` (red at `os.access(_SCRIPT, os.X_OK)` — the documented bare head is not executable). Both are absorbed green at `FINAL` (their assertions reshape to the enforced properties — the F27 pin asserts `pytest.raises(WorkflowError)` with node and outcome unchanged; the F28 pin asserts the documented heads run as written). F26 closes `no regression test` naming this brief's commit (rule 8's ORIGIN: BRIEF form: a later committed brief corrects the text — this one does).

Slow-mark convention: `tests/test_phase5_run_entry_fixes_2_review.py` 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); the named `.venv/bin/python -m pytest` line runs the cases directly.

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:

- `Guarded-surface shape` (F27): `Controller.mark_infeasible` refuses a zero-recorded-failure lineage with a named `WorkflowError` and admits no event (the absorbed probe); an accepted lineage settles exactly once and a duplicate call dedupes against the shared `infeasible-{node_id}` key; a call on a terminal run is retained late with no outcome rewrite — the behaviour the fixes-2 review measured in its answer 2, unchanged.
- `Runnable-doc shape` (F28): every Commands-section head runs exactly as written (the `python3` form the clean-env pin executes), the `python3`-must-resolve-`yaml` prerequisite is named beside them, and no bare `scripts/orchestrate.py …` head appears (the absorbed probe asserts the documented-form property; `test_clean_env_cli_shape` continues to run the same form).

REV: 6ad098906d6e180e4bff3a5362f1c030ba42230b
CLOSE OUT: yes
DIVERGENCES: none

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>
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>
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.>
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
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 only automated check in the method. The
ACCEPTANCE lines inside the brief under review are the implementer's; re-run them to verify the
delivery and record the results 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. 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.

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