REPORT — phase6-grading-seed-review
STEP: phase6-grading-seed (Phase 6: the grading gate runs seeded — F8)
REV: 0c02b27   FINAL: b852fd43d381627b7045411e382ebc803002441d
CHANGED: no existing file is edited by this review. It adds two artifacts, both new: `tests/test_review_phase6_grading_seed.py` (the five-consecutive-grades probe on the lottery's flipping shape — the shape the delivered pin does not build) and this report. No committed module was edited by this review.
VERIFIED: REVIEW ACCEPTANCE run first: `scripts/check-scope 0c02b273bc10fb1509c534da903d35cad33cbca0 b852fd43d381627b7045411e382ebc803002441d docs/research/phase6-grading-seed-brief.md` — exit 0, prints `tripped: none` and `scope: ok (3 path(s) ...)` with `claimed: src/orchestrator/project_oracle.py tests/test_phase3_project_oracle.py`. The embedded brief inside the review brief matches the committed brief file verbatim (diff empty). None of the three named commits was written by this review's session (the work commit landed 15:02, the report commit 16:15, this session began after 16:30). FINAL is the work commit `b852fd4` (`Actor: IMPLEMENTER`, exactly `src/orchestrator/project_oracle.py` +1 line and `tests/test_phase3_project_oracle.py` +63 lines); the separate report commit `d011142` (`Actor: IMPLEMENTER`, one file) is never named as FINAL. `git diff 0c02b27 b852fd4` touches only the two IN SCOPE files plus the added brief (`A docs/research/phase6-grading-seed-brief.md`) — no committed test edit outside IN SCOPE — and `scripts/check-tests` is byte-identical at REV and FINAL (git show diff empty for both revisions), so the gate script was not edited; it forwards `"$@"` to pytest and the seed rides as an argument through it.
VERIFIED: the seed is one argv literal, not a seam — `src/orchestrator/project_oracle.py:734` `"--hypothesis-seed=424242",` sits after the `-k` exclusion expression and before the `--ignore=` entries in the frozen `gate-check-tests` argv; a repo-wide grep for `hypothesis-seed|HYPOTHESIS_SEED|hypothesis_seed` across `src/`, `scripts/`, `tests/` returns that single line (no parameter, no environment lookup — `build_project_oracle`'s signature carries `repo_root`, `venv_path`, `gate_timeout_seconds`, `registry_timeout_seconds`, `ignore_modules`, no seed); the driver template embeds argv as a data-only literal (`safe_argv = list(argv)`) and the seed comes only from the CLI token (the driver's env writes `HYPOTHESIS_STORAGE_DIRECTORY`, `RUFF_NO_CACHE`, `HOME`, `PYTHONSAFEPATH` — none is a seed source); the installed plugin's `--hypothesis-seed` sets `core.global_force_seed` for all tests (hypothesis 6.168.0, pytest 9.1.1 — accepted live, the pin's nested runs would exit usage-error otherwise); `conftest.py` is a frozen controlled basename (`src/orchestrator/project_oracle.py:116`, rejection note at `:628`), so no conftest-side profile override can shadow the seed; and the nested gate's hypothesis database is per-run ephemeral (a fresh tmpfs `/tmp` per probe with `HYPOTHESIS_STORAGE_DIRECTORY=/tmp/hypothesis` inside it, plus `-p no:cacheprovider`), so no draw state survives a grade and the seed is the only draw source.
VERIFIED: the delivered determinism pin at FINAL, on a byte-verified scratch of `b852fd4` (`git archive` extraction, `git show b852fd4:<file>` diffs empty for both IN SCOPE files): `.venv/bin/python -m pytest tests/test_phase3_project_oracle.py::test_grading_gate_grades_one_candidate_identically_across_consecutive_runs` — `1 passed in 203.64s` — five consecutive grades of the known-good shape with identical PASS verdicts (the verdict-identity assertion at `tests/test_phase3_project_oracle.py:621` and the survivor assertion at `:629` both pass). An independent `/proc` walk right after the run found no survivor (`survivors: []` — R13's orphan probe re-walked after the pin's nested runs at FINAL, no `/work/.venv` chain, no `sandbox_launcher`). The pin is the module's sixth test, slow-marked, `pytest.mark.timeout(1200)`.
VERIFIED: the same pin on the byte-verified REV scratch (the delivered test module copied in uncommitted, byte-verified against `b852fd4`'s copy): `1 passed in 185.17s` — F13's core claim holds, the pin passes at REV on the unseeded gate; and under 10-core CPU load it still passes (`1 passed in 268.49s`, ~53.7s per grade, every verdict PASS). The brief's named red — the known-good candidate flipping PASS→CANDIDATE_TIMEOUT — does not appear in this environment, idle or loaded at 10-core contention.
VERIFIED: F8's flip red at REV, driven three ways on the byte-verified REV scratch. Idle host: `1 passed in 123.90s`, `1 passed in 120.77s`, `1 passed in 125.19s` — the report's claimed 3/3 flip does NOT reproduce on an idle host. Under 10-core CPU load the named flip reproduces: `1 failed in 174.07s`, `AssertionError: assert 'CANDIDATE_TIMEOUT' == 'FAIL'` at `tests/test_phase3_project_oracle.py:449` (test wall ~176s, matching the implementer's failing walls of 178.94/175.68/175.85s). The broken-source candidate's own grade walls, idle and unseeded, measured 44.43–48.29s — the flip needs contention, not a heavier draw (see F14). Versus the seeded determinism at FINAL: the neutralisation test is green in the FINAL module run (`6 passed in 576.05s`, the neutralization call `150.01s`).
VERIFIED: the five-consecutive-grades probe this review adds — `tests/test_review_phase6_grading_seed.py::test_broken_source_grades_identically_across_consecutive_runs` — five consecutive `gate-check-tests` grades of the neutralisation test's broken-source candidate (the shape the delivered pin does not build). On the byte-verified scratches at the fixture's own 60.0s deadline: REV unseeded `FAIL`×5, walls 44.43–48.29s; FINAL seeded `FAIL`×5, walls 44.43–46.31s — the seeded determinism holds on the unstable half of the surface, not only the stable half the pin grades. In the workspace (seeded) the probe now builds with the oracle's default 300.0s deadline, isolating the draw class from the wall class: `1 passed in 293.98s`, walls 54.97–62.44s, five identical `FAIL` verdicts; at the fixture's 60.0s deadline the same workspace shape measured one mid-run flip (`FAIL`, `FAIL`, then `CANDIDATE_TIMEOUT`×3 at 57.16–60.10s) and one clean `FAIL`×5 (56.28–59.29s) under this machine's background load — see F16.
VERIFIED: the ACCEPTANCE lines re-run at FINAL in the clean workspace: `scripts/check-tests --fast` — `976 passed, 107 deselected in 91.00s (0:01:30)`, exit 0 (counts match the report). `.venv/bin/python -m pytest tests/test_phase3_project_oracle.py --durations=5` — `6 passed in 576.05s (0:09:36)`, slowest five `219.07s corpus`, `189.24s pin`, `150.01s neutralization`, `8.85s setup`, `8.69s registry` (counts and shape match; walls differ). `scripts/check-static` — exit 0, the gated `ruff check --select BLE001,S110 src/orchestrator` prints `All checks passed!` (also re-run standalone, exit 0), the advisory `B,SIM` run prints `Found 104 errors.` — matches the report; the REV baseline is also 104 (a scratch prints 106 only while this review's probe file lives inside it; the committed probe adds no advisory finding — the pin module's 13 advisory findings are the same 13 at REV, all at pre-existing line numbers, the pin block adds none). `scripts/check-docs` — the workspace prints `385 Total (in 1s 256ms) 179 Unique 385 OK 0 Errors`, exit 0; the FINAL scratch without the report file prints `384 Total (in 206ms) 179 Unique 384 OK 0 Errors` — the report's figure is the gate's own printed line at FINAL, and the +1 is the report commit's own markdown.
VERIFIED: the standing battery at FINAL: `scripts/check-tests` (full suite, slow modules included) — `1083 passed in 771.01s (0:12:51)`, exit 0. Its first run was ENOSPC-invalidated by a filled shared tmpfs inode table (195 setup errors, `OSError: could not create numbered dir ... in /tmp/pytest-of-ruben/pytest-28 after 10 tries`; classified per the report template's timeout taxonomy as isolation, never a value change — 81 leaked `orchestrator-probe-*` trees from earlier sessions, this step's implementer session among them, filled the table to 3 free inodes) and was re-run after pruning the leaked trees. The module boundary held throughout: `tests/test_phase3_project_oracle.py ......` (all six green in the full run).
VERIFIED: the report's forms — every template field present and filled (`REPORT`, `STEP`, `REV/FINAL`, two `CHANGED`, five `VERIFIED`, `NOT VERIFIED`, `FINDINGS`, `SHAPES`, `TRIPPED: none`, `PROPOSED ROWS: none`, `METHOD FRICTION: none`, `INHERITED`), nothing outside the template added; FINAL names the work commit, never the report commit; the `INHERITED` block carries the received set verbatim (a diff of the report's received block against the brief's `INHERITED` is empty up to the report's own F13 append) and keeps the brief's expected dispositions (F8 fixed-close with the named red, F11/F12 carried); `TRIPPED: none` matches the live `scripts/check-scope` output; the SHAPES field declares the named shape unbuilt rather than burying it.
NOT VERIFIED: the brief's literal `Determinism shape` — N consecutive grades of the known-good tree with non-identical verdicts (red at REV on the unseeded gate) — is not built and cannot be built here: the known-good candidate measures 37.0–40.7s per grade against the 60.0s deadline on an idle host and holds at ~53.7s per grade under 10-core load, so no unseeded draw this review or the implementer drove (12+ pin runs, 60+ grades) produced the named flip. This is F13's brief defect, carried, not a step defect.
NOT VERIFIED: the F8 red on an idle host — the report's `3 of 3 runs at REV` did not reproduce idle in this review's hands (0/3; the flip is load-borne, see F14), so the red evidence is conditionally reproducible and the report should have named the condition.
NOT VERIFIED: the seeded determinism on the near-deadline candidate at the fixture's 60.0s deadline — under this machine's background load the seeded grade flipped mid-run once (F16); the draw class is closed, the wall class is the ruled budget class surviving it.
FINDINGS:
  F14 | SEVERITY: P2 | ORIGIN: DOCUMENT | STATE: carried
  The F8 red evidence is load-borne and the implementer report does not say so. The report's `1 failed in 178.94s / 175.68s / 175.85s` (3 of 3 runs) and this review's loaded run (`1 failed in 174.07s`, `AssertionError: assert 'CANDIDATE_TIMEOUT' == 'FAIL'` at `tests/test_phase3_project_oracle.py:449`) all sit ~1.4x this review's idle walls (`1 passed` in 123.90s / 120.77s / 125.19s) — CPU contention, not the unseeded draw, is what crosses the fixture's 60.0s deadline: idle, the broken-source grade measures 44.43–48.29s and stays under it five runs out of five. The report's causal framing (SHAPES: "the unseeded draw crosses it"; F8's FIXED line: "3 of 3 runs at REV") presents that contention flip as a bare-draw flip, so a later actor re-driving the red on an idle host sees green and either concludes the red is chimeric or re-loads the host without knowing why the first attempt went green. The delivered seed is not in doubt — the draw dimension is closed structurally (single argv literal at `src/orchestrator/project_oracle.py:734`, per-run ephemeral hypothesis database, no cacheprovider) — and the flip shape it must contain is the near-deadline one this review drove under load. What carries is the report text.
  FIXED: no regression test — a document defect in a committed report, which only a later step (or the planner's correction of the carried F8 block) can change; the mechanism is measured in this review's VERIFIED lines, both idle and loaded.
  F15 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  A session killed mid-run leaks its intermediate probe trees and nothing reaps them; the shared tmpfs inode table filled to 3 free entries and the standing battery's first run died with 195 ENOSPC setup errors, invalidating it until 81 leaked `orchestrator-probe-*` trees (dated from Sep 29 through this step's implementer session, whose three 10-12 clusters match its run) were pruned by hand. `_run_probe`'s cleanup (`src/orchestrator/oracle.py:743`–`:749`) is correct on every path this review exercised — this review's ~50 grades leaked nothing — so the leak is killed-run residue, and its owner is the harness's scratch hygiene (or the method's), not this step. Next action: a tombstone or janitor for intermediate probe trees (keyed by the same per-run identity the copies already carry), or a planner ruling that scratch hygiene is each session's duty.
  FIXED: no regression test — carried as harness/environment hygiene; the battery's valid re-run (`1083 passed in 771.01s`) is in VERIFIED.
  F16 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  The seeded determinism is wall-bounded: the fixture's 60.0s per-check deadline sits ~1.3x above the near-deadline candidate's unloaded wall (44.43–48.29s measured), so host load flips the seeded grade on the unstable half — FAIL, FAIL, then CANDIDATE_TIMEOUT×3 at 57.16–60.10s in one workspace run, and one grade at 62.44s in another. The delivered pin grades only the known-half candidate (37.0–40.7s per grade), which is why the pin never sees it; the seeded draws are identical, and the wall is the residual the seed does not close (the same ruling class as R13's budget decision, now measured live across the deadline). Next action is the fixture's owner: raise `gate_timeout_seconds` for grading runs that sit near the deadline (the 300.0 default `build_project_oracle` carries gives a >=5x margin on this candidate) or record that the deadline's load envelope is governed, not deterministic.
  FIXED: no regression test — the regression pin for this class is this review's committed probe at the oracle's default deadline (five identical `FAIL` verdicts, `1 passed in 293.98s`), which deliberately does not re-run the load-flaky 60.0s shape; the 60.0s measurement is carried in this finding and in the probe's docstring.
SHAPES: The exact shape the brief names — "PASS on one run, CANDIDATE_TIMEOUT on the next" on the known-good candidate at REV unseeded — is not built and measured empty three ways: idle REV pin `1 passed in 185.17s`, loaded REV pin `1 passed in 268.49s` at ~53.7s per grade (10-core CPU load), and the implementer's ten idle pin runs, all PASS. Built and probed instead, all hand-driven here unless named committed: the five-consecutive-grades probe on the broken-source candidate (`tests/test_review_phase6_grading_seed.py`, this review's new file) — REV unseeded `FAIL`×5 at 44.43–48.29s and FINAL seeded `FAIL`×5 at 44.43–46.31s, which extends the verdict-identity claim to the unstable half of the surface the delivered pin does not grade, and its committed workspace form at the default deadline `FAIL`×5 at 54.97–62.44s; the F8 flip shape under 10-core load (the line-449 red reproduced once, not committed); the loaded pins at REV and FINAL (both pass — the seeded determinism is not load-fragile on the known-good half at 10-core contention); and the orphan probe re-walked after the FINAL pin (`survivors: []`). The report's substitute shapes are measured, not buried: its SHAPES field declares the named shape unbuilt and names what it probed instead; this review's correction is only that its near-deadline red is load-borne (F14) and that the wall class survives the seed on the unstable half (F16).
TRIPPED: none
PROPOSED ROWS: none
METHOD FRICTION: none
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.

Expected dispositions (rule 8 forms): F8 fixed with red evidence (named below — the seed closes the lottery, the flip shapes grade stable across N consecutive runs). F11 and F12 stay carried (both real, both named against the missing container boundary, both outside this brief's scope; the seed changes no kill surface and no whole-tree sentence).

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.

CLOSEOUT
DECLINED: none
DIVERGENCES CLOSED: none
