<!-- informative -->

# Adversarial review: bounded recursive-planning pilot — admission guard and P1

Revision reviewed: **`f907c80`** (detached worktree `/tmp/kilo/pilot-review`).
Verdict: **NO-GO** for the model producer to land on this base, pending the
bounded corrections in *Findings*. The guard is not yet sound enough to be the
pilot's safety surface: the scope-containment bound (P4) is enforced *only* by
the guard, and three of the guard's own bounds can be silently weakened
(falsy/`NaN` parent budget, caller-supplied depth, caller-supplied per-trial
count). This is the same defect class that already shipped once in `f907c80`.

All commands below are run from `/tmp/kilo/pilot-review` with
`PYTHONPATH=/tmp/kilo/pilot-review/src` and the project venv
`/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python`; probe sources
are under `/tmp/kilo/pilot-probes/`.

## Baseline

| Check | Result |
| --- | --- |
| `python -m pytest -q` | **805 passed** on the reviewed tree. A fresh worktree has no `.venv`, so a first run reports `801 passed, 4 failed` for `FileNotFoundError: .../.venv/bin/ruff` and `.../.venv/bin/python` (environmental, not code); symlinking `.venv` makes those four pass and the total 805 (see *Reproduce*). |
| `scripts/check-tests --fast` | **775 passed, 30 deselected** |
| `scripts/check-docs` | **246 links OK**, table verification passed |
| `scripts/check-static` | rc 0 (gated BLE001/S110 clean; B/SIM advisory output expected) |
| `scripts/check` | rc 0 |

The four environmental failures vanish with `.venv` present, so the brief's
"805 passed" baseline is confirmed and this revision is green.

## Verdict and rulings

### Verdict: NO-GO

The four commits are internally consistent and P1 discharges its obligation, but
the new guard has three under-restriction defects and one single-layer bound:

1. **P4 scope containment is enforced by nothing but the pilot guard.**
   `validate_decomposition` accepts a child whose scope escapes its parent (probe
   G). A guard bug or an aliased post-admission mutation (concern 3) is therefore
   a direct path to an out-of-parent child with no downstream catch.
2. **The budget bound silently disables itself on a falsy or `NaN` parent
   budget** (`parent_budget=0`, `""`, `[]`, `{}`, or a `NaN` limit admits an
   arbitrarily large child) — the exact "permits too much" direction `f907c80`
   was supposed to close.
3. **The depth bound and the per-trial ceiling are caller-supplied and
   unverifiable**; the guard admits a proposal at a controller-depth-5 parent when
   the caller passes `parent_depth=0`, and admits 36 children across split calls
   while reporting `already_proposed=0`.

None of these is a partial-structure failure (guarantee 1 holds), and the reducer
remains authoritative for fan-out and budget, but the pilot's claim to be "the
entire safety surface until the reducer sees the event" is not true for P4, and
the budget guard does not reliably narrow.

### Ruling on concern 1 (depth semantics)

**The two computations do not agree, and the pilot's is not self-enforcing.**
`Controller._node_depth` (`controller.py:166`) walks `CHILD_OF` relations from the
run's `root_node_id`; the pilot's `parent_depth` is a caller-supplied integer
defined as "levels below the derived root" (`planning_pilot.py:76`). Probe:

```
node root: controller depth = 0
node A:    controller depth = 1
...
node E:    controller depth = 5
guard admitted proposal at parent 'E' with parent_depth=0 while controller depth=5: True
guard refused with true controller depth: proposal refused: parent is at depth 5 ...
```

The two disagree whenever the "derived root" is not the run root, and the guard
cannot detect an under-count. Contrary to the brief's premise, the controller
*does* refuse on depth: `propose_decomposition` calls `_enforce_run_limits` with
`("maximum_depth", _node_depth(parent)+1, 0.0)` (`controller.py:710-721`), and the
experiment populates `maximum_depth` into `run_limits` (`trial_driver.py:1531`),
so `_enforce_run_limits` raises `RunLimitExhausted` at controller depth 5
(`controller.py:196-219`). The **authoritative** number is the controller's — it
is derived from replayable state and actually refuses.

Consequence: the pilot's tighter bound (2) is real only if the caller passes the
controller's `_node_depth`; if it passes a smaller number, the pilot's bound
degrades to the controller backstop (5), not beyond. That still bounds recursion,
but it falsifies the "bounded more tightly than the harness" guarantee as
written. Before a producer relies on either number, the guard should take the
`RunState` + parent node id and derive depth itself (it currently receives only
`children`, `parent_scope`, `parent_depth`), or the spec must state that
`parent_depth` **is** `Controller._node_depth` and pin that integration in a test.
Which is authoritative: the controller's.

