IMPLEMENTER BRIEF — phase6-sandbox-sweep (Phase 6: the sandbox kill sweeps to quiescence — F20)
GOAL: The nested-grading survivor class is closed by the sandbox's own kill: a racing-forker workload that double-forks past teardown leaves no descendant alive after `SandboxRunner._kill` returns — pinned by `tests/test_batch3_execution.py` itself — and the Record's sweep attribution covers the corpus's sandbox drives, not only the supervisor's sweep.
CONTEXT: The phase-6 chain stands delivered with non-terminal report rows ([record.md](../record.md#record): REV `ba9e25e`, `c6d2d7a`); its accepted reviews converge (no P0/P1) but carry F20 (P2, ORIGIN: CODE): the boundary review's first oracle re-drive caught a live four-process stack adopted by init, alive 15+ minutes past the grade — 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. The fix is the supervise_run fix's own pattern (`scripts/supervise_run.py:193`–`:216`): capture, kill, re-capture until the chain is empty or a bounded retry budget expires. `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-cleanup-implementer.md`, its `INHERITED` block verbatim:

  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, 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 senten... (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.

  Received F19 is fixed by this step (above), so it does not ride; received F20 and F21 stay carried with their named owners. Added by this step: F22 (P2, ORIGIN: BRIEF) — the brief's review-block copy of the carried F17 finding is truncated mid-sentence (the literal `(line truncated to 2000 chars)` marker), which rides as a carried text-correction to the planner.

From `docs/research/phase6-supervisor-cleanup-review.md` — its `INHERITED` block's received F19/F20/F21/F22 dispositions only (the chain above is already carried verbatim through the cleanup implementer's INHERITED, and rule 2 governs the planner's copy of this block; the review's received set is the cleanup brief's carried F20/F21 plus its F19/F22, F19 fixed at FINAL, F20/F21/F22 carried):

  Expected dispositions of the received set (rule 8 forms), kept: received F19 fixed by this step (the absorbed pin, re-driven by this review — red under the leak defect at REV, green at FINAL); F13-F17 stay carried; F20 and F21 stay carried (each with its named next action); F11/F12/F18 stay fixed as recorded in the reports that filed them. Added by this review: none.

Expected dispositions (rule 8 forms): F20 fixed with red evidence (named below — the sandbox sweep closes the racing-fork survival, red on the delivered `_kill`, green at FINAL). F21 stays carried (a document deviation in a committed report, absorbed only by a later step's correction). F11/F12/F18/F19 stay fixed as recorded in the reports that filed them. F13–F17/F22 stay carried with their named owners and text corrections.

IN SCOPE: src/orchestrator/sandbox.py, tests/test_batch3_execution.py
RESIDUALS:

none — rule 3 selection for this brief's `IN SCOPE`: no `docs/residuals.md` trigger glob matches `src/orchestrator/sandbox.py` or `tests/test_batch3_execution.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-sandbox-sweep-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 sweep rides as runner code the tests pin, not as a gate-script edit. If the gate script needs a code change, stop and report `IN SCOPE` as insufficient.
- `scripts/supervise_run.py`, `tests/test_phase6_supervisor.py`, `tests/test_review_phase6_supervisor_boundary.py`: the supervisor chain is delivered; no supervisor, boundary, or leaf change rides here. The supervisor's freeze-and-sweep loop is the pattern, not the patient.
- `src/orchestrator/sandbox_launcher.py`: the launcher's own kill and containment stand; the defect is the runner-side `_kill`, not the launcher. If the launcher 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`: the seed chain is closed; no grading-gate, deadline, or determinism change rides here.
- `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 sweeps the sandbox kill.
- Every committed test module except the IN SCOPE pin module — `tests/test_milestone3_sandbox.py`, `tests/test_axis2_robustness.py`, `tests/test_phase6_supervisor.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 (F20 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_batch3_execution.py --durations=5
    scripts/check-static
    scripts/check-docs
    scripts/check-scope d9c660e <FINAL> docs/research/phase6-sandbox-sweep-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 batch3 line rides because this brief's IN SCOPE touches files under `src/` 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 sandbox runner and its pin module, so the line is the step's own battery — the oracle line is not named because the pin runs no trial and no sandboxed suite beyond its own probe drives). 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 sweep fix (`src/orchestrator/sandbox.py`, in place — `SandboxRunner._kill` only): the single capture-then-kill becomes capture, kill, re-capture until the descendant chain is empty or a bounded retry budget expires — the supervise_run fix's own pattern. Each pass re-walks `/proc` from the launcher pid (`_descendants`), signals the freshly captured set (killpg, then the per-pid SIGKILL the delivered code already performs), and settles briefly so reparented children land in the next capture; the loop exits when a capture returns empty or the budget (a module-level pass cap in the single digits, the supervisor's own `SWEEP_PASSES`-class bound) expires. The cgroup arm stands first where a cgroup exists (the delivered `cgroup.kill()` line is untouched); the sweep is the no-cgroup arm's quiescence, and where both exist they compose — the launcher's reparented stack dies by the tree walk even where delegation is absent. `_teardown`'s survivor verification (`_await_dead` over `killed + killed_now`, the `processes survived teardown` error) stands unchanged: the sweep feeds it an empty-or-bounded remainder, never a weaker claim. No new exception class, no signature change (`_kill(process, cgroup) -> list` stands — the returned list is the union of the passes' captures), no launcher change. If the sweep cannot be delivered inside `_kill` without touching the launcher or the teardown contract, stop and report `IN SCOPE` as insufficient.

The racing-fork pin (`tests/test_batch3_execution.py`, in place — the module's next test after the F1 escape pin): a workload that forks session-escaped `sleep` grandchildren in a loop across teardown, then double-forks one sleeper whose middleman exits before the kill (F20's stack shape: launcher/shim chain plus a reparented sleeper adopted by init). The drive runs the runner with a short wall (the delivered F1 pin's `should_cancel`-on-marker form or a `wall_seconds` overrun — the module's own forms, moved, not re-derived), and asserts no `/work/probe.py` descendant survives teardown (the module's `_probe_pids` form: `assert survivors == []`). The pin reuses the module's `_probe_plan`/`_caps` surface (`_caps` fails closed where NAMESPACE_V1 is unavailable — the module's own discipline; where the sandbox cannot run, the pin skips the same way). The pin carries `@pytest.mark.timeout(120)`: the fork loop across the wall plus the sweep passes and the post-teardown `/proc` walk must fit inside one test's wall budget with margin for a loaded host (expected, with basis, per rule 15 — set from the F1 pin's own measured walls at REV, quoted in EXPECTED WALLS).

Red evidence at `REV` `d9c660e` (each unit must be replayable; the batch3 module is green at REV, so the red is written by this step and demonstrated at REV on a scratch copy diff-verified against `git show d9c660e:…` 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: F20's racing-fork red — at REV, with the delivered single-capture `_kill`, the racing forker's final tail forks plus the double-forked sleeper survive teardown adopted out-of-tree (the named failing assertion is the pin's post-teardown `_probe_pids` survivor assertion — the F20 stack class the boundary review measured; 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:

- `Sandbox-sweep shape` (F20): a racing forker's tail plus a double-forked sleeper are dead after sandbox teardown — the racing-fork pin, red at REV on the delivered `_kill`, green at FINAL.

EXPECTED WALLS: the measured baseline at this brief's drafting: `scripts/check-tests --fast` — `980 passed, 108 deselected in 103.55s (0:01:43)`; `scripts/check-docs` — `393 Total / 180 Unique / 393 OK / 0 Errors` (this session's HEAD line); `scripts/check-static` — exit 0, gated `All checks passed!`, advisory `Found 104 errors.` unchanged. The batch3 module walls at REV are not yet measured by a report with VERIFIED lines for these IN SCOPE files — the first VERIFIED lines this step writes set the budgets; the pin's `120`s timeout is set from the F1 escape pin's own shape (a full sandbox setup plus a 120s sleeper under a marker-cancelled drive) with margin for a loaded host — expected, with basis, per rule 15.

REV: d9c660e
CLOSE OUT: no
DIVERGENCES: none
REVIEW: one session — the sweep above all: does the pin reproduce F20's stack live at REV (the named failing survivor assertion, red on the delivered `_kill` — an error or a hang is not red), does the sweep close the shape with one seam over the whole descendant surface (capture, kill, re-capture to quiescence or a bounded budget — not another enumerated list of cases, rule 13), 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 — 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.
