REVIEW BRIEF — phase6-scan-anchor (Phase 6: the scan matches what the plans drive — F27)
REV: cc2ac822d78f243f4c0dece9d3dff7e8f7ed5108
FINAL: fa75ff06c2011745ebf9807dcd6c527e389d9574
REVIEW ACCEPTANCE: scripts/check-scope cc2ac822d78f243f4c0dece9d3dff7e8f7ed5108 fa75ff06c2011745ebf9807dcd6c527e389d9574 docs/research/phase6-scan-anchor-brief.md
FOCUS: the anchoring above all — does the scanned pair become the driven pair (one source, the drift class red at REV, green at FINAL), does the conjunction member state the selectivity in one scan, and does F29's absorb-both reading hold against the brief's absorption paragraph.
SEVERITY SCALE: P0 blocks the step; P1 is serious; P2 is minor.
QUESTIONS TO ATTACK:

  F29 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
  The brief's probe-absorption paragraph reads against its anchor paragraph and its red-evidence sentence: the anchor section says "the review probe's anchor member moved, not re-derived" and the red evidence names "the anchor member's own red … against the delivered anchor (a plan tuple no longer equal to the scanned pair)", while the absorption paragraph says the seam-anchor member "reddens on nothing — it asserts what the module now holds structurally". Two readings stood: (a) both members absorbed into the batch3 module — the reading the review's F27 FIXED also directs ("a later brief absorbs these members into the pinned module"), and the one the GOAL's "a plan-shape change … fails a committed member" requires, since the conjunction member alone guards only _probe_plan's command and not the F1/F20 pins'; (b) the seam-anchor member superseded and only the conjunction member absorbed. The reading taken is (a). The anchor member is the probe's, moved, with one necessary adaptation — its command=-keyword value resolution reads the constant the plans now hold (globals()[…] for a Name, ast.literal_eval otherwise) because a verbatim ast.literal_eval move errors on the Name node — and its assertion class (every plan command equals the scanned pair) is unchanged.
  FIXED: no regression test — an ORIGIN: BRIEF finding is fixed once a later committed brief corrects the text; the members land as described and are green at FINAL.

  1. The anchoring above all — the delivery's one question. Drive it live against FINAL on scratch copies diff-verified against git show cc2ac82:… before use: (a) the anchor is one source — _probe_plan and both pins drive command=_PROBE_ARGV, the three literals gone — re-drive the C1/C2 drift against the delivered module and name which member reddens on which assertion; (b) the conjunction member states the selectivity in one scan at FINAL — carrier not counted, holder counted, exactly the holder — re-drive it and name the line; (c) the absorbed members' REV reds — the riding probes' C1 reds on the REV scratch plus the stacked weakened-capture battery — re-drive or verify the report's lines. Report each guarantee as falsified-with-reproducer or attacked-and-not-falsified with the method.

  2. F29's absorb-both reading. The implementer's F29 says the brief's absorption paragraph ("reddens on nothing") reads against its anchor paragraph ("moved, not re-derived") and its red-evidence sentence, so reading (a) — both members absorbed — was taken over reading (b) — anchor superseded. Verify against the brief's text and the delivered module: does the absorption paragraph admit both readings, is (a) the only one consistent with the rest of the brief (GOAL's "fails a committed member", F27's FIXED directing both members in, the conjunction member guarding only _probe_plan's command), and does the delivered module hold both members with the anchor's assertion class unchanged (every plan command equals the scanned pair, the Name-node adaptation the only move)? If a second consistent reading stands, the step returns to planning; if (a) is the only consistent one, F29 carries as filed. File a finding per falsified class.

  3. The report's forms and counts (J-class). FINAL is the work commit fa75ff06c2011745ebf9807dcd6c527e389d9574, never the report commit df21eaa — verify rather than taking the report's word. Re-run the brief's ACCEPTANCE lines at FINAL (fast suite 983 passed, 109 deselected; the batch3 module battery 15 passed; static gated 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 cc2ac822d78f243f4c0dece9d3dff7e8f7ed5108 fa75ff06c2011745ebf9807dcd6c527e389d9574 --stat touches only the IN SCOPE files plus the brief (no committed test edit outside them — verify, including the deleted probe module). SHAPES' none-claim against rule 7: the anchored-scan shape built as anchor plus conjunction — adjudicate whether the pair holds the shape whole or buries a member the suite should still build. INHERITED's F27 fixed-close and F28 carry 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-scan-anchor-brief.md; the committed file is authoritative) ---
IMPLEMENTER BRIEF — phase6-scan-anchor (Phase 6: the scan matches what the plans drive — F27)
GOAL: The scoped scan cannot silently go blind: the argv pair the scan matches is the pair the plans drive — one source, not four literals — so a plan-shape change either moves the scan with it or fails a committed member, and the conjunction the F24 shape names (an unrelated argv-carrier not counted while a live workload-surface holder still is) is one committed member, not two disconnected halves.
CONTEXT: The phase-6 chain stands delivered with non-terminal report rows ([record.md](../record.md#record): REV `cc2ac82` latest); its accepted reviews converge (no P0/P1) but carry F27 (P2, ORIGIN: CODE): 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`) with nothing holding them equal — and plan-shape drift leaves every committed pin green while the scan undercounts (C1/C2 both `13 passed`; C1 stacked with the weakened-capture mutant goes `2 passed` over 123 live survivors the scan never sees). The machines are the review's two committed probes (`tests/test_review_phase6_probe_scope.py`: the conjunction member and the seam-anchor member, green at HEAD). `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-probe-scope-implementer.md`, its `INHERITED` block verbatim:

  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.

From `docs/research/phase6-probe-scope-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 probe-scope brief's carried chain plus its F24/F26, F24 fixed at FINAL, F26 carried):

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

  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.

Expected dispositions (rule 8 forms): F27 fixed with red evidence (named below — the anchor holds the copies equal or the conjunction member builds the selectivity in one scan, red on the drift class, green at FINAL). F28 stays carried (a document deviation in a committed report, absorbed only by a later step's correction). F11/F12/F18/F19/F20/F24/F25 stay fixed as recorded in the reports that filed them. F13–F17/F21–F23/F26 stay carried with their named owners and text corrections.

IN SCOPE: tests/test_batch3_execution.py, tests/test_review_phase6_probe_scope.py
RESIDUALS:

none — rule 3 selection for this brief's `IN SCOPE`: no `docs/residuals.md` trigger glob matches `tests/test_batch3_execution.py` or `tests/test_review_phase6_probe_scope.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-scan-anchor-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 anchoring rides as test code the module holds, 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 runner and launcher stand; no kill-surface, containment, or teardown change rides here. The sweep is delivered; this step anchors the scan that grades it.
- `scripts/supervise_run.py`, `tests/test_phase6_supervisor.py`, `tests/test_review_phase6_supervisor_boundary.py`: the supervisor chain is delivered; no supervisor, boundary, or leaf change rides here.
- `src/orchestrator/project_oracle.py`, `tests/test_phase3_project_oracle.py`, `tests/test_review_phase6_grading_seed.py`: the seed chain is closed; no grading-gate, deadline, or determinism change rides here.
- `src/orchestrator/oracle.py`, `src/orchestrator/experiment_phases.py`, `src/orchestrator/hidden_oracle.py`, `src/orchestrator/conformance.py`: no grading-runner, calibration, probe-shape, or trusted-gate change rides here. No new event type, no `docs/tables/*` change and no table regeneration, no `docs/event-catalogue.md` change.
- `docs/self-host.md`, `docs/residuals.md`, `docs/record.md`, `docs/method.md`, `docs/templates/`: the status edit, if any is owed, rides a later step; this step anchors the scan.
- Every committed test module except the two IN SCOPE modules — `tests/test_review_phase6_sandbox_sweep.py`, `tests/test_milestone3_sandbox.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 (F27 is the open finding whose next brief is this one; no `test_bug_*` name — the open-defect registry would then own it).
- Registry and control files: `tests/counterexamples.yaml`, `tests/guard_mutation_matrix.yaml`, `tests/fixture_fidelity.yaml`, `tests/verifier_registry.yaml`, `tests/spend_paths.yaml`, `tests/invariants.py`, `tests/helpers.py`, `pytest.ini`, tool configuration.
- No new dependencies, no tooling configuration, no reformatting. No new exception class and no `*Executor`/`*ModelClient` class or provider-registry registration.

ACCEPTANCE: Commands (run every one and paste what each prints into `VERIFIED`; expected result is green, exit 0, for each):

    scripts/check-tests --fast
    .venv/bin/python -m pytest tests/test_batch3_execution.py --durations=5
    scripts/check-static
    scripts/check-docs
    scripts/check-scope cc2ac82 <FINAL> docs/research/phase6-scan-anchor-brief.md

Every `pytest` line names `.venv/bin/python -m pytest` deliberately (the interpreter rule: the bare `pytest` on PATH has no `pytest-timeout` and `pytest.ini`'s `strict_config = true` rejects it — run these lines exactly as written and claim them under these names). The batch3 line rides because this brief's IN SCOPE touches files under `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 batch3 pin module and the riding review probe, so the line is the step's own battery — the oracle line is not named because the pin runs no trial and no sandboxed suite beyond its own probe drives). The docs gate is expected green with 0 errors — and every count figure you write in `VERIFIED` is the gate's own printed line, never the REV line quoted in this brief's CONTEXT and never recomputed from memory (rule 14). The scope line is expected green, exit 0, printing `tripped: none` (and the `claimed:` line the parser prints). `REV` below names the step's base — the parent of this brief commit — and is not claimed to be `FINAL`'s parent.

The anchor (`tests/test_batch3_execution.py`, in place — one seam, not an exclusion list, rule 13): the scanned pair is the driven pair — one source the plans drive and the scan matches, so the copies cannot drift. The delivered form is the review probe's anchor member moved, not re-derived: `_probe_plan` builds its `SandboxPlan` with `command=_PROBE_ARGV` (the `:49` tuple becomes the constant), and the F1 escape pin (`:231`) and the F20 racing pin (`:306`) do the same — three literals become three uses of the one source. No helper-surface change, no assertion change, no new mark: the F1/F20 pins keep their shape and their walls. If the anchor cannot be delivered as one source without touching the pins' assertions or the runner, stop and report `IN SCOPE` as insufficient.

The conjunction member (`tests/test_batch3_execution.py`, in place — the review probe's conjunction member moved, not re-derived): the module gains the one scan that states the F24 shape's "not counted … while … still is" as a single selectivity measure — an unrelated argv-carrier and a live pair-holder alive at once, one scoped scan returning exactly the holder. The delivered form is the probe's member with its module adjusted to its new home: the pair-holder is built from the plan's own `command` (the anchor above keeps it the scanned pair), the carrier retains the probe-path literal the same way the probe builds it, and the member keeps the host-only guard the probe carries (no cgroup2 visible — skip, the R08-type fresh root). The member needs no sandbox drive and no trial: it spawns two host processes and scans, so it rides the fast suite with no slow mark — but if the member cannot ride the fast suite without breaking the oracle's inner deterministic suite, keep the slow mark it carries and say so in `CHANGED` (the oracle line is then owed as ACCEPTANCE, and `IN SCOPE` is insufficient as written — stop and report it). The repointed carrier probe (`tests/test_review_phase6_sandbox_sweep.py`) stands untouched: the conjunction member supersedes its carrier half in the delivered module, and the probe retires only when the delivered member holds the shape — deletion, if owed, rides a later step.

The probe absorption (`tests/test_review_phase6_probe_scope.py`, in place — the riding probes' own disposition): when the anchor lands, the seam-anchor member reddens on nothing — it asserts what the module now holds structurally — so delete the module (both members absorbed or superseded; the scope review's friction entry about scratch-tree venv resolution rides the report, not the module), or repoint what the module still uniquely holds. Exactly one of the two, named in `CHANGED`: deletion needs no red (the absorbed members' reds below are the evidence); a repoint carries the same slow mark and host-only guard with the still-unique shape named.

Red evidence at `REV` `cc2ac82` (each unit must be replayable; the batch3 module is green at REV modulo the riding probes, so the reds are the review's measured classes re-driven at REV on scratch copies diff-verified against `git show cc2ac82:…` 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: F27's drift red — at REV, with the plan `command` tuples drifted (the C1 shape: a second argv element in all three plan tuples, `_PROBE_ARGV` untouched) stacked with the weakened-capture mutant, the F1 and F20 pins stay green over live workload survivors the scan never sees (the named failing assertion is the absorbed conjunction member's `found == [holder.pid]`-class assertion on the same drifted shape — `2 passed` where survivors stood; an error or a hang is not red, the assertion must be the thing that failed). The anchor member's own red is the C1/C2 drift against the delivered anchor (a plan tuple no longer equal to the scanned pair — the probe's measured `At index 1 diff` class).

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:

- `Anchored-scan shape` (F27): the scan matches what the plans drive and the selectivity holds in one scan — the anchor plus the conjunction member, red at REV on the drift class, green at FINAL.

EXPECTED WALLS: the measured baseline at this brief's drafting: `scripts/check-tests --fast` — `981 passed, 111 deselected in 101.48s (0:01:41)`; `scripts/check-docs` — `397 Total / 180 Unique / 397 OK / 0 Errors` (this session's HEAD line); `scripts/check-static` — exit 0, gated `All checks passed!`, advisory `Found 104 errors.` unchanged; `.venv/bin/python -m pytest tests/test_batch3_execution.py --durations=5` — `13 passed in 3.76s`–`4.05s` (probe-scope review's VERIFIED at FINAL `14b6862`: slowest `1.08s`/`1.10s` racing pin, `0.89s`/`0.90s` cancellation pin, `0.58s` F1 escape pin). The anchoring changes no drive wall — three literals become three uses of one source, and the conjunction member spawns two host processes and scans — so no new timeout rides; the module's existing pins keep their marks.

REV: cc2ac82
CLOSE OUT: no
DIVERGENCES: none
REVIEW: one session — the anchoring above all: does the scanned pair become the driven pair (one source, the drift class red at REV, green at FINAL), does the conjunction member state the selectivity in one scan, 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 brief-text corrections — 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.
