REVIEW BRIEF — phase4-recursive-planning-integration-api-shape (Phase 4: the admission capability, the two mint points, and the constructor rename)
REV: 41ec3303c9c184138f5ca3201f40fc00ba9ce7de
FINAL: 98988d44515cb0f088885c3b6d5f6f6c051c6fec
REVIEW ACCEPTANCE: scripts/check-scope 41ec3303c9c184138f5ca3201f40fc00ba9ce7de 98988d44515cb0f088885c3b6d5f6f6c051c6fec docs/research/phase4-recursive-planning-integration-api-shape-brief.md
SEVERITY SCALE: P0 blocks the step; P1 is serious; P2 is minor.
QUESTIONS TO ATTACK:
F8 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
  The rename mandate names only F6's two pins and is silent about in-scope test identifiers that embed the retired unguarded entry name: retargeting `test_propose_decomposition_blocks_dependents_only` to `admit_derived_decomposition` without renaming it would re-open F6's class (a name stating `propose_decomposition` over a call that no longer makes it). Exactly one reading is consistent with the Pin-name shape's name-states-the-enforced-property rule — such identifiers are renamed with the entry — and this step took it: the test is `test_admitted_decomposition_blocks_dependents_only` (tests/test_milestone2_acceptance.py).
  FIXED: no regression test — an ORIGIN: BRIEF finding is fixed once a later committed brief states the rule in text; none has at this commit, so this is carried into the closeout for the ruling rather than declined.

1. F8's rename class, copied above: attack its completeness and its reading. Does any remaining in-scope identifier (test name, docstring, assertion message) still embed the retired unguarded `propose_decomposition` sense while its call no longer makes it? Is rename-with-the-entry the right reading of the Pin-name shape? Also verify F6's `fixed` claim against `git show 41ec3303c9c184138f5ca3201f40fc00ba9ce7de:tests/test_review_depth_walk.py`: the two pins renamed, their assertions unchanged.

2. `Two-mint-point shape`: attempt a third mint — pickle, copy, `dataclasses.replace`, direct construction of `AdmissionCapability`, reachability of the private mint helper, any path that hands a capability to a caller that never passed the guard. Falsified-with-reproducer or attacked-and-not-falsified.

3. `Digest-binding shape`: attempt acceptance of a capability minted over one admitted structure at a submission whose children digest differs; and check the digest covers exactly the admitted children — not a constant, not coverage or dependencies alone.

4. `Derived-only naming shape`: can any model-routed path reach `admit_derived_decomposition`? Is `conformance.py`'s use of the derived entry for the `decomp-1`/`decomp-2` corpus recordings correct, or does a corpus recording model a run that must hold a capability?

5. `Transit immutability shape`: the report claims `test_admitted_payload_is_forwarded_unmutated` is byte-identical between REV and FINAL and that the file's diff is the spy only. Verify with `git show 41ec3303c9c184138f5ca3201f40fc00ba9ce7de:tests/test_planning_pilot_routing.py` against `git show 98988d44515cb0f088885c3b6d5f6f6c051c6fec:tests/test_planning_pilot_routing.py`, not the report's account.

6. Observable behaviour: DIRECT, FIXED_ONE_LEVEL, `RECURSIVE_LAZY`, and `RECURSIVE_CONCURRENT` must keep their current observable behaviour. Attack with the brief's named acceptance modules and the conformance corpus.

7. METHOD FRICTION entry (2) claims this brief's history was rewritten while the step was already implementing it. That is a J-class claim — open `git log` before accepting it: `c60e398` and `af4cbca` precede the first dispatch, `2f6c3e5` followed the aborted attempt and preceded the re-dispatch. File a finding if the claim misstates the history. The two METHOD FRICTION entries question the method's templates, not this brief, so they are not carried here beyond this attack.

