IMPLEMENTER BRIEF — phase6-supervisor-cleanup (Phase 6: absorb the leaf-cleanup probe — F19)
GOAL: The leaf-cleanup probe is a delivered pin, not a review rider: the deadline drive's container leaf is gone after the supervisor exits — asserted by `tests/test_phase6_supervisor.py` itself — and the module docstring's removal sentence names the clean-child corner it does not cover.
CONTEXT: The boundary step stands delivered with a non-terminal report row ([record.md](../record.md#record): REV `ba9e25e`); its accepted review raises no P0/P1 but carries F19 (P2, ORIGIN: CODE): the container leaf's removal is claimed (`scripts/supervise_run.py:106`–`:107`, "removed when the child is done") and demonstrated by hand at FINAL (`leaves: []` after every measured drive), but no delivered pin holds it — under a `_container_close`-leaks mutant both boundary pins stayed green 2 of 2 drives while empty leaves stood under the boundary parent. The shape is the review's committed probe (`tests/test_review_phase6_supervisor_boundary.py::test_the_deadline_drive_leaves_no_container_leaf`, green at FINAL `1 passed in 0.95s`, red under the leak mutant `1 failed in 6.01s`), which rides until the delivered module absorbs it. Folded into F19: the clean-child corner (a child exiting 0 while an adopted orphan outlives it) leaves one leaf standing after `_container_close`'s bounded 20×50ms wait (measured: exit 0, `recovered: false`, the orphan `state=S ppid=3174`) — `_container_close`'s docstring honestly names it, the module docstring does not, and the deadline contract does not cover the clean path. `REV` names the step's base — the parent of this brief commit — and is not claimed to be `FINAL`'s parent.
INHERITED:

From `docs/research/phase6-supervisor-boundary-implementer.md`, its `INHERITED` block verbatim:

  Nothing else in the received set is still open: the brief's INHERITED carried F4, F5 and F6 (each fixed at the fixes step), F7 (fixed as recorded in the review that filed it), F9 (fixed at the fixes-2 step), F10 (fixed at the fixes-2 step), F11 and F12 (each `carried`, fixed here with the red evidence above), and F8 (`fixed` as recorded in the grading-seed step, unchanged here). Still open, each copied verbatim with its ID:
    F13 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
    The brief names the pin's red as "N consecutive grades of the known-good tree produce non-identical verdicts (PASS on one run, CANDIDATE_TIMEOUT on the next)". In this environment the known-good tree's `gate-check-tests` grade is stable well under the fixture's 60.0s deadline (ten pin runs, 50 grades, ~37–46s each, every grade PASS), so the pin passes at REV. The lottery's grade-flip needs a candidate whose suite fails — a failing tree's hypothesis tests shrink, and the shrinking varies the suite's wall — and the near-deadline flip is the neutralisation test's broken-source candidate (FAIL→CANDIDATE_TIMEOUT, 3/3 at REV). The pin's assertion and the seeded determinism are correct; the brief's stated candidate is simply not the one that flips here.
    FIXED: no regression test — an ORIGIN: BRIEF finding is fixed once a later committed brief corrects the text; the pin and the seed land as delivered.

    F14 (P2, ORIGIN: DOCUMENT, carried) — the F8 red evidence is load-borne and the implementer report does not say so; a later actor re-driving the red on an idle host sees green and may conclude the red is chimeric. Next action is the planner's: carry the load condition into the carried F8 block (or a later committed brief's correction), the seed and the pins stand as delivered.

    F15 (P2, ORIGIN: CODE, carried) — killed runs leak intermediate probe trees and no janitor reaps them; the shared tmpfs inode table filled to 3 free and the standing battery's first run died ENOSPC until 81 leaked trees were pruned by hand. Next action is the harness owner's (a tombstone/janitor keyed by the run identity) or a planner ruling that scratch hygiene is each session's duty.

    F16 (P2, ORIGIN: CODE, carried) — the seeded determinism is wall-bounded: at the fixture's 60.0s deadline the near-deadline candidate's seeded grade flips FAIL→CANDIDATE_TIMEOUT under host load (measured once mid-run and once at a 62.44s wall), so the pin's green determinism is stable-half evidence only. Next action is the fixture owner's: raise the grading deadline for near-deadline candidates (the 300.0 default gives a >=5x margin here) or an OWNER ruling that the deadline's load envelope is governed, not deterministic.

    F17 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
    The brief's boundary-fix instruction is internally inconsistent (FINDINGS, F17): the double-fork pin must leave no descendant alive after the exit while the F10 q1e boundary shape must survive the fix, and the two name one live shape (a session-escaped middleman spawning a session-escaped sleeper then exiting before the deadline, the sleeper adopted by init) that no container boundary can kill and spare at once. The GOAL reading was taken (F11/F12 fixed by the container boundary, both pins green at FINAL, no committed discriminating member changed verdict); the boundary this step retires is the named init-adopted orphan, and the new boundary is what the child never forked. Next action is the planner's: a later committed brief's text correction — the q1e-survival sentence, F12's "without also catching the documented boundary" clause, and the boundary sentence in the module docstring this step corrected in code.

From `docs/research/phase6-supervisor-boundary-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 boundary implementer's INHERITED above plus its F17/F18, F11/F12/F18 fixed at FINAL, F13–F17 carried):

  From `docs/research/phase6-supervisor-boundary-implementer.md`, its `INHERITED` block verbatim:

    Nothing else in the received set is still open: the brief's INHERITED carried F4, F5 and F6 (each fixed at the fixes step), F7 (fixed as recorded in the review that filed it), F9 (fixed at the fixes-2 step), F10 (fixed at the fixes-2 step), F11 and F12 (each `carried`, fixed here with the red evidence above), and F8 (`fixed` as recorded in the grading-seed step, unchanged here). Still open, each copied verbatim with its ID:
    F13 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
    The brief names the pin's red as "N consecutive grades of the known-good tree produce non-identical verdicts (PASS on one run, CANDIDATE_TIMEOUT on the next)". In this environment the known-good tree's `gate-check-tests` grade is stable well under the fixture's 60.0s deadline (ten pin runs, 50 grades, ~37–46s each, every grade PASS), so the pin passes at REV. The lottery's grade-flip needs a candidate whose suite fails — a failing tree's hypothesis tests shrink, and the shrinking varies the suite's wall — and the near-deadline flip is the neutralisation test's broken-source candidate (FAIL→CANDIDATE_TIMEOUT, 3/3 at REV). The pin's assertion and the seeded determinism are correct; the brief's stated candidate is simply not the one that flips here.
    FIXED: no regression test — an ORIGIN: BRIEF finding is fixed once a later committed brief corrects the text; the pin and the seed land as delivered.

    F14 (P2, ORIGIN: DOCUMENT, carried) — the F8 red evidence is load-borne and the implementer report does not say so; a later actor re-driving the red on an idle host sees green and may conclude the red is chimeric. Next action is the planner's: carry the load condition into the carried F8 block (or a later committed brief's correction), the seed and the pins stand as delivered.

    F15 (P2, ORIGIN: CODE, carried) — killed runs leak intermediate probe trees and no janitor reaps them; the shared tmpfs inode table filled to 3 free and the standing battery's first run died ENOSPC until 81 leaked trees were pruned by hand. Next action is the harness owner's (a tombstone/janitor keyed by the run identity) or a planner ruling that scratch hygiene is each session's duty.

    F16 (P2, ORIGIN: CODE, carried) — the seeded determinism is wall-bounded: at the fixture's 60.0s deadline the near-deadline candidate's seeded grade flips FAIL→CANDIDATE_TIMEOUT under host load (measured once mid-run and once at a 62.44s wall), so the pin's green determinism is stable-half evidence only. Next action is the fixture owner's: raise the grading deadline for near-deadline candidates (the 300.0 default gives a >=5x margin here) or an OWNER ruling that the deadline's load envelope is governed, not deterministic.

    F17 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
    The brief's boundary-fix instruction is internally inconsistent (FINDINGS, F17): the double-fork pin must leave no descendant alive after the exit while the F10 q1e boundary shape must survive the fix, and the two name one live shape (a session-escaped middleman spawning a session-escaped sleeper then exiting before the deadline, the sleeper adopted by init) that no container boundary can kill and spare at once. The GOAL reading was taken (F11/F12 fixed by the container boundary with both pins green at FINAL, no committed discriminating member changed verdict); the boundary this step retires is the named init-adopted orphan, and the new boundary is what the child never forked. Next action is the planner's: a later committed brief's text correction — the q1e-survival sentence, F12's "without also catching the documented boundary" clause, and the boundary sentence in the module docstring this step corrected in code.

  From the same report, the carried findings' full blocks from its `FINDINGS` section, moved verbatim (the F17 block, complete; F14–F16 ride as complete inline copies above; F13 rides complete above with its FIXED line):

    F17 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
    The brief's boundary-fix instruction is internally inconsistent: it requires the double-fork pin to leave no descendant alive after the supervisor exits (GOAL, expected dispositions, the pin's spec) while also requiring that "the F10 q1e boundary shape ... still survives it — the review's discriminating member, re-driven, must stay green or the fix over-reaches" — and the two name one live shape. The F10 q1e shape (the fixes-2 implementer's SHAPES reparented-orphan boundary, probed at `--budget 3`, surviving `state=S ppid=3174`) and F12's reported variant (the fixes-2 review's double-forking fixture child) are both a session-escaped middleman spawning a session-escaped sleeper then exiting before the deadline, and F12's own text calls the shape "the named boundary at a higher fork rate"; F11's text likewise says a subreaper catches the shapes but "also catches the documented init-adopted boundary (measured against the F10 q1e shape)". cgroup membership is fixed at fork and is not changed by reparenting, so no container boundary can catch the F12 sleeper and spare the q1e orphan: they are the same process, reached the same way. The reading taken, per the brief's own instruction ("If exactly one reading is consistent, take it and file a FINDING with ORIGIN: BRIEF that names the reading you took"): the GOAL reading — F11 and F12 fixed by the container boundary with both pins green at FINAL — because the OWNER has not ruled (record.md's Owner-rulings section holds no F11/F12 ruling; its Pending section still queues the rule-13 ownership of the shape ruling, and the brief's own conditional is "If the OWNER has not ruled, deliver the container boundary"), so the narrowing branch is unavailable. The q1e clause is satisfied in the only physically possible sense: no committed discriminating member changed verdict (all 13 module pins and both review probes green at FINAL, above). Next action is the planner's: a later committed brief's text correction — the boundary sentence... (line truncated to 2000 chars)
    FIXED: no regression test — the reading is delivered in the work commit and its evidence is the two reds above and the FINAL battery above; the correction itself is a committed brief's prose, which has none.

  Expected dispositions of the received set (rule 8 forms), kept: F11/F12 fixed with red evidence (the pins at `tests/test_phase6_supervisor.py:627`/`:662`, each red at REV on the delivered sweep — re-driven by this review); F13–F16 stay carried; F17 carried; F18 fixed (the guard rides the delivered measurement; the sandbox condition re-driven by this review).

  Added by this review, each carried finding with its ID:
      F19 (P2, ORIGIN: CODE, carried) — the container leaf's removal is claimed and demonstrated but not held by any delivered pin (leak-mutant red, both boundary pins green over it); the committed probe holds the shape. Next action is the next implementer brief's (absorb the probe; devolve the module docstring's removal sentence to name the clean-child corner).
      F20 (P2, ORIGIN: CODE, carried) — the nested-grading survivor class re-sighted once at FINAL (leaked launcher/collect/pytest stack adopted by init, alive 15 minutes past the grade; red-then-green oracle re-drives); the owner is `SandboxRunner._kill` (`src/orchestrator/sandbox.py:1081`, out of scope of every phase-6 brief so far). Next action is the planner's: a brief in scope of the sandbox kill, or a load-envelope ruling folding the corpus's sandbox drives into the F16 disposition.
      F21 (P2, ORIGIN: DOCUMENT, carried) — the implementer report's module-battery line is a widened substitute (supervisor module + review module, `15 passed`) for the brief's documented command, whose own printed line the report never recites; the documented form re-ran green here (`13 passed in 12.46s`). Next action is the planner's: a committed brief or report correction of the carried note.

  F19 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  The container leaf's removal is claimed (`scripts/supervise_run.py:106`–`:107`, "removed when the child is done") and demonstrated by hand at FINAL (`leaves: []` after every measured drive), but no delivered pin holds it: under a `_container_close`-leaks mutant (the removal loop disabled on a byte-verified scratch) both boundary pins stayed green 2 of 2 drives while empty leaves of the drives stood under the boundary parent — a removal regression would go unheld by the delivered suite. Folded in: the module docstring's removal sentence is also the report's one over-claim corner — the clean-child corner (a child exiting 0 with a document while an adopted orphan outlives it) leaves one leaf standing after `_container_close`'s bounded 20×50ms wait (measured: exit 0, `recovered: false`, the orphan `state=S ppid=3174`, one leaf holding it), which the `_container_close` docstring honestly names ("A leaf still occupied after the budget … is left standing") — the deadline contract does not cover the clean path, the orphan's survival predates the boundary (nothing killed it pre-boundary either), and what the corner adds is only the standing leaf itself. Next action is the next implementer brief's: absorb the leaf-cleanup pin into `tests/test_phase6_supervisor.py` and devolve the module docstring's removal sentence to name the corner.
  FIXED: no regression test of the delivered module's own — the shape is this review's committed probe (`tests/test_review_phase6_supervisor_boundary.py::test_the_deadline_drive_leaves_no_container_leaf`), green at FINAL (`1 passed in 0.95s`) and red under the leak mutant (`1 failed in 6.01s`); it rides until the delivered module absorbs it as its own pin.

  F20 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  The nested-grading survivor class re-sighted at FINAL: this review's first oracle re-drive failed only on the determinism pin's post-run survivor sweep (the assertion at `tests/test_phase3_project_oracle.py:630`) catching a live four-process stack (two `sandbox_launcher.py` in a launcher/shim chain, the `/work/.venv` identity collect runner, the nested `pytest -m not slow`), every member adopted by init (`ppid=3174`), `state=S`, alive 15+ minutes after the grade returned PASS verdicts and the value assertions held — no grade flip, no gate-check FAIL: not the F8/F18 class. All four were SIGKILLed and confirmed gone. The reaping defect's owner is `SandboxRunner._kill` (`src/orchestrator/sandbox.py:1081`–`:1102`): a single capture-then-kill with no sweep to quiescence — the pre-F9 surface the supervisor's own sweep left behind when the phase-6 fixes ported it — and `src/orchestrator/sandbox.py` is OUT OF SCOPE of every phase-6 brief so far. `record.md`'s "left zero survivors … the class is closed by the phase-6 descendant sweep" attribution holds for `scripts/supervise_run.py`'s sweep, not for the corpus's sandbox drives; a second oracle re-drive on the same host otherwise idle returned `6 passed in 536.49s`, so the class is not a standing red — it is the load-borne half the F14/F16 dispositions already govern. Next action is the planner's: a brief in scope of `SandboxRunner._kill` (sweep to quiescence, the supervise_run fix's own pattern) or a ruling folding the corpus's sandbox drives into the F16 load-envelope ruling.
  FIXED: no regression test — the standing survivor sweep that caught the leak (`:630`) is delivered and held; the reaping defect is outside the phase-6 steps' IN SCOPE files; both re-drive lines (red, then green) are recorded here.

  F21 | SEVERITY: P2 | ORIGIN: DOCUMENT | STATE: carried
  The implementer report's supervisor-module battery line records the module battery widened by the review module (`.venv/bin/python -m pytest tests/test_phase6_supervisor.py tests/test_review_phase6_supervisor.py --durations=5` — `15 passed in 17.72s`) and never the brief's documented form (`.venv/bin/python -m pytest tests/test_phase6_supervisor.py --durations=5`) with the documented form's own printed line. The wide form is a strict superset (the module's 13 pins plus the review module's 2 probes), green, and every figure it carries is its own printed line — nothing is evaded; but the brief's acceptance names the documented command, and the report's own template requires each claimed figure to name the command that actually ran while this acceptance line names both the documented form it did not run and the wide form it did. This review ran the documented form at FINAL — `13 passed in 12.46s` — so the figures stand; what carries is the report-text deviation from the brief's named battery.
  FIXED: no regression test — a document deviation in a committed report, which only a later step (or the planner's correction of the carried note) absorbs; the documented form's gate line is in this review's VERIFIED.

Expected dispositions (rule 8 forms): F19 fixed with red evidence (the absorbed leaf-cleanup pin, red under the leak defect, green at FINAL — the probe's green `1 passed in 0.95s` and its leak-mutant red `1 failed in 6.01s` are the named red class). F20 stays carried (owner `SandboxRunner._kill`, out of scope of every phase-6 brief; the planner's next brief or a load-envelope ruling). F21 stays carried (a document deviation in a committed report, absorbed only by a later step's correction). F11/F12/F18 stay fixed as recorded in the reports that filed them. F13–F17 stay carried with their named owners and text corrections.

IN SCOPE: scripts/supervise_run.py, tests/test_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` or `tests/test_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-cleanup-brief.md`). A committed brief is never modified; a re-cut is a new file.
- `scripts/check-tests` in full: the gate script is delivered and frozen; the absorption rides as pins the tests hold, not as a gate-script edit. If the gate script needs a code change, stop and report `IN SCOPE` as insufficient.
- `src/orchestrator/sandbox.py`, `src/orchestrator/sandbox_launcher.py`, the sandbox's own kill and containment in full: F20's reaping defect (`SandboxRunner._kill`, no sweep to quiescence) is the next chain's work under a separate brief; the absorption changes no sandbox surface. If the sandbox needs a code change, stop and report `IN SCOPE` as insufficient.
- `src/orchestrator/project_oracle.py`, `tests/test_phase3_project_oracle.py`, `tests/test_review_phase6_grading_seed.py`, `tests/test_review_phase6_supervisor_boundary.py`: the seed chain is closed and the review probe rides until absorbed — this step absorbs its shape into the delivered module but never edits the probe file itself (the probe retires only when the delivered pin holds the shape; deletion, if owed, rides a later step). No grading-gate, deadline, or determinism change rides here. F21's report-text deviation is corrected in this brief's prose, not by editing any committed report.
- `src/orchestrator/oracle.py`, `src/orchestrator/experiment_phases.py`, `src/orchestrator/hidden_oracle.py`, `src/orchestrator/conformance.py`: no grading-runner, calibration, probe-shape, or trusted-gate 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 absorbs the probe.
- Every committed test module except the IN SCOPE pin module — `tests/test_review_phase6_supervisor.py`, `tests/test_run_entry.py`, `tests/test_axis2_robustness.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 (F19 is the open finding whose next brief is this one; no `test_bug_*` name — the open-defect registry would then own it).
- 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 --durations=5
    scripts/check-static
    scripts/check-docs
    scripts/check-scope c6d2d7a <FINAL> docs/research/phase6-supervisor-cleanup-brief.md

Every `pytest` line names `.venv/bin/python -m pytest` deliberately (the interpreter rule: the bare `pytest` on PATH has no `pytest-timeout` and `pytest.ini`'s `strict_config = true` rejects it — run these lines exactly as written and claim them under these names). The supervisor 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 the supervisor script's docstring and its pin module, so the line is the step's own battery — the oracle line is not named because the probe runs no trial and no sandboxed suite). 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 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.

The absorbed pin (`tests/test_phase6_supervisor.py`, in place — the review probe's shape, absorbed as the module's own): a full escaped-forker deadline drive (the F11 scenario at the delivered boundary pins' own `--budget 0.4`) asserts the drive's container leaf is gone after the supervisor exits. The leaf set is diffed before and after the one drive (a fresh measurement window around it, the same 5.0s window the probe uses), so concurrent suites' leaves are never this assertion — the probe's own form, moved, not re-derived. The pin reuses the module's helpers (`_run_supervisor`, `_single_document`, `_boundary_available` for the skip) — no new helper surface except the leaf-listing the shape needs (the probe's `_boundary_leaves` form: `supervise_run._container_boundary` plus the `orchestrator-supervisor-` prefix glob). Skip discipline is the delivered pins' pattern, decided by the supervisor's own measurement: where no cgroup v2 delegation exists the leaf cannot exist, so the drive is skipped and the nested gate carries no cost. The pin carries `@pytest.mark.timeout(120)`: the escaped-forker drive at `--budget 0.4` plus the freeze-and-sweep passes, the bounded leaf-removal wait, and the 5.0s measurement window must fit inside one test's wall budget with margin for a loaded host (expected, with basis, per rule 15 — set from the measured module walls at REV: `13 passed in 12.46s`, slowest `3.52s tree pin`, `2.52s double-fork pin`, `0.86s escaped-forker pin`).

The docstring devolution (`scripts/supervise_run.py`, in place — the module docstring's removal sentence only): the "removed when the child is done" sentence (`:106`–`:107`) devolves to name the clean-child corner — a leaf still occupied after `_container_close`'s bounded budget is left standing by construction, and the deadline contract does not cover the clean path. No kill-surface change rides: `_container_close`, its budget (`CONTAINER_REMOVALS = 20`, `CONTAINER_REMOVAL_SETTLE = 0.05`), and the sweep loop stand untouched. If the docstring's sentence cannot be devolved without touching the kill surface, stop and report `IN SCOPE` as insufficient.

The module docstring's red block (`tests/test_phase6_supervisor.py`, in place — prose only): the red block records the absorbed pin as the cleanup step's red — green at FINAL, red under the `_container_close`-leaks defect (the probe's measured class: `1 failed in 6.01s` against the delivered close). No pin-count change beyond the one absorbed pin: the module grows by exactly one test.

Red evidence at `REV` `c6d2d7a` (each unit must be replayable; the supervisor module is green at REV modulo the riding probe, so the red is the probe's own measured class re-driven at REV on a scratch copy diff-verified against `git show c6d2d7a:…` before use). `FIXED` names the pin's node id, the command, the named failing assertion, and the delivered file's line numbers or none. Named reds to produce: F19's leaf-leak red — at REV, with `_container_close`'s removal loop disabled on the scratch, the absorbed pin's leaf-set assertion fails (leaves left standing under the boundary parent — the probe's `1 failed in 6.01s` class); the two boundary pins stay green over the same mutant (the unheld residue the absorption closes). An error or a hang is not red, the assertion must be the thing that failed.

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:

- `Leaf-cleanup shape` (F19): a deadline drive's container leaf is gone after the supervisor exits — the absorbed pin, red at REV under the leak defect, green at FINAL.

EXPECTED WALLS: the measured baseline at this brief's drafting: `scripts/check-tests --fast` — `979 passed, 108 deselected in 95.17s (0:01:35)`; `scripts/check-docs` — `391 Total / 180 Unique / 391 OK / 0 Errors`; `scripts/check-static` — exit 0, gated `All checks passed!`, advisory `Found 104 errors.` unchanged; `.venv/bin/python -m pytest tests/test_phase6_supervisor.py --durations=5` — `13 passed in 12.46s` (boundary review's VERIFIED at FINAL `c218654`: slowest `3.52s tree pin`, `2.52s double-fork pin`, `2.33s killed-child pin`, `0.91s racing-fork pin`, `0.86s escaped-forker pin`). The absorbed pin's `120`s timeout is set from these walls plus the 5.0s measurement window with margin for a loaded host — expected, with basis, per rule 15.

REV: c6d2d7a
CLOSE OUT: no
DIVERGENCES: none
REVIEW: one session — the absorption above all: does the absorbed pin reproduce the probe's shape live at REV (the leaf-set assertion red under the leak defect, both boundary pins green over the same mutant), does the devolved docstring name the clean-child corner without touching the kill surface, 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 (the probe file itself untouched — it retires only when the delivered pin holds the shape). Whether anything remains open after this step — F20's sandbox-kill brief, F21's text correction — 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. A new module under tests/ that runs trials or sandboxed suites carries
pytestmark = pytest.mark.slow at module level: the oracle's internal gate runs the fast suite
(-m "not slow") and an unmarked trial-running module breaks it. 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.
