REVIEW BRIEF — phase6-supervisor-fixes (Phase 6: the supervisor's kill-tree fix — F4–F6)
REV: 9b78d7a63ce69a4ed5db5a4f59c1edeaa3652bec
FINAL: 5ce423e97f45688d6808af40fdee8a506c816a98
REVIEW ACCEPTANCE: scripts/check-scope 9b78d7a63ce69a4ed5db5a4f59c1edeaa3652bec 5ce423e97f45688d6808af40fdee8a506c816a98 docs/research/phase6-supervisor-fixes-brief.md
FOCUS: the kill-tree fix above all — does the expiry kill reach the whole surface (descendant sweep after the group kill, no survivor in the session-escaped fixture shape and none in the real-head `--budget 8` re-drive), do F5/F6's absorbed probes live in the delivered module and go red under their mutants, is the `IN SCOPE` line plain with scope green, are the docs figures the gate's own printed lines (rule 14), and does the step touch only the IN SCOPE files with every committed battery green and no committed test edit outside them.
SEVERITY SCALE: P0 blocks the step; P1 is serious; P2 is minor.
QUESTIONS TO ATTACK:

  F8 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  The phase3 oracle fixture's gate-check grade is a hypothesis-seed lottery, not a load margin: `tests/test_phase3_project_oracle.py`'s `project_oracle_context` builds the manifest with `gate_timeout_seconds=60.0`, and `oracle._run_probe` covers the probe-tree copies, the identity digests, and the in-sandbox gate execution in that one 60.0s deadline (`src/orchestrator/oracle.py:632`, `:636`–`:637`, the probe call and its `GRADE_CANDIDATE_TIMEOUT` exception map at `:701`–`:705`) — while the frozen corpus's unseeded in-sandbox suite duration swings ~24–67s run-to-run (the fuzzer tests' hypothesis draws: shrinking/repro depth varies per seed against a fresh per-run hypothesis database on the sandbox's tmpfs), its seeded structural cost being ~30s. When a heavy draw lands past the deadline, correct grades flip instead of timing out loudly for a real reason: a graded FAIL becomes CANDIDATE_TIMEOUT (`AssertionError: assert 'CANDIDATE_TIMEOUT' == 'FAIL'`) and, in the five-case calibration, a `CORRECT_ACCEPTANCE` becomes `FALSE_SUCCESS` (`ExperimentError: calibration case 'known-good' classified 'FALSE_SUCCESS', expected 'CORRECT_ACCEPTANCE'` at `src/orchestrator/experiment_phases.py:265`).
  FIXED: tests/test_phase3_project_oracle.py::test_gate_config_and_test_corpus_neutralization_is_rejected and tests/test_phase3_project_oracle.py::test_project_oracle_classifies_the_five_case_corpus_on_a_real_repository, `.venv/bin/python -m pytest tests/test_phase3_project_oracle.py`, the two failing assertions quoted above — red at REV with no changes of this step in the tree (1 failed in 161.69s at load ~4.2 after passing in 159.95s at load ~3.3), so the lottery predates this brief. The discriminator that this step's pins are not the cause: the fixed-seed A/B inside the same sandbox shape, `--hypothesis-seed=424242` over the same 58-module selection — 30.27s / 30.81s with this step's pins and 25.14s / 23.42s without them (the pins' true in-sandbox cost ~+6s, twice, deterministic), and the full-corpus collection subprocess both grades depend on measures 2.0–2.3s with or without the pin module; the unseeded draws (24–67s across today's runs) are the seed's, not the corpus's. Next action: the fixture's owner raises `gate_timeout_seconds` toward `build_project_oracle`'s 300.0 default, or gives the in-sandbox gate a fixed hypothesis seed/profile so a red means a real regression; both files are outside this brief's scope and stayed untouched.

  1. The whole-surface kill live at FINAL — the one question. Re-drive the expiry kill through the supervisor as a subprocess: (a) the session-escaped fixture shape — a grandchild started in its own session out of the child group — leaves no survivor after the supervisor exits; (b) the in-group shape — a grandchild holding the output pipes — is dead at the fixed observation point, not merely after the exit; (c) the real-head `--budget 8` scripted-environment drive leaves no descendant alive at the exit and none 15s after, against REV's four survivors. Report each guarantee as falsified-with-reproducer or attacked-and-not-falsified with the method. Then the rule-13 structural question: is the descendant sweep one seam over the whole surface (captured before the kill, group kill first, per-descendant SIGKILL after), or does a surface remain that the sweep cannot reach — a descendant forked between the chain capture and the group kill, a descendant whose parent was already reaped, a PID reuse across the sweep? Attack the window, not only the faces. File a finding per falsified class.

  2. The absorbed probes and their mutants. Verify the review's two probes live in the delivered module (`test_the_deadline_kill_reaches_the_tree_at_a_fixed_time_and_the_whole_surface_after_the_exit`, `test_the_child_head_receives_the_whole_environment_and_runs_once`) and `tests/test_review_phase6_supervisor.py` stands unedited beside them. Re-run the brief's named mutants at FINAL on a scratch worktree diffed against FINAL before trusting each result: the lone-child-kill mutant red on the fixed-time member, the double-launch/dropped-secret/added-variable mutants red on the child-head observation — which pin goes red, and on which member? Is there a child-head mutant the observation still misses (a reordered argv, a dropped non-ORCHESTRATOR variable the run needs, a second child launched after the recovery)?

  3. F8's lottery and its ownership. The implementer's F8 names a committed-fixture lottery outside this brief's scope (gate 60.0s vs unseeded draws 24–67s, two named failing assertions, red at REV with none of this step's changes in the tree). Adjudicate: is the lottery real and outside this step (the fixed-seed A/B discriminator holds), and does F8's `carried` name an owner that can act (the fixture's owner, the two named remedies)? Or does the oracle line's flakiness block this step — is a green-at-FINAL oracle run the deliverable, or does a carried lottery ride to the Record? Also adjudicate the `NOT VERIFIED` full-suite gap the same way: does the pre-commit hook's double coverage plus the `--fast` battery close it, or does the slow battery need its own run?

  4. The report's forms and counts (J-class). `FINAL` is the work commit `5ce423e97f45688d6808af40fdee8a506c816a98`, never the report commit `07169a1` — verify rather than taking the report's word. Re-run the brief's ACCEPTANCE lines at FINAL (fast suite 975/106, the 12-passed supervisor-plus-review line, the 17-passed axis2 non-slow battery, the oracle module, static gated `BLE001,S110` clean with advisory `Found 104 errors.` unchanged, docs printed line with 0 errors — every figure the gate's own printed line, rule 14, never the REV line quoted in CONTEXT); `TRIPPED: none` matches check-scope's `tripped:` line and REVIEW ACCEPTANCE is green run first. `git diff 9b78d7a63ce69a4ed5db5a4f59c1edeaa3652bec 5ce423e97f45688d6808af40fdee8a506c816a98 --stat` touches only the IN SCOPE files plus the brief (no committed test edit outside them — verify). `SHAPES`' real-head whole-tree face read against rule 7: the green face at FINAL is a hand measurement this time, and the fixture-session pin builds the shape — adjudicate whether the shape is properly both pinned and measured rather than buried. `INHERITED`'s F4–F6 fixed-closes against the received set (the fixes brief's carried F4/F5/F6; F7 fixed as recorded). Every field of the report present and filled, nothing outside the template added. Standing battery: `scripts/check-tests` (your full run — record it in `VERIFIED`).