### Ruling on concern 4 (duplicated containment)

**Current agreement does not hold; unify now.** `planning_pilot._prefix_segments`
and `decomposition._scope_fixed_prefix` (used by `experiment_target._scope_contained`
at `:426-440`) implement the same rule differently. Observed divergences:

```
pilot=False gate=True  child='src/a/x.py' parent='src/a//**'   (pilot keeps the empty segment)
pilot=False gate=True  child='src/a/x.py' parent=''            (gate's prefix is [] → everything contained)
pilot=False gate=True  child='src/x.py'   parent=''
```

The pilot is the *more restrictive* side here (safe for proposals), but the
docstring's claim that a proposed child and a declared child "meet one
containment standard" (`planning_pilot.py:55-56`) is false, and the gate's
empty-parent answer (everything contained) is itself wrong. Unify on one helper
(`decomposition._scope_fixed_prefix` is the shared one) and make an empty or
all-glob parent prefix an explicit refusal rather than an implicit "contained".
The `..`-segment laxity (`src/a/../b` under `src/a/**` reads as contained in
*both* implementations) should be closed in the shared helper at the same time.

## Findings

Severity: **P0** = a safety bound reachable with no enforcement; **P1** = the
guard is the sole enforcement for a bound, or a silent under-restriction; **P2** =
robustness / unenforced guarantee; **P3** = documentation / duplication.

### F1 — P1 — Scope containment (P4) is enforced only by the pilot guard

Guarantee violated: 7 and the authority map (guard load-bearing where it should
be defence-in-depth). Reproducer
(`/tmp/kilo/pilot-probes/p1_depth_authority.py`):

```python
validate_decomposition(proposal_with_child_scope_["src/evil/x.py"], state2)  # parent owns src/good/**
# → returns normally: validate_decomposition ACCEPTED a child escaping its parent scope
```

`decomposition.validate_decomposition` checks child scope *non-emptiness*
(`decomposition.py:98-101`) but never that it sits inside the parent's
`owned_scope`; the reducer's `_on_decomposition_admitted` only re-runs it
(`reducer.py:415`). The pilot's `check_scope_containment` is the only
containment check on the proposal path. Expected: either
`validate_decomposition` refuses an escaping child, or the guard's result is
re-checked against the parent node's real scope in the reducer. Regression test:
build a `RunState` with a parent owning `src/good/**`, pass a child owning
`src/evil/x.py` to `validate_decomposition`, assert `DecompositionError`.

### F2 — P1 — The budget bound silently disables itself on a falsy or `NaN` parent budget

Guarantee violated: 6 and 7. Reproducer
(`/tmp/kilo/pilot-probes/p1_budget_edges.py`):

```
parent_budget=0    child asks 1e9  → ADMITTED
parent_budget=0.0  child asks 1e9  → ADMITTED
parent_budget=''   child asks 1e9  → ADMITTED
parent_budget=[]   child asks 1e9  → ADMITTED
parent_budget={}   child asks 1e9  → ADMITTED
parent_budget=None child asks 1e9  → ADMITTED
parent limit NaN   child asks 1e9  → ADMITTED
```

`check_budget_authority` begins `if not parent_budget: return`
(`planning_pilot.py:133-134`), so a scalar `0`, an empty string/list/dict, or
`None` all skip the whole bound instead of refusing. Separately,
`value > float(limit)` with `limit = NaN` is always `False`, so a `NaN` parent
limit disables the per-child comparison. This is the same "permit too much"
class `f907c80` fixed; the fix moved to per-dimension lookups but kept a
truthiness gate and an unvalidated `float(limit)`. Expected: refuse a
non-mapping `parent_budget` and a non-finite/non-numeric limit rather than
treating them as "no limit". Regression test: `parent_budget=0` and
`parent_budget={"MODEL_COST": float("nan")}` each raise `DecompositionError` for
an over-limit child.

### F3 — P2 — Truthy non-mapping `parent_budget` / non-numeric limit crash