--- BEGIN BRIEF UNDER REVIEW (copy of docs/research/phase4-recursive-planning-integration-api-shape-brief.md; the committed file is authoritative) ---
IMPLEMENTER BRIEF — phase4-recursive-planning-integration-api-shape (Phase 4: the admission capability, the two mint points, and the constructor rename)
GOAL: R1's prevention shape lands. The entry that admits a decomposition requires a non-data admission capability bound to a digest of the admitted children — never a declarative `source`/marker field (omittable and forgeable, and model output is data). The capability has exactly two mint points: `planning_pilot.admit_proposal` (guarded) and the deterministic derivation admission path (derived). Data alone cannot reconstruct one; in-process trusted-code circumvention stays outside the threat model (`PILOT-R10`). The unguarded `Controller.propose_decomposition` name does not survive: the entry the deterministic derivation path uses is renamed so its name declares the derived-only route, and the model-routed entry requires the capability. Transit immutability (F2's re-word per R6) is the named no-mutation shape: the producer payload reaches controller admission unedited in transit, dependency edges ride the `dependencies` argument, and the controller's deterministic admission normalisation (`parent_proposal`, budget defaults) is the only delta the admitted event carries. F6 is fixed: the two absorbed depth pins in `tests/test_review_depth_walk.py` are renamed so their names state the enforced property. DIRECT, FIXED_ONE_LEVEL, `RECURSIVE_LAZY`, and `RECURSIVE_CONCURRENT` keep their current observable behaviour.
CONTEXT: Owner ruling R1 (`docs/record.md`) is the requirement and rules the marker field out; R6 settles F2's meaning as transit immutability and assigns the re-word to this brief (the frozen provider brief stands as written). Measured call surface of the rename: `controller.propose_decomposition` at `src/orchestrator/conformance.py:220,283` and `src/orchestrator/trial_driver.py:1092,1590` (the routed forward at 1092, the un-routed derived admission at 1590), and in seven test modules named in `IN SCOPE`. `planning_pilot.propose_decomposition` already routes through `admit_proposal` (`planning_pilot.py:664`); `plan_decomposition` is a pure derivation and should keep its signature. Stated reading of R1's rename sentence: the routes' names are split — the deterministic derivation path's entry carries a name that declares the derived-only route, and the model-routed entry requires the capability. If exactly one alternative reading is consistent with the rest of R1, take it and file a FINDING with ORIGIN: BRIEF naming the reading you took. Per R7 (this brief is the re-cut it directs), `INHERITED` carries F6 and F7's standing half only; F2, F3, and F4 are fixed with `no regression test` and are named with their FIXED lines where each is stated below; the residual rows ride `RESIDUALS`, never `INHERITED`. Dispatch-time tree note: the working tree carries uncommitted partial edits from an aborted implementer attempt (`src/orchestrator/controller.py`, `src/orchestrator/planning_pilot.py`) — raw material inside `IN SCOPE`, unreviewed and uncommitted. Keep, revise, or discard them as your implementation judgement requires; your one `Actor: IMPLEMENTER` work commit carries the final state either way, and your report's `CHANGED` names what that commit holds.
INHERITED:

From `docs/research/phase4-recursive-planning-integration-fixes-implementer.md`: none still open. R7 fixed F2, F3, and F4 under rule 8 as amended, and the `PILOT-R2` re-note's measured-unenforced interval closed when the depth pins went green (the fixes review's answer 4).

From `docs/research/phase4-recursive-planning-integration-fixes-review.md`:

F6 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  Two absorbed pins keep names that state the bug's behaviour, opposite to what they enforce (see F6 above for the finding and remedy).

F7 | SEVERITY: P2 | ORIGIN: DOCUMENT | STATE: carried
  The implementer report's residual accounting mis-votes TRIPPED (names `PILOT-R2`, omits `PILOT-R1`/`PILOT-R10`).