--- BEGIN BRIEF UNDER REVIEW (copy of docs/research/phase6-supervisor-fixes-brief.md; the committed file is authoritative) ---
IMPLEMENTER BRIEF — phase6-supervisor-fixes (Phase 6: the supervisor's kill-tree fix — F4–F6)

GOAL: The review (`docs/research/phase6-supervisor-review.md`) falsified one absolute and left two pin gaps; all three are disposed and the supervisor's "kills the whole process tree" sentence holds as written. F4: the expiry kill reaches the whole process tree structurally — the descendant-chasing technique already in `src/orchestrator/sandbox.py:1081`'s `_kill` (capture the descendant chain before the kill, `killpg` the group, then `SIGKILL` each surviving descendant individually) over the supervisor's whole surface — so a sandboxed grandchild the real head starts in its own session dies with the child instead of surviving the deadline by ~26–29s. F5: the delivered tree pin discriminates a group kill from a lone child kill — the grandchild's liveness is measured at a fixed time after the deadline, not after the supervisor's exit (the lone-child-kill mutant then goes red instead of green). F6: the child head's own launch count and environment are observed — the `--json` head's argv and whole `ORCHESTRATOR_*` environment are recorded, so "launches exactly one child" and "every variable passes through unchanged, none added, none redacted" have an observation on the child head, not only the recovery head. F7 stays fixed as recorded in the review that filed it (an already-committed report defect; a committed report is never modified).

CONTEXT: The review re-drove every face live at FINAL `90b54a15692f34faa49fb5802af1f3d74f32c8ad` and ran fifteen mutants on a scratch worktree diffed against FINAL: ten red on the delivered pins, five survive (one semantically equivalent, four exposing F5/F6). F1–F3 stay fixed (each the one consistent reading, each pinned — the F1 mutant red on six pins, F2's on two assertion members, F3's on the empty-stdout member). The mechanism behind F4 is in the sandbox's own words: `src/orchestrator/sandbox.py:797` starts `sandbox_launcher.py` with `start_new_session=True`, and `sandbox.py:1028` records that the workload "calls `setsid`" and so "leaves the launcher's process group, so `killpg` alone misses it" — the supervisor's single `os.killpg(process.pid, signal.SIGKILL)` therefore cannot reach the sandbox subtree, measured live: four descendants (two launchers, two workloads) alive ≥15s after exit at `--budget 8`/`6`, dead by ~26–29s, none at `--budget 14`. Per rule 13 the next brief makes the claim structurally true over the whole surface (this brief) rather than answering with another enumerated list — and the technique is already in the tree (`SandboxRunner._kill`), so no new primitive is invented. Red at this brief's `REV`: the suite is green — red evidence is written first (see the Red evidence section). `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/phase6-supervisor-implementer.md`, its `INHERITED` block verbatim:

  INHERITED:
  none — the received INHERITED is the brief's clean block ("INHERITED: none — nothing carried into this step"); F1-F3 are fixed, not carried. Nothing came in, nothing is open, and nothing is carried forward.

From `docs/research/phase6-supervisor-review.md` — its `INHERITED` block, then each carried finding's block from its `FINDINGS` section, moved verbatim (rule 2 governs the planner's copy of this block; the review's received set is the brief's clean block, F1–F3 fixed-not-carried, F7 fixed as recorded):

  Nothing in the received set is open: the first block reads `none`, and the second carries nothing. Added by this review, each carried finding with its ID:
  F4 (P1, ORIGIN: BRIEF, carried) — the brief's "the kill reaches sandboxed grandchildren" is falsified in the real shape: the supervisor's single `killpg` cannot reach the sandbox subtree the real head starts in its own sessions. Next action is the planner's per rule 13 (make it structurally true, or an OWNER ruling narrowing the claim).
  F5 (P1, ORIGIN: CODE, carried) — the delivered tree pin cannot discriminate a group kill from a lone child kill; the discriminating member (grandchild liveness at a fixed time after the deadline) is committed in this review's probe file and must land in the module it belongs to.
  F6 (P2, ORIGIN: CODE, carried) — the child head's launch count and environment are unobserved by the delivered module; the observation is committed in this review's probe file and must land in the module it belongs to.
  F7 (P2, ORIGIN: DOCUMENT) is `fixed`, not carried: its close is `recorded in the review that filed it`, and the substantive `none` was right.

  F4 | SEVERITY: P1 | ORIGIN: BRIEF | STATE: carried
  The brief's expired-kill promise is absolute — "kills the whole process tree (the child and everything it started — `start_new_session` at launch so the kill reaches sandboxed grandchildren, `killpg` on expiry)" and the GOAL's "kills the whole process tree" — but the delivered kill is one `os.killpg(process.pid, signal.SIGKILL)` over the smoke_run child's process group, and the real head's sandbox subtree is launched OUTSIDE that group: `src/orchestrator/sandbox.py:797` starts `sandbox_launcher.py` with `start_new_session=True`, and `src/orchestrator/sandbox.py:1027`–`1030` records in its own words that the workload "calls `setsid`" and so "leaves the launcher's process group, so `killpg` alone misses it". Sandboxed grandchildren therefore survive the deadline kill.
  FIXED: no regression test — the falsified shape is a hand measurement (rule 7) and no pin builds it: the brief's own pin text scopes the tree pin away from it ("this pin runs the supervisor's own process-group kill, never a sandboxed workload") and the pin is additionally confounded (F5). Repro: `python3 scripts/supervise_run.py --budget 8` from the repository root with the scripted environment above; the deadline lands during oracle calibration; four descendants (two `sandbox_launcher.py`, two sandboxed workloads) are still alive 15s after the supervisor exits 1 with an empty stdout, and all are dead by ~26–29s (reproduced again at `--budget 6`; at `--budget 14` no descendant survives). This review's probe `test_the_group_kill_reaches_the_grandchild_before_the_supervisor_exits` measures only the group-kill shape with a fixture grandchild and is green at FINAL, so it does not carry the real-head shape. Next action is the planner's per rule 13: the next brief makes the claim structurally true (descendant-chasing kill, the technique already in `src/orchestrator/sandbox.py:1081`'s `_kill`, over the whole surface) or the OWNER narrows the claim by ruling.

  F5 | SEVERITY: P1 | ORIGIN: CODE | STATE: carried
  The delivered tree pin cannot tell a group kill from a lone child kill: `test_the_deadline_kill_reaches_the_whole_process_tree` calls `_wait_until_dead(grandchild_pid)` (`tests/test_phase6_supervisor.py:331`) and `assert not _pid_alive(grandchild_pid)` (`:332`) only after `_run_supervisor` has waited for the supervisor to exit, and a grandchild that survived the kill keeps the child's inherited stdout/stderr pipe fds open, so the supervisor's post-kill `communicate()` blocks until that grandchild ends on its own — at which point the pin finds it dead anyway. The liveness member therefore passes under a lone child kill.
  FIXED: no regression test — the red is a mutant, not a REV failure: at FINAL, patching `scripts/supervise_run.py` to `process.kill()` in place of `os.killpg(process.pid, signal.SIGKILL)` leaves all nine delivered pins green (`9 passed in 62.90s`, `.venv/bin/python -m pytest tests/test_phase6_supervisor.py`, worktree `/tmp/kilo/phase6-review/FINAL`, the 62.90s being the grandchild's own 60s sleep delaying the supervisor's exit), while this review's committed probe fails with `AssertionError: grandchild <pid> survives the deadline kill: the expiry kill does not reach the whole process group`. Next action: the next implementer brief lands the discriminating member — measure the grandchild at a fixed time after the deadline, not after the supervisor's exit.

  F6 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  The delivered module observes only the recovery head. The child head's own launch count and environment are never recorded, so two guarantees of the brief — "Launches exactly one child: `sys.executable scripts/smoke_run.py --json`" and "every `ORCHESTRATOR_*` variable the operator sets passes to the child unchanged; the supervisor adds none and redacts none" — have no observation at all: the only recorded argv and environment come from the `--resume` invocation.
  FIXED: no regression test — three mutants survive every delivered pin at FINAL while breaking those guarantees: launching the child twice before the recovery (`9 passed in 4.96s`), passing the child an environment without `ORCHESTRATOR_PROVIDER_API_KEY` (`9 passed in 4.90s`), and adding `ORCHESTRATOR_SUPERVISOR_ADDED=1` to the child's environment (`9 passed in 4.87s`); the delivered code does satisfy both, which this review's probe `test_the_child_head_receives_the_whole_environment_and_runs_once` proves (green at FINAL, red under each of the three mutants). Next action: the next implementer brief lands the observation in the module it belongs to.

