REVIEW BRIEF — phase5-run-entry (Phase 5: the run-spec over an arbitrary repository, the operator start/inspect/stop CLI, and the evidence-policy binding)
REV: a13aacfe2219e3dbd1b6207a28bbe0f980c78b2c
FINAL: dae836f9bee9c03a7708d4364f381658be70caf1
REVIEW ACCEPTANCE: scripts/check-scope a13aacfe2219e3dbd1b6207a28bbe0f980c78b2c dae836f9bee9c03a7708d4364f381658be70caf1 docs/research/phase5-run-entry-brief.md
SEVERITY SCALE: P0 blocks the step; P1 is serious; P2 is minor.
QUESTIONS TO ATTACK:

F10 (docstring half) | SEVERITY: P2 | ORIGIN: BRIEF | STATE: fixed
  `AdmissionCapability`'s claim that "construction without the module-private mint nonce is refused" is falsified by `copy.copy` and by `__new__`, inviting a reader to claim a third-mint closure that `PILOT-R10` does not buy.
  FIXED: no regression test — this step's later committed code edit replaces the clause in src/orchestrator/controller.py (commit dae836f) with "data-only construction is refused", matching the Capability shape's "a caller holding only data cannot construct one"; a wording fix has no failing assertion at REV to name, and the change makes no claim beyond the data-only threat model.

METHOD FRICTION: none against the method's steps. One informational note: `experiment_target.build_target`'s `budgets` keyword is a per-component derivation allocation, not the run's budget dimensions, so `freeze_target` does not forward the run-spec's `budgets` to it (forwarding them raised `DerivationError: budget names no declared component`); the run's budgets reach the run configuration directly. This is not a deviation from the method.

1. F10's `fixed` claim, copied above: read `git show a13aacfe2219e3dbd1b6207a28bbe0f980c78b2c:src/orchestrator/controller.py` against FINAL. Is the clause replaced as claimed and is nothing else in the class changed? Does the new wording claim nothing beyond the data-only threat model, and does any other tree text still claim that construction without the mint nonce is refused (`PILOT-R10` stays accepted)? Attack the FIXED form too: R8 made this half live code while rule 8 closes an ORIGIN: BRIEF finding only "once a later committed brief corrects the text" — is a code edit with `no regression test` the right close here, or does the report's FIXED line state the wrong form? Name a finding either way.

2. METHOD FRICTION's budgets note, copied above: attack the budgets wiring end to end. The run-spec's `budgets` must reach `RunConfiguration.budgets` and the admitted root contract's `budgets` record (the `Run-spec load shape` claim), and `build_target`'s per-component derivation allocation must not silently absorb run budgets. Unknown budget dimensions must fail closed at load with no store writes. J-class: run the wiring; do not read the report's account.

3. `Run-spec load shape`: freeze a run-spec over a real fixture repository. Exactly one `build_target` freeze? A `RunConfiguration` `Controller.submit_run` admits? The admitted root contract carries the configured owned scopes, budgets, limits, control-policy version, and evidence policy in the frozen `run_specification` binding beside `policy_version`? Do the filled `project_kernel` and `experiment_manifest` references match CONTEXT's stated reading (the named repository commit; the run-spec's own content digest), is the digest stable across reloads, and does a changed run-spec change it?

4. `Configuration refusal shape`: do the twelve parameterised malformed specs cover the brief's named list — evidence-policy level outside [Evidence policy levels](../glossary.md#evidence-policy-levels), non-positive evidence-policy version, unknown budget dimension (outside [Budget dimensions](../glossary.md#budget-dimensions)), missing or empty repository or base commit, and a `RunConfiguration` the schema rejects? Each refusal must be load-time with zero events admitted: verify by opening the store file, not by trusting the test's assertions. Then mutate one validation away on a scratch copy — a pinned check that cannot fail proves nothing.

