REVIEW BRIEF — phase6-supervisor-boundary (Phase 6: the sweep's whole-tree predicate — F11/F12's out-of-group shapes and the container boundary)
REV: ba9e25e34ae5091e329469aab8c099675741f60d
FINAL: c2186543f356755d2102457b56f0283ffec4e6f0
REVIEW ACCEPTANCE: scripts/check-scope ba9e25e34ae5091e329469aab8c099675741f60d c2186543f356755d2102457b56f0283ffec4e6f0 docs/research/phase6-supervisor-boundary-brief.md
FOCUS: the boundary above all — does each pin reproduce its carried shape live at REV (the named failing liveness assertion, red on the delivered sweep), does the cgroup leaf close both shapes with one seam that adoption cannot leave (cgroup membership fixed at fork, unchanged by reparenting — measured, not assumed), does the F10-q1e survival clause hold or fall as F17 claims (same live shape as F12, caught and killed by the same leaf), and does the sandbox skip guard keep the nested oracle line green without weakening the pins where the boundary exists.
SEVERITY SCALE: P0 blocks the step; P1 is serious; P2 is minor.
QUESTIONS TO ATTACK:

  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.

  F18 | SEVERITY: P1 | ORIGIN: BRIEF | STATE: fixed
  The boundary pins as the brief specifies them — unconditional post-exit liveness assertions — fail inside the R08 grading sandbox, reddening the standing oracle line on a good tree. The nesting is structural: `gate-check-tests` runs the suite's deterministic subset (`check-tests --fast` minus the runner-spawning modules) inside a sandbox whose fresh root mounts no `/sys` and whose `mountinfo` carries no cgroup2 (measured above), so the supervisor's boundary is unavailable there and the sweep alone cannot reach the out-of-group shapes — F11/F12's own finding. Measured on the unguarded intermediate delivery: `.venv/bin/python -m pytest tests/test_phase3_project_oracle.py` went `3 failed, 3 passed in 299.19s (0:04:59)` — the five-case corpus's `ExperimentError: calibration case 'known-good' classified 'FALSE_SUCCESS', expected 'CORRECT_ACCEPTANCE'` at `src/orchestrator/experiment_phases.py:265` (call `36.62s`), the determinism pin's `assert verdicts == [oracle.GRADE_PASS] * runs` at `tests/test_phase3_project_oracle.py:621` (call `178.53s`), and the neutralization test's benign-tree `assert grade_one("gate-check-tests", benign_tree) == oracle.GRADE_PASS` at `:444` (call `75.37s`) — every failure the same nested `gate-check-tests: FAIL` on a known-good tree, probed directly (`oracle.grade_manifest` printing `gate-check-tests: FAIL`, the nested suite at `35.5s` inside its `60.0s` budget: a value failure, not a timeout). The fix rides in scope: both pins measure the boundary's availability through the supervisor's own measurement (`_boundary_available`, `tests/test_phase6_supervisor.py:362`) and skip where no cgroup v2 delegation exists — a skip whose reason names the measurement, and which is also what makes the REV red work (a supervisor without the measurement runs the pin and fails on its assertion). With the guard the oracle line is green again (VERIFIED's `6 passed in 490.83s`) and the sandbox's condition shows `11 passed, 2 skipped`.
  FIXED: the guard at `tests/test_phase6_supervisor.py:362` and its two call sites (`:638`, `:676`); the failing assertions named above were re-driven green by `.venv/bin/python -m pytest tests/test_phase3_project_oracle.py` — `6 passed in 490.83s (0:08:10)` — and the sandbox condition by the `/sys`-shadowed namespace drive — `11 passed, 2 skipped in 7.25s`. (Template note: those assertions live against this step's unguarded intermediate delivery, not at REV — the oracle line's REV baseline is the seed closeout's own FINAL run, `6 passed in 576.05s` at `b852fd4`, whose oracle module and `project_oracle.py` are byte-identical at `ba9e25e` (the intervening commits add only `tests/test_review_phase6_grading_seed.py`) — so the FIXED form names the intermediate run's assertions and the two re-drive commands.)

  the report template's FIXED form ("the named failing assertion at REV") has no room for a regression authored and fixed inside one step before any commit: F18's red exists only against this step's unguarded intermediate delivery (the oracle line's REV baseline is the seed closeout's green run on a byte-identical module), so the FIXED line names the intermediate run's assertions and the two re-drive commands instead. No other departure: every field here is filled and nothing outside the template is added, and the brief's pin specification against the sandboxed nested gate is filed as a FINDING (F18), not friction.

  1. The boundary above all — the delivery's one question. Drive it live against FINAL on scratch copies diff-verified against `git show ba9e25e:…` before use: (a) each pin reproduces its carried shape at REV on the delivered sweep — the escaped-forker pin's post-exit forked-PID liveness assertion (`:656`, the 1-to-3-of-80-class survival) and the double-fork pin's post-exit sleeper-PID liveness assertion (`:691`, the 11-of-11-class structural survival) — each a named failing assertion after the supervisor's exit, no error, no hang, no collection failure; (b) at FINAL the cgroup v2 leaf (`_container_join`'s pre-exec write `:185`, `_container_kill` riding every sweep pass `:209`, `_container_close`'s bounded removal `:237`) leaves both shapes' recorded PIDs dead after the exit — measured, including the mechanism the implementer names (an adopted sleeper, `ppid` of init, killed inside the leaf; the delegation's leaves at `0`, cleaned up not leaked); (c) the pre-exec join is load-bearing, not stylistic — the post-`Popen` join loses in-window forks (the F12 sleeper stays in the parent cgroup and survives) — re-drive the join placement or falsify the claim. Report each guarantee as falsified-with-reproducer or attacked-and-not-falsified with the method. Then the structural question: one seam over the whole surface, or another enumerated list of cases (rule 13) — does the leaf reach what adoption cannot move for every descendant the child forks, or only for the two pinned shapes?

  2. F17's one-reading claim. The implementer's F17 says the brief's F10-q1e survival clause and the double-fork GOAL name one live shape (session-escaped middleman, session-escaped sleeper, middleman exits before the deadline, sleeper adopted by init) that no container boundary can kill and spare at once — cgroup membership fixed at fork, unchanged by reparenting — so the GOAL reading was taken and the q1e clause satisfied only as "no committed discriminating member changed verdict". Verify against the delivered code and the fixes-2 evidence: are the q1e shape and F12's variant the same process reached the same way (re-drive the q1e probe shape against the delivered supervisor and name what survives), and is there truly no second consistent reading (a boundary that kills the F12 sleeper inside the leaf yet spares an init-adopted orphan outside it — which orphan, forked by whom, in which cgroup)? If F17's identity claim holds, the brief's q1e clause is dead text and the boundary sentence moves as the implementer records; if it fails, the fix over-reaches and the step returns. File a finding per falsified class.

  3. F18's guard and the nested gate. F18 is filed fixed: the unconditional pins reddened the standing oracle line inside the R08 grading sandbox (no `/sys`, no cgroup2 — `3 failed, 3 passed`, every failure the same nested `gate-check-tests: FAIL` on a known-good tree), and the guard (`_boundary_available`, `:362`, skip naming the measurement) restores it (`6 passed in 490.83s`; sandbox condition `11 passed, 2 skipped`). Adjudicate: (a) re-drive the sandbox condition (fresh root, no cgroup2, `/sys` absent) and the oracle line at FINAL and name the outcomes — does the guard hold the nested gate green on a good tree; (b) the guard's cost — where the boundary is unavailable the pins skip, so the out-of-group shapes go unpinned there by construction: is the skip a sound availability guard (the boundary cannot exist, the sweep stands alone and says so) or does it weaken the pins into conditional evidence that passes exactly where it cannot fail — and does the REV red still work (a supervisor without the measurement runs the pin and fails on its assertion)? (c) the FIXED form's template departure — intermediate-delivery assertions instead of REV assertions — is the departure honest (the oracle module byte-identical between `b852fd4` and `ba9e25e`, the seed closeout's green run as baseline) or does it bury a REV red that was never demonstrated?

  4. The report's forms and counts (J-class). `FINAL` is the work commit `c2186543f356755d2102457b56f0283ffec4e6f0`, never the report commit `69e0077` — verify rather than taking the report's word. Re-run the brief's ACCEPTANCE lines at FINAL (fast suite `978 passed, 108 deselected` with the delta exactly the two new pins against the REV scratch's `976 passed, 108 deselected`; the supervisor module battery; static gated `BLE001,S110` clean with advisory `Found 104 errors.` unchanged; docs printed line with 0 errors — every figure the gate's own printed line, rule 14, never the REV line quoted in CONTEXT); `TRIPPED: none` matches check-scope's `tripped:` line and REVIEW ACCEPTANCE is green run first. `git diff ba9e25e34ae5091e329469aab8c099675741f60d c2186543f356755d2102457b56f0283ffec4e6f0 --stat` touches only the IN SCOPE files plus the brief (no committed test edit outside them — verify, including the `tests/test_phase3_project_oracle.py` and `tests/test_review_phase6_grading_seed.py` lines the report re-drove: re-driven, not edited). `SHAPES`' launch-window race ("closed by construction", unpinned), clean-child residue (one leaf holding one orphan on the exit-0 corner, unpinned), and no-cgroup skip against rule 7: each names its reason, but adjudicate whether "closed by construction" and unpinned residues bury shapes the suite should build — which pin goes red on which member if the pre-exec join regresses to post-`Popen`, if `_container_close` leaks the leaf, if the clean-child corner's orphan escapes the leaf? `INHERITED`'s F11/F12 fixed-close and F13–F16 carries against the received set. Every field of the report present and filled, nothing outside the template added. Standing battery: `scripts/check-tests` (your full run — record it in `VERIFIED`).

