<!-- informative -->

# Record

Record state: the defect-pattern ledger, one row per completed step, the OWNER rulings, and the
method friction waiting for an OWNER ruling. The method that governs them is in
[method.md](method.md); this file holds what changes while the method does not. The PLANNER edits it
during a step; the OWNER edits Owner rulings and Pending for the owner between steps.

## Owner rulings

Consumed rulings are removed in the commit that appends the Record row that consumed them, never
earlier. Appending the row does not remove a ruling by itself. A ruling is consumed by the work it
governs — the Record row that completes the brief it names, the work it directs, or the migration it
authorises. Standing rulings are removed only by the OWNER. A ruling holds only the case it
decides: anything in it that binds beyond the case goes into `method.md` or a template in the same
commit that writes the ruling.

### R4 — Detection-brief ratio stands (standing)

At most one detection brief per three feature briefs while a ledger row has no test. Three feature
briefs have landed (provider, fixes, api-shape) against one detection brief, so a detection brief is
within the ratio. A ratio amendment is declined.

### R9 — `REVIEW: none` granted for pure new-test steps (standing)

`REVIEW: none` is granted where the diff is only new `tests/test_*.py` files and non-normative
documents (first line not `<!-- normative -->`). The grant is conditional on the actual diff: if the
diff exceeds that shape, a review becomes required, which counts as an addition under the add-only
rule. A skip under this ruling records `0 (OWNER R9)` in the Record's `Reviews` column and counts
toward the three-grant trigger that will build the mechanical predicate.

### R13 — The grading gate runs seeded; verdicts are reproducible

F8 of the phase-6 supervisor chain — the oracle fixture's grade flip, filed in
[the fixes implementer report](research/phase6-supervisor-fixes-implementer.md) and carried through
[the fixes-2 review](research/phase6-supervisor-fixes-2-review.md) — is fixed by the seed, not the
budget. The nested grading gate runs with a fixed hypothesis seed (`--hypothesis-seed=424242`, the
measured seed): the same candidate grades the same verdict every time. The grade-flip symptom — one
candidate grading `FALSE_SUCCESS` on one run and `CANDIDATE_TIMEOUT` on the next — is a grader
defect, not a test annoyance. Exploration stays in the outer suite, which fuzzes unseeded every
run; the grading run's job is verdicts. F8 stays carried in `INHERITED` until the named brief fixes
it: the seed brief inherits F8 and closes it with red evidence.

The fixture's 60s `gate_timeout_seconds` stands. At seed 424242 the nested suite measures 30.27s
and 30.81s (`--hypothesis-seed=424242` over the same 58-module selection in the same sandbox shape —
[the fixes implementer report](research/phase6-supervisor-fixes-implementer.md) line 23), and the
60s deadline also covers the probe-tree copies and identity digests, so the margin is a little
under 2×. A different seed draws different examples: the brief either uses 424242 or measures its
own seed's nested duration before claiming margin. Raising the budget is a prediction, not a
measurement — basis: the `known-timeout` candidate waits out the whole budget on every run — and it
predicts +240s per module run at 300 and +90s at 150; both declined.

The orphan probe is recorded: on 2026-10-11 a full `tests/test_phase3_project_oracle.py` run
(5 passed in 337.57s) left zero survivors — no `/work/.venv` chain, no `sandbox_launcher` — the
class is closed by the phase-6 descendant sweep, and the earlier host sightings predate it. The
named brief's `ACCEPTANCE` repeats that sweep after its runs: the determinism pin runs the module
repeatedly, and a survivor is a finding.

The next brief is `docs/research/phase6-grading-seed-brief.md`: the gate's arguments gain the seed,
and a determinism pin lands (N consecutive grades of one candidate, identical verdicts). F11 and
F12 of the phase-6 supervisor chain — the session-escaped forker and the double-fork boundary,
filed in [the fixes-2 review](research/phase6-supervisor-fixes-2-review.md) — follow that brief;
their shape (a container boundary, or a narrowed whole-tree claim under rule 13) is a separate
ruling, requested when that brief is planned. Consumed by the Record row that completes the named
brief.

### R14 — The phase-6 supervisor chain's text defects close as actionless

Thirteen carried findings of the phase-6 supervisor chain (grading-seed through deadline-margin)
are text and record defects in finished artifacts: no future brief rewrites that historical text,
so no possible next action exists — the F43 form. They close at this ruling with that reason:
F13, F17, F22, F23, F26, F29, F30, F32 (`ORIGIN: BRIEF`) and F14, F21, F28, F31, F33 (`ORIGIN:
DOCUMENT`). Their frozen blocks stay as written in the reports that name them; no committed row
or report is edited. Rule 8's actionless close now runs at every step decision (same commit), so
this class cannot accumulate again across a chain that never closes out.

### R15 — The exit gate's sustained runs, scoped (amended after the referral)