Guarantee violated: 6 (refusal is a typed `DecompositionError` everywhere else).
`parent_budget=10.0` → `AttributeError: 'float' object has no attribute 'get'`;
`parent_budget=[10.0]` → same; `{"MODEL_COST": "ten"}` → uncaught `ValueError`.
The implementer's own test passes the stale scalar form
(`tests/test_planning_pilot.py:205`, `parent_budget=10.0`) and only avoids the
crash because `check_scope_containment` fails first. Regression test: the scalar
form refuses with `DecompositionError`, and no input raises `AttributeError` /
`ValueError`.

### F4 — P1 — The depth bound is caller-supplied and unverifiable

Guarantee violated: 2. Reproducer
(`/tmp/kilo/pilot-probes/p1_depth_authority.py`): a parent the controller places
at depth 5 is admitted to propose with `parent_depth=0`. Nothing in the guard
derives depth from state. The controller's `maximum_depth=5` remains a backstop
only on `propose_decomposition`; the reducer's `_on_decomposition_admitted` does
not check depth. Regression test: once `admit_proposal` can accept a `RunState`,
assert it refuses to let a controller-depth-2 parent propose regardless of the
caller's number.

### F5 — P1 — The per-trial ceiling is caller-trusted and has no second site

Guarantee violated: 4. Reproducer (`/tmp/kilo/pilot-probes/p1_ceiling.py`):

```
6 calls × 6 children, each with already_proposed=0 → 36 admitted > 32
already_proposed=-10**9 → admitted
```

`check_bounds` computes `already_proposed + len(children)`
(`planning_pilot.py:87-92`); `already_proposed` is a caller argument that nothing
derives, and splitting one oversized proposal across calls evades the ceiling
entirely. No reducer/controller check enforces "32 proposed children per trial"
(the `nodes: 30` run limit is a different bound, and in the experiment it is
*looser-or-tighter* by 2, so the pilot ceiling can never bind). Answer to the
brief's question: the guard cannot be made robust here as a pure function; the
ceiling needs the `RunState` (or the projection) or must move into the reducer.
Regression test: derive `already_proposed` from admitted state and assert a
sixth wave is refused.

### F6 — P2 — Shallow copy shares nested `contract` / `budget_allocation`

Guarantee violated: 1 in spirit (the admitted structure is not isolated from the
caller). Reproducer (`/tmp/kilo/pilot-probes/p1_guard.py`, section I):

```
adm[0]["contract"]["owned_scope"].append("src/evil/x.py")
caller contract mutated by returned-child nested mutation: ['src/a/x.py', 'src/evil/x.py']
re-admission of the caller's child → refused (scope now escapes)
```

`admit_proposal` does `proposed = [dict(child) for child in children]`
(`planning_pilot.py:200`), a shallow copy. Because the reducer re-validates but
does **not** re-check containment (F1), a producer that mutates a returned
child's nested contract after admission changes the structure that will be
admitted with no downstream catch. This is concern 3 confirmed as a real hole.
Expected: deep-copy the nested `contract`/`budget_allocation`, or add the
reducer containment check from F1. Regression test: mutate a returned child's
nested contract and assert the caller's child (and a subsequent admission) is
unaffected.

### F7 — P2 — `record_outcome` is not wired and its counts are unverified

Guarantee violated: 8. `admit_proposal` never calls `record_outcome`
(`inspect.getsource` shows no reference), so "every proposal produces one of
these" is aspirational; the counts (`proposed`, `accepted`, `depth_reached`) are
echoed from the caller and nothing cross-checks them against the admitted
structure. A refusal with an empty stage records `refusing_stage=""` rather than
`None` (`record_outcome(False, refusing_stage="")` → `''`). Regression test: the
admission path emits a record whose `accepted_children` equals the returned
length and whose `refusing_stage` names the check that actually raised.

### F8 — P3 — Two containment implementations that do not agree

Concern 4 confirmed; see the concern-4 ruling. `planning_pilot._prefix_segments`
keeps empty segments and `decomposition._scope_fixed_prefix` drops them;
`experiment_target._scope_contained` is a third copy of the same rule. Regression
test: a parameterised table over both helpers asserts identical answers, or the
pilot imports the single shared helper.

### F9 — P3 — Spec P2's proposal field names do not match the guard's input

The spec (`phase4-recursive-planning-pilot-spec.md:63-64`) describes a proposal
child as `child_id`, `scope`, `criterion_ids`, `depends_on`, `budget`; the guard
reads `node_id`, `contract.owned_scope`, `budget_allocation` (the reducer child
shape). The producer does not exist, so the interface is undecided; the spec and
code should name one shape before the producer is written.

