IMPLEMENTER BRIEF — oracle-classify-correct-refreeze
GOAL: the project oracle grades the known-good tree CORRECT_ACCEPTANCE and the frozen corpus covers the current tests/ tree including tests/test_dispatch_failure_split.py: the classification-path defect behind F1's FALSE_SUCCESS is fixed in src/ and the corpus is re-frozen around the fixed grading path by the registry meta-test's trusted re-freeze act, so test_project_oracle_classifies_the_five_case_corpus_on_a_real_repository and test_gate_config_and_test_corpus_neutralization_is_rejected are both green at FINAL.
CONTEXT: R17 rules this order (docs/record.md:113-130): the trusted re-freeze is the implementer's, in this brief, after the known-good classification defect is fixed — the corpus must not certify a grading path that is currently mis-grading known-good trees. The two reds are measured on this tree. First, the five-case corpus grade fails its known-good case: calibration case 'known-good' classified 'FALSE_SUCCESS', expected 'CORRECT_ACCEPTANCE' (ExperimentError at src/orchestrator/experiment_phases.py:265, raised by _calibrate_case when oracle.classify_trial's verdict differs from expected). Re-driven by the planner at HEAD with the new module present and at the D-split REV with the new module moved aside, the same red holds (with-module: 1 failed in 34.46s; without-module at REV: 1 failed in 36.07s per the implementer report) — the defect is in the grading path, not the new module. The planner's per-check diagnosis on a faithful known-good copy (intact tree plus the benign comment edit the corpus itself builds) grades OUTCOMES {'gate-check-static': 'PASS', 'gate-check-tests': 'FAIL', 'registry-counterexample-floors': 'PASS', 'registry-open-defect-floors': 'PASS', 'registry-guard-floors': 'PASS', 'registry-fidelity-floors': 'PASS'} with CLASS FALSE_SUCCESS: only gate-check-tests fails while every registry-floor check passes on a tree that must be accepted. Second, the neutralization battery's additive-module row asserts grade_one("gate-check-tests", added_tree) == GRADE_FAIL for a tree carrying a new tests/ module (tests/test_phase3_project_oracle.py:444); the same frozen-corpus rule fails the tree carrying tests/test_dispatch_failure_split.py (assert 'FAIL' == 'PASS' at :444 alongside the consecutive-runs determinism member). The brief's ACCEPTANCE demands both the new module and a green oracle; the two cannot hold together until the corpus is re-frozen by a trusted step. The suspected interaction the implementer must confirm or refute by reading the code (not assumed here): the frozen gate argv in src/orchestrator/project_oracle.py:730-737 passes --hypothesis-seed=424242 to scripts/check-tests, which forwards unknown flags to pytest, and the installed hypothesis 6.168.0 may not register a --hypothesis-seed option (no hypothesis-seed match in pytest.ini, scripts/check-tests, or pyproject.toml; the planner's --help grep for "hypothesis" printed no --hypothesis-seed line, while --hypothesis-seed=424242 alone collects fine on the host). If the flag is unrecognized inside the grading sandbox, the gate exits 4 (measured host-side: 73 deselected, 13 errors, "Unknown config option: timeout" is a separate missing-plugin shape of the same class) and the known-good tree grades FAIL through no fault of its own. This is a lead, not a verdict: read the driver, the gate-compare, and the classify path, reproduce the red at REV first, and fix what the code shows. The re-freeze act is the registry meta-test's own: tests/test_phase3_project_oracle.py's inventory (frozen_floors at src/orchestrator/project_oracle.py:195 reading gate/test identities, registry floors, and registry structural rules; build_project_oracle at :578 binding them with _verify_frozen_inputs_match_commit provenance) plus the neutralization battery that proves the freeze landed. The frozen-carry rule: an ORIGIN: CODE fix plus a registry act is feature-shaped (R17 clause 4), not a detection brief, so no R4 waiver exists or is needed. The D-split REV text is corrected by this brief under rule 8 (see INHERITED F3): the misprinted full sha does not resolve, its prefix resolves to close-out 617e74f4ecc0c5fcdc6cc77e2d236103e5016dff, and the scope invocation that ran green at that base is cited in EXPECTED WALLS.
INHERITED:
  F1 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  The oracle's five-case corpus grade fails at REV with or without this step: known-good classifies FALSE_SUCCESS, expected CORRECT_ACCEPTANCE (test_project_oracle_classifies_the_five_case_corpus_on_a_real_repository, ExperimentError at src/orchestrator/experiment_phases.py:265). Re-driven with tests/test_dispatch_failure_split.py moved aside: same red (1 failed in 36.07s). This step touches no src/ path and no oracle input.
  FIXED: no regression test — out of IN SCOPE (src/** is OUT OF SCOPE) and pre-existing at the brief's base; the hand re-drive above is the evidence.
  F2 | SEVERITY: P2 | ORIGIN: DOCUMENT | STATE: carried
  The oracle's neutralization battery fails its additive-module row once any new tests/ module lands: grade_one("gate-check-tests", added_tree) asserts GRADE_FAIL for a tree carrying tests/test_candidate_addition.py, and the same frozen-corpus rule fails the tree carrying this step's tests/test_dispatch_failure_split.py (assert 'FAIL' == 'PASS' at tests/test_phase3_project_oracle.py:444; the consecutive-runs determinism member fails alongside it). The brief's ACCEPTANCE demands both the new module and a green oracle; the two cannot hold together until the corpus is re-frozen by a trusted step.
  FIXED: no regression test — a frozen-corpus re-freeze is a trusted action outside this brief's IN SCOPE; next action the planner's (re-freeze the corpus with this module, or rule the additive row covers it).
  F3 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
  The brief's REV 617e74f2b88425317bd84860b73f547846ee0a90 does not resolve to any object in this tree (git rev-parse --verify fails; git cat-file: could not get object info), while its 7-char prefix resolves to the close-out commit 617e74f4ecc0c5fcdc6cc77e2d236103e5016dff. The work commit's parent is the brief commit 4e66da0, whose parent is that same close-out commit, so the base is unambiguous in content but check-scope cannot run as written and the report's REV/FINAL lineage is asserted, not gated.
  FIXED: no regression test — an ORIGIN: BRIEF finding is fixed once a later committed brief corrects the text; next action the planner's (correct the REV hash or the scope-gate invocation).
  (No INHERITED block was received: the brief's operative STEP section carries no open items forward — its INHERITED-bearing review chains sit above the STEP line as history, and every finding named there is already disposed in the report that filed it. No new carried items beyond F1/F2/F3 above.)
IN SCOPE: src/orchestrator/oracle.py, src/orchestrator/project_oracle.py, src/orchestrator/experiment_phases.py, src/orchestrator/hidden_oracle.py, tests/test_phase3_project_oracle.py
RESIDUALS: none — no row in docs/residuals.md:70-79 names an oracle, experiment, or phase3 glob, so rule 3 selects nothing for this diff.
OUT OF SCOPE: tests/test_dispatch_failure_split.py (lands as carried corpus content once the freeze covers it; do not edit it); 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 (edit YAML plus scripts/tables.py --write only if a machine definition must move, which this fix must not need); 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: the fix must survive the oracle's own sandboxed gate-check-tests run.
ACCEPTANCE:
- `.venv/bin/python -m pytest tests/test_phase3_project_oracle.py::test_project_oracle_classifies_the_five_case_corpus_on_a_real_repository -p no:cacheprovider` — green (the known-good case classifies CORRECT_ACCEPTANCE; expected red at REV: calibration case 'known-good' classified 'FALSE_SUCCESS', expected 'CORRECT_ACCEPTANCE', ExperimentError at src/orchestrator/experiment_phases.py:265)
- `.venv/bin/python -m pytest tests/test_phase3_project_oracle.py::test_gate_config_and_test_corpus_neutralization_is_rejected -p no:cacheprovider` — green (the re-freeze landed: the additive-module row rejects a fresh unlisted module while the committed tests/test_dispatch_failure_split.py tree grades PASS; expected red at REV: assert 'FAIL' == 'PASS' at tests/test_phase3_project_oracle.py:444)
- `.venv/bin/python -m pytest tests/test_phase3_project_oracle.py -p no:cacheprovider` — green, whole module
- `scripts/check-tests --fast` — green, including the corpus re-freeze members (drive multi-minute gates 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. Known-good accepted: the intact repository plus a behaviour-preserving source edit grades gate-check-static PASS and gate-check-tests PASS through the sandboxed grading path (hidden_runner at src/orchestrator/hidden_oracle.py:328 via _calibrate_case at src/orchestrator/experiment_phases.py:236-265), and oracle.classify_trial (src/orchestrator/oracle.py:909) returns CORRECT_ACCEPTANCE for the ACCEPTANCE_CLAIMED controller outcome. Diagnose the single FAILing check first: reproduce the planner's per-check OUTCOMES line at REV, then fix the grading path so the verdict follows the tree's behaviour, never the reverse.
2. Re-freeze around the fixed path: the frozen inventory (frozen_floors at src/orchestrator/project_oracle.py:195, bound by build_project_oracle at :578 with _verify_frozen_inputs_match_commit provenance) covers the current tests/ tree including tests/test_dispatch_failure_split.py, so the neutralization battery's additive-module row still rejects an unlisted fresh module (regression pin for the freeze) while the committed tree with the D-split module grades PASS. If the fix changes the frozen gate argv, gate scripts, control/test identities, or registry floors, the freeze moves with it in the same step — never a freeze of the old path plus a fix beside it.
3. No vacuous accept: the broken-source, known-timeout, and infrastructure calibration cases keep their expected verdicts (CORRECTLY_UNRESOLVED, FALSE_SUCCESS, INDETERMINATE), and the neutralization battery's hostile rows (gate-config neutralization, pytest/conftest neutralization, -k rename, benign/broken source edits) stay red-turned-green as the battery asserts — the fix narrows the mis-grade, it does not widen the pass.
Each case: reproduce the red at REV before fixing (the node id, the exact command, the named failing assertion), assert the fixed verdict is the gate's own (anti-vacuity: the sandboxed grade line, not a unit-level mock of it), 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 7518ae8): `scripts/check-tests --fast` — `1076 passed, 110 deselected in 85.66s (0:01:25)`; `scripts/check-docs` — green; `scripts/check-static` — exit 0; `.venv/bin/python scripts/tables.py` — `Table verification passed.`; retrospective `scripts/check-scope 617e74f4ecc0c5fcdc6cc77e2d236103e5016dff 052df2fd1c9516b6caa11fb18fc2e97c35095392 docs/research/detection-d-dispatch-failure-split-brief.md` — `scope: ok (2 path(s) in 617e74f4ecc0c5fcdc6cc77e2d236103e5016dff..052df2fd1c9516b6caa11fb18fc2e97c35095392)`, `tripped: none`; the D-split step's own lines at its FINAL 052df2f: new-module battery `2 passed in 0.57s`, fast suite `1076 passed, 110 deselected in 88.55s`, oracle module `3 failed, 4 passed in 332.78s` (the F1/F2 reds this brief fixes), fidelity pair `6 passed in 0.60s`.
REV: 7518ae8
CLOSE OUT: no
DIVERGENCES: none — oracle classification-path fix plus the corpus re-freeze its registry act proves; no normative document changes.
REVIEW: one session — the classification fix and the re-freeze: does the known-good tree grade CORRECT_ACCEPTANCE through the sandboxed path at FINAL with the red re-driven at REV, does the frozen inventory cover the D-split module while still rejecting an unlisted fresh module, do the broken/timeout/infrastructure cases and every hostile neutralization row keep their verdicts, is the diff limited to the oracle classification path plus the freeze inventory plus the corpus battery 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-classify-correct-refreeze-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.
