<!-- informative -->

# MEASUREMENT-Gate Adversarial Review — Batch 4

- Repo: `/home/ruben/Projectos/meta-project/orchestrator`
- Revision reviewed: `3e63e3a` (`main`), frozen worktree `/tmp/kilo/measurement-review-3e63e3a`.
- Re-verification: `6978d5f` (fixes), frozen worktree `/tmp/kilo/measurement-review-6978d5f`;
  probes re-run from `/tmp/kilo/measurement-probes-6978d5f/`; suite **522 passed in 161.39s**;
  `scripts/check-static` (gated BLE001/S110) and `scripts/check-docs` (164 links OK) pass.
  See [§7](#7-re-verification-against-6978d5f).
- Reviewer independence: not an author of `3e63e3a` or of any commit adding the MEASUREMENT mechanisms.
  The normative sources (`docs/experiment.md`, `docs/control-plane.md`, `docs/tables/limits.yaml`,
  `docs/tables/node-lifecycle.yaml`, `docs/tables/attempt-lifecycle.yaml`,
  `docs/report-milestone8-readiness.md` R08/R10/R13/R14) and the in-scope source
  (`experiment.py`, `controller.py`, `observability.py`, `oracle.py`, `reducer.py`, `store.py`)
  were read before the implementer's tests. No source was edited; all probes live under `/tmp/kilo/`.
- Baseline: `.venv/bin/python -m pytest -q` (from the frozen worktree) → **517 passed in 101.65s**.
  A green suite is not a verdict.
- No real credentials, no network, no paid model calls; deterministic scripted clients and the local
  `NAMESPACE_V1` sandbox only.

### Host layout (recorded for the host-dependent probes)

| Property | Value |
|---|---|
| Kernel | `6.12.96+deb13-amd64` (Debian, x86_64) |
| Sandbox profile | `NAMESPACE_V1` available (user/mount/PID/net/IPC/UTS namespaces, `pivot_root`, Landlock, seccomp) |
| cgroup | v2; sandbox cgroups created and removed per run (none left behind, verified) |
| Python | `/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python` (CPython 3.13) |

---

## 1. Verdict

**NO-GO for the MEASUREMENT gate.**

**Re-verdict on `6978d5f`: GO for the MEASUREMENT gate.** All three findings (F1 P1, F2 P2, F3 P2) are
closed; the original F1 reproducer through the real driver now terminates via `_TrialAborted` with the
node and run `INFEASIBLE`, and the R08/R10/R13/R14 guarantees remain verified. See §7. The verdict below
describes `3e63e3a`; §7 records the `6978d5f` re-verification.

The four in-scope guarantees are largely met, and the R08 isolation and R14 crash-recovery mechanisms
survived every attack that was run. However, **one reachable P1 falsification remains**: the bounded
repair loop (R10) raises `UnknownTransition` on the *second* validation failure instead of driving the
node to a recorded terminal `INFEASIBLE`. The exception is not `_TrialAborted`, so `run_trial` does not
catch it: the trial is left ungraded, the run is left live, and the trial's spend reservation is left
outstanding. The shipped R10 regression test does not catch this because it reuses a single attempt for
both cycles, which keeps the retry-policy lineage count at one; the real driver creates a new attempt per
cycle, so the second failure reaches the frozen lineage limit and takes a different node transition.

Two P2 issues are also recorded (a collapsed headline outcome in the R13 grade projection, and an orphan
child budget when recovery is skipped for a run that became terminal after a crash).

The P1 branch is **not reached by the calibrated frozen trial set**: the fixed `CommandExecutor` always
records a `COMMAND_RESULT` for BUILD/TEST, so a result is only ever rejected at admission (the
`RESULT_REJECTED` path), never admitted-but-visibly-failed. The defect is therefore a correctness gap in
the guarantee as written rather than a mis-measurement of the four frozen arms; it must still be fixed
before the gate is a GO, because R10 is stated over the repair loop and the public acceptance API, and
the failure mode (ungraded trial + outstanding reservation) is exactly the "exception leaving a live run"
the guarantee forbids.

---

## 2. Findings

### F1 — P1 — R10: the repair loop raises `UnknownTransition` on the second validation failure instead of a recorded terminal outcome

- **Invariant (R10, in-scope guarantee 2):** "a repeatedly failing action is driven by a bounded repair
  loop to a recorded terminal outcome (INFEASIBLE) before the trial is graded, without consuming extra
  reasoning budget or redispatching paid work."
- **Root cause (three interacting steps):**
  1. `Controller.authorise_acceptance` computes retry eligibility *before* emitting
     `VALIDATION_STARTED` (`src/orchestrator/controller.py:1551`). Eligibility is
     `retry_policy.evaluate(...)`, which returns not-retryable once the node's terminal-attempt count
     reaches `retries_per_action_lineage` (2). Because the driver creates a **new attempt per cycle**
     (`_execute_leaf`, `src/orchestrator/experiment.py:2149`), the second failure is already at the limit,
     so `VALIDATION_FAILED` routes the node to `REPLAN_REQUIRED`
     (`src/orchestrator/reducer.py:146-154,166-177`).
  2. `_accept` then calls `evaluate_repeated_failure(..., replan_material_change=True)`
     (`src/orchestrator/experiment.py:2274`).
  3. `evaluate_repeated_failure` only takes its `NODE_MARKED_INFEASIBLE` branch when
     `not replan_material_change` **and** the node is already `REPLAN_REQUIRED`
     (`src/orchestrator/controller.py:1650-1657`). With `replan_material_change=True` it falls through to
     the repeated-fingerprint branch and emits `REPLAN_REQUESTED`
     (`src/orchestrator/controller.py:1658-1664`), which `node-lifecycle.yaml` does not allow from
     `REPLAN_REQUIRED`. `NODE_TABLE.resolve` raises `UnknownTransition`.
- **Reproducer** (`/tmp/kilo/measurement-probes/probe_r10_driver_crash.py`) — uses the real
  `experiment._execute_leaf` with a scripted executor whose response carries no `COMMAND_RESULT`
  observations (admitted because `all([]) is True`, but the visible checker fails with
  `NO_VISIBLE_CHECKS`):

  ```bash
  /home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python \
      /tmp/kilo/measurement-probes/probe_r10_driver_crash.py
  ```

- **Observed:**

  ```
  RAISED orchestrator.tables.UnknownTransition: node: no legal transition from
      'REPLAN_REQUIRED' on 'REPLAN_REQUESTED' in node-lifecycle.yaml
  is _TrialAborted: False
  node = REPLAN_REQUIRED outcome = None
  attempts = 2
  ```

  The equivalent controller-level trace (`/tmp/kilo/measurement-probes/probe_r10_two_cycle.py`) shows
  cycle 1 ending `READY` / `NO_ACTION`, and cycle 2 ending `REPLAN_REQUIRED` followed by the raised
  transition.

- **Expected:** the node is driven to a recorded terminal `INFEASIBLE` and `_execute_leaf` raises
  `_TrialAborted` (the driver's frozen stopping signal), as it does for the result-rejection branch
  (`EXP-DIRECT-1003` reaches `INFEASIBLE`).
- **Impact:** `run_trial` only catches `_TrialAborted` and `BudgetExhausted`
  (`src/orchestrator/experiment.py:1899-1902`), so `UnknownTransition` propagates out of the trial: no
  grading evidence is persisted, no `TrialMetrics` is produced, and the spend reservation is never
  settled. The run is left live with the node in `REPLAN_REQUIRED`. This is precisely the
  "exception leaving a live run is not an honest terminal outcome" case R10 forbids.
- **Reachability:** the validation-failure branch requires a result that is admitted while the visible
  check fails. In the frozen target `CommandExecutor` always records `COMMAND_RESULT` for BUILD/TEST and
  admission rejects any non-zero exit, so the fixed arms take the `RESULT_REJECTED` path and are not
  affected. The branch is reachable through the controller/experiment API (no `COMMAND_RESULT`, or
  `exit_code == 0` with a non-zero `signal` — the visible checker tests the signal, admission does not).
- **Proposed regression test:** extend the R10 repair test so each cycle uses a fresh attempt (as the
  driver does). Drive `_execute_leaf` with a stateful script that returns no `COMMAND_RESULT` on both
  calls and assert it terminates via `_TrialAborted` with the node `INFEASIBLE`; or call
  `authorise_acceptance` with a failing visible bundle twice on two attempts and assert
  `evaluate_repeated_failure(..., replan_material_change=True)` never emits `REPLAN_REQUESTED` from
  `REPLAN_REQUIRED` (it should mark the node `INFEASIBLE` when there is no material change).
- **Maps to:** R10.

### F2 — P2 — R13: `oracle_grades()` reports `FAIL` for a non-gradeable (infrastructure/timeout) outcome

- **Invariant (R13, in-scope guarantee 3):** "the grading record is durable with its outcome categories
  (infrastructure and timeout not collapsed to booleans)."
- **Observation:** the categories *are* preserved in `versions.initial_outcomes` /
  `versions.effective_outcomes` (verified), but the headline `outcome` field that
  `observability.ObservabilityBackend.oracle_grades` derives from the boolean `checks` collapses a
  non-gradeable outcome to `FAIL` (`src/orchestrator/observability.py:242-246`).
- **Reproducer** (`/tmp/kilo/measurement-probes/probe_r13.py`, `DIRECT` seed 1004,
  `ORACLE_INFRASTRUCTURE`):

  ```bash
  /home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python \
      /tmp/kilo/measurement-probes/probe_r13.py
  ```

- **Observed:** `initial_outcomes.hidden-parse = "ORACLE_INFRASTRUCTURE_ERROR"`,
  `trial_classification = "INDETERMINATE"`, yet `oracle_grades()[0]["outcome"] == "FAIL"`.
- **Expected:** a consumer of the durable grade should not read an infrastructure error (or a candidate
  timeout) as a candidate failure from the headline field. The raw categories survive, so this is a
  projection defect, not a durability defect.
- **Proposed regression test:** for the `ORACLE_INFRASTRUCTURE` seed, assert the reconstructed grade's
  reported outcome reflects the non-gradeable category (or is omitted / `INDETERMINATE`), not `FAIL`.
- **Maps to:** R13.

### F3 — P2 — R14: recovery of a run that became terminal after a crash leaves an orphan child budget

- **Invariant (R14):** "recovery reconciles unfinished controller-owned consequences … and never
  resurrects work for a terminal run."
- **Observation:** `_recover_decompositions` correctly returns early when `state.outcome is not None`
  (`src/orchestrator/controller.py:2402-2406`), so no child is resurrected — but a decomposition that
  crashed after `DECOMPOSITION_ADMITTED` registered the child budget and before the child node events
  leaves that budget with no node, and `orphan_child_budget_violations`
  (`tests/invariants.py:167-178`) still fires after recovery.
- **Reproducer** (`/tmp/kilo/measurement-probes/probe_r14.py`, scenario C):

  ```bash
  /home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python \
      /tmp/kilo/measurement-probes/probe_r14.py
  ```

- **Observed:** after recovery of a `CANCELLED` run:
  `orphan child budgets after recovery: ["child budget 'R14-T-child-budget' for node 'R14-T-child' has no node"]`.
- **Expected:** either the orphan budget is reclaimed/accounted for a terminal run, or the orphan-budget
  invariant is explicitly scoped to non-terminal runs.
- **Reachability:** requires a terminal event to be admitted after the crash but before `recover`, which
  the normal restart path never does (recovery runs first and completes the decomposition). Low severity.
- **Maps to:** R14.

---

## 3. Claims verified

Every in-scope guarantee was attacked; the following were **not falsified**. Probe outputs are quoted.

### R08 — evaluator isolation

- **Expected-value reachability sweep** (`/tmp/kilo/measurement-probes/probe_r08_sweep.py`): a driver run
  through the *real* `hidden_runner` collector/plan swept `os.environ`, `sys.argv`, `/proc/self/cmdline`,
  `/proc/<parent>/{cmdline,environ,maps,mem}`, `/work`, `/tmp`, `/etc` for the serialised expected values,
  check ids, and a sentinel. The needles were base64-encoded into the driver so the search string itself
  could not false-positive. **Result:** the only hits were `"REPORT: "` inside the candidate's *own*
  solution file and the visible test — i.e. the candidate's own source, not controller-side expected
  values. No expected value, check id, or `_HIDDEN_EXPECTED` marker was reachable from inside the
  sandbox. The grade store is not mounted into the sandbox (the sandbox root contains only `/work` and
  the toolchain mounts; the sandbox runs in its own PID namespace, so the controller is not visible).
- **Forge / suppress / early-exit / flood** (`/tmp/kilo/measurement-probes/probe_r08_forge.py`, plus the
  shipped `tests/test_r08_evaluator_isolation.py`): an `atexit`-forged trailing `DRIVER:` line, an
  `os._exit(0)` inside the called function, and `sys.stdout` replacement all return `FAIL`; the correct
  candidate returns `PASS` (anti-vacuity). `hidden_runner` takes the last `DRIVER:` line, but a candidate
  cannot place a *correct* line without already knowing the expected values.
- **Residual (known, documented):** a candidate that already knows the hidden expected outputs can
  hard-code them; the collector embeds the driver (inputs and call shape) as a Python literal in its
  argv. This is the documented residual of R08 and is unchanged by this revision.

### R10 — retry/repair identity and boundedness

- **Cycle identity differs per cycle:** a repaired node that fails once and then succeeds produces
  `validate-start-<node>-1` and `validate-start-<node>-2` and reaches `ACCEPTED`
  (`VALIDATION_STARTED keys: [...-1, ...-2]`). Verified.
- **Model review runs once per leaf:** `_execute_leaf` calls `_model_review` only on `cycle == 0`
  (`src/orchestrator/experiment.py:2149-2174`); `_execute_leaf_batch` reviews each node once and falls
  back to `_execute_leaf(..., review=False)`. Retries re-run only the deterministic executor action, not a
  paid model call. Verified by inspection and by the batch/retry tests.
- **Frozen result-rejection path reaches a recorded terminal outcome:** `EXP-DIRECT-1003` records
  `REPLAN_REQUESTED` from `READY` and `NODE_MARKED_INFEASIBLE`, ending `INFEASIBLE`
  (`outcome='INFEASIBLE'`, `classification='CORRECTLY_UNRESOLVED'`). Verified by event-log dump.
- **Bounded:** `max_cycles = retries_per_action_lineage = 2`. Verified.
- **Not falsified / documented shape:** for a decomposed arm with a permanently failing child, the child
  is terminal `INFEASIBLE` and the root stays `BLOCKED` with `controller_outcome=None`
  (`probe_r10_child.py`); the brief's R10 attack explicitly names this shape ("child terminal with the
  root blocked") and the shipped milestone-6 test asserts it, so it is not counted as a falsification.
  The remaining `render` node is `READY` (abandoned), which is the same "live run" concern as F1 but is
  the documented expectation; noted as residual risk in §4.
- **Falsified for the validation-failure branch:** see F1.

### R13 — grade persistence, reconstruction, and separation

- **Durable and reconstructable:** for `DIRECT` seeds 1001/1003/1004, `reconstruct_grade` and
  `reconstruct_classification` from a reopened store reproduce the in-memory grade and
  `TrialMetrics.classification` exactly (`PASS`/`CORRECT_ACCEPTANCE`, `FAIL`/`CORRECTLY_UNRESOLVED`,
  `ORACLE_INFRASTRUCTURE_ERROR`/`INDETERMINATE`). Verified.
- **Categories survive:** `initial_outcomes` and `effective_outcomes` preserve
  `ORACLE_INFRASTRUCTURE_ERROR`; `rerun_eligible=("hidden-parse",)`, `rerun_spent=True`. Verified.
- **Mutation reflects the durable record exactly:** editing the persisted grading payload's
  `initial_outcomes`, `classification`, and `manifest_hash` in SQLite and reopening yields exactly the
  mutated outcomes/classification/hash (`probe_r13.py`). The reconstruction is a faithful projection of
  the store.
- **Grading separate from acceptance:** hidden grading evidence is admitted with
  `check_class="HIDDEN"` and `authorise_acceptance` requires `VISIBLE`; the hidden grade evidence does not
  mutate acceptance. Verified.
- **RESTRICTED classification:** hidden grading evidence is classified `RESTRICTED`; searching every
  non-restricted projection (`run_history`, `nodes`, `attempts`, `ledger`, VISIBLE evidence) for the
  expected values produced no leaks. Verified.
- **Partial:** the headline `outcome` collapses non-gradeable categories — see F2. Note also that
  `reconstruct_classification` returns the *stored* classification rather than re-deriving it from the
  recorded outcomes, so a store whose outcomes and classification disagree is not detected; this is a
  design observation, not a stated requirement.

### R14 — crash recovery of derived consequences

- **Derived cancellation:** crashing before `CANCELLATION_CONFIRMED` after
  `BUDGET_EXHAUSTION_RECORDED` leaves the originating event durable; recovery reconciles the attempt to
  `CANCELLED`/`FINALLY_SETTLED`, does not redispatch (`dispatches == 0`), and a second `recover` is
  idempotent (`12 → 12` events). Verified (`probe_r14.py` scenario A).
- **Derived artefact rejection:** crashing before `ARTEFACT_REJECTED` after
  `SANDBOX_VIOLATION_RECORDED` leaves the artefact a candidate; recovery rejects it, no redispatch,
  second `recover` idempotent (`10 → 10`). Verified (scenario B).
- **Replay and recovery agree:** `store.replay_fresh(run_id)` equals the recovered `state(run_id)` after
  both scenarios. Verified.
- **Terminal run not resurrected:** recovery of a `CANCELLED` run does not introduce the interrupted
  child. Verified (scenario C) — with the orphan-budget caveat in F3.
- The shipped crash matrix (`tests/test_crash_matrix.py`) crashes before commit at *every* event index of
  the accept/decomposition/timeout/cancel/root-replacement/budget-exhaustion workflows and asserts the
  recovery invariants, no redispatch, and idempotent double recovery; it is green.

---

## 4. Residual unknowns

- **F1 reachability in a real (non-frozen) run.** The frozen `CommandExecutor` never produces an
  admitted-but-visibly-failed result, so F1 does not affect the four calibrated arms. Any future arm
  whose executor can return `exit_code == 0` with a non-zero `signal`, or no `COMMAND_RESULT`, will hit
  it. I did not construct a real `CommandExecutor` response that both admits and fails the visible
  checker without editing source.
- **Concurrent validation cycles for one node.** `_validation_cycle` reads history outside the admission
  lock, so two concurrent `authorise_acceptance` calls for the same node could compute the same cycle
  index and collide on `validate-start-<node>-<n>`. The experiment driver is sequential and I did not
  build a concurrency harness; this is the same class of read-decide-emit race flagged elsewhere (R16)
  and remains untested here.
- **R14 orphan budget (F3)** requires a terminal event between crash and recovery; I did not find a
  production path that does this.
- **Budget-accounting laundering** was not re-attacked beyond the shipped `_assert_no_laundered_actual`
  crash-matrix check, which is green.

---

## 5. Reachability audit

| Attack | Reachable? | Evidence |
|---|---|---|
| R08 expected values from inside the sandbox | No | sweep found only candidate's own source; store not mounted; PID namespace hides controller |
| R08 forge / suppress / early-exit / flood / shadow module | No | all `FAIL`; correct candidate `PASS` |
| R10 second validation failure (new attempt per cycle) | Yes (API); not by frozen arms | `UnknownTransition` from `REPLAN_REQUIRED` — F1 |
| R10 result-rejection repeated failure | Yes | `EXP-DIRECT-1003` → `INFEASIBLE`, `CORRECTLY_UNRESOLVED` |
| R10 repaired node re-validates under a fresh cycle | Yes | `validate-start-...-1/-2`, node `ACCEPTED` |
| R10 child terminal + root blocked | Yes (documented) | `probe_r10_child.py`; milestone-6 test asserts it |
| R13 durable/reconstructable grade | Yes | all three seeds reproduce exactly |
| R13 headline outcome for infra/timeout | Yes | `oracle_grades()[0]["outcome"] == "FAIL"` — F2 |
| R13 RESTRICTED hidden evidence | Yes | no leaks in non-restricted projections |
| R13 mutation reflected in reconstruction | Yes | SQLite edit reproduced exactly |
| R14 derived cancellation / artefact rejection | Yes | reconciled, idempotent, no redispatch, replay agrees |
| R14 terminal run orphan child budget | Yes (contrived) | `orphan_child_budget_violations` fires — F3 |

---

## 6. Reproduce everything

```bash
# Baseline (frozen worktree)
git worktree add --detach /tmp/kilo/measurement-review-3e63e3a 3e63e3a
cd /tmp/kilo/measurement-review-3e63e3a
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python -m pytest -q   # 517 passed

# R08 — expected-value reachability sweep (real hidden_runner plan)
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python /tmp/kilo/measurement-probes/probe_r08_sweep.py
# R08 — forge / suppress / early-exit
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python /tmp/kilo/measurement-probes/probe_r08_forge.py

# R10 — child-failure shape across arms
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python /tmp/kilo/measurement-probes/probe_r10_child.py
# R10 — F1: controller-level two-cycle ordering
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python /tmp/kilo/measurement-probes/probe_r10_two_cycle.py
# R10 — F1: through the real experiment driver (_execute_leaf)
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python /tmp/kilo/measurement-probes/probe_r10_driver_crash.py

# R13 — persistence / reconstruction / categories / RESTRICTED / mutation
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python /tmp/kilo/measurement-probes/probe_r13.py

# R14 — derived consequences, double recovery, replay agreement, terminal run
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python /tmp/kilo/measurement-probes/probe_r14.py
```

Probe scripts: `/tmp/kilo/measurement-probes/*.py`. Temporary trees created by the probes are removed
after the run; no orphan processes or sandbox cgroups were left behind (verified with `ps` and
`/sys/fs/cgroup`).

---

## 7. Re-verification against `6978d5f`

`6978d5f` ("Fix the MEASUREMENT-gate review findings (F1-F3)") changes three files plus tests:
`src/orchestrator/experiment.py` (`_accept` branches on the node's actual state before calling
`evaluate_repeated_failure`), `src/orchestrator/observability.py` (headline grade outcome derived from the
persisted `effective_outcomes` categories), and `tests/invariants.py` (the orphan-child-budget invariant
is scoped to non-terminal runs). New regression tests: `tests/test_batch5_retry.py` (fresh attempt per
cycle → `_TrialAborted` + node/run `INFEASIBLE`), `tests/test_batch6_grade_projection.py` (infrastructure
and timeout report `INDETERMINATE`, PASS/FAIL unchanged), and `tests/test_batch5_recovery.py` (terminal run
leaves no child and no orphan budget).

### Results

| Finding | Status on `6978d5f` | Evidence |
|---|---|---|
| F1 (P1, R10) | **Closed** | `probe_r10_driver_crash.py` → `RAISED orchestrator.experiment._TrialAborted`, `is _TrialAborted: True`, `node = INFEASIBLE outcome = INFEASIBLE`, 2 attempts. The fix's own regression test (`test_two_cycle_validation_failure_reaches_terminal_infeasible`) asserts the same. |
| F2 (P2, R13) | **Closed** | `probe_r13.py` seed 1004 now reports `oracle_grades()[0]["outcome"] == "INDETERMINATE"` (was `"FAIL"`), with `initial_outcomes`/`effective_outcomes` still carrying `ORACLE_INFRASTRUCTURE_ERROR`; seeds 1001/1003 still report `PASS`/`FAIL`. |
| F3 (P2, R14) | **Closed** | `probe_r14.py` scenario C: `orphan child budgets after recovery: []` and the child is still not resurrected for the `CANCELLED` run. Scenarios A and B unchanged (reconciled, idempotent, no redispatch). |

### Regression sweep (probes re-run on `6978d5f`)

- **R08:** reachability sweep still finds no expected value, check id, or `_HIDDEN_EXPECTED` marker
  reachable from inside the sandbox (only the candidate's own `"REPORT: "` source text); forge / atexit /
  `os._exit` / stdout-suppression all `FAIL`, correct candidate `PASS`.
- **R10:** `DIRECT` seed 1003 still `INFEASIBLE` / `CORRECTLY_UNRESOLVED`; the decomposed child-failure
  shape is unchanged (child `INFEASIBLE`, root `BLOCKED`, `controller_outcome=None`), matching the
  documented expectation. The repaired-node success path still emits distinct cycle identities
  (`...-1`, `...-2`) and reaches `ACCEPTED`.
- **R13:** grades reconstruct exactly across the three seeds; hidden grading evidence stays `RESTRICTED`
  with no leaks in non-restricted projections; a SQLite mutation of the persisted grade is still reflected
  exactly.
- **R14:** derived cancellation and artefact rejection reconciled, double recovery idempotent
  (`12→12`, `10→10`), `replay_fresh == state`, zero recovery dispatches.

### Residual (non-blocking, unchanged by the fix)

The low-level `Controller.evaluate_repeated_failure(..., replan_material_change=True)` still raises
`UnknownTransition` when called while the node is already `REPLAN_REQUIRED` — the driver no longer makes
that call (`_accept` branches, `_advance_repair` passes `False`), and no other production caller does
(`conformance.py` calls it from `READY`). A defensive guard inside `evaluate_repeated_failure` (treating
"already `REPLAN_REQUIRED` + material change" as a no-op or `READY` transition) would harden the API
against a future caller, but it is not required by R10 as exercised.

### Reproduce the re-verification

```bash
git worktree add --detach /tmp/kilo/measurement-review-6978d5f 6978d5f
cd /tmp/kilo/measurement-review-6978d5f
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python -m pytest -q          # 522 passed
PATH="/home/ruben/Projectos/meta-project/orchestrator/.venv/bin:$PATH" scripts/check-static   # rc 0
scripts/check-docs                                                                     # 164 links OK

# Original probes, re-pointed at 6978d5f:
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python /tmp/kilo/measurement-probes-6978d5f/probe_r10_driver_crash.py
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python /tmp/kilo/measurement-probes-6978d5f/probe_r13.py
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python /tmp/kilo/measurement-probes-6978d5f/probe_r14.py
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python /tmp/kilo/measurement-probes-6978d5f/probe_r08_sweep.py
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python /tmp/kilo/measurement-probes-6978d5f/probe_r08_forge.py
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python /tmp/kilo/measurement-probes-6978d5f/probe_r10_child.py
```