### F10 — P3 — `_nesting_shape` is one level deep

Residual, not a regression: `_nesting_shape` only inspects the direct
`obligations` of top-level obligations (`derive_obligations.py:600-614`), so a
change to grandchildren is invisible to `NESTING`. The pilot admits depth-2
structures (grandchildren), so the axis will not see structural change at that
level. Named for the S7/S12 residual surface rather than fixed here.

## Claims verified

| # | Guarantee | Attempt | Outcome |
| --- | --- | --- | --- |
| 1 | Refusal is total | Good-first/bad-last proposal; input deep-compared before/after; source inspection for return-and-raise and partial lists (`p1_guard.py` F) | **Attacked, not falsified.** Nothing is returned until every check passes; a refusal carries no children; input unchanged. (The shallow-copy alias F6 does not create a partial structure; it is a post-return mutation hole.) |
| 2 | Depth (P3) | Constructed a 6-deep `RunState`, compared `Controller._node_depth` with `parent_depth`; admitted at controller depth 5 with `parent_depth=0` (`p1_depth_authority.py`) | **Falsified as "bounded more tightly / not caller-trusted"** → F4. The code's `parent_depth>=2` check is correct *given* a truthful argument; the controller backstop does refuse at 5. |
| 3 | Per-node fan-out (P3) | 7 children refused; `maximum_children_per_node()` read from `limits.yaml`; also enforced by `validate_decomposition:65-70` and controller `maximum_children_per_node` | **Attacked, not falsified.** Triple-enforced, pilot never raises it. |
| 4 | Per-trial ceiling (P3) | Split across 6 calls; under-counted `already_proposed` (`p1_ceiling.py`) | **Falsified** → F5. |
| 5 | Scope containment (P4) | Sibling reach, `**`, `""`, `..`, duplicate slashes, textual-vs-segment prefix (`p1_guard.py` D) | **Partly falsified.** Segment-wise comparison closes the `src/ab`-under-`src/a` case and sibling reach is refused; but the bound is guard-only (F1) and the implementations disagree (F8); children with no `owned_scope` are skipped (reducer then refuses them, so not a hole). |
| 6 | Budget authority (P5) | Cross-dimension, uncatalogued dim, omitted dim, `NaN`/`inf`/`-0.0`/string/`Decimal`/`bool`/`None`, missing allocation, exact-limit+zero, falsy/NaN/non-mapping parent (`p1_guard.py` E, `p1_budget_edges.py`) | **Partly falsified.** Per-dimension comparison works; `NaN`/`inf`/negative child amounts are refused; cross-dimension summing is gone. But falsy/`NaN` parent budgets disable the bound (F2) and truthy scalars crash (F3). Omitted dimension is admitted by the guard but refused by the reducer (see authority map). |
| 7 | Guard only narrows | Checked each check's direction and whether the reducer trusts the guard (`p1_depth_authority.py` G) | **Falsified for P4.** Containment is guard-only (F1); depth/ceiling are caller-trusted (F4/F5); budget can be silently loosened (F2). The guard cannot raise a table limit or widen a scope beyond the passed `parent_scope`, so the *narrowing* direction is intact. |
| 8 | Instrumentation (P8) | Source inspection + calls to `record_outcome` (`p1_budget_edges.py`) | **Falsified** → F7. |
| 9 | P1 nested spelling excluded | Direct `_nesting_shape` invariance/sensitivity; fixed-target NESTING + `contract_hash` pin (existing tests; `TestP1NestedSpellingExcluded` 4 passed) | **Attacked, not falsified.** Rename leaves the shape unchanged; add/remove/re-parent change it; the fixture still measures `NESTING` and `contract_hash == sha256:157bbd15…f40cf848`. |
| 10 | P1 obligation discharged end to end | Patched `derive_obligations` to return nested obligations (the F2 scenario) and drove `measure_divergent_axes` (`p1_nesting.py`) | **Attacked, not falsified — it holds.** With derivation nesting: nested rename → `[]` (no `NESTING`); removal/adding/re-parenting → `{'NESTING'}`. The implementer's indirect pin is correct end to end, contrary to the brief's "not demonstrated". (Blind spot: grandchild-level change, F10.) |
| P6/P7 | Not reviewed as guarantees | Source inspection | Nothing landed *presumes* them: no code path marks a pilot structure `DECLARED`, and no kernel edit landed. |

