REVIEW BRIEF — oracle-gate-identity-scope (the identity pin reaches only the tests gate; its provenance is stated)
REV: 9302405d3bd94949d03f6586718891ec8d4e7785
FINAL: d796402ab5cc7adc16371118575157ff7337b19e
REVIEW ACCEPTANCE: scripts/check-scope 9302405d3bd94949d03f6586718891ec8d4e7785 d796402ab5cc7adc16371118575157ff7337b19e docs/research/oracle-gate-identity-scope-brief.md
FOCUS: the parameter split and its weakest points. Does the formatted
gate-check-static driver carry no GIT_AUTHOR_* or GIT_COMMITTER_* entry
while the gate-check-tests driver carries all four pinned values — re-drive
the R1 shape at REV (both drivers carry all four) and at FINAL from the
formatted drivers, not from the member's account of them. Is the default
genuinely absent (None means no entry, not an empty update that still
drifts the static probe's identity), and does the empty mapping change the
static check's probe identity or target binding relative to REV. Is the
comment's provenance claim now true: the pin is a fixed oracle-supplied
identity the nested suite needs, deliberately not the trusted host's. Do
the corpus and neutralisation members stay green with the additive row
still rejecting an unlisted fresh module, and do the five calibration
verdicts and every hostile row keep theirs. Is the new member a true
behavioral red (fails at REV on the static driver's non-empty identity,
passes at FINAL) rather than an echo of the implementation, and does its
monkeypatch of sandboxed_probe leak into any other member. Is the diff
limited to the parameter plus the comment plus the member plus the report.
QUESTIONS TO ATTACK:
  F1 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: fixed
  The brief's R2 deliverable offers two readings — pin the trusted `GIT_ENVIRONMENT` name/email, or correct the comment — and the taken reading is the second: the pin is a fixed oracle-supplied identity, because the nested suite only needs any valid identity and adopting the trusted name would bind candidate-visible commits to the orchestrator's own identity.
  FIXED: no regression test — the reading is recorded in the corrected comment at src/orchestrator/project_oracle.py:139-149, committed at d796402.
An item is a question, not a prediction: word mutant items as "which pin goes red, and on which
member?" — the reviewer measures it. A mutant prediction names the first member the runner reaches.



--- BEGIN BRIEF UNDER REVIEW (copy of docs/research/oracle-gate-identity-scope-brief.md; the committed file is authoritative) ---
IMPLEMENTER BRIEF — oracle-gate-identity-scope
GOAL: the nested-gate git-identity pin reaches only the check whose suite
needs it, and the pin's provenance is true in the code: `_gate_check`
takes the identity as a parameter defaulting to absent, `gate-check-tests`
passes it, `gate-check-static` does not, and the comment over
`_GATE_GIT_IDENTITY` states what the pin is (a valid fixed identity the
oracle supplies because the sandbox carries none) rather than claiming it
is the trusted host's. Both oracle members stay green at FINAL with no
freeze-input change.
CONTEXT: The refreeze step (`3381145`) fixed the known-good FALSE_SUCCESS
by injecting `_GATE_GIT_IDENTITY` into the shared gate driver
(`src/orchestrator/project_oracle.py:148-153`, applied at `:320` inside
`_GATE_DRIVER_TEMPLATE`, bound unconditionally at `:544` in `_gate_check`).
The review (`docs/research/oracle-classify-correct-refreeze-review.md:26-31`)
re-drove the red at REV and the green at FINAL independently and converged
the step, carrying two P2s that are this brief's whole scope. R1: the
unconditional injection means `gate-check-static` receives all four
variables too, although the static gate runs no git and reads none of
them, so the static check's probe identity and target binding drift with
what is otherwise a tests-gate-only fix. R2: the pin is not the identity
the trusted host supplies — the host git config is `gituser <a@b.c>`,
`worktree.GIT_ENVIRONMENT` is `orchestrator <orchestrator@localhost>`
(`src/orchestrator/worktree.py:38-55`, full trusted set with fixed dates
and the R01 config-devnull discipline), and the pin is `oracle-gate` /
`oracle-gate@localhost` — so the comment's "the identity the trusted host
would supply" (`project_oracle.py:145`) is false, and an identity-sensitive
suite member would see a host/sandbox divergence. The deliverable is the
review's two named next actions, and only those: parameterise `_gate_check`
with an identity argument defaulting to absent and pass the pin only from
the `gate-check-tests` call site (`:744-767`), leaving the
`gate-check-static` call site (`:727-743`) without it; and either pin the
trusted `GIT_ENVIRONMENT` identity (name/email only — never its fixed
dates, its R01 config-devnull discipline, or any host ambient config) or
correct the comment to state the pin is a valid fixed oracle-supplied
identity with its requirement explicit. The second reading is the expected
one: the nested suite only needs a valid identity (the hook test passes
with the pin as measured), while adopting the trusted name risks binding
candidate-visible commits to the orchestrator's own identity. If exactly
this reading is taken, file it as an `ORIGIN: BRIEF` finding naming the
taken reading. The driver template keeps the single `env.update(...)`
line; the parameter only decides what mapping it receives. No freeze
input moves: the frozen hashes, corpus, and argv are unchanged, and no
registry floor is touched.
INHERITED:
  R1 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  _gate_check unconditionally injects _GATE_GIT_IDENTITY into the shared gate driver, so gate-check-static receives the four variables too. The static gate runs no git and reads none of them, so its current verdict is unchanged, but the pin is broader than the nested gate it is for and the static check's probe identity/target binding drift with what is otherwise a tests-gate-only fix.
  FIXED: no regression test — hand capture /tmp/capture_driver.py shows both formatted drivers carry all four vars; next action: parameterise _gate_check and pass the identity only from the gate-check-tests call site.
  R2 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  The pin is not the identity the trusted host supplies: the host's git config is gituser <a@b.c>, worktree.GIT_ENVIRONMENT is orchestrator <orchestrator@localhost>, and the pin is oracle-gate <oracle-gate@localhost>. The current suite only needs a valid identity (the nested hook test passes with the pin), but the comment's claim "the identity the trusted host would supply" is false and an identity-sensitive test would see a host/sandbox divergence.
  FIXED: no regression test — hand comparison of `git config --show-origin --get user.name/user.email` and worktree.GIT_ENVIRONMENT; next action: pin the trusted GIT_ENVIRONMENT identity or correct the comment and make the identity requirement explicit.
  (No other item is open: the review's F3/F4 are fixed/declined in the report that filed them, R3 is declined with no action, and the frozen D-split findings stay disposed in the report that filed them.)
IN SCOPE: src/orchestrator/project_oracle.py, tests/test_phase3_project_oracle.py
RESIDUALS: none — no row in docs/residuals.md names an oracle, experiment, or phase3 glob, so rule 3 selects nothing for this diff.
OUT OF SCOPE: src/orchestrator/worktree.py (read, never edited — the trusted identity is reference only); every other src/ file; every other existing test module; tests/open_defects.yaml, 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; docs/tables/*.yaml and every generated Markdown table (this fix must not need a machine move); any docs/ file except your report. Define no new *Executor or *ModelClient class (the fixture-fidelity meta-test requires a registry row for every one). Spawn no new sandbox shapes.
ACCEPTANCE:
- `.venv/bin/python -m pytest tests/test_phase3_project_oracle.py -p no:cacheprovider` — green, whole module (the corpus member still classifies known-good CORRECT_ACCEPTANCE through the pinned tests driver; the neutralisation member still passes with the committed tree; the additive row still rejects an unlisted fresh module; the static gate's verdict is unchanged)
- `scripts/check-tests --fast` — green (drive through background-process tooling; the gate's own printed line is the evidence)
- `scripts/check-static` — green
- `scripts/check-docs` — green
The fix must cover these shapes (a list, not a count):
1. Static driver clean: the formatted `gate-check-static` driver carries no `GIT_AUTHOR_*`/`GIT_COMMITTER_*` entry, while the formatted `gate-check-tests` driver carries all four with the pinned values — assert the drivers' own formatted text (the review's uncaptured shape: `/tmp/capture_driver.py` showed both drivers carrying all four; no suite member asserts the static driver's env). A new member in `tests/test_phase3_project_oracle.py` may format `_gate_check` for both call sites and assert the split; mark it `@pytest.mark.timeout` if it builds manifests, and `pytestmark = pytest.mark.slow` is not needed (no trials or sandboxed suites run inside the member — formatting only).
2. Identity requirement explicit: the comment over the pin states what the nested suite needs (any valid git identity, because the sandbox carries none) and what the pin is (a fixed oracle-supplied identity), with no claim it is the host's or the trusted environment's. If the trusted `GIT_ENVIRONMENT` name/email is pinned instead, no fixed date, config-devnull, or host ambient value rides with it.
3. No widened pass, no narrowed freeze: the five calibration verdicts and every hostile neutralisation row keep their verdicts — the parameter narrows which driver receives the pin, it does not change what the pin contains or what the freeze covers. Reproduce the R1 shape at REV before fixing (both formatted drivers carry all four vars), assert the split at FINAL from the formatted drivers, and mark any new long-running case `@pytest.mark.timeout` so a deadlock fails instead of hanging. An assertion behind a condition that can be false at run time is not evidence: if a shape cannot be built, say so in your report rather than shipping a conditional.
EXPECTED WALLS: the measured baseline at this brief's drafting (HEAD 9302405): `scripts/check-tests --fast --durations=5` — `1076 passed, 110 deselected in 88.44s (0:01:28)` (slowest five: 8.78s test_phase2_non_self_repository_runs_end_to_end; 7.24s test_patch_mode_never_batches_review_n7; 6.52s test_the_group_kill_reaches_the_grandchild_before_the_supervisor_exits; 5.82s test_crlf_base_refuses_the_lf_context_reply_review_f1; 5.76s test_unterminated_file_refuses_the_markerless_eof_reply_review_n2); `scripts/check-static` — exit 0; `scripts/check-docs` — `409 Total / 183 Unique / 409 OK / 0 Errors`; `.venv/bin/python scripts/tables.py` — `Table verification passed.`
REV: 9302405d3bd94949d03f6586718891ec8d4e7785
CLOSE OUT: no
DIVERGENCES: none — the review's two named next actions with no freeze or registry move.
REVIEW: one session — the identity scope and provenance: does the static driver format without the four vars while the tests driver carries them pinned, is the comment's provenance claim true, do the corpus and neutralisation members stay green with the additive row still rejecting, is the diff limited to the parameter plus the comment plus the driver-split member plus the report, and are the figures the gates' own printed lines (rule 14).

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/oracle-gate-identity-scope-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.
REPORT — <phase>-<subject>-<role>
STEP: <implementer brief subject>
REV: <copied from the brief's REV — the step's base, not FINAL's parent>   FINAL: <implementer: sha of your work commit, never the commit that holds this report;
  reviewer: the sha under review, copied from the review brief>
CHANGED: <files, one line each>
VERIFIED: <command, duration, counts>
         Every VERIFIED and ACCEPTANCE claim names the command that actually ran — never a
         substituted interpreter, wrapper, or narrowed form. If the documented form cannot run in
         your environment, record both commands and the documented form's separate check. Every
         pytest line names .venv/bin/python -m pytest (bare pytest lacks pytest-timeout; strict
         config rejects it). A suite run records its slowest five (--durations=5): budgets are set
         from measured per-test walls. A timeout is a symptom; classify it before rerunning —
         hang (a surviving descendant or tree; EAGAIN from accumulated children: a kill-surface
         fix), under-budgeted slow test (a heavy but legitimate draw past a fixture wall budget),
         or contention (xdist, a full shared tmpfs — ENOSPC — or a cgroup: isolation, never a
         value change). A "Timeout >120s" line
         is the global firing; anything else naming a timeout (a CANDIDATE_TIMEOUT grade, a
         wall-budget INFEASIBLE, EAGAIN, ENOSPC) is not it.
NOT VERIFIED: <why, or none>
FINDINGS: none | one block each:
  ID | SEVERITY: P0|P1|P2 | ORIGIN: BRIEF|CODE|DOCUMENT | STATE: fixed|declined|carried
  <root cause, one line>
  FIXED: <node id, command, and the named failing assertion at REV — or "no regression test">
         An error or a collection failure is not red. The assertion has to be the thing that
         failed; a run that merely crashed proves nothing.
  STATE means: fixed (above); declined = not a defect, with the reason; carried = a real defect
  left unfixed, passed on in INHERITED. A defect you will not fix now is carried, never declined.
  An ORIGIN: BRIEF finding is fixed once a later committed brief corrects the text: FIXED: names
  that brief's commit and reads "no regression test". Carried means a future actor has something to
  do with it; at closeout a finding with no possible next action is closed — a defect in an
  already-committed report reads FIXED: recorded in the review that filed it, and an authoring
  lesson from a finished brief goes into record.md's Observations. IDs are stable keys: the F<n>
  sequence is the default, and a prefix must name its origin.
SHAPES: <shapes probed that the suite does not build, or none with a reason>
        Every shape this report names needs a test or an entry here: a hand measurement is not a
        test. A facet claimed unchanged is re-driven at FINAL when your fix touches its surface.
        SHAPES: none claims nothing probed is left unbuilt — never that unbuilt probes were left
        unnamed.
TRIPPED: <copied from check-scope's tripped: line>
PROPOSED ROWS: <ledger rows, or none>
METHOD FRICTION: none | <where you deviated from the method or its templates, misread them, or
  found them silent. A defect in the brief is a FINDING, not friction. This form is exhaustive:
  every field is filled and nothing outside it is added. A departure from the form is friction
  even when it changes no outcome — silence is not compliance.>
INHERITED:
<<every INHERITED item you received that is still open, copied verbatim; then each
  finding you marked carried, with its ID>>
Rule 2 governs the planner's copy of this block. What goes in it is yours: an implementer or
reviewer who received an obligation, finding, entry or trigger carries it forward verbatim, and
adds anything new that is still open. A block reading `none` is correct only when nothing came in
and nothing is open. INHERITED never carries residual rows; they are re-selected from the store per
brief.
--- 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/oracle-gate-identity-scope-review.md. If you cannot commit, stop and say so.
