REPORT — phase6-probe-scope-review
STEP: phase6-probe-scope (Phase 6: F24 — the survivor scan counts the workload's own surface)
REV: 12f1f839a140d56275a0b5b01840b9795db95f82   FINAL: 14b6862ded5ecb01982ffd24fdbc24124695bdfa
CHANGED: tests/test_review_phase6_probe_scope.py — new review module (two probes, `pytestmark = pytest.mark.slow`): the scoped-scan shape's conjunction member (`test_the_scoped_scan_counts_a_live_pair_holder_and_not_an_argv_carrier`) and the seam-anchor member (`test_every_probe_plan_command_still_names_the_scanned_pair`); no delivery file touched
CHANGED: docs/research/phase6-probe-scope-review.md — this report
VERIFIED: REVIEW ACCEPTANCE run first (the method's gated check): `scripts/check-scope 12f1f839a140d56275a0b5b01840b9795db95f82 14b6862ded5ecb01982ffd24fdbc24124695bdfa docs/research/phase6-probe-scope-brief.md` — exit 0, `claimed: tests/test_batch3_execution.py tests/test_review_phase6_sandbox_sweep.py`, `tripped: none`, `scope: ok (3 path(s) in 12f1f839a…14b6862…)`; re-run at the FINAL worktree with the brief's short-sha form — the same three lines, exit 0. The tree under review is clean (no uncommitted changes at review start). `git diff 12f1f83… 14b6862… --stat` names the two IN SCOPE files plus the brief only (186 insertions, 28 deletions) — no committed test edit outside IN SCOPE. The review brief's embedded copy of the implementer brief is byte-identical to the standalone committed `docs/research/phase6-probe-scope-brief.md` (140 lines both) — no ORIGIN: BRIEF divergence rides. The work commit carries `Actor: IMPLEMENTER` and the review session wrote none of the commits under review; `0e45fb4` adds only `docs/research/phase6-probe-scope-implementer.md` (58 insertions) so FINAL is the work commit, never the report commit.
VERIFIED: Q1(a) — the carrier half, both directions, on scratch copies (git worktrees at `12f1f83` and `14b6862`, every file cmp-verified against `git show <rev>:…` before use; the shared `.venv` symlinked into each worktree — see METHOD FRICTION): REV tree + the REV probe's old assertion over the delivered whole-table scan — `1 passed in 0.33s` (the over-match counts the carrier: the direction the fix retires); REV tree carrying only the delivered scoped helper (the probe untouched, its import satisfied by inlining the pre-image pair — `_PROBE_ARGV` does not exist at REV) — `1 failed in 0.32s`, re-driven `1 failed in 0.27s` after a `__pycache__` purge, the named failing assertion `assert carrier.pid in found` (`assert 3511544 in []`) with the carrier alive at `returncode: None` and its literal retained — that red is the absorption signal the probe's own docstring named; FINAL tree (scoped scan + repointed probe) — `1 passed in 0.30s`. Attacked-and-not-falsified: the scoped scan stops counting the unrelated argv-carrier, in both directions.
VERIFIED: Q1(b) — the survivor half. Module battery at FINAL: `.venv/bin/python -m pytest tests/test_batch3_execution.py --durations=5` — `13 passed in 3.76s` and again `13 passed in 4.05s`, slowest five `1.08s`/`1.10s` racing pin, `0.89s`/`0.90s` cancellation pin, `0.57s`/`0.59s` deadline pin, `0.58s` F1 escape pin, `0.18s`/`0.22s` limits pin (matches the report's own line). Green alone does not prove counting, so the counting direction was re-driven as a red class: the weakened-capture mutant (one inserted `return []` at the head of `SandboxRunner._descendants`, `src/orchestrator/sandbox.py:1043`, the whole mutant diff-verified one line against `git show 14b6862:src/orchestrator/sandbox.py`) leaves teardown blind-but-verifying and both pins red on their own named assertions — F1 `assert survivors == [], f"escaped workload survived teardown: {survivors}"` at `tests/test_batch3_execution.py:242` (`assert [3514171] == []`), F20 at `tests/test_batch3_execution.py:317` (a live list of racing-forker survivors) — the escaped and forked workloads' host argv is the plan's own `/usr/bin/python3 /work/probe.py` pair, so the scoped scan counts a live workload survivor exactly as the F1/F20 class needs. Attacked-and-not-falsified.
VERIFIED: Q1(c) — the seam's form and its anchor. Form (rule 13): the delivered scan is one adjacency rule over `_PROBE_ARGV` (`tests/test_batch3_execution.py:187`–`:201`), no exclusion list, and the `finally` cleanup loops (`:244`, `:319`) call the same helper — attacked-and-not-falsified by read plus every drive below. Anchor (the plan's executor-invocation argv pair as the surface the pins grade): FALSIFIED-with-reproducer. Two plan-shape mutants, each on its own diff-verified FINAL scratch (`_PROBE_ARGV` left untouched, the drift the question names): C1 a second argv element added to all three plan `command` tuples (`:49`, `:231`, `:306` → `("/usr/bin/python3", "-u", "/work/probe.py")`) — `13 passed in 4.04s`, no pin reddens; C2 the interpreter path moved (`→ ("/usr/bin/python3.13", "/work/probe.py")`) — `13 passed in 3.90s`, no pin reddens. The discriminating stack, C1 + the weakened-capture mutant (both diffs verified against `git show 14b6862:…`): `2 passed in 1.64s` — F1 and F20 both green while 123 live workload survivors (`argv ['/usr/bin/python3', '-u', '/work/probe.py']`, the escaped workload plus 122 racing-forker sleepers) were alive on the host, enumerated and reaped after the run (the pair-matching set was empty throughout — the scoped scan saw none of them; the pins' own `finally` cleanups, which inherit the scoping, leaked them all). Contrast: the weakened-capture mutant alone reds both pins (above). So the answer to "which pin goes red, and on which member": none — on plan-tuple shape change the survivor pins' red class, the survivor counting, and the teardown-cleanup inheritance all die silently; the members that red on drift are this review's probes (SHAPES, FINDINGS F27), not the delivered suite. The seam is one surface rule in form, but it is keyed to a copy of the surface (`_PROBE_ARGV`, the fourth literal beside the three plan tuples) with no member holding the copies equal.
VERIFIED: Q2 — F26's repoint-reading claim, against the brief's text and the delivered probe. The brief's repoint sentence reads "A repoint carries the same slow mark and host-only guard with the assertion inverted (the carrier alive, the scoped scan empty)" and its red-evidence paragraph names the failing assertion as the probe's old line `assert carrier.pid in found`. "The assertion inverted" fixes the form: the precise inverse `assert carrier.pid not in found`, with the carrier's liveness asserted beside it — exactly what the delivered probe asserts (`assert carrier is not None and carrier.poll() is None` then `assert carrier.pid not in found`, `tests/test_review_phase6_sandbox_sweep.py:87`–`:92`; slow mark and cgroup2 host-only guard kept). The parenthetical gloss "the scoped scan empty" admits a literal whole-scan `assert not found` reading in isolation, and F26 is right that it does; but that reading is not consistent with the rest of the brief — (a) the named failing assertion is the pid-form's inversion, not a new whole-scan assertion; (b) the brief keeps the F1/F20 survivor class with the pins, while `assert not found` would grade that class (and red on any live workload survivor) from this host-side probe, recoupling it to unrelated host state — the over-match brittleness F24 is about; (c) the brief expects the probe green at FINAL on a host that may hold live survivors of the pins' class. Verdict: the taken reading is the only one consistent with the whole brief; no second consistent reading stands, so the step does not return to planning and F26 carries as filed (the planner's named-form text correction remains its next action).
VERIFIED: Q3(a) — the report's forms and counts, every figure the gate's own printed line at FINAL (rule 14): `scripts/check-tests --fast` at the FINAL worktree — `981 passed, 109 deselected in 97.20s (0:01:37)` (the report's counts). `.venv/bin/python -m pytest tests/test_batch3_execution.py --durations=5` at FINAL — `13 passed in 4.05s`. `scripts/check-static` at FINAL — exit 0, gated `All checks passed!`, advisory `Found 104 errors.`; the pristine REV scratch prints the same pair of lines (`All checks passed!`, `Found 104 errors.`), so "advisory unchanged" is verified. `scripts/check-docs` at FINAL — `396 Total / 180 Unique / 396 OK / 0 Errors`, exit 0 — the report's figure stands as the FINAL gate line; its accompanying baseline claim is falsified and filed (FINDINGS F28): the pristine `12f1f83` worktree prints `395 Total / 180 Unique / 395 OK / 0 Errors` (the brief's own EXPECTED WALLS baseline), and the 395→396 delta is exactly the range's added `docs/research/phase6-probe-scope-brief.md` (`git diff 12f1f83 14b6862 --stat -- docs/` names that one path, 140 insertions; docs markdown count 160→161). `scripts/check-scope 12f1f83 14b6862… docs/research/phase6-probe-scope-brief.md` — `tripped: none`, matching the report's TRIPPED field. Report fields: every template field present and filled (CHANGED one line per file, NOT VERIFIED filled, FINDINGS with the template's FIXED forms, SHAPES filled, TRIPPED, PROPOSED ROWS, METHOD FRICTION, INHERITED), nothing outside the template added. The report's CHANGED line numbers verified against the delivered file (`_PROBE_ARGV` `:184`, `_probe_pids` `:187`–`:201`, cleanups `:244`/`:319`, probe `:54`–`:96`). F24 fixed-close verified: its named red class re-driven both ways (Q1(a) drives) and the fix's green is the FINAL probe run; the INHERITED accounting matches the received set (F13–F17, F21, F22, F23 carried verbatim with their owners; F26 added carried; F19/F20/F11/F12/F18/F25 stay fixed as recorded) and the brief's expected dispositions line is mirrored exactly. The report's F24 FIXED red form (`assert carrier.pid in found`, `assert <pid> in []`) reproduces at the same class (this review's `assert 3511544 in []`).
VERIFIED: SHAPES' none-claim adjudicated against rule 7 (the split halves): the named scoped-scan shape ("an unrelated argv-carrier is not counted a survivor while a live workload survivor still is") is delivered as two disconnected members — the repointed probe grades only the carrier half and the F1/F20 pins grade only the no-survivor-after-teardown half — and no committed member measures the conjunction in one scan. The split satisfies the letter ("one shape needs at least one test" — it has two) but buries the conjunction member: the only member that states the named shape's "not counted … while … still is" as one selectivity measure, and the only committed-form member that would have red on both the overcount and the undercount directions. Probed here and listed under SHAPES; whether the suite builds it as one is the planner's call (cycle step 5).
VERIFIED: standing battery — `scripts/check-tests` (no arguments, the full run, slow modules included) at the review tree (this review's probe module included): `1092 passed in 1035.46s (0:17:15)` — the counted whole (981 fast pins + 108 slow + the sweep probe 1 + this review's probes 2), all green, both review probes running through (`tests/test_review_phase6_probe_scope.py ..`), no skip and no flake; the tree was left untouched for the battery's whole wall (the seeded-determinism pin grades the dirty working tree, F25's class — this review's module is slow-marked at module level and the report was drafted outside the tree until the run completed)
NOT VERIFIED: the report's live end-to-end line (`the work commit's own pre-commit hook … 949 passed … 32 passed`) is not re-driven in that exact form (re-committing would touch the history under review); its class — an invoking command line carrying the probe-path literal beside a green tree — is re-driven instead as D1a's carrier direction (the REV scan counts the wrapper) and was sighted again in this review's own `pgrep` wrapper matching the literal while reaping the C1 survivors. Everything else the report claims was re-driven or inspected at the named revisions.
FINDINGS:
  F27 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  The scoped scan's surface is a duplicated literal: `_PROBE_ARGV` (`tests/test_batch3_execution.py:184`) sits beside three independent plan `command` tuples (`:49`, `:231`, `:306`) and nothing holds them equal, while the named scoped-scan shape is split across the repointed carrier probe (carrier half) and the F1/F20 pins (survivor half) so no committed member asserts selectivity in one scan. Measured: plan-shape drift leaves every committed pin green while the scan undercounts — C1 (a second argv element in all three plan tuples) `13 passed in 4.04s`, C2 (the interpreter path moved to `/usr/bin/python3.13`) `13 passed in 3.90s`; and the drift silently destroys the pins' red class — C1 stacked with the weakened-capture mutant (that mutant alone reddens F1/F20 on `assert survivors == []`) goes `2 passed in 1.64s` over 123 live workload survivors whose argv carried the drifted shape (enumerated and reaped post-run; the pair-matching set empty throughout), leaking past the `finally` cleanups (`:244`, `:319`) that inherit the same blind scoping. The seam is one rule in form (no exclusion list, rule 13) but is keyed to a copy of the surface rather than to the surface the pins grade; the burial of the conjunction member is what lets the anchor drift stay invisible.
  FIXED: the machines this review commits: `tests/test_review_phase6_probe_scope.py::test_every_probe_plan_command_still_names_the_scanned_pair` (AST-parses the batch3 module and asserts every plan `command` tuple equals the scanned pair; green at HEAD `1 passed`, red on C1 with `At index 1 diff: '-u' != '/work/probe.py'` and on C2 the same class) and `tests/test_review_phase6_probe_scope.py::test_the_scoped_scan_counts_a_live_pair_holder_and_not_an_argv_carrier` (one scan over a live carrier and a live holder built from the plan's own `command`: green at HEAD `2 passed in 0.29s` for the module; red on the REV whole-table scan `assert carrier.pid not in found` — `the scoped scan counted an unrelated argv carrier: [3526004, 3526010, 3526011]` — and red on drift when the plan-built holder stops being counted). Next action is the planner's: a later brief absorbs these members into the pinned module (or pins the anchor its own way) — the drift class itself has no single node id at REV, its red is the mutant battery named above.
  F28 | SEVERITY: P2 | ORIGIN: DOCUMENT | STATE: carried
  The report's docs-baseline claim is falsified: "a pristine `12f1f83` extraction prints the same `396 Total`, so the brief's `395` baseline is not this step's" — the pristine `12f1f83` worktree prints `395 Total / 180 Unique / 395 OK / 0 Errors` (the brief's EXPECTED WALLS line, correct at drafting), and the 395→396 delta is exactly `docs/research/phase6-probe-scope-brief.md` added in the reviewed range (docs markdown count 160→161 across `git diff 12f1f83 14b6862 --stat -- docs/`, one path). The figure `396 Total … 0 Errors` is the gate's own printed line at FINAL and stands under rule 14 — what fails is the explanatory claim and its dismissal of a baseline that reproduces.
  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 measured correction is in this review's VERIFIED.
SHAPES: the shapes this review probed that the delivered suite does not build:
  - The scoped-scan conjunction member (an unrelated argv-carrier and a live workload-surface holder alive at once, one scan returning exactly the holder): the delivered suite builds the halves disconnected (repointed probe; F1/F20 pins), the conjunction itself unbuilt. Built by `test_the_scoped_scan_counts_a_live_pair_holder_and_not_an_argv_carrier` (this review's module; both red classes re-driven — the REV over-match and the drift undercount). The holder is a live `/usr/bin/python3` whose argv carries the plan's `command` pair adjacently (no `/work` staging is possible unprivileged on this host — the F1/F20 weakened-capture red is the genuine pair-at-(0,1) class and is re-driven above).
  - The seam-anchor member (every plan `command` tuple equals the pair the scan matches): unbuilt by the delivered suite — nothing couples `_PROBE_ARGV` to the three plan tuples. Built by `test_every_probe_plan_command_still_names_the_scanned_pair` (red on C1/C2).
  - The weakened-capture red class (`_descendants` → `[]`, teardown blind but verifying): probed as the survivor-counting machine; the delivered F1/F20 pins' `assert survivors == []` members are this shape already, so no pin is owed beyond the anchor coupling above.
TRIPPED: none
PROPOSED ROWS: none
METHOD FRICTION: one place, the scratch-drive environment. The brief's scratch-copy rule ("scratch copies diff-verified against `git show 12f1f83:…` before use") does not cover a bare `git worktree` checkout's missing `.venv`: `scripts/check-tests` resolves `$PROJECT_ROOT/.venv/bin/python` and falls back to the system `python3` (pytest present, pytest-timeout absent), after which `pytest.ini`'s `strict_config = true` errors every timeout-marked module (`81 deselected, 16 errors in 1.64s`, `Failed: 'timeout' not found`) without naming the cause — an interpreter-swap exactly of the class the brief's interpreter rule warns about, but silent through the gate script. Worked around by symlinking the shared `.venv` into each worktree before trusting any gate line (the discarded run is recorded above); the method's silence about venv resolution in scratch trees is what the friction names.
INHERITED:
  From the brief under review, the still-open items copied verbatim (the chain through the probe-scope step's own carried set):

  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.
  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.

  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.

  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.

  F23 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
  The brief's named red at REV is not reproducible — "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". In a NAMESPACE_V1 drive the workload is the PID-namespace init, _descendants always captures it (descendants=128 namespace_inits=[…]), and its SIGKILL makes the kernel reap the whole namespace (init death kills the namespace; measured: 124 live descendants after a weakened kill, 0 after the init dies), so the delivered _kill already leaves no descendant alive and the pin passes at REV. The sweep lands as the brief's requested defense-in-depth port and the pin as a regression pin; the named red is chimeric for the sandbox, and the load-borne leak F20 measured rode the nested-grading/oracle path, not a standing sandbox-drive race.
  FIXED: no regression test — an ORIGIN: BRIEF finding is fixed once a later committed brief corrects the text; the sweep and the pin land as delivered, and the pin's red class is the kill-surface mutant above.

  F26 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
  The repoint instruction names the assertion as "the assertion inverted (the carrier alive, the scoped scan empty)". The probe's old line is `assert carrier.pid in found`; the reading taken is its precise inverse, `assert carrier.pid not in found` (the scoped scan is empty *of the carrier*), with the carrier's liveness asserted beside it. The parenthetical also admits a literal whole-scan `assert not found` reading, which would red on any live workload survivor — the F1/F20 class the brief says stays with the pins — and would couple this host-side probe to unrelated host state, the over-match brittleness F24 is about. Next action is the planner's: a later committed brief's text correction naming the assertion form.
  FIXED: no regression test — an ORIGIN: BRIEF finding is fixed once a later committed brief corrects the text; the repoint lands as delivered (carrier-pid inversion) and is green at FINAL.

  Then each finding marked carried by this step, with its ID:

  F27 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried (the seam's duplicated literal and the buried conjunction member — plan-shape drift silently kills the survivor pins' red class; see FINDINGS above; its next action is a later brief absorbing this review's two probes).

  F28 | SEVERITY: P2 | ORIGIN: DOCUMENT | STATE: carried (the report's docs-baseline claim falsified — pristine `12f1f83` prints 395; see FINDINGS above; its next action is the planner's correction of the carried note).