The phase's remaining work is the seed-matrix campaign: four consecutive real runs (seeds
1001–1004), each driving the four arms — the worksheet's shape, `trials = len(ARM_ORDER) ×
len(seeds)` = 16 (`cap_worksheet`, `scripts/smoke_run.py:734`) — of the model `kilo-auto/free`
(`run.sh`'s export at line 15, per the OWNER's "use the model in run.sh". "Muse Spark 1.3
Contributor" is unlocatable in the repo, the Kilo config, and the host, and does not bind; the
export remains the single knob if its gateway id is ever known), driven by the tracked
`scripts/smoke_run.py` in real mode (`ORCHESTRATOR_MODE=real`, `ORCHESTRATOR_CONFIRM_REAL=yes`)
against this repository at the pinned base commit the brief names, cloned fresh into
`ORCHESTRATOR_WORKDIR` per authorisation. Every trial settles.

The contract is pinned by environment, not by `run.sh`: that file is gitignored (`.gitignore:1`)
and untracked, so no base commit pins it and rule 1 cannot make it the actor's input. The brief
carries the full env contract; the cited command is `.venv/bin/python scripts/smoke_run.py` at the
pinned base. The key enters the process environment — it is present in the session that runs the
campaign — never a file in the tree, never the brief or the report.

"Sustained" means the matrix completes back-to-back under one authorisation with the cumulative
spend of all 16 trials under the cap. The cap is 10 USD at `ORCHESTRATOR_CAP`; with
`ORCHESTRATOR_MODEL_COST=0.5` and `ORCHESTRATOR_PER_ATTEMPT_COMMITMENT=0.1` the worksheet prints
`required 9.6 over 16 trials`, margin +0.4. The brief's first ACCEPTANCE line runs `cap_worksheet`
and a negative margin refuses the run — the gate that caught the previous figures. The pricing
exports carry the gateway's published rates at dispatch (rule 15; a free tier prices at zero and is
recorded as such — the cap then holds trivially while transport, credentials, settlement, and the
scan run for real). `ORCHESTRATOR_OWNER` names the authorising owner; the call and token limits
stay within the cap bounds, and the brief sizes `MAX_MODEL_CALLS` to its attempt shape. After the
last trial the credential-bytes scan runs against every store, the debug transcript included
(`ORCHESTRATOR_CREDENTIAL_TTL_SECONDS=600` bounds the credential's life; `ORCHESTRATOR_REVOKE_URL`
is set if the provider supports revocation).

The next brief is `docs/research/phase6-exit-gate-runs-brief.md`: it drives this campaign and
records the sustained-settle-under-cap evidence the phase's exit gate draws from. Consumed by the
Record row that completes the named brief.

### R17 — The detection-D chain continues: one brief fixes the oracle classification and re-freezes the corpus

(1) The trusted re-freeze is the implementer's, in the named 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, and the re-freeze needs the registry meta-test to prove it landed
inside the brief's `IN SCOPE`. (2) F1's `FALSE_SUCCESS` on the known-good tree (the oracle's
five-case corpus grade fails at `experiment_phases.py:265` with or without the new module; the
hand re-drive is the evidence) is a code defect at the classification path — the next work is a
code-fix brief against it, **not** a tests-only scope waiver; a scope waiver would leave the
grading oracle lying while the chain's evidence leans on its verdicts. (3) The D-split brief's
`REV` text is corrected by the same brief under rule 8 — the misprinted full sha does not resolve,
its prefix resolves to close-out `617e74f4…`, and the scope invocation that ran green at that base
is cited. (4) The chain does not close out on the landed module: row D stays `partial` through the
follow-up brief, and no R4 waiver exists or is needed — the follow-up is feature-shaped (an
`ORIGIN: CODE` fix plus a registry act), not a detection brief.

The next brief is `docs/research/oracle-classify-correct-refreeze-brief.md` (the planner names it
by the house convention). Consumed by the Record row that completes that brief.

### R19 — The swallowed trusted-gate evidence: one diagnostic brief

The trusted-side gate raises at `project_oracle.py` — the docs gate and the conformance gate above
it — discard the captured `stdout`/`stderr`, so a gate failure names itself only as "the trusted-side
documentation gate failed". That silence cost the VM migration six diagnostic rounds; the actual
cause (a `--unit` service's PATH missing `~/.local/bin`, so `pymarkdown` was unfindable) was
invisible by construction. The next brief is `docs/research/oracle-diagnostic-stderr-brief.md`: each
trusted-gate raise carries the nested gate's output, pinned by a member that induces a docs failure
in a scratch tree and asserts the raised `ExperimentError` message carries it, with the fail-closed
raise unchanged. Consumed by the Record row that completes the named brief.

## Pending for the owner

Each `METHOD FRICTION` entry is copied per [method.md](method.md#exit)'s closeout duty. The OWNER
clears an entry by ruling on it between steps: amend the method or its templates,
or decline with a reason. An entry is never cleared by the PLANNER. A concern for the OWNER
([method.md](method.md#rules) rule 11) also lives here and closes the same way. The section is a
queue: an entry is deleted when the OWNER rules on it, and the ruling's commit message records how
it was ruled.

None.

## Observations

Seen once. A rule is added at the second occurrence, not the first.

- **A nested-oracle counterfactual cannot run on a scratch copy on this host.** The control
  experiment reproduces the calibration failure ("known-good" classified "FALSE_SUCCESS"), so such
  halves are recorded `NOT VERIFIED` rather than trusted; the mutant methodology (diff each mutant
  against `git show <rev>:...`, run only on faithful copies) covers everything it is applied to.

- **A rename mandate must cover the class, not two pins: identifiers embedding a retired entry name
  are renamed with the entry.** The api-shape brief named F6's two pins and was silent about
  `test_propose_decomposition_blocks_dependents_only`; the implementer took the only consistent
  reading (rename with the entry) and filed the silence as F8 (the api-shape chain's).

- **A factual claim in a friction entry should cite a commit.** The claim that the brief was re-cut
  and rewritten under a live implementer was wrong on timing and on fact (F9 disproved both against
  `git log`); a citation turns such a disagreement into a lookup instead of a falsification round.

- **An `ORIGIN: BRIEF` finding's close form follows where the text lives.** Rule 8's "a later
  committed brief corrects the text" governs defects whose text sits in a committed brief; after R8
  split F10, its docstring half was live code and closed with the code edit the later brief directed
  (`no regression test`, the commit named) — the run-entry review's answer 1 adjudicated the form.

- **When a brief's word names values two seams take differently, the brief must say which seam each
  value goes to.** `experiment_target.build_target`'s `budgets` keyword takes per-component
  derivation allocations, not the run's budget dimensions; the run-entry implementer hit the seam,
  routed run budgets to the run configuration instead, and reported the trap as informational.

- **A `FIXED` line's citations must name the delivered file's line numbers, or none.** The fixes
  report's numbers matched neither the committed test file nor one scratch layout (F22): the helper
  revert made the hybrid ten lines shorter, so two citations matched the hybrid and the rest matched
  nothing. The named assertions carried the evidence; the numbers subtracted from it.

- **When a named shape's sentence is universal, the brief's remedy list must cover the same set — or
  the sentence narrows in the same breath.** The Settled-start shape named three escape classes and
  its remedies covered two (F19); the Fail-closed-load shape claimed "every malformed class" and its
  remedy could not reach the freeze boundary (F21). Both true sentences became ORIGIN: BRIEF findings
  because the work never promised to make them true. The class returned over the loader's
  named-refusal face three steps running: F35's `UnicodeDecodeError` (the fix order's "YAML decode
  errors"), F36's `RecursionError` (the tuple's inventory), and F38–F40's typed-constructor leaks
  (raw `ValueError`/`AttributeError`/`KeyError` out of `!!int`/`!!timestamp`/`!!bool` — builtins no
  YAML-type inventory enumerates). The rule is owed at these recurrences (the concern is in Pending
  for the owner): an absolute claim ("every failure", "never a run-time surprise") demands a
  structural fix — an envelope over the whole surface — never an inventory of classes.

- **A substituted command in `VERIFIED` is a declared departure, never a parenthetical — second
  sighting this step (F17 and F24).** In both, the entry named one command and the run used another
  (an interpreter, a plugin-bearing `pytest`); the class is "the command executed is not the command
  named", and its second sighting owes a rule in `method.md` or `report.txt` (see Pending for the
  owner).

- **When a brief prescribes a new public surface, the transition guard is a check inside it, not a
  caller contract in its docstring.** `Controller.mark_infeasible` admitted a terminal decision on a
  zero-failure lineage because its guard ("Deterministic infeasibility policy passes") was prose
  (F27): a mechanical precondition was available and unenforced.

- **A documented command form must match the artefact's runnability, and the pin runs the documented
  form.** The Commands section named bare `scripts/orchestrate.py …` heads for a mode-100644 script
  with a shebang and no `python3`-with-`yaml` prerequisite (F28); the pin had been running a
  different head than the doc showed (F24's residue). One form, named, runnable, pinned.

- **A `SHAPES: none` claim over named shapes is a measurement claim — second sighting (F25, F30).**
  Every named shape needs a test or an explicit unbuilt entry, and a hand measurement is not a test.
  The class first appeared as F25's "nothing probed by hand was left unbuilt" and again as F30's
  three facets hidden behind "unchanged as measured by the fixes-2 review". The rule is owed at this
  second occurrence (the concern is in Pending for the owner).

- **A claim of "unchanged as measured by" an earlier review is re-driven at `FINAL` when the fix
  touches the surface.** F30's second half: the zero-fingerprint `mark_infeasible` call on a
  terminal run changed from retained-late to refusing under F27's guard, while the report read
  "unchanged" from a measurement taken before the guard existed.

- **An `INHERITED` block's lead token `none` claims nothing is open — a review that marks a finding
  `carried` and leads its `INHERITED` with `none` contradicts itself.** The fixes-5 review's block
  reads "none — … Two new findings are filed by this review: F36 (carried, above) and F37 (fixed,
  above). Nothing else is open." while rule 9's convention holds a block reading `none` "correct
  only when nothing came in and nothing is open"; the next brief's rule-2 copy takes F36 from the
  block's prose rather than its lead. Seen once — every earlier block either listed its carried
  items or read `none` with nothing open.

- **A chain whose only remaining items are brief-text defects ends at its last closeout, closing
  them as actionless — it does not open a step to close them.** FFR-4's text lived in a frozen
  review brief with no possible next action and should have closed at the fixes-8 closeout;
  instead fixes-9 ran to close it and manufactured a self-contradiction along the way (F43). The
  mechanics corner: a step with no tree change cannot exist (`check-scope`'s empty-diff error and
  the work-commit rule both require one), so a text-close step invents work or contradicts itself —
  `FINAL = REV` waits for a genuine case's second sighting. Seen once (the fixes-8 closeout
  misapplied rule 8's correction form to record text).

- **The loader chain ran nine steps (fixes-1 to fixes-9) on one interface — the measured cost of
  the inventory-remedy class** (answering an absolute "never" claim with a list of cases), which
  rule 13 now prevents. The chain ended at fixes-9: its `INHERITED` is clean, and the fixes-9
  Record row names the end.

- **A defect in a verification battery leaks into every later step's walls — cite the battery's
  numbers, never the estimates.** The phase-6 grading-seed review's F15: killed runs leak
  intermediate probe trees, the shared tmpfs inode table filled to 3 free entries, and the standing
  battery's first run died with 195 ENOSPC setup errors — invalidated until 81 leaked
  `orchestrator-probe-*` trees were pruned by hand (`1083 passed in 771.01s` on the valid re-run).

- **A re-drive that proves a new head-driven face must name it an unbuilt shape, not bury it in
  "unchanged as maintained".** The exit-gate implementer re-drove the validation-stage face through
  the documented `start` head — a face no committed test drives (its cited drive is in-process, the
  prior runners hand measurements) — while its `SHAPES` lead read `none` with the face "green as
  maintained" (F2). The claim's evidence was the review's own runner, not the battery it cited. A
  face driven live through the head is a shape probed; `SHAPES` lists it with the pin that does not
  exist.

## Ledger

Defect patterns, seeded from 125 commits and eight review rounds analysed in
[research/report-recurring-failures.md](research/report-recurring-failures.md). Seeded rows are
historical; the Detection column is live and must be true when read. "Partial" means a test touches
the area without enforcing the property.

| Pattern | Seen | Detection today |
| --- | --- | --- |
| A. inverted or stale predicate laundering accounting | 8 | test: `test_cancel_by_dispatch.py` (both cancel-time branches forced under interleave, plus an unforced admission race and replay) |
| B. coercion, "looks close enough" | 16 | test: `test_boundary_mutations.py`, `test_verifier_mutations.py` |
| C. a sentinel or default disables a guard | 8 | test: `test_guard_disable_mutation.py`, `guard_mutation_matrix.yaml` |
| D. fail-open or swallowed failure | 16 | partial: `scripts/check-static` gates ruff's blind-`except` and `try`/`except`/`pass` only |
| E. recovery, restart and cancel reconciliation | 14 | partial: paths covered, reconciliation invariants not |
| F. verifier or oracle binds the wrong object | 14 | test: `test_verifier_mutations.py`, `verifier_registry.yaml` |
| G. identity or aliasing not bound | 10 | test: `verifier_registry.yaml`, `counterexamples.yaml` |
| H. concurrency and interleaving | 11 | test: `test_single_flight_concurrency.py` |
| I. vacuous truth, claim-behaviour drift | 14 | partial: tamper-proofs in `tests/invariants.py` only |
| J. a claim or departure not declared against its source | 11 | review-only; no test can bind prose to an artifact |

A row is earned when the same class appears twice.

### Row J

The method's own defect class: a claim or departure never checked or declared against the artifact
it cites. Eleven instances, eight of them claims made from memory — a heading count, a registry's
coverage, a line threshold, which debt a change paid, a corpus-wide claim built from one review
chain, a diagnosis of a suite failure read out of a code comment instead of tested, and a
measurement attributed to the revision *before* the change that made it true. Every one was wrong in a
direction that flattered the change.

The eleventh is different in a way worth keeping. It was not made from memory: the command was run
and its output was on screen. `git log --oneline -1 -- docs/method.md` printed one line, and the
claim that followed was that the log *returned* one commit. The artifact was opened and still
misreported, because the command that ran was not the command the claim was about. A verification step
does not help when the verification does not answer the question.

Detection is a reviewer's falsification duty and no test is owed, because prose cannot be bound to an
artifact by one. That detection has now caught the class eleven times, which says something about the
prevention: it is one-sided. For a **departure**, declare before editing or in the same commit as the
edit that supersedes. For a **claim**, open the artifact before asserting about it — and run the
command that answers the question, without a narrowing flag, rather than a convenient one.

Two earlier instances are worth keeping for what they say about the method. The seventh landed in the
commit that described the sixth, and the gates section that exists to prevent unlocatable figures
recorded its first figure against the wrong revision. Every mechanism this method carries was added
against a hypothesised failure from a review exchange, not an observed one; `METHOD FRICTION` in each
report is where the first real sample goes.

## Record

Append one row per completed step, when the step's decision is taken. A report for a step that is not
terminal, a closeout for one that is; the counter columns are filled when a closeout is consumed and
left `—` on a report row. The `REV` column names the step's base — the same `REV` the reports name.
The `Reviews` column records the review sessions the step ran; `0 (mechanical)` or `0 (OWNER Rn)`
marks a skipped review, and it follows the same fill-at-closeout rule. This table is the index
starting procedure step 2 reads, so it is append-only and its last row is the pointer.

| Artifact | REV | Fixed | Red | Carried | Declined | Reviews |
| --- | --- | --- | --- | --- | --- | --- |
| `docs/research/detection-a-cancel-by-dispatch-implementer.md`, `docs/research/detection-a-cancel-by-dispatch-review.md` | 1932f2d365fc22fb8f719915816af9685a08142a | 0 | 0 | 0 | 2 | 1 |
| `docs/research/phase4-recursive-planning-integration-provider-implementer.md`, `docs/research/phase4-recursive-planning-integration-provider-review.md` | afc5316b5d3b3111704830849efcd2257b3366fe | — | — | — | — | — |
| `docs/research/phase4-recursive-planning-integration-fixes-implementer.md`, `docs/research/phase4-recursive-planning-integration-fixes-review.md` | f74a9f0a8b236278f765496b80ec6a8238f9384b | 2 | 2 | 5 | 0 | 1 |
| `docs/research/phase4-recursive-planning-integration-api-shape-implementer.md`, `docs/research/phase4-recursive-planning-integration-api-shape-review.md` | 41ec3303c9c184138f5ca3201f40fc00ba9ce7de | 1 | 0 | 4 | 0 | 1 |
| `docs/research/phase5-run-entry-implementer.md`, `docs/research/phase5-run-entry-review.md` | a13aacfe2219e3dbd1b6207a28bbe0f980c78b2c | — | — | — | — | — |
| `docs/research/phase5-run-entry-fixes-implementer.md`, `docs/research/phase5-run-entry-fixes-review.md` | aa33970c6d3b8f369b25be99145075fe7f48b64c | — | — | — | — | — |
| `docs/research/phase5-run-entry-fixes-2-implementer.md`, `docs/research/phase5-run-entry-fixes-2-review.md` | 544a0bf0ae130d7391d5215054c78ca60bebd81d | 9 | 4 | 3 | 0 | 1 |
| `docs/research/phase5-run-entry-fixes-3-implementer.md`, `docs/research/phase5-run-entry-fixes-3-review.md` | 6ad098906d6e180e4bff3a5362f1c030ba42230b | — | — | — | — | — |
| `docs/research/phase5-run-entry-fixes-4-implementer.md`, `docs/research/phase5-run-entry-fixes-4-review.md` | 5711e48a57dcd9df9184083009be720bd20cd7bf | 5 | 1 | 1 | 0 | 1 |
| `docs/research/phase5-run-entry-fixes-5-implementer.md`, `docs/research/phase5-run-entry-fixes-5-review.md` | 8adc6c544277e002e7c555df395582043920f098 | 3 | 1 | 1 | 0 | 1 |
| `docs/research/phase5-run-entry-fixes-6-implementer.md`, `docs/research/phase5-run-entry-fixes-6-review.md` | 9bb1d14181e34325820e0dedd3f2d43be1bd317f | — | — | — | — | — |
| `docs/research/phase5-run-entry-fixes-7-implementer.md`, `docs/research/phase5-run-entry-fixes-7-review.md` | b7a010a1cbc984493033d9bd4872d7aeacfe9b48 | 4 | 3 | 5 | 0 | 1 |
| `docs/research/phase5-run-entry-fixes-8-implementer.md`, `docs/research/phase5-run-entry-fixes-8-review.md` | b68be80aa9762eb964bd27190331617e404014ae | 4 | 1 | 1 | 0 | 1 |
| `docs/research/phase5-run-entry-fixes-9-implementer.md`, `docs/research/phase5-run-entry-fixes-9-review.md` | 49e98407fbe3c96ecbc093afafd2ff8b8e5185aa | 2 | 0 | 0 | 0 | 1 |
| `docs/research/phase5-exit-gate-implementer.md`, `docs/research/phase5-exit-gate-review.md` | 21d891aaa6d572adcfcb24fd6f762b6b0485040a | 2 | 0 | 0 | 0 | 1 |
| `docs/research/phase6-supervisor-implementer.md`, `docs/research/phase6-supervisor-review.md` | 307aaa0f4a150be5e7c5556e3517f77699d62243 | — | — | — | — | — |
| `docs/research/phase6-supervisor-fixes-implementer.md`, `docs/research/phase6-supervisor-fixes-review.md` | 9b78d7a63ce69a4ed5db5a4f59c1edeaa3652bec | — | — | — | — | — |
| `docs/research/phase6-supervisor-fixes-2-implementer.md`, `docs/research/phase6-supervisor-fixes-2-review.md` | 2da5a5a9a67336c1b8c9bb1d0f49e703eb32f806 | — | — | — | — | — |
| `docs/research/phase6-grading-seed-implementer.md`, `docs/research/phase6-grading-seed-review.md` | 0c02b273bc10fb1509c534da903d35cad33cbca0 | 1 | 1 | 5 | 0 | 1 |
| `docs/research/phase6-supervisor-boundary-implementer.md`, `docs/research/phase6-supervisor-boundary-review.md` | ba9e25e34ae5091e329469aab8c099675741f60d | — | — | — | — | — |
| `docs/research/phase6-supervisor-cleanup-implementer.md`, `docs/research/phase6-supervisor-cleanup-review.md` | c6d2d7adb1d5f67c99b31d3a976d6763dfdfcdc5 | — | — | — | — | — |
| `docs/research/phase6-sandbox-sweep-implementer.md`, `docs/research/phase6-sandbox-sweep-review.md` | d9c660e06ac530394dd6f072461b99ff6edc59fe | — | — | — | — | — |
| `docs/research/phase6-probe-scope-implementer.md`, `docs/research/phase6-probe-scope-review.md` | 12f1f839a140d56275a0b5b01840b9795db95f82 | — | — | — | — | — |
| `docs/research/phase6-scan-anchor-implementer.md`, `docs/research/phase6-scan-anchor-review.md` | cc2ac822d78f243f4c0dece9d3dff7e8f7ed5108 | — | — | — | — | — |
| `docs/research/phase6-probe-janitor-implementer.md`, `docs/research/phase6-probe-janitor-review.md` | e2271de17c3cd14a54bafda7d3f20dd8bb0d0331 | — | — | — | — | — |
| `docs/research/phase6-deadline-margin-implementer.md`, `docs/research/phase6-deadline-margin-review.md` | a1d4e07bf198bd11fae20a32cb9767facdf08793 | — | — | — | — | — |
| `docs/research/phase6-exit-gate-runs-implementer.md`, `docs/research/phase6-exit-gate-runs-review.md` | c418342625ca65ea3f5637b03ada4acde5641d0c | 0 | 0 | 0 | 0 | 1 |
| `docs/research/phase6-closeout-status-implementer.md`, `docs/research/phase6-closeout-status-review.md` | 18d9f89657da4d3d8b2a9c435aed29be249a696e | 0 | 0 | 0 | 0 | 1 |
| `docs/research/phase6-janitor-window-implementer.md`, `docs/research/phase6-janitor-window-review.md` | 498cce3544374b1aa46ee919dbebbeea7525e5cf | 1 | 0 | 0 | 0 | 0 |
| `docs/research/phase7-shadow-tag-universe-implementer.md`, `docs/research/phase7-shadow-tag-universe-review.md` | d78d1a82371e541bc64db5c46469d752417286dd | 0 | 0 | 2 | 0 | 1 |
| `docs/research/harness-hook-env-scrub-implementer.md`, `docs/research/harness-hook-env-scrub-review.md` | 0e45cb9fa0e32ad2b5b284f07d57745688397b7f | 0 | 0 | 2 | 0 | 1 |
| `docs/research/harness-hook-seam-absorption-2-implementer.md`, `docs/research/harness-hook-seam-absorption-2-review.md` | bd86141b9900686808441a71c49026873acb87b3 | 1 | 0 | 0 | 0 | 1 |
| `docs/research/harness-git-ops-seam-implementer.md`, `docs/research/harness-git-ops-seam-review.md` | 0a254663b184ea3ff9ea1157db169610a3870abc | 1 | 0 | 0 | 0 | 1 |
| `docs/research/harness-read-path-seam-implementer.md`, `docs/research/harness-read-path-seam-review.md` | 6bcec84e2db8ad682af9a8ace3a708cd4d3bc803 | 1 | 0 | 0 | 0 | 2 |
| `docs/research/detection-d-dispatch-failure-split-implementer.md` | 617e74f4ecc0c5fcdc6cc77e2d236103e5016dff | — | — | — | — | — |
| `docs/research/oracle-classify-correct-refreeze-implementer.md`, `docs/research/oracle-classify-correct-refreeze-review.md` | 7518ae86b59597d8051740709cffc21b15824a92 | — | — | — | — | — |
| `docs/research/oracle-gate-identity-scope-implementer.md`, `docs/research/oracle-gate-identity-scope-review.md` | 9302405d3bd94949d03f6586718891ec8d4e7785 | 0 | 0 | 0 | 0 | 1 |
| `docs/research/harness-hook-env-scrub-2-implementer.md` | 216b1c5e364264ecc3daa429ea5aa80a2316af7a | — | — | — | — | — |
| `docs/research/harness-copying-fixture-seam-implementer.md`, `docs/research/harness-copying-fixture-seam-review.md` | 360ba3fd62e2424053d5357be5d3befe445334cc | 1 | 1 | 5 | 0 | 1 |

The oracle-gate-identity-scope step delivers the refreeze review's two named next actions and
closes the chain. `_gate_check` takes `git_identity: Optional[Mapping[str, str]] = None` and
formats `dict(git_identity or {})` into the driver; only the `gate-check-tests` call site passes
`_GATE_GIT_IDENTITY`, so the static driver's formatted text carries `env.update({})` with no
`GIT_*` entry while the tests driver carries all four pinned values — R1 fixed with red
character (the new member fails at REV on the static driver's non-empty identity and on the
missing parameter, passes at FINAL; the review re-drove both drivers from the pre-image and
from the real `_gate_check`). The comment over the pin now states a fixed oracle-supplied
identity the nested suite needs, deliberately not the trusted host's — R2 fixed on the taken
reading the brief named as expected (the trusted name would bind candidate-visible commits to
the orchestrator; the nested suite only needs any valid identity), filed as the implementer's
F1 and answered in the review's QUESTIONS. The whole oracle module is green at FINAL (`8
passed`, the new split member plus the seven refreeze members), the fast suite holds its
selection (`1076 passed, 111 deselected` — the module-marked-slow member rides deselected), and
REVIEW ACCEPTANCE is green (`scope: ok (3 path(s) in 9302405..d796402)`, `tripped: none`). The
review files FINDINGS none, SHAPES none-with-reason, METHOD FRICTION none — so no new pending
entry arises — raises no P0 and no P1, and answers the one QUESTIONS item. The step's
`INHERITED` carries no finding: R1/R2 arrived carried and leave fixed, the implementer's F1
leaves fixed, and every older item stays disposed in the report that filed it. No closeout
counters move except the row's own (Fixed 0, Red 0, Carried 0, Declined 0). Ledger row D reads
`partial` through this row; the chain's remaining ledger question — whether the D-split module
plus this chain's green oracle promotes row D's Detection — is a fresh status decision and is
not taken here. This step's own commits carry their trailers (`d796402`/`940f7ec` IMPLEMENTER,
`88f8e58` PLANNER, `272eec1` REVIEWER, author the shared gituser identity).

CLOSEOUT
DECLINED: none
DIVERGENCES CLOSED: none — the brief named none and the diff moved none.

The oracle-classify-correct-refreeze step is the R17 follow-up to the detection-D split's
non-terminal report row. It fixes the classification path so the known-good tree grades
CORRECT_ACCEPTANCE: the grading sandbox runs the frozen suite with HOME on a private tmpfs
(R08) and no ambient git identity, and `tests/test_hook_env_scrub.py`'s suppression control
builds its commit env from `{**os.environ, ...}`, so it failed inside the gate with "Author
identity unknown" while passing on the trusted host — `src/orchestrator/project_oracle.py`'s
gate driver now pins `GIT_AUTHOR_NAME/EMAIL` and `GIT_COMMITTER_NAME/EMAIL` (`oracle-gate` /
`oracle-gate@localhost`) for the nested gate (one file, +18). Red evidence at REV with the fix
stashed (`2 failed in 99.78s`: known-good FALSE_SUCCESS at
`src/orchestrator/experiment_phases.py:265`; benign-edit `assert 'FAIL' == 'PASS'` at
`tests/test_phase3_project_oracle.py:444`) and green at FINAL (the corpus member `1 passed in
431.29s`; the neutralisation member `1 passed in 107.74s`; whole module `7 passed in 755.84s`),
independently re-driven by the review on a diff-verified scratch (`2 failed in 104.22s` at the
same named assertions; exact nested argv `1 failed, 864 passed` reverted vs `865 passed` pinned;
inner single-module reproduction `1 failed, 6 passed` reverted vs `7 passed` pinned). The
inherited F2's "stale freeze" mechanism is measured wrong and answered: the frozen corpus is
derived from the target tree at `build_project_oracle` time and already covers
`tests/test_dispatch_failure_split.py`, so the registry meta-test re-freezes around the fixed
path with no freeze-input edit — the additive row still rejects an unlisted fresh module while
the committed tree grades PASS. The inherited F3 (D-split REV misprint) is fixed by this step's
own committed briefs (`c38347c`/`771b4fa`), and the brief's `--hypothesis-seed` lead (F4) is
refuted (gate exits 1, pytest accepts the flag; the red re-drive's nested run confirms). The
review answers every QUESTIONS TO ATTACK item, raises no P0 and no P1, and REVIEW ACCEPTANCE is
green (`scope: ok (2 path(s) in 7518ae8..3381145)`, `tripped: none`) — the step converges, but
CLOSE OUT is no: the review files two carried P2s with named next actions, so the decision is
return to planning. R1 (the identity pin also reaches gate-check-static, which runs no git —
parameterise `_gate_check` and pass it only from the gate-check-tests call site) and R2 (the pin
is not the trusted host's identity — `gituser <a@b.c>` on the host,
`orchestrator <orchestrator@localhost>` in `worktree.GIT_ENVIRONMENT`, `oracle-gate` in the
pin — pin the trusted `GIT_ENVIRONMENT` identity or correct the comment and make the identity
requirement explicit). R3 (the brief's "re-freeze act" naming a mechanism that does not exist)
is declined: the GOAL's substantive outcome is verified by the two acceptance tests and the full
module; only the mechanism wording over-specified. F3's caveat stands as a correction inside the
closed item: `git rev-parse --verify` echoes a syntactically valid 40-hex name with exit 0; `git
cat-file -t` and `git log` are the checks that fail — the inheritance corrected no command. The
frozen D-split FINDINGS F1/F2 stay disposed in the report that filed them and are not re-counted;
only R1/R2 are carried. This step's own commits carry their trailers (`3381145`/`4c5cd77`
IMPLEMENTER, `3659dde` PLANNER, `7ad6829`/`6f3254f` REVIEWER, author the shared gituser
identity). Ledger row D stays `partial` through this row; the chain's next move (R1/R2
micro-fix plus the ledger-D detection refresh) is a fresh decision. R17 is consumed by this
row: it named `docs/research/oracle-classify-correct-refreeze-brief.md`, and the classification
fix plus corpus coverage it ruled are delivered above.

The harness-read-path-seam step routes the three unseamed production read sites through the refusal seam (`derive_obligations._python_files` and `_read_blob` plus the oracle frozen-input `cat-file --batch`, each now spawning through `worktree._git_environment()` via a function-level import on the `git_ops` precedent; `worktree.py`/`git_ops.py` read, never edited) with a seventh committed member (`test_a_linked_worktree_leak_cannot_steer_read_children_into_another_tree`: the three routed reads plus a steering-capable control against the deliberate five-leak), red at REV on the byte-identical scratch pre-image (`1 failed, 6 passed`, the unseamed `ls-tree` raising `DerivationError: cannot list ... fatal: not a tree object` at the named assertion while the control proves the same leak steers past the seam to a zero exit with the diverted tree's bytes) and green at FINAL (`7 passed in 0.39s`; each read serves its own repository's objects under the same leak), re-driven red-to-green at FINAL by the review on a `cmp`-verified scratch — the derive-only revert mutant reddens only the new member at the same assertion and the oracle-only revert mutant reddens only the new member at the frozen-input tail (`ExperimentError: frozen gate input ... is not a blob`), proving each routing necessary site by site; no import cycle, no further wrong-tree read site on the review's enumeration, and the six existing members unweakened. REVIEW ACCEPTANCE is red as the review brief predicts (`tripped: PILOT-R7 PILOT-R8 PILOT-R9`, exit 1) — confirmed the brief's under-promise, not a wider diff (claimed exactly the three IN SCOPE paths; delivery touches no other path). The review files two carried BRIEF P2s (its F1: the RESIDUALS names only R7/R8 while the gate trips R7/R8/R9 on the same `derive_obligations.py` glob — the checker's whole-brief grep finds no literal `PILOT-R9` line outside carried rows; its F2: the brief names the derive helper `_list_files` while the REV pre-image defines `_python_files`, same site, true name routed/pinned), raises no P0 and no P1 — the step converges on the work. The step fixes one P2 finding (gitops F1, the read-path steering class) and files two new carried BRIEF P2s (each fixed once a later committed brief corrects the text); the older carried set (scrub F2, scrub-review F3, the phase-6 chains, the exit-gate-runs chain) stays carried with its named next actions and is not re-counted. This step's own commits carry their trailers (`1183977`/`e3f0a49` IMPLEMENTER, `3133643` REVIEWER, author the shared gituser identity). The fast suite is green on its own printed line via the background wrapper (`1074 passed, 110 deselected in 87.70s`; the implementer's foreground ceiling kill is confirmed environmental).

The harness-git-ops-seam step routes `git_ops._git` through the refusal seam (`src/orchestrator/git_ops.py`: `env={**os.environ, **GIT_ENVIRONMENT}` becomes `env=_git_environment()`, import line only other delta; `src/orchestrator/worktree.py` byte-identical REV..FINAL) with a sixth committed member (`test_a_linked_worktree_leak_cannot_steer_git_ops_children_outside_their_tmpdir`, a leaked parent steering `_git` init/add/commit), red at REV on the byte-identical scratch pre-image (`1 failed, 5 passed`, `ExperimentError` from `git_ops.py:35`, shared config gaining `worktree = <linked path>`) and green at FINAL (`6 passed in 0.27s`), re-driven red-to-green at FINAL by the review on a diff-verified scratch — the git_ops-only revert mutant reddens only the new member (proved necessary, not decorative), the weakened-shared-seam mutant reddens the fixture-child/environment/suppression/new members together (one seam holds both modules as a class), and the exact GCP-skip mutant reproduces the prior four-of-five red class. The review's last-bypass falsification enumerates every `git` spawn and confirms all named production readers route through the seam, but answers the brief's "last bypass" question no for reads: three unseamed `git -C` read sites (`derive_obligations.py:62,91`, `project_oracle.py:826`) still steer under a leaked parent (silent wrong-tree success, hand-measured, never a write outside the tmpdir — the brief's stated refusal bar still holds where drawn). The review files one carried P2 (its F1, the read-path steering class with its named next action), raises no P0 and no P1, and REVIEW ACCEPTANCE is green (`scope: ok (3 path(s) in 0a25466..16ace3e)`, `tripped: none`) — the step converges. The step fixes one P2 finding (scrub F1, the `git_ops._git` seam bypass) and files one new carried P2 (the read-path class); the older carried set (scrub F2, scrub-review F3, the phase-6 chains, the exit-gate-runs chain) stays carried with its named next actions and is not re-counted. This step's own commits carry their trailers (`16ace3e`/`6123dc5` IMPLEMENTER, `9ca9d13` REVIEWER, author the shared gituser identity). The fast suite is green twice on its own printed line (`1073 passed, 110 deselected in 85.21s/86.02s`; the implementer's ceiling kills are confirmed environmental since the identical selection is green via the documented wrapper itself).

The harness-hook-seam-absorption-2 step absorbs the scrub review's two committed probes into the pinned module with the seam unchanged: `tests/test_hook_env_scrub.py` gains the suppression member (`test_a_riding_hooks_path_cannot_silently_disable_a_real_hook`, a riding hooksPath against a real failing hook) and the caller-level tar-fetch member (`test_the_materialise_tar_fetch_refuses_a_diverting_parent`, the materialise tar fetch under a diverted `GIT_DIR`), both red at REV on the byte-identical scratch pre-image at their named assertions (`assert (landed.returncode, after) == (1, before)` with `(0, '1')`; `ProtocolViolation` from the unseamed tar fetch) and green at FINAL (`5 passed in 0.21s`), re-driven red-to-green at FINAL by the review on a diff-verified scratch — the four-of-five mutant reddens the environment member plus the suppression member at its behavioral assertion (a commit that must fail lands with the validator riding: a true behavioral red, not an environment echo), and the tar-revert mutant reddens only the caller-level member (proved necessary, not decorative). The disposable-linked-worktree drive is green with the shared config sha256-identical before/after, and the seam's fixture identity and `GIT_CONFIG_*` discipline are byte-identical REV..FINAL. The review files FINDINGS none and SHAPES none-with-reason, raises no P0 and no P1, and REVIEW ACCEPTANCE is green (`scope: ok (2 path(s) in bd86141..0759b5f)`, `tripped: none`) — the step converges. The step fixes one P2 finding (F4, the unbuilt suppression member) and files no new carried findings; the older carried set (scrub F1/F2, scrub-review F3/F4, the phase-6 chains, the exit-gate-runs chain) stays carried with its named next actions and is not re-counted. This step's own commits carry their trailers (`0759b5f`/`22bb86e` IMPLEMENTER, `f871fad` REVIEWER, author the shared gituser identity). The oracle module drive is honestly red in both reports (`3 failed, 4 passed`, ~310s) via the frozen corpus hash freeze — the candidate copy carries the extended pin file the driver's frozen `test_hashes` pins against — and the REV-pin baseline of the same test passes, so the red is not this step's; it rides as NOT VERIFIED, not as a gate failure.

The harness-hook-env-scrub step delivers R17's remedy: a linked-worktree commit leaks none of the git-internal environment — `scripts/hooks/pre-commit` unsets `GIT_DIR GIT_INDEX_FILE GIT_WORK_TREE GIT_PREFIX GIT_CONFIG_PARAMETERS` guard-first before its first git read, and `src/orchestrator/worktree.py`'s `_git_environment` pops the same five from every child environment it builds (the module's sole env-merge site; `materialise` now routes through it), pinned by a three-node module with red evidence at REV (the fixture-child pin's shared-config-moves failure, exactly the planner probe's form) re-driven green at FINAL by the review — the red re-derived on a diff-verified scratch, four mutants each reddening a committed member, the REAL-hook disposable-linked-worktree commit drive green with the shared config byte-identical, fixture identity and the `GIT_CONFIG_*` devnull discipline unchanged, and the fast selection plus the oracle module green. The review answers every QUESTIONS TO ATTACK item and both friction items, raises no P0 and no P1, and REVIEW ACCEPTANCE is green (`scope: ok (4 path(s) in 0e45cb9..47dad55)`, `tripped: none`) — the step converges. The step files two P2 carried findings, and the older carried set stays carried with its named next actions and is not re-counted: F1 (`git_ops._git` bypasses the seam, outside `IN SCOPE`, next action the harness owner's or a later brief's) and F2 (the brief's disposable-worktree ordering ambiguity, corrected text to the planner's later brief). The review files one carried finding each: F3 (the review FOCUS's missing-hook-dir failure premise falsified — the riding parameter suppresses hooks silently; only malformed parameters fail loudly — text correction to the planner) and F4 (the parameters-channel behavioral red unconstructible for the faithful-leak shape; either accept the environment-level pin or add the suppression/exit-code member named in SHAPES — a later brief's decision). The review's standing-battery `NOT VERIFIED` is a documented contention kill (twice in the same oracle member, that member standalone-green at FINAL), not a gate failure. This step's own commits carry their trailers (`47dad55`/`743ce21` IMPLEMENTER, `4880923` REVIEWER, author the shared gituser identity). No live-tree commit ran outside the method's hooks; the phase-7 scratch stands finished and unreferenced.

R17 is consumed by this row: it named `docs/research/harness-hook-env-scrub-brief.md`, and the scrub it ruled now holds on both paths.

The phase7-shadow-tag-universe step delivers R16's hardening: `load_run_spec` refuses every non-plain YAML tag at load through one structural seam (`_PlainTagLoader.compose_node` over the safe loader's own constructible tag set), pinned by a generated-inputs pin with companion pins and red evidence at REV (`run_id: !!str r1` reaching validation) re-driven green at FINAL by the review — the review's 191-document refusal matrix, revert/inventory-leak/scalar-demotion/over-match mutants each reddening a committed member, A/B plain-parity over a 14-case corpus, and the full battery green. The review answers every QUESTIONS TO ATTACK item, raises no P0 and no P1, and REVIEW ACCEPTANCE is green (`scope: ok (2 path(s) in d78d1a8..18059d5)`, `tripped: none`) — the step converges. F1 (P1, the hook's inherited `GIT_DIR` corrupting a linked-worktree branch and the shared config) answers a QUESTIONS item about the brief's explicitly OUT OF SCOPE live-working-tree seam, so it leaves as carried under the Exit clause and stays in pending-for-the-owner (recorded for the OWNER's ruling) until ruled; F3 (the spilled `GIT_CONFIG_PARAMETERS` extending F1's scrub set) rides F1's owner action as the second carried item. F2 (the brief's "every non-plain tag" not naming the bare `!`) is a brief-text defect whose taken reading the implementer delivered and the review verified; this chain ends here, so it closes as actionless and is not counted. The older carried set stays carried with its named next actions and is not re-counted. This step's own commits carry their trailers (`18059d5`/`1a1d0e5` IMPLEMENTER, `50b09e7` REVIEWER, author the shared gituser identity). The step's artifacts live on branch `phase7-shadow-tag-universe` for the human review and merge; the live tree is untouched.

R16 is consumed by this row: it named `docs/research/phase7-shadow-tag-universe-brief.md`, and the hardening it scoped is delivered above.

The janitor-window step fixes the closeout-status review's F2 (the pin's whole-`gettempdir()` scan
coupling): the later brief (`e9a37db`) took the re-scope reading and the implementer delivered it
with red evidence at REV and FINAL, re-driven by the review on diff-verified scratches plus a
deterministic out-of-process creator (retired class red 3× at REV, green 6× at FINAL) and the
`--fast --parallel` interleave green twice. The review files FINDINGS none and no new shapes ride
committed members. The exit-gate-runs chain's F1–F4 and the older carried set stay carried with
their named planner next actions; the trailer backlog the exit-gate-runs F4 filed extends to the
planner's own brief `e9a37db` (sixth consecutive trailerless commit), while this step's own two
commits carry `Actor: IMPLEMENTER` and its review `Actor: REVIEWER`.

The exit-gate-runs row's REV cell is corrected in the same write (the closeout-status review's F3:
the cell named `c41834285ba0…`, which `git rev-parse --verify` refuses; the true full hash of the
commit the reports name as REV is `c418342625ca65e…`). The closeout-status row closes its step's
carried set as actionless (rule 8's form, as R14 established it): F1 (the step's commit-trailer
lapse), F2 (the janitor pin's whole-`gettempdir()` scan coupling — a battery member exposed to
concurrent workers, next action a later brief's re-scope or serial-set move), F3 (this cell's own
hash, corrected here), F4 (the brief's mandated "2326 stores" noun) — each names a defect in a
finished artifact or a correction this write already makes, so no possible next action remains.
Their frozen blocks stay as written; no committed report is edited.

R15 is consumed by this row: it named `docs/research/phase6-exit-gate-runs-brief.md`, and the
campaign it scoped is delivered above. The step's carried set closes as actionless (rule 8's form,
as R14 established it): F1, F2 (filed by the implementer report), F3, F4 (filed by the review) —
each names a defect in a finished artifact (the step's own brief, the step's own report, or the
step's own commit messages), so no future brief rewrites that text and no possible next action
exists. Their frozen blocks stay as written; no committed row or report is edited. Received F32/F33
were already closed actionless by R14 and are not re-counted.

The harness-copying-fixture-seam step routes the six raw copying merges — `src/orchestrator/conformance.py:82`, `tests/test_derive_obligations.py:38`, `tests/test_milestone3_acceptance.py:66` and `:495`, `tests/test_milestone8_readiness.py:51` and `:156` (one-line drift from the brief's REV citations under the added imports; the anchor names the true sites) — through `worktree._git_environment(GIT_ENVIRONMENT)` with function-level imports, and every in-scope fixture-building `rev-parse HEAD` read rides the same scrubbed copy (the implementer's F2, found and fixed in-step with red evidence). Fixture identity and the seam's base keys ride unchanged, and `src/orchestrator/worktree.py` is byte-identical REV..FINAL. Red at REV on the byte-identical scratch (`2 failed, 9 deselected in 0.23s` in the report, re-driven `2 failed, 9 deselected in 0.35s` by the review, each red at its named assertion) and green at FINAL (`11 passed in 0.58s`, re-driven `11 passed in 0.71s`); each routed site is proved necessary by its own revert mutant (M1–M7 redden exactly their member) and the nine prior members stay red-classed on their named mutants (N1–N7). The fast suite holds its selection (`1080 passed, 111 deselected in 114.23s` — the brief's `1078/111` baseline plus exactly the two new nodes) and the review's standing battery is green (`1191 passed in 1224.25s`). The review answers every QUESTIONS TO ATTACK item, endorses the routing reading of R18's candidate (both quoted measurements reproduce on this host), raises no P0 and no P1, and REVIEW ACCEPTANCE is green (`scope: ok (6 path(s) in 360ba3f..2de5371)`, `tripped: none` — independently re-driven). The step's INHERITED carries five findings: the implementer's F1 (BRIEF — the R18 dict-carries-refusal wording, carried for a later brief's text correction) and the review's F34 (the two env-less verification reads residual), F35 (the anchor's cast-limited exactness), F36 (the SHAPES(2) justification misstatement, corrected below), F37 (the check-scope module surface outside the enumeration); the older carried set (scrub F2, scrub-review F3, the phase-6 F13–F17/F21–F23/F26/F28–F33) stays carried with its named next actions and is not re-counted. F36's corrected reading is recorded here: the three milestone-8 consumer tests are plain fast tests (`3 passed, 27 deselected in 0.65s`, no NAMESPACE_V1 gate), the routing is positively member-exercised, and the leak-behavioral drive for those two inline sites remains the unbuilt shape. No closeout counters move except the row's own (Fixed 1, Red 1, Carried 5, Declined 0). No ledger change; PROPOSED ROWS none. This step's own commits carry their trailers (`2de5371`/`4a2e78d` IMPLEMENTER, `ab7b482`/`f9988c7` PLANNER, `f1abc3a` REVIEWER, author the shared gituser identity). R18 is consumed by this row: it named `docs/research/harness-copying-fixture-seam-brief.md`, and the routing plus anchor it ruled are delivered above.

CLOSEOUT
DECLINED: none
DIVERGENCES CLOSED: none — the brief named none and the diff moved none.

Phase 6 baseline (16 rows, 11 with counters): Fixed 32, Red 12. The ORIGIN pass over the step
reports (block counts; a finding re-stated across reports counts per statement) separates the
populations: CODE 26 fixed / 23 carried / 3 declined, BRIEF 15 fixed / 34 carried / 4 declined,
DOCUMENT 6 fixed / 14 carried. Fifteen of forty-one fixed blocks are text closes, so the `Fixed`–`Red`
gap no longer means "fixes without a regression test". Carried ran 5, 4, 3, 1, 1, 5, 1, 0, 0 across
the counter rows — the actionable-only rule's visible effect. Retire candidates when the size limit
next bites: rule 12 (two early sightings) and rule 10's residual clause (no brief has ever failed
it).

`Carried` counts findings a closeout left open — a chain on one goal ends when its last step
converges and its `INHERITED` carries no finding (`method.md`'s `## Exit`) — so it is recorded
rather than subtracted. `ORIGIN`
is a fixed token in the report rather than a column here: capture it now, group by it once there is a
question a count would answer.

Prose in `research/` is evidence for a row, never a substitute for it.

- **A non-resolving sha needs the failing checker, not the echoing one.** `git rev-parse --verify`
  echoes a syntactically valid 40-hex name with exit 0; `git cat-file -t` and `git log` are the
  checks that fail. The refreeze review's F3 caveat is the sample: the evidence stands corrected
  with no outcome change.