R7 withdrew F7's INHERITED half as a finding against correct behaviour — rule 3 selects residuals per brief, and the implementer's exclusion of the seven rows was right — so F7 stands only as its wrong-`TRIPPED` half, quoted above.
IN SCOPE: src/orchestrator/controller.py, src/orchestrator/planning_pilot.py, src/orchestrator/trial_driver.py, src/orchestrator/conformance.py, tests/test_planning_pilot.py, tests/test_planning_pilot_routing.py, tests/test_review_depth_walk.py, tests/test_crash_recovery.py, tests/test_crash_matrix.py, tests/test_batch5_recovery.py, tests/test_milestone2_acceptance.py, tests/test_milestone8_readiness.py, docs/research/phase4-recursive-planning-integration-api-shape-brief.md
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`–`PILOT-R6` and `PILOT-R10` trigger globs (`planning_pilot.py`, `controller.py`); `PILOT-R7`–`PILOT-R9` (`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-R2` | accepted | `src/orchestrator/decomposition.py`, `src/orchestrator/planning_pilot.py` | single-layer containment (F1): scope, budget and bounds admit exactly one recursive level; deeper proposals are legitimate work the guard will refuse | the pilot's mandate is deliberately one level deeper than FIXED_ONE_LEVEL and no more | [pilot re-review 3](research/phase4-recursive-planning-pilot-re-review-3.md) |
| `PILOT-R3` | accepted | `src/orchestrator/model.py`, `src/orchestrator/planning_pilot.py` | `RunState.clone()` is for replay snapshotting, not authority isolation (deepcopy kept): a future model provider must be handed the isolated `provider_state`, never the live state — if a provider is given the live state it can rewrite its own bounds | the pilot spec's threading warning; the live state was handed over exactly once, at the producer seam | [pilot re-review 3](research/phase4-recursive-planning-pilot-re-review-3.md) |
| `PILOT-R4` | accepted | `src/orchestrator/planning_pilot.py` | `parent_scope` is an assertion, not a restriction: containment is multi-scope and refusal is by comparison with the derived parent, not by trusting the argument. Multi-scope containment reaches only one level — a grandchild of a multi-scope parent may not propose | the contract reads `owned_scope: Sequence[str]` as a plural, and S5.4 in R3 of the option (e) review stands | [pilot re-review 3](research/phase4-recursive-planning-pilot-re-review-3.md), [option (e) review](research/phase4-option-e-review-report.md) |
| `PILOT-R5` | accepted | `src/orchestrator/planning_pilot.py`, `src/orchestrator/decomposition.py` | all-glob parent refused: `scope_contained` treats a bare `**` or `*` parent as a containment failure and refuses every child | conservative rather than unsafe; the fixed target owns `src/**`, so its proposals are unaffected | [pilot re-review 3](research/phase4-recursive-planning-pilot-re-review-3.md), [option (e) review](research/phase4-option-e-review-report.md) |
| `PILOT-R6` | accepted | `src/orchestrator/planning_pilot.py` | proposal content is not derivable (shape only): the checks prove shape, budget, bounds and one level of containment — never that a proposal is the right decomposition. If the future model path validates only shape, a well-formed wrong tree is admitted | the independent oracle and the acceptance grading remain the correctness authority; the guard's job is admissibility, not quality | [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.
OUT OF SCOPE:
- Editing this brief file (`docs/research/phase4-recursive-planning-integration-api-shape-brief.md`). `IN SCOPE` claims that path only so `scripts/check-scope` admits the planner's re-cut commits: a rewrite of an existing `docs/research/` document must be claimed (`tests/test_check_scope.py::test_existing_doc_under_research_must_be_claimed`), and a re-cut brief is such a rewrite. The brief is frozen at dispatch — your work commit must not touch it.
- Any `docs/` file except your report: no `docs/control-plane.md` or other normative freeze of the shape (R1's shape lands as code and tests here; freezing it into a normative document is a later owner-approved step), no `docs/residuals.md` edit (the planner maintains it), no `docs/record.md` edit, no `docs/event-catalogue.md` change, no new event type.
- `src/orchestrator/reducer.py`, `src/orchestrator/model.py`, `src/orchestrator/decomposition.py`, `src/orchestrator/derive_obligations.py`, `src/orchestrator/project_oracle.py`, `src/orchestrator/model_adapter.py`, `src/orchestrator/experiment.py`, `src/orchestrator/experiment_spec.py`, `src/orchestrator/experiment_target.py`. `plan_decomposition` keeps its signature (pure derivation). If one of these must change, stop and report `IN SCOPE` as insufficient.
- A declarative `source`/marker field anywhere (payload, event, capability-as-data): declined by R1 — omittable and forgeable, and model output is data.
- Closing `PILOT-R10`: in-process trusted-code circumvention is outside the capability's threat model. The capability answers data-only reconstruction; do not claim more.
- Re-wording the frozen provider brief (F2): the frozen brief stands as written. The re-word lives in this brief's Transit immutability shape only. F2 is fixed as that shape: `no regression test` — `c39b094`.
- 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 new `*Executor` or `*ModelClient` class and no provider-registry registration; no new dependencies; no new arm; no `docs/tables/limits.yaml` change.
- Name no test `test_bug_*` (the open-defect registry would then own it).
- Do not mutate an admitted payload between the guard and event admission.
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_planning_pilot.py tests/test_planning_pilot_routing.py tests/test_review_depth_walk.py
    pytest tests/test_crash_recovery.py tests/test_crash_matrix.py tests/test_batch5_recovery.py
    pytest tests/test_milestone2_acceptance.py tests/test_milestone8_readiness.py
    pytest tests/test_milestone2_conformance.py tests/test_milestone3_conformance.py
    pytest tests/test_phase3_project_oracle.py
    scripts/check-static
    scripts/check-docs
    scripts/check-scope 41ec3303c9c184138f5ca3201f40fc00ba9ce7de <FINAL> docs/research/phase4-recursive-planning-integration-api-shape-brief.md

Never put a full run in `ACCEPTANCE`; the reviewer runs `scripts/check-tests`. The conformance and milestone modules are named because `conformance.py` and the seven test modules are the rename's call surface. `pytest tests/test_phase3_project_oracle.py` is named per the standing rule for `tests/` changes. `REV` below names the step's base — the parent of this brief commit — and is not claimed to be `FINAL`'s parent (F4 fixed: `no regression test` — `61e6d07`, which corrected the `REV` field and range hygiene).

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`. Prefer no new modules: the capability shapes belong beside the existing pilot and controller tests. F3 is fixed as this note: `no regression test` — `61e6d07`.

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

- `Capability shape`: admitting a decomposition without a valid admission capability is refused — a caller holding only data (children, coverage, dependencies) cannot construct one, and the refusal is observable (the same rejection surface an admission failure uses today, never a second path).
- `Two-mint-point shape`: the capability is mintable at exactly two places — `planning_pilot.admit_proposal` (guarded) and the deterministic derivation admission path (derived). No third mint exists: construction outside those paths is impossible or refused, and a test names both mint points as the only ones.
- `Digest-binding shape`: the capability is bound to a digest of the admitted children — a capability minted over one admitted structure is refused at a submission whose children digest differs, and the guarded mint binds exactly the structures the guard admitted.
- `Derived-only naming shape`: the entry the deterministic derivation path uses carries a name that declares the derived-only route; the old unguarded `propose_decomposition` name does not remain callable without a capability. Both routes land the same observable admission behaviour as today (`DECOMPOSITION_ADMITTED` payloads, run-limit checks, dependency edges).
- `No-marker shape`: no declarative `source`/marker field exists on the payload, the event, or any capability structure — the capability is authority, not annotation.
- `Transit immutability shape` (F2's re-word per R6; F2 fixed: `no regression test` — `c39b094`): the children, coverage, and dependencies the driver forwards reach controller admission unedited in transit — dependency edges ride `propose_decomposition`'s `dependencies` argument, not children carving — and the only delta the admitted event carries over the guard's return is the controller's deterministic admission normalisation (`contract.parent_proposal`, budget defaults). `test_admitted_payload_is_forwarded_unmutated` stands unchanged as the pin.
- `Pin-name shape` (F6): `tests/test_review_depth_walk.py`'s two renamed pins state the enforced property — the root reads depth zero and a true depth-2 leaf reads two (subtree height is not depth); the pilot depth guard refuses a proposal at a true depth-2 node at BOUNDS. The third pin's name already does.
REV: 41ec3303c9c184138f5ca3201f40fc00ba9ce7de
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. 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: <base sha>   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".
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: <base sha>   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".
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.