Expected dispositions (rule 8 forms): F4 fixed with red evidence (named below — the falsified absolute made structurally true, pinned by a test over the whole surface per rule 13); F5 and F6 fixed with red evidence (the review's absorbed probes land in the module they belong to; the delivered mutants go red on them at REV). F7 stays `fixed: recorded in docs/research/phase6-supervisor-review.md`.

IN SCOPE: scripts/supervise_run.py, tests/test_phase6_supervisor.py, tests/test_review_phase6_supervisor.py

RESIDUALS:

none — rule 3 selection for this brief's `IN SCOPE`: no `docs/residuals.md` trigger glob matches `scripts/supervise_run.py`, `tests/test_phase6_supervisor.py`, or `tests/test_review_phase6_supervisor.py` (the `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/phase6-supervisor-fixes-brief.md`). A committed brief is never modified; a re-cut is a new file.
- `scripts/smoke_run.py` in full: the run and `--resume` recovery it drives are delivered and pinned; the supervisor calls them as subprocesses and edits neither. If recovery needs a code change, stop and report `IN SCOPE` as insufficient.
- `scripts/stress_run.py` in full: its child discipline is the pattern the supervisor follows, not a seam the supervisor edits. If the discipline needs a change, stop and report `IN SCOPE` as insufficient.
- `src/orchestrator/sandbox.py` in full: the descendant-chasing technique is the pattern the supervisor follows (`SandboxRunner._kill`), not a seam this brief edits. Read it, do not touch it; if the technique needs a change, stop and report `IN SCOPE` as insufficient.
- `src/orchestrator/controller.py`, the store, the experiment harness, `src/orchestrator/secrets.py`, `src/orchestrator/spend.py`: no controller, store, credential, or ledger change rides here. No new event type, no `docs/tables/*` change and no table regeneration, no `docs/event-catalogue.md` change.
- `docs/self-host.md`, `docs/residuals.md`, `docs/record.md`, `docs/method.md`, `docs/templates/`: the status edit, if any is owed, rides a later step; this step delivers the kill-tree fix.
- Every committed test module except the three IN SCOPE files — `tests/test_run_entry.py`, `tests/test_axis2_robustness.py`, `tests/test_smoke_run_client.py`, and every other committed module are read-only here. No committed test file outside IN SCOPE is edited. 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 (F4–F6 are open findings whose next brief is this one; no `test_bug_*` name — the open-defect registry would then own it).
- The controller stack, `experiment_target.build_target`, `schemas.py`.
- 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 new dependencies, no tooling configuration, no reformatting. No new exception class and no `*Executor`/`*ModelClient` class or provider-registry registration.

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_phase6_supervisor.py tests/test_review_phase6_supervisor.py
    .venv/bin/python -m pytest tests/test_axis2_robustness.py -m "not slow"
    .venv/bin/python -m pytest tests/test_phase3_project_oracle.py
    scripts/check-static
    scripts/check-docs
    scripts/check-scope 9b78d7a63ce69a4ed5db5a4f59c1edeaa3652bec <FINAL> docs/research/phase6-supervisor-fixes-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 axis2 non-slow line is the supervisor's invariant battery (`17 passed, 4 deselected` at the fixes REV — the spend-settle and lock pins it must not regress). The oracle line rides because this brief's IN SCOPE touches files under `scripts/` and `tests/` (rule: a brief that adds a file under `tests/` or `scripts/` also names `pytest tests/test_phase3_project_oracle.py`; this brief edits under both). The docs gate is expected green with 0 errors — and every count figure you write in `VERIFIED` is the gate's own printed line, never the REV line quoted in this brief's CONTEXT and never recomputed from memory (rule 14, the F41 class). The scope line is expected green, exit 0, printing `tripped: none` (and the `claimed:` line the parser prints). `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).

The kill-tree fix (`scripts/supervise_run.py`, in place): on `subprocess.TimeoutExpired` the supervisor captures the descendant chain before the kill (the `/proc` parent-chain walk, the technique already in `SandboxRunner._descendants`), kills the child's process group with one `killpg`, then `SIGKILL`s each surviving descendant individually (the technique already in `SandboxRunner._kill` — descendants captured before the kill so an escaped process is still terminated), then reaps. The group kill stays first (the fast path for the fixture shape); the descendant sweep is the structural half that reaches what left the group (the sandbox subtree). Read `src/orchestrator/sandbox.py`'s `_descendants`/`_kill` as the pattern; write the supervisor's own small copy — no import from the controller stack (the supervisor's only heads stay the two recorded subprocesses). The recovery path is unchanged: exactly one recorded `--resume` after a killed/lost/nonzero child, none after a clean child, same environment, same single-document stdout with narration on stderr, same exit rules, same fail-closed misuse.

The pins (`tests/test_phase6_supervisor.py`, in place — absorb, do not duplicate): the review's two probes land in the module they belong to — the grandchild's liveness measured at a fixed time after the deadline (F5's discriminating member: red under the lone-child-kill mutant) and the `--json` head's launch count, argv, and whole `ORCHESTRATOR_*` environment on the clean and lost faces (F6's observation: red under the double-launch, dropped-secret, and added-variable mutants). `tests/test_review_phase6_supervisor.py` stays green and unedited (it is IN SCOPE so the scope gate's claim covers it; the probes live on in the delivered module, and the review file is not re-cut — a reviewer fixes nothing and its committed probes stand as filed). No committed test file outside IN SCOPE is edited.

Red evidence at `REV` `9b78d7a63ce69a4ed5db5a4f59c1edeaa3652bec` (each unit must be replayable; the suite is green at REV, so each red is written by this step and demonstrated at REV against the unfixed code on a scratch copy diff-verified against `git show 9b78d7a:…` before use). `FIXED` names the pin's node id, the command, the named failing assertion, and the delivered file's line numbers or none (F22). Named reds to produce: F4's real-head tree red — at REV the `--budget 8` scripted-environment drive leaves sandbox descendants alive ≥15s after exit (the review's measured shape: four descendants, two launchers and two workloads, alive at 15s, dead by ~29s); the pin that goes red is the new whole-surface tree pin (a named failing assertion on descendant liveness after the supervisor's exit — an error or a hang is not red, the assertion must be the thing that failed). F5's red — the lone-child-kill mutant (`process.kill()` in place of the group kill) leaves the absorbed discriminating member red at REV. F6's reds — the double-launch, dropped-secret, and added-variable mutants each leave the absorbed child-head observation red at REV.

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:

- `Whole-surface tree shape` (F4): the expiry kill reaches descendants that left the child's process group — a fixture child that starts a grandchild in its own session (the sandbox shape: `start_new_session`/`setsid` out of the group) is reaped with no survivor after the supervisor's exit, and the real-head `--budget 8` drive from the review's repro leaves no descendant alive after exit (the shape is pinned by the fixture-session test; the real-head drive is the hand measurement in `SHAPES` that goes green).
- `Discriminating tree shape` (F5): the grandchild's liveness at a fixed time after the deadline — the absorbed probe, red under the lone-child-kill mutant.
- `Child-head observation shape` (F6): the `--json` head's launch count (exactly one), argv, and whole `ORCHESTRATOR_*` environment — the absorbed probe, red under each of the three child-head mutants.

REV: 9b78d7a63ce69a4ed5db5a4f59c1edeaa3652bec
CLOSE OUT: yes
DIVERGENCES: none
REVIEW: one session — the kill-tree fix above all: does the expiry kill reach the whole surface (descendant sweep after the group kill, no survivor in the session-escaped fixture shape and none in the real-head `--budget 8` re-drive), do F5/F6's absorbed probes live in the delivered module and go red under their mutants, is the `IN SCOPE` line plain with scope green, are the docs figures the gate's own printed lines (rule 14), and does the step touch only the IN SCOPE files with every committed battery green and no committed test edit outside them. Whether anything remains open after this step is the loop's exit input — report findings and let the planner decide (cycle step 5).

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.
--- 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; the registry owns test_bug_* pins only, and a
test_review_* probe rides red until absorbed. 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. Answers live in the form's fields —
a finding in FINDINGS, a measurement in VERIFIED/SHAPES. 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.
