REPORT — phase6-supervisor-review
STEP: phase6-supervisor (Phase 6: the external supervisor — the phase's main missing piece)
REV: 307aaa0f4a150be5e7c5556e3517f77699d62243   FINAL: 90b54a15692f34faa49fb5802af1f3d74f32c8ad
CHANGED:
  tests/test_review_phase6_supervisor.py — new file (mode 100644), this review's two discriminating probes, both green
  at FINAL: `test_the_group_kill_reaches_the_grandchild_before_the_supervisor_exits` (the grandchild's liveness
  measured at a fixed time after the deadline, the member the delivered tree pin cannot discriminate) and
  `test_the_child_head_receives_the_whole_environment_and_runs_once` (the `--json` head's launch count, argv and whole
  `ORCHESTRATOR_*` environment, the observation the delivered module never makes). Advisories clean
  (`ruff check --select B,SIM tests/test_review_phase6_supervisor.py` → `All checks passed!`), so the advisory gate keeps
  its printed line at `Found 104 errors.`.
  docs/research/phase6-supervisor-review.md — this report.
  No delivered file is edited: a reviewer fixes nothing. Both files under review are byte-identical to FINAL's blobs
  (`git ls-tree 90b54a15692f34faa49fb5802af1f3d74f32c8ad`: `9177dcaf2766ec0a95cdd41a94b72f4692a856e2` for
  `scripts/supervise_run.py`, `a3d9c3a0fce8d52765610d120738bc937531b5d6` for `tests/test_phase6_supervisor.py`); every
  mutant ran on a scratch worktree (`git worktree add --detach /tmp/kilo/phase6-review/FINAL 90b54a15692f34faa49fb5802af1f3d74f32c8ad`,
  plus `/tmp/kilo/phase6-review/REV` for the red evidence), each diffed against FINAL before its result was trusted and
  reverted afterwards; the delivered tree's working copy was never touched by a mutant.

VERIFIED: REVIEW ACCEPTANCE, run first — `scripts/check-scope 307aaa0f4a150be5e7c5556e3517f77699d62243 90b54a15692f34faa49fb5802af1f3d74f32c8ad docs/research/phase6-supervisor-brief.md` — exit 0, prints `claimed: scripts/supervise_run.py tests/test_phase6_supervisor.py`, `tripped: none`, `scope: ok (3 path(s) in 307aaa0f4a150be5e7c5556e3517f77699d62243..90b54a15692f34faa49fb5802af1f3d74f32c8ad)`. `IN SCOPE: scripts/supervise_run.py, tests/test_phase6_supervisor.py` (the brief's line 51) is plain — two comma-separated paths, no glob, no prose — and `claimed:` prints exactly those two. No session then head wrote the commits under review (`git log -1 --format=%B 90b54a1` ends `Actor: IMPLEMENTER`; so does `9afb8a3`; this session wrote neither).
VERIFIED: scripts/check-tests — `1078 passed in 476.69s (0:07:56)`, exit 0 (this review's standing battery and falsification ground, run at FINAL before this review's own file existed: 1078 = 972 non-slow + 106 slow, so the delivered tree's full suite is green, not merely its `--fast` form).
VERIFIED: scripts/check-tests, re-run with this review's two files present — `1080 passed in 532.28s (0:08:52)`, exit 0 (the standing battery over the review's own additions: 1078 + the two committed probes, nothing regressed by them and the whole suite green).
VERIFIED: scripts/check-tests --fast — `972 passed, 106 deselected in 72.71s (0:01:12)`, exit 0 (the report's `972 passed, 106 deselected` re-measured: same counts, only the duration drifts).
VERIFIED: .venv/bin/python -m pytest tests/test_phase6_supervisor.py — `9 passed in 4.83s`, exit 0 (the report's `9 passed` re-measured).
VERIFIED: .venv/bin/python -m pytest tests/test_axis2_robustness.py -m "not slow" — `17 passed, 4 deselected in 5.71s`, exit 0 (the report's `17 passed, 4 deselected` re-measured; the spend-settle, lock and deadline pins it must not regress).
VERIFIED: .venv/bin/python -m pytest tests/test_phase3_project_oracle.py — `5 passed in 240.09s (0:04:00)`, exit 0 (the report's `5 passed` re-measured).
VERIFIED: scripts/check-static — exit 0. The gated `ruff check --select BLE001,S110 src/orchestrator` prints `All checks passed!`; the advisory line prints `Found 104 errors.`, and the same advisory line in the REV worktree prints `Found 104 errors.` too (with and without the new module), so the count is unchanged. One imprecision in the report's parenthetical is recorded, not filed: the SUPERVISOR script is outside the advisory scan's trees (`src/orchestrator tests`), and scanning it directly reports one `SIM105` for its `try/except ProcessLookupError/pass`; the gate's figure of 104 is nonetheless the gate's own printed line and the new TEST module adds none.
VERIFIED: scripts/check-docs — exit 0, prints `376 Total (in 889ms) 174 Unique 376 OK 0 Errors` (the report's figure re-measured at FINAL: same 376/174/376/0, only the duration string drifts).
VERIFIED: scripts/check-scope 307aaa0f4a150be5e7c5556e3517f77699d62243 90b54a15692f34faa49fb5802af1f3d74f32c8ad docs/research/phase6-supervisor-brief.md — exit 0, `tripped: none`, `scope: ok (3 path(s) …)` (the brief's ACCEPTANCE line, same command as REVIEW ACCEPTANCE; `TRIPPED: none` copies the gate's `tripped:` line).
VERIFIED: both gates re-run with this review's own two files present, so the review's additions change no gate figure: `scripts/check-static` exits 0 with the advisory line `Found 104 errors.` (the review probe file is advisory-clean, `ruff check --select B,SIM tests/test_review_phase6_supervisor.py` → `All checks passed!`) and `scripts/check-docs` exits 0 printing `376 Total (in 6s 462ms) 174 Unique 376 OK 0 Errors` (the counts unchanged; only the duration string drifts).
VERIFIED: the red evidence at REV — a worktree at `307aaa0f4a150be5e7c5556e3517f77699d62243` (where `scripts/supervise_run.py` is absent: `ls` fails) with `tests/test_phase6_supervisor.py` copied in uncommitted, run as `/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python -m pytest tests/test_phase6_supervisor.py`: exit 2, `collected 0 items / 1 error`, `ERROR collecting tests/test_phase6_supervisor.py`, `tests/test_phase6_supervisor.py:60: in <module> import supervise_run`, `E   ModuleNotFoundError: No module named 'supervise_run'`, `Interrupted: 1 error during collection`. Adjudicated absence, not regression, exactly as the brief directs: no committed module exists at REV that could show these pins red-then-green, and rule 6's red unit (a named failing assertion) is not what a collection failure is — the brief says so itself ("red evidence of absence, not a regression").
VERIFIED: question 4, every face driven through the supervisor as a subprocess with fixture children this review owns (my runner `.venv/bin/python /tmp/kilo/phase6-review/probe_faces.py`, supervisor launched with `cwd` at a fixture root holding `scripts/smoke_run.py`, the full `ORCHESTRATOR_*` set including a test secret `phase6-review-probe-secret-9f1c`): (a) killed (sleep past a 2s budget) — exit 1, one stdout line `{"workdir": …, "code": 0, "timed_out": true, "recovered": true, "child_wall_seconds": 2.002}`, `child_wall_seconds` reaped at the budget, exactly one `--resume`, the secret on neither stream, stderr `[supervise] child killed at the 2s wall budget`; (b) lost (exit 3, no document) — exit 3 (the child's code), one line with `recovered: true`, exactly one `--resume` with argv `["--resume"]` and the recorded `ORCHESTRATOR_*` environment equal to the supervisor's own; (b2) nonzero with a document (exit 5) — exit 5, one line `code: 0, recovered: true`, one `--resume`, same environment; (b3) exit 0 without a document — exit 1, one recovery, one line `code: 0`; (c) clean (exit 0 with a document) — exit 0, `recovered: false`, no `--resume` at all; (d) single-document shape — every face's stdout was exactly one non-blank line parsing as one JSON object, and all narration (`[supervise] child exit=…`, the recovery's own stdout and stderr, the misuse reasons) was on stderr. Guarantees attacked and not falsified: the killed child dies as a tree in the fixture shape, exactly one recorded `--resume` under the run's own environment on the lost/nonzero faces, none on the clean face, one document on stdout with narration on stderr, and every documented exit face is 1/killed, 1/exit-0-without-a-document, 3 or 5 propagated — no face exits 0 with a recovery, and no face exits a code the brief's rule does not produce.
VERIFIED: question 4's misuse faces, re-driven by the same runner: missing `ORCHESTRATOR_WORKDIR` — exit 2, empty stdout, stderr `error: ORCHESTRATOR_WORKDIR is not set: the supervisor needs the workdir the child runs in (the same one the recorded --resume recovery reads)`; unparsable `--budget not-a-number` — exit 2, empty stdout, stderr `supervise_run.py: error: argument --budget: budget 'not-a-number' is not a number of seconds`; a `--resume` that exits 7 — exit 7, empty stdout with no half-printed document, stderr ending `error: the recorded recovery (--resume) failed with exit code 7; the workdir … is not settled`. No misuse shape prints a document.
VERIFIED: question 4, the real recorded head driven live (my runner `.venv/bin/python /tmp/kilo/phase6-review/probe_real.py`, `python3 scripts/supervise_run.py --budget …` from the repository root with the scripted environment `ORCHESTRATOR_WORKDIR=… ORCHESTRATOR_OWNER=phase6-review ORCHESTRATOR_CAP=500 ORCHESTRATOR_AUTHORIZED_AT=2026-01-01T00:00:00Z ORCHESTRATOR_AUTH_METHOD=phase6-review-probe ORCHESTRATOR_SEEDS=1001 ORCHESTRATOR_REQUIRE_CONFORMANCE=0`, no network, no real spend, the supervisor's descendant tree sampled from /proc every 150ms): clean drive (`--budget 900`) — exit 0, one line `{"workdir": …, "code": 0, "timed_out": false, "recovered": false, "child_wall_seconds": 16.107}`, four trials, ledger `in_flight: {}`, `committed: 12.0` equal to the actuals sum `12.0`, and no descendant alive after the supervisor exited; controller death mid-comparison (`--budget 14`) — exit 1, `timed_out: true`, one recovery, `EXP-FIXED_ONE_LEVEL-1001: spend settled at 7.0 (RECOVERED)`, ledger `in_flight: {}`, `committed: 8.0` equal to the actuals sum `8.0`, no descendant alive after exit; controller death before any trial store (`--budget 8`) — exit 1, empty stdout, stderr `no trials directory to resume` and `error: the recorded recovery (--resume) failed with exit code 1; the workdir … is not settled` (fail closed). The report's three SHAPES faces are reproduced here, including the ledger closing `in_flight` empty with `committed` == actuals.
VERIFIED: question 4, the real-head process tree — the falsified guarantee (F4). At `--budget 8` and again at `--budget 6` (deadline during oracle calibration), four descendants survived the expiry kill and were still alive 15s after the supervisor exited, all dead by ~26–29s: two `sandbox_launcher.py` processes and two sandboxed workloads (`/usr/bin/python3 -c …` and `/usr/bin/python3 -P -c …`), measured by `.venv/bin/python /tmp/kilo/phase6-review/probe_survivors.py` and `.venv/bin/python /tmp/kilo/phase6-review/probe_lifetime.py`. At `--budget 14` (deadline mid-comparison) 72 descendants were seen and none survived. Mechanism: `src/orchestrator/sandbox.py:797` starts the launcher with `start_new_session=True`, and the launcher starts its workload in its own session, so neither is in the supervisor's `os.killpg(child.pid, SIGKILL)` group.
VERIFIED: question 1, F1's one-reading claim (guarantee attacked-and-not-falsified). `scripts/supervise_run.py:73` is the literal `CHILD = "scripts/smoke_run.py"`, launched as `[sys.executable, CHILD, "--json"]` (`:107`) with no `cwd`/`env=`/`path` derivation from `__file__`, so the path resolves against the supervisor's working directory; and the pins launch fixture children by running the supervisor with `cwd` at the fixture root (`tests/test_phase6_supervisor.py:167`). A second reading was attacked and excluded: resolving the child against the supervisor script's own directory makes the pins' fixture children unlaunchable (the child would always be the repository's real head) and would need either a third setting the brief forbids or a committed-file write the OUT OF SCOPE list forbids. The mutant (CHILD = the supervisor's own directory + "smoke_run.py") is red on six of the nine pins — `test_killed_child_is_reaped_marked_timed_out_and_drives_recovery`, `test_lost_child_drives_the_recovery_head_once_under_the_same_environment`, `test_child_exiting_zero_without_a_document_is_lost`, `test_nonzero_child_with_a_document_still_drives_recovery`, `test_the_deadline_kill_reaches_the_whole_process_tree` (`tests/test_phase6_supervisor.py:177`, `expected exactly one JSON document on stdout, got: ''`), `test_failing_recovery_fails_closed` (`:376`, `assert 0 != 0`) — so the reading is the shipped one and it is pinned.
VERIFIED: question 2, F2's exit-rule reading (guarantee attacked-and-not-falsified). All four faces re-driven above: killed exits 1, exit-0-without-a-document exits 1 with exactly one recovery, nonzero propagates 3 and 5. No face exits 0 with a recovery, and no face exits a code the rule does not produce. The competing reading ("produced none" = no exit code) would let an exit-0-without-a-document child exit 0, contradicting the same sentence's "exits 0 only when the child exited 0 with a document and no recovery ran". The mutant (`supervisor_exit = code` instead of `child.exit_code` on the nonzero face) is red on `test_lost_child_drives_the_recovery_head_once_under_the_same_environment` and `test_nonzero_child_with_a_document_still_drives_recovery`, on the members `assert completed.returncode == 3` and `assert completed.returncode == 5`. The `code` field's meaning was attacked by enumerating the six printed-document faces: `code` is the recovery's code whenever a recovery ran and the child's code otherwise, which is what `"code": <child-or-recovery code>` promises on every face — and measured, the field is `0` in every printed document, because a printed document exists only when the child was clean (exit 0) or the recovery succeeded (code 0); a failing recovery prints no document, so no document ever carries a nonzero code. A `code: 0` document beside a nonzero exit is therefore not a special case but the uniform consequence of the brief's own rule, and `recovered`/`timed_out`/the exit code carry the discrimination.
VERIFIED: question 3, F3's uniform no-document misuse (guarantee attacked-and-not-falsified). All three misuse shapes re-driven above exit nonzero with the reason on stderr and an empty stdout; no shape prints a document and no failing `--resume` leaves a half-printed one. The mutant (printing the document carrying the recovery's nonzero code on the failing-`--resume` face) is red on `test_failing_recovery_fails_closed`, on the member `assert completed.stdout.strip() == ""` (`tests/test_phase6_supervisor.py:377`). The implementer's F1–F3 are each the one consistent reading on F1 and F2 and, on F3, an honestly named choice between two fail-closed readings with the stronger one taken and pinned — nothing there returns the step to planning.
VERIFIED: questions 1–3, fifteen mutants run at FINAL on a scratch worktree, each diffed against `git show 90b54a15692f34faa49fb5802af1f3d74f32c8ad:scripts/supervise_run.py` before the run was trusted, each reverted after. Ten are red on the delivered pins (F1's mutant; F2's mutant; F3's mutant; no `start_new_session`; recovery twice; no recovery for a nonzero child; recovery for a clean child; echoing the child's stdout; dropping the `timed_out` marker; scrubbing the secret from both heads — that last one red on the recovery-environment equality member at `tests/test_phase6_supervisor.py:256`). Five survive — one semantically equivalent (skipping the post-kill `communicate()` changes nothing, because the killed child is reaped when the supervisor exits) and four that expose the two pin gaps named in F5 and F6.
VERIFIED: question 5, the report's forms and counts (J-class). `FINAL` is the work commit `90b54a1` ("Deliver the phase 6 external supervisor"), never the report commit `9afb8a3`: `git show --stat 90b54a15692f34faa49fb5802af1f3d74f32c8ad` lists exactly `scripts/supervise_run.py` (273 insertions) and `tests/test_phase6_supervisor.py` (378 insertions), and `9afb8a3` lists only `docs/research/phase6-supervisor-implementer.md`. `git diff --stat 307aaa0f… 90b54a1…` touches three paths (the two new files plus the brief, which the scope gate allows implicitly under `docs/research/`), `git diff --diff-filter=M …` is empty — no existing file, committed test included, was modified — and both new files are mode 100644 as the brief requires. `TRIPPED: none` matches the gate's `tripped:` line. The embedded brief in the review brief (its lines 32–212) is byte-identical to the committed `docs/research/phase6-supervisor-brief.md` at HEAD (substring comparison, exit 0), so the review runs against the committed file and no finding rides the copy. Every template field is present and filled and nothing outside it is added: REPORT, STEP, REV+FINAL, CHANGED, VERIFIED, NOT VERIFIED, FINDINGS, SHAPES, TRIPPED, PROPOSED ROWS, METHOD FRICTION, INHERITED; every count above is this session's re-measured printed line, never the REV line the brief's CONTEXT quotes.
VERIFIED: question 5, `SHAPES`' three real-head faces read against rule 7 ("Shapes are a list, not a count"): the delivered pins drive fixture children by the brief's own design ("without running a real trial"), so no committed pin launches the real `scripts/smoke_run.py` through the supervisor — grep for `supervise_run` across the delivered tree at FINAL returns only the two in-scope files, the brief and report documents, and the supervisor's own usage line (`scripts/supervise_run.py:25`) — and the three live real-head probes are properly listed unbuilt shapes rather than buried (each names its command, environment and measured outcome, and each is re-driven above). The list is not however complete: the real-head tree kill is a fourth unbuilt shape and it is where the brief's absolute claim is falsified (F4, listed below), and `NOT VERIFIED`'s full-suite gap is closed by this review's own standing battery rather than carried.
VERIFIED: question 5, the two remaining unbuilt shapes probed (`.venv/bin/python /tmp/kilo/phase6-review/probe_extra.py`): wrong working directory — the supervisor launched from a directory with no `scripts/smoke_run.py` fails closed in effect (the child cannot start, exit 2, no document; the recovery cannot start either; exit 2, empty stdout, the reason on stderr), which falsifies no brief guarantee because the brief documents the invocation from the repository root and names only three misuse shapes; and a hung `--resume` — the supervisor has no deadline on the recovery subprocess and was still running 20s after a lost child with empty stdout, which also falsifies no brief guarantee because the brief deadlines only the child.
NOT VERIFIED: none. Every ACCEPTANCE line was re-run and printed its own line above; the standing battery ran in full (`scripts/check-tests`, no `--fast`, `1078 passed`) which closes the implementer's `NOT VERIFIED` on the full-suite shape; the red evidence was reproduced at REV; every guarantee of the FOCUS list was re-driven live at FINAL through the supervisor as a subprocess; and no count is quoted from the brief's CONTEXT rather than re-measured.
FINDINGS:
  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.
  F7 | SEVERITY: P2 | ORIGIN: DOCUMENT | STATE: fixed
  The report's `INHERITED` block retypes rather than copies the received set (rule 2: "`INHERITED` is copied, never retyped. Take the source text and move it") and quotes a fragment — `"INHERITED: none — nothing carried into this step"` — that appears nowhere in the brief: the brief's `INHERITED` (`docs/research/phase6-supervisor-brief.md:37`–`49`) carries two verbatim blocks, the phase5 implementer's and the phase5 review's, and its own closing sentence "The copied blocks carry nothing open; nothing is carried forward."
  FIXED: no regression test — a defect in the already-committed report `9afb8a3`; a committed report is never modified and a reviewer fixes nothing, so its close is the one the form gives this class, `recorded in the review that filed it` (this review, question 5). The substance is right — both received blocks carry nothing open, so `none` is the correct value and nothing was lost or mis-carried — so nothing rides forward on its account, and the planner's next copy of the block takes the brief's own text.
SHAPES: probed by this review's four runners (`/tmp/kilo/phase6-review/probe_faces.py` — the fixture-child faces; `/tmp/kilo/phase6-review/probe_real.py` and `probe_lifetime.py` — the real head with /proc descendant tracking; `/tmp/kilo/phase6-review/probe_extra.py` — the two extra misuse-shaped faces) and by the REV worktree for the collection failure; the committed suite builds the fixture-child faces (nine pins) and nothing else, and these it does not:
  - The real-head clean drive through the supervisor (`--budget 900`): exit 0, one document, four trials, `in_flight: {}`, `committed: 12.0` == actuals `12.0`, no surviving descendant. No committed pin launches the real head through the supervisor.
  - The real-head controller death mid-comparison (`--budget 14`): exit 1, `timed_out: true`, exactly one `--resume`, `EXP-FIXED_ONE_LEVEL-1001` settled `RECOVERED` at 7.0, ledger `in_flight: {}`, `committed: 8.0` == actuals `8.0`, no surviving descendant. Unbuilt: the suite's controller-death pins are all fixture children, and no pin drives the real ledger-settling recovery.
  - The real-head controller death before any trial store (`--budget 8`): exit 1, empty stdout, `no trials directory to resume`, recovery exits 1, fail closed. Unbuilt, and also the F4 reproducer's run.
  - The real-head process tree under the expiry kill: 4 escaped sandbox descendants alive ≥15s after exit and dead by ~26–29s at `--budget 8`/`6`, none at `--budget 14`. Unbuilt — the F4 evidence, and a hand measurement under rule 7.
  - The grandchild's liveness at a fixed time after the deadline (rather than after the supervisor's exit) with a fixture grandchild: unbuilt by the delivered module (F5), built by this review's committed probe, which is green at FINAL and red under the lone-child-kill mutant.
  - The `--json` head's launch count, argv and whole `ORCHESTRATOR_*` environment on the clean and lost faces: unbuilt by the delivered module (F6), built by this review's committed probe, green at FINAL and red under the three mutants named in F6.
  - The wrong-working-directory shape and the hung-`--resume` shape (probed, no brief guarantee falsified, recorded above).
  - The REV collection failure itself: an error, not a red unit — recorded verbatim in VERIFIED as the brief directs, and counted nowhere.
  No `test_bug_*` pin is needed for these: F4–F6 are open findings whose next brief is not written, and no registration is owed to `tests/open_defects.yaml` by this review.
TRIPPED: none
PROPOSED ROWS: none
METHOD FRICTION: one deviation, recorded because the brief cites rules by number that its own routing rule keeps me from reading. The review brief's FOCUS and questions invoke "rule 14", "rule 6", "rule 3", "rule 2" and "rule 7" by number without quoting them, while AGENTS.md's routing rule ("if you were handed a brief, follow only the brief; do not read `docs/method.md`") and method.md rule 1 (whose only reviewer exception is `research/report-recurring-failures.md`) forbid the lookup that adjudicating them needs. I read only method.md's Rules section (`sed -n '89,143p'`) to adjudicate the five cited rules, and nothing else in that document; the brief should either quote the rule it invokes or exempt a reviewer's rule lookup, otherwise the actor either guesses at the rule or violates the routing rule. No other friction: the ACCEPTANCE lines ran literally under `.venv/bin/python -m pytest`, every mutant ran on a scratch worktree diffed against FINAL before its result was trusted, the delivered tree's working copy was never mutated, and the scratch worktrees were removed afterwards.
INHERITED:
  From `docs/research/phase6-supervisor-brief.md`, its `INHERITED` block verbatim (two blocks, in report order):

  INHERITED:
  none — the received INHERITED is the fixes-9 review's clean block (nothing carried, FFR-4/`DIVERGENCES CLOSED: document amended (b68be80…)` closed at the fixes-9 closeout). F1 is fixed, not carried (FINDINGS, F1). Nothing came in, nothing is open, and nothing is carried forward.

  INHERITED:
  nothing came in and nothing is open after this review. The received set is the fixes-9 review's clean block (FFR-4 closed by this step's brief text, FRK-1 fixed at `ca9a25a`, FFR-1/FFR-2/FFR-3 closed by the fixes-8 brief's text, F41 closed at the fixes-7 closeout) and nothing was carried in it; F1 is filed `fixed` by the implementer and its close form is adjudicated above, so it rides nowhere; the `ProtocolViolation` carry adjudicated in question 1 rides on a green committed pin and owes no future action; and this review's F2 is a defect in an already-committed report, which the form closes as `recorded in the review that filed it` rather than carrying. No residual row rides (rule 3: `tripped: none`).

  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.
  No residual row rides (rule 3: `tripped: none`).