--- BEGIN BRIEF UNDER REVIEW (copy of docs/research/phase6-supervisor-boundary-brief.md; the committed file is authoritative) ---
IMPLEMENTER BRIEF — phase6-supervisor-boundary (Phase 6: pin the session-escape boundary — F11/F12)
GOAL: The sweep's named boundary is a committed pin, not a probe: a session-escaped-forker fixture child (F11's shape) and a double-forking predecessor-exited fixture child (F12's shape) each leave no descendant alive after the supervisor exits — or the boundary stands pinned as surviving out-of-tree with the whole-tree sentence narrowed to the in-group forker surface.
CONTEXT: The supervisor chain's three steps stand committed with non-terminal report rows ([record.md](../record.md#record): REV `307aaa0`, `9b78d7a`, `2da5a5a`); the chain converges only when its `INHERITED` carries no finding. What stands open is the fixes-2 review's session-escape boundary against the freeze-and-sweep loop (`scripts/supervise_run.py:192`–`:216`, FINAL `0459c5b`): a session-escaped forker outside the frozen group re-opens the capture window every pass — 2 of 80 / 1 of 80 / 2 of 77 / 3 of 79 / 2 of 79 final tail forks survive adopted out-of-tree — and the double-forking variant with the middleman gone before the deadline survives 11 of 11, 10 of 10 alive ([record.md](../record.md#pending-for-the-owner), rule 11). Both shapes survive by adoption, so no kill technique reaches them without also catching the documented init-adopted boundary (the F10 q1e shape) — only a container boundary (cgroup/pid-namespace, which a process cannot leave by adoption) or an OWNER ruling narrowing the whole-tree sentence reaches them. The seed chain is closed (grading-seed closeout, REV `0c02b27`): F8 stays fixed, F14–F16 ride this brief's INHERITED as carried P2s with other owners, and [self-host.md](../self-host.md#phase-6-operational-envelope) names this boundary as phase 6's one open remainder. `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-fixes-implementer.md`, its `INHERITED` block verbatim:

  Nothing in the received set is still open: the brief's INHERITED carried F4, F5 and F6 (each `carried`), all three are fixed here — F4 fixed by the descendant-chasing kill over the supervisor's whole surface (its falsified absolute made structurally true, post-exit liveness of a session-escaped grandchild pinned at `tests/test_phase6_supervisor.py:432`), F5 fixed by absorbing the review's discriminating member into the merged tree pin (fixed-time assertion at `:416`), F6 fixed by absorbing the review's child-head observation as `tests/test_phase6_supervisor.py::test_the_child_head_receives_the_whole_environment_and_runs_once` (`:450`) — and F7 stays `fixed` as recorded in the review that filed it, unchanged. Added by this step, each carried finding with its ID:
    F8 (P2, ORIGIN: CODE, carried) — the phase3 oracle fixture's gate-check grade is a hypothesis-seed lottery: the frozen corpus's unseeded in-sandbox suite (24–67s per draw) exceeds the fixture's 60.0s per-check deadline on heavy draws and flips correct grades (FAIL→CANDIDATE_TIMEOUT; CORRECT_ACCEPTANCE→FALSE_SUCCESS). Next action is the fixture's owner: raise `gate_timeout_seconds` toward the 300.0 default or fix the in-sandbox gate's hypothesis seed/profile (both files are outside this brief's scope).

From `docs/research/phase6-supervisor-fixes-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 fixes brief's carried F4/F5/F6, all three fixed at FINAL, F7 fixed as recorded):

  Nothing in the received set is still open: the fixes brief carried F4, F5 and F6 (each `carried`), and all three are fixed at FINAL — F4 fixed by the descendant-chasing kill over the captured surface (session-escaped grandchild dead after the exit, pinned at tests/test_phase6_supervisor.py:432; real-head `--budget 8` leaves no descendant at the exit or 15s after), F5 fixed by the absorbed discriminating member (fixed-time assertion at :416, red under the lone-child-kill mutant), F6 fixed by the absorbed child-head observation (tests/test_phase6_supervisor.py:450, red under the double-launch, dropped-secret, and added-variable mutants) — and F7 stays `fixed` as recorded in the review that filed it, unchanged. Added by this review, each carried finding with its ID:
    F9 (P1, ORIGIN: CODE, carried) — the descendant sweep cannot reach what is born or reparented after the chain capture: tail forks of a racing forker (3 of 331) and a doubly-escaped orphan adopted by init survive the deadline kill by construction. Next action is the planner's per rule 13: re-walk-and-sweep to quiescence or an OWNER ruling narrowing the whole-tree sentence to the captured-at-deadline surface.
    F8 (P2, ORIGIN: CODE, carried) — the phase3 oracle fixture's gate-check grade is a hypothesis-seed lottery (60.0s fixture deadline vs unseeded in-sandbox draws, green at FINAL). Next action is the fixture's owner: raise `gate_timeout_seconds` toward the 300.0 default or pin the in-sandbox gate's hypothesis seed/profile.

  F9 | SEVERITY: P1 | ORIGIN: CODE | STATE: carried
  The descendant sweep cannot reach a process forked between the chain capture and the group kill, nor one already reparented out of the chain: a racing fixture child that forks session-escaped `sleep 60` grandchildren every ~5ms across the 2s deadline leaves 3 of 331 forked PIDs alive after the exit — always the final three forks (2495117, 2495118, 2495119 of 331), i.e. born after `_descendants` walked /proc; and a doubly-escaped orphan (a session-escaped middleman that spawns a session-escaped sleeper then exits, so the sleeper is adopted by PID 3174/systemd before the deadline) survives the kill still adopted out-of-tree (`state=S ppid=3174` after exit 1). The delivered sweep is capture-then-signal over numeric PIDs with no re-walk and no container boundary, so anything born-or-reparented after the snapshot is outside the surface by construction.
  FIXED: no regression test — both reds are this review's hand-driven probes on scratch fixture children (`/tmp/kilo/q1d_window2.py`, `/tmp/kilo/q1e_rerun.py`), not committed pins; no committed module was edited by this review. Next action is the planner's per rule 13: re-walk-and-sweep to quiescence (capture, kill, re-capture until the chain is empty or a bounded retry budget expires), or an OWNER ruling narrowing the whole-tree sentence to the captured-at-deadline surface; the PID-reuse corner needs no action (capture-to-kill is adjacent statements, pid_max 4194304, no I/O between — recycle inside the window is not a live shape).

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

  Nothing in the received set is still open: the brief's INHERITED carried F9 (P1, carried) and F8 (P2, carried). F9 is fixed here — the racing-fork pin at tests/test_phase6_supervisor.py:491 and the sweep-to-quiescence fix at scripts/supervise_run.py:193–:216 — and F8 stays carried, its owner named below. Added by this step, each carried finding with its ID: none (F10 is fixed, not carried).
    F8 (P2, ORIGIN: CODE, carried) — the phase3 oracle fixture's gate-check grade is a hypothesis-seed lottery: the frozen corpus's unseeded in-sandbox suite (24–67s per draw) exceeds the fixture's 60.0s per-check deadline on heavy draws and flips correct grades (FAIL→CANDIDATE_TIMEOUT; CORRECT_ACCEPTANCE→FALSE_SUCCESS). Next action is the fixture's owner: raise `gate_timeout_seconds` toward the 300.0 default or fix the in-sandbox gate's hypothesis seed/profile (both files are outside this brief's scope).

From `docs/research/phase6-supervisor-fixes-2-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 fixes-2 brief's carried F9/F8, F9 fixed at FINAL, F8 carried):

  Nothing in the received set is still open: the brief's INHERITED carried F9 (P1, carried) and F8 (P2, carried). F9 is fixed here — the racing-fork pin at tests/test_phase6_supervisor.py:491 and the freeze-and-sweep fix at scripts/supervise_run.py:193–:216 — and F8 stays carried, its owner named below. Added by this review, each carried finding with its ID:
    F11 (P1, ORIGIN: CODE, carried) — a session-escaped forker outside the frozen group re-opens the capture window every pass; its final tail forks survive adopted by init. Next action is the planner's per rule 13: a container boundary or an OWNER ruling narrowing the whole-tree sentence to the in-group forker surface.
    F12 (P2, ORIGIN: CODE, carried) — a double-forking shape whose middleman exits before the deadline falls outside the surface by construction (the named boundary at a higher fork rate). Next action is the planner's: pin the boundary explicitly or narrow the whole-tree sentence the same way F11 goes.

  F11 | SEVERITY: P1 | ORIGIN: CODE | STATE: carried
  A session-escaped forker — a fixture child whose forker itself runs session-escaped (outside the frozen group) — re-opens the capture window every pass: its tail forks are born after the frozen chain's captures and are adopted by init at the pass boundary, so no pass from the child pid reaches them, and the sweep converges while they survive. Measured live against the sweep-to-quiescence fix at FINAL `0459c5b` (re-driven across three runs and an at-deadline variant): 2 of 80 / 1 of 80 / 2 of 77 / 3 of 79 / 2 of 79 final tail forks survive, always the final tail, adopted out-of-tree (`state=S ppid=3174`); a double-forking variant with the middleman exiting before the deadline survives 11 of 11, 10 of 10 alive (the named boundary at a higher fork rate). A subreaper would catch them but also catches the documented init-adopted boundary (measured against the F10 q1e shape), so the surface cannot be extended by a kill technique — only by a container boundary (cgroup/pid-namespace) that adoption cannot leave, or by an OWNER ruling narrowing the whole-tree sentence to the in-group forker surface.
  FIXED: no regression test — a review probe on a scratch fixture, not a committed pin; no committed module was edited by this review. Next action is the planner's: pin the boundary explicitly or narrow the whole-tree sentence the same way F11 goes; OUT OF SCOPE names the missing boundary explicitly, so this finding leaves as carried and does not block.

  F12 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  A session-escaped forker whose middle layer exits before the first capture leaves its children outside the surface by construction: the sweep's process-group freeze cannot reach a forker that is already init's child, the client's freeze-and-slow-findings kill is checked within the same untouched-except-watchdog / in-scope-group invariant, and every source-level variant of the post-freeze sweep trialled upstream died trying to cross the same line (the adopted process is init's child). The reported variant drives a double-forking fixture child (a session-escaped middleman that spawns a session-escaped sleeper, then exits before the deadline) against the sweep-to-quiescence fix at FINAL `0459c5b`: the sleeper survives adopted out-of-tree, and the survival is structural, not a fork-rate accident — the middleman's early exit is the mechanism. Re-driven across three runs and lower fork-rate variants it survives session-escaped at 11 of 11, 10 of 10 alive (the named boundary at a higher fork rate). Only a container boundary (cgroup/pid-namespace, which a process cannot leave by adoption) reaches it without also catching the documented boundary; absent that the ruling narrows the whole-tree sentence the same way F11 goes.
  FIXED: no regression test — a review probe on a scratch fixture, not a committed pin; no committed module was edited by this review. Next action is the planner's: pin the boundary explicitly or narrow the whole-tree sentence the same way F11 goes; OUT OF SCOPE names the missing boundary explicitly, so this finding leaves as carried and does not block.

  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.

From `docs/research/phase6-grading-seed-review.md` — its `INHERITED` block's appended findings only (the chain above is already carried verbatim through the seed implementer's INHERITED, and rule 2 governs the planner's copy of this block; the review's received set is the seed brief's carried F8/F11/F12, F8 fixed at FINAL, F11/F12 carried):

  Added by this review, each carried finding with its ID:
    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.

Expected dispositions (rule 8 forms): F11 and F12 fixed only with red evidence at REV (the boundary pins, red on the delivered sweep, green at FINAL — or narrowed with an OWNER ruling's next action consumed as written). F8 stays fixed as recorded in the review that filed it (F14's load-condition text rides the carried F8 block below only when the OWNER rules the F14 wording; this brief does not rewrite it). F13 stays carried (an ORIGIN: BRIEF finding is fixed once a later committed brief corrects the text — that correction is not this brief's). F14/F15/F16 stay carried with their named owners (F14 the planner's text carry, F15 the harness owner's janitor or a scratch-hygiene ruling, F16 the fixture owner's deadline raise or a load-envelope ruling — none is this step's).

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-boundary-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 boundary rides as supervisor 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.
- `src/orchestrator/sandbox.py`, `src/orchestrator/sandbox_launcher.py`, the sandbox's own kill and containment in full: this step's boundary lives in the supervisor's expiry kill, not the sandbox's launcher. 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`: the seed chain is closed; no grading-gate, deadline, or determinism change rides here. F14's load-condition text and F16's deadline are their owners', not this step's.
- `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 pins the boundary.
- 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 (F11/F12 are the open findings whose next brief is this one; no `test_bug_*` name — the open-defect registry would then own them).
- 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 ba9e25e <FINAL> docs/research/phase6-supervisor-boundary-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 carries `--durations=5` (the budgets rule: the boundary pins' fork-rate and settle walls are set from measured per-test walls). 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 and its pin module, so the line is the step's own battery). 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 boundary pins (`tests/test_phase6_supervisor.py`, in place — two pins, one per shape, named below): each pin drives the supervisor's own kill path against a fixture-child scenario that reproduces the carried shape, and asserts no descendant of the child survives the supervisor's exit. The `escaped-forker` pin's fixture scenario is a child whose forker itself runs session-escaped (outside the frozen group — F11's shape): the forker forks session-escaped `sleep 60` sleepers across a short deadline and records every forked PID, and the pin asserts none of the recorded PIDs is alive after the exit (the existing `:491` racing-fork pin's assertion form, with the forker outside the frozen group — the module docstring records which pin covers which shape). The `double-fork` pin's fixture scenario is a child whose session-escaped middleman spawns a session-escaped sleeper then exits before the deadline (F12's shape): the pin records the sleeper's PID and asserts it is dead after the exit. Both pins reuse the module's helpers (`_write_fixture`, `_supervisor_env`, `_run_supervisor`, `_pid_alive`, `_kill_pid` for the cleanup path) — no new helper surface unless the recorded shape needs it. Both pins carry `@pytest.mark.timeout(120)`: the F11 shape's fork loop across a short deadline plus the freeze-and-sweep passes and the post-exit liveness walk 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: `3.51s` tree pin, `0.76s` racing-fork pin, `11 passed in 8.07s`-scale).

The boundary fix (`scripts/supervise_run.py`, in place): the expiry kill reaches the out-of-group shapes — a container boundary (cgroup/pid-namespace, which a process cannot leave by adoption), or a narrowed whole-tree sentence the OWNER rules between steps. If the OWNER has not ruled, deliver the container boundary: every pass of the freeze-and-sweep loop reaches what adoption cannot move, and the F10 q1e boundary shape (the documented init-adopted case the subreaper measurement protects) still survives it — the review's discriminating member, re-driven, must stay green or the fix over-reaches. No new exception class, no new subprocess head, no daemon: the supervisor's two recorded heads stand. If no container boundary is available in this environment (no unprivileged user namespace, no cgroup delegation — measured, not assumed), stop and report `IN SCOPE` as insufficient with the measurement: the boundary is then the OWNER's narrowing ruling, and the pins land as the ruling's red evidence grading the narrowed sentence. Do not answer the falsified absolute with another enumerated list of cases (rule 13): either one seam over the whole surface, or the narrowed claim.

Red evidence at `REV` `ba9e25e` (each unit must be replayable; the supervisor module is green at REV, so each red is written by this step and demonstrated at REV on a scratch copy diff-verified against `git show ba9e25e:…` 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: F11's escaped-forker red — at REV, the delivered sweep leaves the session-escaped forker's final tail forks alive adopted out-of-tree (the named failing assertion is the pin's post-exit forked-PID liveness assertion — the 2-of-80-class survival the fixes-2 review measured; an error or a hang is not red, the assertion must be the thing that failed). F12's double-fork red — at REV, the delivered sweep leaves the predecessor-exited sleeper alive adopted out-of-tree (the named failing assertion is the pin's post-exit sleeper-PID liveness assertion — the 11-of-11-class structural survival; an error or a hang is not red, the assertion must be the thing that failed). If the boundary lands as the OWNER's narrowing ruling instead of a container fix, the reds grade the narrowed sentence: each pin's assertion is the narrowed claim's witness, red at REV on the delivered sweep.

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:

- `Escaped-forker shape` (F11): a session-escaped forker's tail forks are dead after the supervisor exits — the escaped-forker pin, red at REV on the delivered sweep, green at FINAL (or graded against the narrowed sentence).
- `Double-fork shape` (F12): a predecessor-exited middleman's sleeper is dead after the supervisor exits — the double-fork pin, red at REV on the delivered sweep, green at FINAL (or graded against the narrowed sentence).

EXPECTED WALLS: this brief's REV `ba9e25e` carries the grading-seed closeout's VERIFIED lines for other files, and the supervisor chain's reports carry no VERIFIED lines for these IN SCOPE files — so the first VERIFIED lines this step writes set the budgets. The measured baseline at this brief's drafting: `.venv/bin/python -m pytest tests/test_phase6_supervisor.py --durations=5` — `11 passed in 8.07s`, slowest five `3.51s tree pin`, `2.23s killed-child pin`, `0.76s racing-fork pin`, `0.28s child-head pin`, `0.21s failing-with-document pin`. The boundary pins' `120`s timeouts are set from these walls plus the F11/F12 fork-loop and sweep-pass cost with margin for a loaded host — expected, with basis, per rule 15.

REV: ba9e25e
CLOSE OUT: no
DIVERGENCES: none
REVIEW: one session — the boundary above all: does each pin reproduce its carried shape live at REV (the named failing liveness assertion, red on the delivered sweep — an error or a hang is not red), does the fix close the shape with one seam over the whole surface (container boundary that adoption cannot leave) or does the step return with the pins as the narrowing ruling's red evidence, 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 — the narrowed sentence or the next chain — 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.
--- END BRIEF UNDER REVIEW ---
You did not write this code and you will not fix it; a finding is output, not an action. The step's
decision is the planner's (cycle step 5): report findings, never decisions. The commits under review
carry the trailer `Actor: IMPLEMENTER`; if your session wrote any of them, stop and say so. Run
REVIEW ACCEPTANCE first: it is the method's only gated check. The ACCEPTANCE lines inside the brief
under review are the implementer's; re-run them to verify the delivery, and run `scripts/check-tests`
as your standing battery — the full suite is your falsification ground — recording both in `VERIFIED`.
The embedded brief is a convenience copy: if the
standalone file it names differs, file a FINDING with ORIGIN: BRIEF and review against the committed
file.
You may create new test files to prove a finding, and modify nothing else. If a failing test would
need registering in tests/open_defects.yaml, say so in the report and leave the registration to the
next implementer brief rather than editing that file; the registry owns test_bug_* pins only, and a
test_review_* probe rides red until absorbed. Read pre-images with git show <rev>:..., not
the implementation's account of them. Run every mutant on a scratch copy of the tree, and diff each
mutant against git show <rev>:... before trusting its result. Attempt to falsify the brief, not only
the code: a finding that the brief was wrong is a finding, and so is a defect the implementer filed
only as friction. Answer every item under QUESTIONS TO ATTACK. Answers live in the form's fields —
a finding in FINDINGS, a measurement in VERIFIED/SHAPES. An added review's QUESTIONS TO
ATTACK come only from the implementer's report — never from another review's findings. Enumerate
the shapes you probed that
the existing suite does not build, as a list; zero with a stated reason is legitimate. Report each
guarantee as falsified-with-reproducer or attacked-and-not-falsified with the method.
Commit your own work: your new test files and your report, together, in one commit whose message
ends with the trailer `Actor: REVIEWER`. Append docs/templates/report.txt verbatim, fill it in, and
write it to docs/research/<phase>-<subject>-review.md. If you cannot commit, stop and say so.
