REPORT — phase6-probe-scope-implementer
STEP: phase6-probe-scope (Phase 6: F24 — the survivor scan counts the workload's own surface)
REV: 12f1f83   FINAL: 14b6862ded5ecb01982ffd24fdbc24124695bdfa
CHANGED: tests/test_batch3_execution.py — `_probe_pids` scoped to the workload's own surface: a module constant `_PROBE_ARGV = ("/usr/bin/python3", "/work/probe.py")` (`:184`) and the scan counts a pid only where its command line names that adjacent argv pair (`:187`–`:201`), replacing the whole-table `/work/probe.py` substring match; the `finally` cleanup loops at `:244` and `:319` reuse the helper and inherit the scoping with no separate edit
CHANGED: tests/test_review_phase6_sandbox_sweep.py — the riding review probe repointed at the scoped surface (`test_the_probe_pid_scan_does_not_count_an_unrelated_argv_carrier`, `:54`): the literal-retaining `bash -c` carrier is built and asserted alive, and the scoped scan must not count it (`:91`); the same `pytestmark = pytest.mark.slow` and host-only guard ride
VERIFIED: scripts/check-tests --fast — `981 passed, 109 deselected in 90.52s (0:01:30)` (exit 0)
VERIFIED: .venv/bin/python -m pytest tests/test_batch3_execution.py --durations=5 — `13 passed in 3.68s`; slowest five: `1.07s` `test_racing_forker_and_double_forked_sleeper_die_at_teardown`, `0.89s` `test_cancellation_during_dispatch_does_not_produce_a_result`, `0.58s` `test_attempt_deadline_is_shared_across_commands`, `0.58s` `test_escaped_process_is_killed_without_a_cgroup`, `0.18s` `test_limits_verified_is_persisted_in_the_command_result` (the F1/F20 pins green — a live workload survivor is still counted)
VERIFIED: scripts/check-static — exit 0, gated `All checks passed!`, advisory `Found 104 errors.` (unchanged from REV; the first form of the pair match used `zip()` and drew one new advisory B905, rewritten as an index loop before commit)
VERIFIED: scripts/check-docs — `396 Total / 180 Unique / 396 OK / 0 Errors` (exit 0); no docs file is in this step's diff, and a pristine `12f1f83` extraction prints the same `396 Total`, so the brief's `395` baseline is not this step's
VERIFIED: scripts/check-scope 12f1f83 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 12f1f83..14b6862ded5ecb01982ffd24fdbc24124695bdfa)`
VERIFIED: red at REV on the delivered scoping — a scratch copy of `12f1f83` (both files diff-verified byte-identical to `git show 12f1f83:tests/…` before use) carrying only this step's `_probe_pids` patch: `.venv/bin/python -m pytest tests/test_review_phase6_sandbox_sweep.py -v --durations=3` — `1 failed in 0.19s`, the named failing assertion `assert carrier.pid in found` firing (`assert 3464012 in []`), the carrier alive at `returncode: None` with its literal retained
VERIFIED: contrast at REV on the delivered whole-table scan — the same probe on the same scratch tree with the patch reverted: `.venv/bin/python -m pytest tests/test_review_phase6_sandbox_sweep.py -v --durations=3` — `1 passed in 0.17s` (the carrier counted by the over-match)
VERIFIED: green at FINAL — the repointed probe `.venv/bin/python -m pytest tests/test_review_phase6_sandbox_sweep.py -v --durations=3` — `1 passed in 0.26s`; both modules together `.venv/bin/python -m pytest tests/test_batch3_execution.py tests/test_review_phase6_sandbox_sweep.py --durations=5` — `14 passed in 3.80s`
VERIFIED: live end-to-end demonstration — the work commit's own pre-commit hook, with the commit message and the `git commit` argv quoting the probe path (the exact class F24 measured against the F1 pin), passed: parallel phase `949 passed in 20.33s`, serial phase (batch3 + milestone3 modules) `32 passed in 12.37s`
NOT VERIFIED: none
FINDINGS:
  F24 | SEVERITY: P2 | ORIGIN: CODE | STATE: fixed
  `_probe_pids` (`tests/test_batch3_execution.py`) scanned the whole process table for any cmdline containing the literal `/work/probe.py`, so an unrelated process that merely carried that string in argv — a commit-hook wrapper, a `bash -c` quoting the path — was counted a teardown survivor and failed the F1 pin. The scan now counts a pid only where its command line names the workload's own executor invocation, the plan's `("/usr/bin/python3", "/work/probe.py")` argv pair, so the over-match is gone while a live workload process and every fork it made are still counted.
  FIXED: `tests/test_review_phase6_sandbox_sweep.py::test_the_probe_pid_scan_counts_an_unrelated_argv_carrier` at REV — on a scratch copy of `12f1f83` (both files diff-verified byte-identical to `git show 12f1f83:…` before use) carrying only the delivered scoping patch, `.venv/bin/python -m pytest tests/test_review_phase6_sandbox_sweep.py -v --durations=3` → `1 failed in 0.19s`, the named failing assertion `assert carrier.pid in found` (`assert 3464012 in []`; the carrier alive at `returncode: None`, its literal retained). The same probe at REV with the delivered whole-table scan is `1 passed in 0.17s` (the carrier counted), so the red is the scoping's. Green at FINAL: the repointed probe `1 passed in 0.26s`, `tests/test_batch3_execution.py` `13 passed in 3.68s` (a live workload survivor still counted), and the commit hook's own run, whose invoking argv (the `git commit` command line and the `bash -c` wrapper) carried the probe path, green (`949 passed in 20.33s` parallel + `32 passed in 12.37s` serial). Delivered file lines: `tests/test_batch3_execution.py:178`–`:201` (`_PROBE_ARGV` at `:184`, `_probe_pids` at `:187`); the repointed probe `tests/test_review_phase6_sandbox_sweep.py:54`–`:96`.
  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.
SHAPES: none — the one named shape (scoped-scan: an unrelated argv carrier not counted while a live workload survivor still is) is built: the carrier half as the repointed probe, the workload-survivor half as the F1/F20 pins re-driven green at FINAL (`13 passed in 3.68s`), whose `_probe_pids` surface this step changed. Nothing probed is left unbuilt.
TRIPPED: none
PROPOSED ROWS: none
METHOD FRICTION: none
INHERITED:
  From the brief's INHERITED block, the items still open, copied verbatim (the chain through the sweep's implementer report; the review's copy moves the same F13–F17/F21/F22/F23 blocks):

  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.

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

  F26 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried (the repoint's assertion form — the precise inverse `assert carrier.pid not in found` taken over a literal whole-scan `assert not found`; see FINDINGS above; its next action is a later committed brief's text correction).

  Received-set dispositions kept: F19 fixed by the prior step's absorbed pin; F20 fixed as recorded in the sweep report; F11/F12/F18/F25 fixed as recorded in the reports that filed them; F24 fixed by this step (above); F13–F17, F21, F22, F23 carried with their named owners and text corrections.