## Authority map

| Bound | Enforced by | Notes |
| --- | --- | --- |
| Depth (P3, 2 levels) | pilot guard (`parent_depth`) **and** controller `_enforce_run_limits` `maximum_depth=5` on `propose_decomposition` | Pilot's tighter 2 is caller-trusted (F4); controller's 5 is state-derived and authoritative. Reducer does not check depth. |
| Per-node fan-out (6) | pilot guard **and** `validate_decomposition:65-70` **and** controller `maximum_children_per_node` | Defence in depth; cannot be raised. |
| Per-trial ceiling (32) | pilot guard only | Caller-trusted `already_proposed` (F5); no second site. |
| Scope containment (P4) | **pilot guard only** | `validate_decomposition` does not check it (F1). Guard-only bound → **finding**. |
| Budget authority (P5) | pilot guard **and** reducer `budget_feasibility_conflict` against ledger `available` + authorised dimensions | Reducer is authoritative and per-dimension; it accepts negative allocations (pre-existing), which the guard refuses, so the guard is load-bearing for negatives. Guard can silently disable itself (F2/F3). |

Bounds enforced by nothing: **none**. Bounds the guard is the only enforcement
for: **P4 scope containment** (F1) and the **per-trial ceiling** (F5).

## The four implementer corrections, verified

1. **Spec size bound 8 → 6.** Present in
   `phase4-recursive-planning-pilot-spec.md:84-90` and `docs/self-host.md`; the
   code calls `maximum_children_per_node()` (6). Verified.
2. **`f907c80` budget fix.** Verified as real (per-dimension, uncatalogued
   refused) and *also* verified as incomplete — F2/F3 are the same class it was
   fixing. This is the finding the brief predicted.
3. **Concern-2 re-open trigger in S7.** Present and accurate
   (`phase4-option-e-implementation-spec.md:210-213`). Note: `git log -S` places
   it at `010e3dc`, i.e. it pre-dates the four commits under review; it is not a
   change this implementer made.
4. **Concern-6 growth note in S12.** Present and accurate
   (`phase4-option-e-implementation-spec.md:288-291`); also introduced at
   `010e3dc`, not in the four commits. The S12 bullet actually added by
   `971efd6` is the "derivation learns to nest" obligation — which P1 discharges.

## Residual unknowns

- **The producer and its call sites do not exist**, so all caller-trust findings
  (F4, F5, and the `parent_scope`/`parent_budget` arguments) are "as the code
  stands"; whether the producer passes truthful arguments is untestable. I tested
  the claims as the code stands and separately state, per finding, that the guard
  *could* derive the argument if it took a `RunState`.
- The controller depth backstop was established by code inspection plus the
  `_node_depth` probe, not by an end-to-end run through `propose_decomposition`
  with a full experiment config (would require the producer path).
- Deeper nesting (grandchildren) in the `NESTING` shape (F10) was not exercised
  through a declaration because the shape is one level by construction.
- No model calls, no network, no credentials were used.

## Reproduce everything

Worktree: `git worktree add --detach /tmp/kilo/pilot-review f907c80`.
`.venv` in the worktree was symlinked to the project venv only to let the four
oracle tests spawn `ruff`/`python`; it is not required for the probes.

```
# probes (PYTHONPATH=/tmp/kilo/pilot-review/src, project venv python)
/tmp/kilo/pilot-probes/p1_guard.py            # A, D, E, F, I
/tmp/kilo/pilot-probes/p1_budget_edges.py     # falsy/NaN parent budget; record_outcome wiring
/tmp/kilo/pilot-probes/p1_depth_authority.py  # B (depth) and G (authority/containment/negative budget)
/tmp/kilo/pilot-probes/p1_nesting.py          # H (P1 end-to-end via patched derive_obligations); 9
/tmp/kilo/pilot-probes/p1_ceiling.py          # C (per-trial ceiling evasion)

# gates
scripts/check-tests --fast        # 775 passed, 30 deselected
scripts/check-docs                # 246 links OK
scripts/check-static              # rc 0
scripts/check                     # rc 0
python -m pytest -q               # 805 passed with .venv present
```

Constructed states: a 6-node `CHILD_OF` chain `root→A→B→C→D→E` for
`Controller._node_depth`; a `RunState` with a parent owning `src/good/**` and a
child owning `src/evil/x.py` for `validate_decomposition`. Patched derivation:
`derive.derive_obligations` monkeypatched to return a nested obligation tuple,
restored in a `finally`.