5. `Start shape`: plan → dispatch over the run-spec's visible commands → observation and result admission → `VisibleAcceptanceChecker` evidence admitted via `Controller.admit_evidence` → `Controller.authorise_acceptance` bound to the node's own produced result. Does any path authorise acceptance from evidence not admitted through `admit_evidence`, or against a result the node did not produce (R09's refusal surface)? Is the failing-commands branch a real refusal — failing checks recorded, acceptance never authorised — and does the run settle with a terminal [Run outcomes](../glossary.md#run-outcomes) value `Controller.get_outcome` reads?

6. `Observe shape`: read-only end to end (re-open the store through a second connection and diff the event log before and after `inspect`), the milestone-1 retrieval set printed (status, outcome, candidate reference, evidence, costs, event history), and functional on a run started by another `Controller` over one `EventStore`.

7. `Stop shape`: on an in-flight run, does `stop` settle every non-terminal attempt (nothing live remains) and admit the root's cancellation? Attack the settled case: a double `stop` and a `stop` after acceptance — can the admitted outcome be rewritten, and does the report's `test_stop_never_rewrites_a_settled_outcome` pin the reducer's late-event rule or a CLI-side guard?

8. `No-harness-import shape`: the test AST-parses the module and CLI sources. Attack the pin itself: does it catch `from orchestrator import experiment`, `import orchestrator.experiment_spec as x`, and a late function-level import? The report admits the CLI's JSON printing is not exercised through a subprocess — run `scripts/orchestrate.py` end to end as a subprocess and record exit codes and output against `docs/run-entry.md`'s claim that `start` exits zero on acceptance and non-zero on refusal.

9. `Evidence-policy shape`: is the `{level, version}` pair recorded beside `policy_version` and read back by `inspect`, and is the level validated only via `glossary.evidence_policy_levels()` (no local redefinition of the catalogue)? `docs/run-entry.md` is marked `<!-- normative -->` — is a normative freeze right for this deliverable without the OWNER's freeze step (the api-shape brief deferred normative freezes), and is every normative claim in its field table true when read against the loader (row J: open the loader and run a spec that exercises each documented field)?

10. Phase 5's exit gate as a whole: "an operator can start, observe, and stop a run on an arbitrary repository without importing the experiment harness." Do it as an operator would — `scripts/orchestrate.py` subprocesses against a real repository, with a second process observing and stopping mid-run. Report each guarantee falsified-with-reproducer or attacked-and-not-falsified with the method.

11. Report hygiene (J-class): the VERIFIED counts against your own re-runs, `TRIPPED` against `scripts/check-scope`'s own line, the shape map against `tests/test_run_entry.py` (ten functions reported as twenty-one cases — every case slow-marked, and the fast suite deselecting exactly 66 = 45 + 21), and `INHERITED: none` against the received `INHERITED` (F10 fixed; nothing else was open) and rule 8.

--- BEGIN BRIEF UNDER REVIEW (copy of docs/research/phase5-run-entry-brief.md; the committed file is authoritative) ---
IMPLEMENTER BRIEF — phase5-run-entry (Phase 5: the run-spec over an arbitrary repository, the operator start/inspect/stop CLI, and the evidence-policy binding)

GOAL: The Phase 5 run entry point exists. A documented run-spec points the controller at an arbitrary repository and base commit and configures the run's owned scopes, budgets and limits, its control-policy version, and its evidence policy — a level from [Evidence policy levels](../glossary.md#evidence-policy-levels) plus a version. `scripts/orchestrate.py` carries the operator workflow the harness has stood in for: `start` freezes the target through `experiment_target.build_target`, builds a `RunConfiguration` that `Controller.submit_run` admits, and drives the run's root execution to a settled attempt and an evidence-bound acceptance claim or recorded refusal; `inspect` prints the run's status, outcome, candidate reference, evidence, costs, and event history read-only from the store; `stop` settles every live attempt and admits the run's cancellation. The configured scopes, budgets, control-policy version, and evidence policy are observable in the admitted root contract — the evidence policy recorded beside the control-policy version in the frozen `run_specification` binding. The entry point imports no experiment-harness module (`orchestrator.experiment`, `orchestrator.experiment_spec`, `orchestrator.experiment_phases`, `orchestrator.trial_driver`, `scripts.smoke_run`); `orchestrator.experiment_target` is the allowed seam. F10's docstring half (INHERITED) is fixed in `AdmissionCapability`'s docstring.

CONTEXT: Phase 5's run-entry item ([self-host.md#phase-5-run-entry-point](../self-host.md#phase-5-run-entry-point)) is selected: Phase 4 is complete as delivered by the integration stream — measured at this commit, `trial_driver._route_decomposition` routes the recursive arms through `planning_pilot.propose_decomposition`, `Controller.propose_decomposition` requires a minted admission capability, the derived entry is `admit_derived_decomposition`, and Phase 4's three named blockers are cleared (R1 and R2 are consumed Record rows; the pilot residual surface migrated into `docs/residuals.md` under R3) — so the roadmap prose's "blocked on two OWNER rulings" sentence no longer describes the tree (a concern for the OWNER, recorded at closeout). Stated readings, each consistent with the rest of this brief: (1) the experiment harness is the four-arm comparison — `src/orchestrator/experiment.py`, `experiment_spec.py`, `experiment_phases.py`, `trial_driver.py`, `hidden_oracle.py`, `scripts/smoke_run.py`, `scripts/stress_run.py`; `experiment_target.build_target` is Phase 2's generic seam and is allowed (its internal lazy `experiment_spec.ExperimentError` import stays inside the builder). (2) `start` drives the root node's ready EXECUTE over the run-spec's visible commands through an injected `DispatchBase` executor (the CLI builds a `CommandExecutor` over the target's visible commands) and binds acceptance with `VisibleAcceptanceChecker` evidence admitted through `Controller.admit_evidence` and `Controller.authorise_acceptance` against the node's own produced result; model-produced candidates, the patch/review path, and recursive decomposition driving are not this brief. (3) The evidence policy is a `{level, version}` pair — level one of [Evidence policy levels](../glossary.md#evidence-policy-levels) through a new `glossary` accessor (the catalogue is never redefined locally), version a positive int — carried as an optional `RunConfiguration` field and recorded beside `policy_version` in the frozen `run_specification` binding `Controller.submit_run` writes; the run-spec freezes its `experiment_manifest` reference from its own content digest and its `project_kernel` reference from the named repository commit. (4) `REV` names the step's base — the parent of this brief commit — and is not claimed to be `FINAL`'s parent (F4's lesson). The working tree at dispatch is clean.

INHERITED:

F10 (docstring half) | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
  `AdmissionCapability`'s claim that "construction without the module-private mint nonce is refused", falsified by `copy.copy` and by `__new__` — is live code and stands as the only carried item.
  The clause should read data-only construction, matching the Capability shape's "a caller holding only data cannot construct one"; as written it invites a reader to claim a third-mint closure that `PILOT-R10` does not buy.
  FIXED: no regression test — an ORIGIN: BRIEF finding is fixed once a later committed brief corrects the text; none has at this commit.

The first line is R8's (`docs/record.md#owner-rulings`) and the two lines after it are the review's remedy clause and `FIXED` line moved verbatim from `docs/research/phase4-recursive-planning-integration-api-shape-review.md`. R8 keeps this half alone — "its brief-wording half has no possible action and closes" — and the closeout closed F7, F8, and F9 (F8's rename lesson as an Observation in `docs/record.md`), so this docstring half is the only item that rides.

IN SCOPE: src/orchestrator/run_entry.py, scripts/orchestrate.py, docs/run-entry.md, src/orchestrator/schemas.py, src/orchestrator/glossary.py, src/orchestrator/controller.py, tests/test_run_entry.py

RESIDUALS:

Rule 3 selection for this brief's `IN SCOPE`, copied verbatim from `docs/residuals.md` and byte-verified against it (fenced so the store's relative evidence links are not re-resolved from this directory): `IN SCOPE` matches `PILOT-R1` and `PILOT-R10` trigger globs (`src/orchestrator/controller.py`); `PILOT-R2`–`PILOT-R9` (`decomposition.py`, `planning_pilot.py`, `model.py`, `derive_obligations.py`) do not match and do not ride.

```
| ID | State | Trigger | Risk | Rationale | Evidence |
| --- | --- | --- | --- | --- | --- |
| `PILOT-R1` | accepted | `src/orchestrator/planning_pilot.py`, `src/orchestrator/controller.py`, `src/orchestrator/reducer.py` | mutable admitted payload (wiring constraint): the caller holds a mutable reference to the admitted payload, and a post-return mutation of a child's scope survives the reducer's re-validation. Any integration must therefore not mutate a payload between the guard and event admission. | the admitted payload is mutable; the reducer's re-derivation runs at admission and on replay, so the guard's result is only as safe as the wiring keeps it | [pilot re-review 3](research/phase4-recursive-planning-pilot-re-review-3.md) |
| `PILOT-R10` | accepted | `src/orchestrator/controller.py`, `src/orchestrator/planning_pilot.py` | in-process trusted-code circumvention of the admission capability: the capability is not reconstructible from data, but trusted code running in-process can hold or mint one and admit anything — if untrusted code is ever loaded in-process, the capability boundary does not hold | R1's prevention-shape ruling: the capability's threat model is data-only reconstruction, and trusted-code circumvention is recorded here rather than claimed solved | [owner rulings](record.md#owner-rulings) (R1) |
```

A tripped trigger is a finding: fixed with red evidence, or carried into the closeout with its reason. `scripts/check-scope` prints the `tripped: <ids>` line your report's `TRIPPED` field copies. Both rows stay accepted: this brief's path never mutates an admitted decomposition payload between the guard and event admission (it never admits a decomposition), and `PILOT-R10` is not closed — the docstring fix below must not claim more than the data-only threat model.

OUT OF SCOPE:
- Editing this brief file (`docs/research/phase5-run-entry-brief.md`). A committed brief is never modified; a re-cut is a new file.
- The experiment harness: `src/orchestrator/experiment.py`, `experiment_spec.py`, `experiment_phases.py`, `trial_driver.py`, `hidden_oracle.py`, `scripts/smoke_run.py`, `scripts/stress_run.py`. `src/orchestrator/experiment_target.py` and `src/orchestrator/derive_obligations.py` are the allowed seam — call `build_target`; do not change them. If one of these must change, stop and report `IN SCOPE` as insufficient.
- Model-produced candidates: the patch/review path (`src/orchestrator/model.py`, `patch_executor.py`, `model_adapter.py`, `Controller.run_model_review`) and recursive decomposition driving (the planning pilot, `Controller.admit_derived_decomposition`, `plan_decomposition`). `start` drives the root's execution only.
- Completing [Acceptance binding](../validation.md#acceptance-binding)'s full list (node-contract version, input versions, artefact hashes, validator and test versions, environment version, acceptance authority): the bindings shape is pre-existing (R09); this brief records the evidence policy beside the control-policy version in the `run_specification` binding only.
- Selecting an executor from `executor_profile` (the field is required by the `RunConfiguration` schema and stays a label; executor selection is separate work).
- Registry and control files: `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`, `pytest.ini`, tool configuration. No `tests/fixtures/` change is required (the new schema field is optional); if you believe one is needed, stop and report `IN SCOPE` as insufficient.
- Any `docs/` file except `docs/run-entry.md` and your report: no `docs/event-catalogue.md` change and no new event type, no `docs/control-plane.md` freeze, no `docs/residuals.md` or `docs/record.md` edit, no `docs/tables/*` change, and no `docs/self-host.md` edit (the phase status is the OWNER's between steps).
- No new dependencies, no tooling configuration, no reformatting. No new `*Executor` or `*ModelClient` class and no provider-registry registration. No new arm and no `docs/tables/limits.yaml` change.
- 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
    pytest tests/test_run_entry.py
    pytest tests/test_harness_schemas.py tests/test_boundary_mutations.py tests/test_categorical_completeness.py
    pytest tests/test_phase3_project_oracle.py
    scripts/check-static
    scripts/check-docs
    scripts/check-scope a13aacfe2219e3dbd1b6207a28bbe0f980c78b2c <FINAL> docs/research/phase5-run-entry-brief.md

Never put a full run in `ACCEPTANCE`; the reviewer runs `scripts/check-tests`. The three suite modules are the changed schema and catalogue surface (`RunConfiguration` mutations and the new `glossary` accessor). `pytest tests/test_phase3_project_oracle.py` is named under the standing rule for new files under `tests/` and `scripts/` (it was named for the same reason in `phase4-recursive-planning-integration-provider-brief.md`). `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, fixed as `no regression test` — `61e6d07`).

Slow-mark convention: any new module under `tests/` slow-marks every case (`@pytest.mark.slow`), because 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`. `tests/test_run_entry.py` slow-marks every case, and `pytest tests/test_run_entry.py` above runs them directly.

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:

- `Run-spec load shape`: a run-spec naming an arbitrary repository and base commit loads fail-closed and freezes the target through `experiment_target.build_target`; the produced `RunConfiguration` is admitted by `Controller.submit_run`, and the admitted root contract carries the configured owned scopes, budgets, limits, control-policy version, and evidence policy in the frozen `run_specification` binding beside `policy_version`.
- `Configuration refusal shape`: every malformed run-spec is refused before any event is admitted and with no store writes — an evidence-policy level that is not one of [Evidence policy levels](../glossary.md#evidence-policy-levels), an evidence-policy version that is not a positive int, an unknown budget dimension (outside [Budget dimensions](../glossary.md#budget-dimensions)), a missing or empty repository or base commit, and a `RunConfiguration` the schema would reject. Each refusal is a named load-time error, never a run-time surprise.
- `Start shape`: `start` drives the root node's ready EXECUTE to a settled attempt and an evidence-bound acceptance claim or recorded refusal — plan, dispatch over the run-spec's visible commands, observation and result admission, `VisibleAcceptanceChecker` evidence admitted via `Controller.admit_evidence`, and `Controller.authorise_acceptance` bound to the node's own produced result. Failing visible commands are a refusal: failing checks are recorded and acceptance is never authorised. The run reaches a terminal [Run outcomes](../glossary.md#run-outcomes) value that `Controller.get_outcome` reads.
- `Observe shape`: `inspect` prints the run's status, outcome, candidate reference, evidence, costs, and event history from the store alone and admits no events — including a run started by another process (two `Controller`s over one `EventStore`), read-only end to end.
- `Stop shape`: `stop` on an in-flight run settles every non-terminal attempt and admits the run's cancellation on the root; the admitted outcome of an already-settled run is never rewritten by `stop`.
- `No-harness-import shape`: the run-entry module's and the CLI's own import surface names none of `orchestrator.experiment`, `orchestrator.experiment_spec`, `orchestrator.experiment_phases`, `orchestrator.trial_driver`, or `scripts.smoke_run` — pin the modules' own imports; do not assert on `sys.modules`, which after a `build_target` call legitimately contains `experiment_spec` (the allowed seam's lazy `ExperimentError` import). `orchestrator.experiment_target` is the allowed seam and is the only target-freeze path.
- `Evidence-policy shape`: the evidence policy binds the run — a catalogue level plus a version recorded beside the control-policy version in the frozen `run_specification` binding and read back by `inspect`; an unknown level is the Configuration refusal shape's load-time failure.

REV: a13aacfe2219e3dbd1b6207a28bbe0f980c78b2c
CLOSE OUT: yes
DIVERGENCES: none

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>
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.
SHAPES: <shapes probed that the suite does not build, or none with a reason>
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.>
INHERITED:
<<every INHERITED item you received that is still open, copied verbatim; then each
  finding you marked carried, with its ID>>
Rule 2 governs the planner's copy of this block. What goes in it is yours: an implementer or
reviewer who received an obligation, finding, entry or trigger carries it forward verbatim, and
adds anything new that is still open. A block reading `none` is correct only when nothing came in
and nothing is open. INHERITED never carries residual rows; they are re-selected from the store per
brief.
--- END BRIEF UNDER REVIEW ---

You did not write this code and you will not fix it; a finding is output, not an action. The
commits under review carry the trailer `Actor: IMPLEMENTER`; if your session wrote any of them, stop
and say so. Run REVIEW ACCEPTANCE first: it is the only automated check in the method. The
ACCEPTANCE lines inside the brief under review are the implementer's; re-run them to verify the
delivery and record the results in VERIFIED. The embedded brief is a convenience copy: if the
standalone file it names differs, file a FINDING with ORIGIN: BRIEF and review against the committed
file.

You may create new test files to prove a finding, and modify nothing else. If a failing test would
need registering in tests/open_defects.yaml, say so in the report and leave the registration to the
next implementer brief rather than editing that file. Read pre-images with git show <rev>:..., not
the implementation's account of them. Run every mutant on a scratch copy of the tree, and diff each
mutant against git show <rev>:... before trusting its result. Attempt to falsify the brief, not only
the code: a finding that the brief was wrong is a finding, and so is a defect the implementer filed
only as friction. Answer every item under QUESTIONS TO ATTACK. Enumerate the shapes you probed that
the existing suite does not build, as a list; zero with a stated reason is legitimate. Report each
guarantee as falsified-with-reproducer or attacked-and-not-falsified with the method.

Commit your own work: your new test files and your report, together, in one commit whose message
ends with the trailer `Actor: REVIEWER`. Append docs/templates/report.txt verbatim, fill it in, and
write it to docs/research/<phase>-<subject>-review.md. If you cannot commit, stop and say so.

# 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>
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.
SHAPES: <shapes probed that the suite does not build, or none with a reason>
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.>
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.
