IMPLEMENTER BRIEF — phase5-run-entry-fixes-8 (Phase 5: kernel_id refused at load — FRK-1; FFR-1–FFR-3 close by text)

GOAL: The loader refuses a present-but-wrong-typed `project_kernel.kernel_id` as a named `RunSpecError` at load, before any store is opened or any event is admitted (owner ruling R11 — FRK-1). `validate_run_spec` is the seam: when the `project_kernel` mapping carries a `kernel_id` key, its value must be a non-empty string (whitespace-stripped), else the load is refused naming the value; a missing key still passes validation and falls back to the snapshot id in `run_configuration`, whose `str()`-coercion stays byte-identical and becomes unreachable from a spec. The generated-input envelope property still holds (a refused document is the property's refusal arm), the new refusal pin rides beside it, and FFR-1, FFR-2, FFR-3 close by this brief's own text under rule 8.

CONTEXT: R11 ([record.md](../record.md)#owner-rulings) settles FRK-1 at load per the fixes-7 refer: a non-string `kernel_id` (dict, list, int confirmed live — `validate_run_spec` checks only that `project_kernel` is a non-empty mapping at `src/orchestrator/run_entry.py:202-204`, and `run_configuration`'s `str(target.project_kernel.get("kernel_id") or target.snapshot_id)` at `:353` coerces a mapping into `kernel_id="{'a': 1}"`, which the admin schema's `_non_empty_str` at `src/orchestrator/schemas.py:162` accepts) is refused as a named `RunSpecError` in `validate_run_spec` before any store is opened — matching the documented promise — while `run_configuration`'s coercion stays untouched. The `or target.snapshot_id` fallback is preserved for a missing key only: an explicitly present key (including an explicit null, an empty string, or whitespace) must be a non-empty string. There is no committed red probe for FRK-1 (the review confirmed it with hand runners, not a committed test), so this step's red is the reproducer below plus the new pin failing at REV before the fix. FFR-1 closes by this brief's IN SCOPE text (plain un-backticked paths, the fixes-6 form — the scope parser now also strips backticks and prints its `claimed:` line, but the brief keeps the contract form). FFR-2 closes by this brief carrying no predicted docs total: every count figure here is the gate's own printed REV line, and ACCEPTANCE names exit-0-with-0-errors rather than a number expected to hold. FFR-3 closes by this brief not restating the falsified mutant prediction anywhere. Gates measured at REV `b68be80` (this step's base): `scripts/check-tests --fast` prints `963 passed, 104 deselected in 95.39s (0:01:35)`; `scripts/check-docs` prints `370 Total (in 784ms) 172 Unique 370 OK 0 Errors`; `scripts/check-static` exits 0 with the gated `ruff check --select BLE001,S110 src/orchestrator` clean and the advisory line `Found 104 errors.`; the loader battery prints `5 passed in 7.65s` (envelope plus absorbed probes) and `54 passed in 29.12s` (the four earlier modules). No `docs/residuals.md` trigger glob matches this brief's IN SCOPE (the ten `PILOT-R*` triggers name `planning_pilot.py`, `controller.py`, `reducer.py`, `decomposition.py`, `model.py`, and `derive_obligations.py`; the store is byte-verified against `docs/residuals.md` before this brief's commit, rule 2). This brief adds one module under `tests/`, so the standing `tests/test_phase3_project_oracle.py` line is named; the new module rides the standing slow-mark convention.

INHERITED:

From `docs/research/phase5-run-entry-fixes-7-implementer.md`, its `INHERITED` block verbatim:

  INHERITED:
  none — the received INHERITED carried exactly one open item, F36 (the fixes-5 review's carried P2, moved into this brief's body). It is fixed in this step (FINDINGS, F36); nothing is carried forward and nothing new is left open.
  From `docs/research/phase5-run-entry-fixes-6-review.md`, its `INHERITED` block verbatim:
  INHERITED:
  F38, F39, F40, F41, F42 are filed carried by this review and live in its FINDINGS above. Nothing else is still open: what this review received is fully disposed — F36 (the only item carried by the fixes-5 review's INHERITED) is fixed by the step under review (its red probe green in both full runs with no test edit), F37 is fixed at the fixes-5 step and green as a maintained pin, the fixes-5 implementer's INHERITED block reads none with nothing open, and the brief's two copied blocks resolve to those same two findings.
  Still open and carried forward by this step:
  F41 (STATE: carried) — the fixes-6 implementer report's "links 364/364 OK" figure; a defect in an already-committed report, carried verbatim above, closed by the planner at this step's closeout (no implementer action).
  FFR-1 (STATE: carried) — the brief's backticked IN SCOPE line defeats `scripts/check-scope`; a later committed brief corrects the IN SCOPE text.
  FFR-2 (STATE: carried) — the brief's predicted docs total 361 is 363 at FINAL; a later committed brief corrects the figure.

From `docs/research/phase5-run-entry-fixes-7-review.md`, its `INHERITED` block verbatim:

  INHERITED:
  none — the received INHERITED carried exactly one open item, F36 (the fixes-5 review's carried P2, moved into this brief's body). It is fixed in this step (FINDINGS, F36); nothing is carried forward and nothing new is left open.
  From `docs/research/phase5-run-entry-fixes-6-review.md`, its `INHERITED` block verbatim:
  INHERITED:
  F38, F39, F40, F41, F42 are filed carried by this review and live in its FINDINGS above. Nothing else is still open: what this review received is fully disposed — F36 (the only item carried by the fixes-5 review's INHERITED) is fixed by the step under review (its red probe green in both full runs with no test edit), F37 is fixed at the fixes-5 step and green as a maintained pin, the fixes-5 implementer's INHERITED block reads none with nothing open, and the brief's two copied blocks resolve to those same two findings.
  Still open and carried forward by this step:
  F41 (STATE: carried) — the fixes-6 implementer report's "links 364/364 OK" figure; a defect in an already-committed report, closed by the planner at this step's closeout as fixed: recorded in the review that filed it (no implementer action).
  FFR-1 (STATE: carried) — the brief's backticked IN SCOPE line defeats `scripts/check-scope`; a later committed brief corrects the IN SCOPE text.
  FFR-2 (STATE: carried) — the brief's predicted docs total is stale at FINAL; a later committed brief corrects the figure.
  FFR-3 (STATE: carried) — the review brief's mutant-(d) prediction is falsified as written (the committed read pin passes without the prefix for `OSError` faces); a later committed brief corrects the prediction.
  FRK-1 (STATE: carried) — the owner-directed `project_kernel.kernel_id` dict-acceptance question confirms (dict/list/int `kernel_id` loads and admits `str()`-coerced past `_non_empty_str`); `run_configuration` is OUT OF SCOPE here, so a later OWNER-directed brief owns its fix.

The copied blocks' resolutions and the still-open findings are moved verbatim here so the brief is the actor's only input, each with this brief's disposition stated after the moved block. F41 is closed at the fixes-7 closeout as `fixed: recorded in` the fixes-6 review (the Record row at REV `b7a010a` consumed it) — it is not open, it rides no INHERITED, and there is no action on it. F38, F39, F40, F42 are fixed and closed — no action.

  FRK-1 | SEVERITY: P1 | ORIGIN: CODE | STATE: carried
  The owner-directed `project_kernel.kernel_id` question confirms: a dict-typed (likewise list/int) `kernel_id` passes `validate_run_spec` (it checks only that `project_kernel` is a non-empty mapping, `src/orchestrator/run_entry.py:202-204`) and is `str()`-coerced in `run_configuration` (`src/orchestrator/run_entry.py:353`) into the admitted contract — a mapping admits as `kernel_id="{'a': 1}"`, which the admin schema's `_non_empty_str` (`src/orchestrator/schemas.py:162`) accepts, so a configuration the controller's schema intent would reject is admitted at load, falsifying `run_configuration`'s docstring sentence ("Schema admission is checked here so a configuration the controller would reject is a load-time refusal, not a run-time surprise"). The `or target.snapshot_id` fallback is intended only for a missing/empty value; the coercion of a present-but-wrong-typed value is the class-B "looks close enough" face.
  FIXED: no regression test here — `run_configuration` is OUT OF SCOPE of this brief; a later OWNER-directed brief owns the fix (a type check on `kernel_id` in `validate_run_spec` or a refusal of non-string `kernel_id` before coercion). Carried, not fixed here.
  This brief's disposition: this brief IS the later OWNER-directed brief — fix it here, in `validate_run_spec`, per R11 and the GOAL. The refusal is a named `RunSpecError` naming the value, raised before any store is opened; when the `project_kernel` mapping carries a `kernel_id` key its value must be a non-empty string (whitespace-stripped) — dict, list, int, bool, explicit null, empty, and whitespace-only all refuse; a missing key passes and the snapshot-id fallback in `run_configuration` (untouched) still covers it. In your report FRK-1's `STATE` is `fixed` and its `FIXED:` line names the new pin's node id, the exact command, and the named failing assertion at REV (the pin red before the fix, green after).

  FFR-1 | SEVERITY: P1 | ORIGIN: BRIEF | STATE: carried
  The brief's `IN SCOPE:` line wraps both intended paths in backticks inside one prose line; `scripts/check-scope`'s awk extractor does not strip backticks, so the patterns match no path and the gate exits 1 naming both intended files "not in IN SCOPE" — the ACCEPTANCE green cannot be satisfied by any in-scope action (editing the brief is OUT OF SCOPE).
  FIXED: no regression test — a committed brief's prose has none; per rule 8's ORIGIN: BRIEF close form a later committed brief corrects the IN SCOPE text to plain, un-backticked paths on their own lines as the fixes-6 brief does, after which `scripts/check-scope` is green. The residual half already prints `tripped: none`.
  This brief's disposition: this brief's own IN SCOPE line below is the correcting text — plain un-backticked comma-separated paths, file-internal restrictions carried in OUT OF SCOPE per the template contract — so `scripts/check-scope` is green on the committed brief. Per rule 8's ORIGIN: BRIEF close form, in your report FFR-1's `STATE` is `fixed` and its `FIXED:` line reads `no regression test` and names **this brief's commit** — obtain the sha before your work commit: `git rev-parse HEAD` is this brief's commit (the tree's tip at dispatch; cross-check with `git log -1 --format=%H -- docs/research/phase5-run-entry-fixes-8-brief.md`, which names the same sha). No code work belongs to FFR-1.

  FFR-2 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
  The brief's ACCEPTANCE sentence predicts the docs gate holds at 361 total; at FINAL `scripts/check-docs` prints 366 total / 366 OK / 0 errors (363 at the implementer's run, 366 now — the count drifts as `docs/research/` grows; the +2 over 361 at work time is the brief's own two `[record.md](../record.md)` links, lychee scanning `**/*.md`). Green with 0 errors; only the predicted figure is stale.
  FIXED: no regression test — a count figure in a committed brief's prose has none; a later committed brief corrects or drops the predicted figure, naming the gate's own printed line (the F41 class).
  This brief's disposition: this brief carries no predicted docs total anywhere — ACCEPTANCE requires exit 0 with 0 errors and every figure recorded from the gate's own printed line (rule 14), and CONTEXT quotes the REV line only as the base measurement, never as expected-to-hold. In your report FFR-2's `STATE` is `fixed` and its `FIXED:` line reads `no regression test` and names **this brief's commit** (obtained as for FFR-1). No code work belongs to FFR-2.

  FFR-3 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
  The review brief's mutant (d) prediction — "drop `{path!r}` from the format string: the read-refusal pin reds (its `assert str(path) in str(error)`)" — is falsified as written: on a scratch copy with the prefix dropped the committed pin passes (1 passed), because each `OSError`'s own text embeds the tmp path, so `str(path) in str(error)` holds via `{error}` alone; the path is lost only for non-`OSError` refusals (typed-scalar message `cannot load run-spec: invalid literal…` names no path), which the pin does not drive.
  FIXED: no regression test — a mutant prediction in a committed review brief's prose has none; a later committed brief corrects the prediction to the measured spacing (the pin covers the `OSError` faces' wrap, not the message prefix; a non-`OSError` refusal is the prefix's true mutant).
  This brief's disposition: this brief restates no mutant prediction about the message prefix anywhere — the correction is omission per R11 ("the falsified mutant prediction not restated"). In your report FFR-3's `STATE` is `fixed` and its `FIXED:` line reads `no regression test` and names **this brief's commit** (obtained as for FFR-1). No code work belongs to FFR-3.

IN SCOPE: src/orchestrator/run_entry.py, tests/test_run_entry_kernel_id_refusal.py

RESIDUALS:

none — rule 3 selection for this brief's `IN SCOPE`: no `docs/residuals.md` trigger glob matches `src/orchestrator/run_entry.py` or the new test module (the ten `PILOT-R*` triggers name `planning_pilot.py`, `controller.py`, `reducer.py`, `decomposition.py`, `model.py`, and `derive_obligations.py`; the store is byte-verified against `docs/residuals.md` before this brief's commit, rule 2). No residual row rides, so the residual half of `scripts/check-scope` has nothing to carry here and it prints `tripped: none` — the line your report's `TRIPPED` field copies.

OUT OF SCOPE:
- Editing this brief file (`docs/research/phase5-run-entry-fixes-8-brief.md`). A committed brief is never modified; a re-cut is a new file.
- In `src/orchestrator/run_entry.py`, everything but `validate_run_spec`'s `project_kernel`/`kernel_id` check: `load_run_spec` (the R10 envelope seam, byte-identical), `freeze_target`, `run_configuration` (R11: its coercion stays untouched — the load-time refusal makes the wrong-typed value unreachable from a spec), `start_run`/`_bind_acceptance`, every `_require_*` helper's body, and the module and `RunSpecError` docstrings (the refusal matches the documented promise as written; no sentence is reworded, narrowed, or widened — a document amended is an OWNER commit, rule 5). If acceptance needs any of these changed, stop and report `IN SCOPE` as insufficient.
- `validate_run_spec`'s normalised copy shape: the admitted `project_kernel` stays `dict(spec["project_kernel"])` as delivered; the fix only refuses earlier. Do not add, drop, or rename a normalised field.
- Every committed pin, probe, and battery module of the earlier steps — `tests/test_run_entry_loader_envelope.py`, `tests/test_phase5_run_entry_fixes_6_review.py`, `tests/test_phase5_run_entry_fixes_5_review.py`, `tests/test_phase5_run_entry_fixes_4_review.py`, `tests/test_run_entry.py`, and `tests/test_phase5_run_entry_fixes_2_review.py` are read-only here. The new pin lives in the new module IN SCOPE names; no existing test file is created or edited. If a pin would have to change for acceptance to pass, stop and report `IN SCOPE` as insufficient.
- `tests/open_defects.yaml` and the registry's meta-tests: no registration rides (the new pin is a plain passing test, not a `test_bug_*` pin; absorbed probes are `test_review_*`).
- `docs/run-entry.md` and every other document: the refusal matches the documented load-time promise as written. No `docs/tables/*` change and no table regeneration, no `docs/event-catalogue.md` change and no new event type, no `docs/control-plane.md` edit, no `docs/residuals.md` or `docs/record.md` edit, no `docs/self-host.md` edit, no `docs/method.md` or `docs/templates/` edit.
- The controller stack, the store, the experiment harness, `scripts/orchestrate.py`, `experiment_target.build_target`, `schemas.py`.
- Registry and control files: `tests/counterexamples.yaml`, `tests/guard_mutation_matrix.yaml`, `tests/fixture_fidelity.yaml`, `tests/verifier_registry.yaml`, `tests/spend_paths.yaml`, `tests/invariants.py`, `tests/helpers.py`, `pytest.ini`, tool configuration.
- No new dependencies, no tooling configuration, no reformatting. No new exception class (`RunSpecError` is the named failure) and no `*Executor`/`*ModelClient` class or provider-registry registration.
- Name no test `test_bug_*` (the open-defect registry would then own it).

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

    scripts/check-tests --fast
    .venv/bin/python -m pytest tests/test_run_entry_kernel_id_refusal.py tests/test_run_entry_loader_envelope.py tests/test_phase5_run_entry_fixes_6_review.py
    .venv/bin/python -m pytest tests/test_phase5_run_entry_fixes_5_review.py tests/test_phase5_run_entry_fixes_4_review.py tests/test_run_entry.py tests/test_phase5_run_entry_fixes_2_review.py
    .venv/bin/python -m pytest tests/test_phase3_project_oracle.py
    scripts/check-static
    scripts/check-docs
    scripts/check-scope b68be80aa9762eb964bd27190331617e404014ae <FINAL> docs/research/phase5-run-entry-fixes-8-brief.md

Every `pytest` line names `.venv/bin/python -m pytest` deliberately (F17's carried correction: the bare `pytest` on PATH has no `pytest-timeout` and `pytest.ini`'s `strict_config = true` rejects it on this host — run these lines exactly as written and claim them under these names). `tests/test_phase3_project_oracle.py` is named per the standing rule for a brief that adds a file under `tests/` (the fast suite and the commit hook both deselect the oracle, and this brief adds one module). The new module and the envelope module share a line with the three absorbed probes — expected at FINAL: 7 passed (2 new cases + 2 envelope cases + 3 probes), exit 0. The four earlier modules are the loader's whole committed battery and must not regress (54 passed). The fast suite's expected shape: the passed count stays 963 (the new module's cases ride slow — see the slow-mark convention) and the deselected count grows from 104 by the new module's case count (2). The docs gate is expected green with 0 errors — and every count figure you write in `VERIFIED` is the gate's own printed line, never the REV line quoted in this brief's CONTEXT and never recomputed from memory (rule 14, the F41 class). The scope line is expected green, exit 0, printing `tripped: none` (and the `claimed:` line the parser now prints). Never put a full run in `ACCEPTANCE`; the reviewer runs `scripts/check-tests`. `REV` below names the step's base — the parent of this brief commit — and is not claimed to be `FINAL`'s parent (F4's lesson).

Red evidence at `REV` `b68be80aa9762eb964bd27190331617e404014ae`: FRK-1 has no committed red probe (the fixes-7 review confirmed it with hand runners), so the step's red is the live bug plus the new pin failing before the fix. The live bug, replayable on the REV tree (command `PYTHONPATH=src .venv/bin/python -c "from orchestrator import run_entry; document = {'run_id': 'R', 'repository': '/tmp', 'base_commit': '0' * 40, 'snapshot_id': 'T', 'task_statement': 't', 'executor_profile': 'command-executor-v1', 'project_kernel': {'kernel_id': {'a': 1}}, 'visible_commands': ['true'], 'components': [['c', 'src/a.py']], 'owned_scope': ['src/**'], 'acceptance_criteria': ['AC'], 'budgets': {'MODEL_COST': 1.0}, 'limits': {}, 'policy_version': 1, 'evidence_policy': {'level': 'MEDIUM', 'version': 1}}; print(run_entry.validate_run_spec(document)['project_kernel'])"`): it prints `{'kernel_id': {'a': 1}}` — a dict `kernel_id` is admitted instead of refused. Your new pin's pre-fix run is the matching test-form red: run the new module before the fix (or against a REV scratch copy diff-verified against `git show b68be80:src/orchestrator/run_entry.py`) and record its node id, the command, and the named failing assertion; `FIXED` names all three plus the delivered file's line numbers or none (F22's lesson). The pin turns green at `FINAL` with the fix alone.

Slow-mark convention: the new module carries `pytestmark = pytest.mark.slow` at module level, so every case in it is slow-marked (the standing convention for a new module under `tests/`: the project oracle's internal gate runs `scripts/check-tests --fast` (`-m "not slow"`, `src/orchestrator/project_oracle.py:731`) and the pre-commit hook deselects the same way; unmarked trial-running cases break `pytest tests/test_phase3_project_oracle.py`). No `hypothesis` property rides here (the envelope property already covers the either/or; see the shapes), so no settings pin is owed.

Named shapes to build — the list of shapes, not the number of tests. One shape needs at least one test, and every named shape needs one:

- `kernel_id load refusal` (FRK-1's fix): a test in the new module driving `validate_run_spec` over a matrix of present-but-wrong-typed `kernel_id` values — dict, list, int, bool, explicit null, empty string, whitespace-only — each refused as a named `RunSpecError` naming the value; plus one file-backed `load_run_spec` drive with a dict `kernel_id` refused as `RunSpecError` with the store absent from the tmp dir (no store file created, zero events by construction — the refusal precedes any store open). The loop form (one test function iterating the matrix, failing named per member like the F38 probe's form) keeps the collected count at the ACCEPTANCE shape above.
- `kernel_id fallback` (the `or snapshot_id` the fix preserves): a test in the new module showing a spec whose `project_kernel` carries no `kernel_id` key validates clean, and `run_configuration` against a stub target admits it with `kernel_id` equal to the snapshot id (the fallback and only the fallback — no `str()` of a wrong-typed value is reachable). The stub supplies the target's read fields (`task_statement`, `owned_scope`, `commit`, `visible_commands`, `acceptance_criteria`, `project_kernel`, `snapshot_id`, `contract_hash`); no git repository is built.

Maintained unchanged (no new test owed; green in the battery lines): the envelope property (`Loader-refusal envelope`), the `Read-refusal pin`, and the absorbed typed-scalar probes (F38/F39/F40) — all green at `FINAL`, none edited; the fix touches only the validation stage, which the envelope explicitly does not enclose, so the property's either/or is undisturbed (a refused document is its refusal arm).

REV: b68be80aa9762eb964bd27190331617e404014ae
CLOSE OUT: yes
DIVERGENCES: none
REVIEW: one session — FRK-1's refusal completeness above all: drive the full wrong-typed matrix (dict, list, int, bool, null, empty, whitespace) plus a missing key through `validate_run_spec` and the file-backed `load_run_spec` head, asking whether any present-but-wrong-typed value still loads and whether the missing key still falls back; verify `run_configuration` byte-identical to REV (the coercion untouched — diff it) and the fallback admitting the snapshot id; mutants (drop the new check — does the new pin go red while everything else stays green? restore it and plant a wrong-typed value the matrix omits — is it refused?); the envelope property and read pin still green with no test edit; the three FFR text-closes (IN SCOPE plain and scope green; no predicted docs figure anywhere in the brief; no restated mutant prediction); the full-suite and module counts and the report's forms (rules 7 and 14; every figure the gate's own printed line); and the Phase 5 exit gate's operator classes only where the validation stage touches them (a wrong-typed spec through the documented `start` head refuses at load with the store absent).

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. Stop and report rather than improvise when IN SCOPE is
insufficient, the brief contradicts the code, you have already failed twice at this goal, or the
requirement is ambiguous and no single reading is consistent with the rest of the brief. If exactly
one reading is consistent, take it and file a FINDING with ORIGIN: BRIEF that names the reading you
took. No new dependencies, no tooling configuration, no reformatting. Run every ACCEPTANCE command;
fix what is in scope and report what is not.

A defect in the brief is a FINDING, never METHOD FRICTION. METHOD FRICTION is only for the method and
its templates: any place you deviated from them, found them ambiguous, or found them silent. Report
friction you worked around — that is the section the method learns from.

Commit your own work. When ACCEPTANCE passes, commit the files you changed, and only those, in one
commit whose message ends with the trailer `Actor: IMPLEMENTER`. That commit's full sha is FINAL.
Then append docs/templates/report.txt verbatim, fill it in, write it to
docs/research/<phase>-<subject>-implementer.md, and commit it in a second commit with the same
trailer. Do not amend the first commit to add the report: FINAL must not change after the report
names it. If you cannot commit, stop and say so; do not leave work uncommitted for someone else to
commit.

# report.txt

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