## Implementer's remediation (2026-09-30)

Six findings closed, two recorded rather than fixed, and two corrections of my own
stated facts. **834 passed**; `scripts/check`, `scripts/check-static` and
`scripts/check-docs` all rc 0 (247 links).

**F2 closed.** A parent budget that is not a usable per-dimension mapping, or a
limit that is not a finite non-negative number, is refused. The truthiness gate
that silently disabled the whole bound on `0`, `""`, `[]`, `{}`, `None` and a
`NaN` limit is gone, as is the unvalidated `float(limit)`. A dimension the parent
does not limit is now **refused** as unbounded rather than admitted (F2's
"omitted dimension" case, which had been disclosed as concern 6).

**F3 closed.** A non-mapping `parent_budget` — including the stale scalar form my
own test passed — raises `DecompositionError` instead of `AttributeError`, and a
non-numeric child or parent amount raises `DecompositionError` instead of
`ValueError`. My test had been passing only because scope containment failed
first; the pins now exercise the budget bound directly.

**F4 and F5 closed by derivation, not by better documentation.** `admit_proposal`
now accepts an optional `state` and `parent_node_id` and derives both the parent's
depth (walking `CHILD_OF` to the run root) and the trial's admitted child count.
When state is supplied, a caller whose stated depth or count disagrees is refused
and the derived number is declared authoritative. This is the review's ruling
applied: the controller's number is the authoritative one, so the guard now
computes the same thing instead of trusting a caller.

**F6 closed.** `admit_proposal` deep-copies each child, so a post-admission
mutation of a returned child's `contract` or `budget_allocation` cannot change the
structure that would be admitted. This mattered more than the review's P2
rating suggested, because it compounded F1: with containment enforced in one place
only, the aliasing was a way around that one place.

**F8 closed.** There is one containment rule: `decomposition.scope_contained`.
Both `experiment_target` and `planning_pilot` delegate to it, and it now refuses a
`..` segment, an empty scope, and an all-glob parent prefix rather than treating
them as permissive. A parameterised table asserts the guard and the shared rule
agree on nine cases, including the three divergences the review found.

**F9 closed.** The spec's proposal child fields now name the reducer's child
shape — `node_id`, `contract.owned_scope`, `budget_allocation` and the rest —
which is the shape the guard already reads, so there is one interface to settle
before the producer is written.

**F1 recorded, not fixed — and the review's first remedy is refused.** The review
offered two remedies for containment being guard-only. Enforcing it in
`validate_decomposition` is not a defence-in-depth addition; it is a change to the
harness's decomposition contract. Existing *admitted* proposals have children whose
scopes escape their parent's declared scope — a `src/m/**` child under a
`src/health/**` parent is in the milestone acceptance corpus — so enforcing it
rewrites semantics that the committed milestone evidence was measured under, and
it broke nine tests when I tried it. The second remedy (re-check in the reducer)
is the same check in the same place. So containment remains single-layer, the gap
is named in the spec's residual section and pinned by
`TestContainmentIsSingleLayer`, which asserts the validator's present behaviour so
the day a second layer lands is the day the test changes.

**F7 and F10 recorded.** `record_outcome` is still not wired, because wiring it
belongs to the producer; the spec says so rather than claiming otherwise. F10
(`_nesting_shape` is one level deep) is named in the spec's residual surface with
the note that it becomes load-bearing if the pilot admits depth-2 structures whose
divergence must be measured.

**Two corrections to my own stated facts**, both the reviewer's:

- I claimed the controller only *records* depth as a metric and refuses on nothing.
  It does refuse: `propose_decomposition` calls `_enforce_run_limits` with
  `maximum_depth = _node_depth(parent) + 1`, so there is a backstop at depth 5.
  This changes the picture materially — the guard's bound of 2 is a tightening on
  a real backstop, not the only depth enforcement, and my brief's premise was wrong.
- I presented the S7 concern-2 trigger and the S12 concern-6 note as corrections
  made by the four commits under review. They pre-date them, landing at
  `010e3dc`. The S12 bullet those commits did add is the "derivation learns to
  nest" obligation, which P1 discharges.

**Guarantee 10 holds.** The review drove it end to end by patching
`derive_obligations` to nest: a nested rename measures no `NESTING`, while
adding, removing, or re-parenting a nested child does. P1 discharges the inherited
obligation, which my brief had doubted.
