<!-- informative -->

# SPEND-Gate Re-Verification — `3533c41` (N1/N2 re-confirmed on `786e90c`)

Independent re-verification of the SPEND gate on current `main`, per
[Reviewer Brief: SPEND-Gate Re-Verification](spend-gate-reverification-brief.md). This replaces the
NO-GO verdict of the [original SPEND review](spend-gate-adversarial-review.md) for the current
revision.

- Repo: `/home/ruben/Projectos/meta-project/orchestrator`
- Revision reviewed: `3533c41` (`3533c41ab9334dde59db23ffdd2b94604d24c6f0`), frozen worktree
  `/tmp/kilo/spend-reverify-3533c41`.
- Corrective revision for the two new findings: `786e90c` (frozen worktree
  `/tmp/kilo/spend-reverify-786e90c`), in which N1 is fixed and N2 is doc-only. Re-confirmation in
  §4.1.
- Original revision reviewed: `9e94357`. Fix commit: `9e657e5`. Later boundary-touching commits
  re-checked: `97c1891`, `d24c505`, `33945bb`, `85959ad`, `8ba7530`, `a9e6ba9`, `a2f0d86`.
- Independence: the re-verifier did not author `9e657e5`, `786e90c`, or any commit touching the
  spend boundary (`Ledger`, `ModelAdapter`, `spend.py`, run-limit enforcement, experiment spend
  gate), and did not perform the original SPEND review. The fix commit messages and the
  implementer's regression tests were treated as claims only; every finding was re-attacked from
  source.
- Baseline: `.venv/bin/python -m pytest -q` in the `3533c41` frozen worktree → **530 passed in
  90.11s**; in the `786e90c` frozen worktree → **531 passed in 164.29s**. A green suite is not a
  verdict.
- No paid calls, no network, no source edits; synthetic in-process clients and local fixtures only.

---

## 1. Verdict

**GO for the SPEND gate on `3533c41`** for a tiny, explicitly capped, owner-authorised smoke test:
all four original P1 falsifications and all P2 findings except the deferred F6 residual are
re-verified closed, the experiment-wide cap and its gate/entry guarantees hold, and the only open
residual (F6, one under-declared call overshooting the aggregate token ceiling) is bounded by one
call and does not pierce the owner-authorised monetary ceiling, so it does not block the gate under
the cap stated in §3.

The "GO" was scoped on `3533c41`: it was not a claim that token ceilings are airtight. F6 remains a
pinned residual. The one new low-severity single-flight gap found there (N1, §4) was re-confirmed
**closed on `786e90c`** (§4.1), as was the doc-only N2.

---

## 2. Per-finding re-verification

Legend: **closed** = original falsification no longer reproduces; **open** = still reproduces;
**residual** = materially narrowed, cannot be fully closed without a contract change.

| Finding | Re-verification method | Observed on `3533c41` | Status |
| --- | --- | --- | --- |
| F1 single-flight under malformed completion | `/tmp/kilo/spend-reverify/spend_adapter_probe_reverify.py`: two threads rendezvous on a barrier, one `(attempt_id, token)`; client's first `complete` returns NaN cost, then unknown units; control returns valid | NaN: `results=[('raise','ModelBudgetRefused'),('raise','ModelBudgetRefused')] client.calls=1`. Unknown units: same, `client.calls=1`. Control: `[('ok','COMPLETED'),('ok','COMPLETED')] client.calls=1` | **closed** |
| F2 cancellation/budget-exhaustion laundering | `/tmp/kilo/spend-reverify/spend_cancel_launder_probe.py` (recover vs cancel after a durably admitted `actual=9.0`, commitment 5.0, budget 10.0); plus a derived `BUDGET_EXHAUSTION_RECORDED` cancel | recover: `total_charged=9.0 total_overrun=4.0 available=1.0`; cancel: `total_charged=9.0 total_overrun=4.0 available=1.0`; derived exhaustion: `total_charged=9.0 overrun=4.0 attempt=CANCELLED accounting=FINALLY_SETTLED` | **closed** |
| F3 `Ledger.transfer` moves spent budget | `/tmp/kilo/spend-reverify/spend_transfer_overcommit_probe.py` and `spend_ledger_probe.py` cases B/C | settle 8.0, then transfer 10.0 → `OvercommitmentError` wrapped as `ReducerError` at `ROOT_REPLACED` admission: `only 2.0 … remains unspent`; fully-spent source transfers `0.0` only | **closed** |
| F4 fabricated inline acceptance evidence | `/tmp/kilo/spend-reverify/spend_acceptance_probe.py` through the real reducer and `EventStore` | all direct-event variants refused: `fabricated-inline-checks`, `fabricated-inline-failing`, `inline-garbage-checks`, `inline-empty-checks`, `missing-acceptance-id`, `fabricated-result-id` → `ReducerError: ACCEPTANCE_AUTHORISED requires admitted evidence_ids …`; `foreign-unknown-evidence` → `references unknown evidence`. Store-level bypass raises | **closed** |
| F5 `run_trial` without an experiment reservation | `/tmp/kilo/spend-reverify/spend_runtrial_probe.py`; `spend_misc_attacks.py` attack A | signature is `run_trial(..., *, spend_ledger: ExperimentSpendLedger)` (no default); passing `None` raises before any durable state; over-cap ledger refuses `reserve` and the trial directory is never created (`durable trial dir exists: False`, in-flight `{}`) | **closed** |
| F6 `(0,0)` declared ceiling overshoot; no `limits` unbounded | `/tmp/kilo/spend-reverify/spend_controller_limits_probe.py`; `spend_adapter_probe_reverify.py` | no `limits` → `call1:REFUSED`, `client_calls=0` (unbounded half **closed**). limit 100 with a `(0,0)` client reporting 100/call → `['call1:OK','call2:OK','call3:REFUSED(RunLimitExhausted)']`, `consumed=200`, `client_calls=2` (one-call overshoot **open**) | **residual** |
| F7 token/money conflation in completion units | `spend_adapter_probe_reverify.py` units block | `USD`/`COST_UNITS` accepted (`COMPLETED`); `TOKENS`, `MODEL_TOKENS`, `bananas`, `""` → `ModelBudgetRefused` | **closed** |
| F8 lost update / shared temp file | `/tmp/kilo/spend-reverify/spend_lostupdate_probe.py` (two processes, `multiprocessing.Barrier`) and `spend_durable_probe.py` case 8 (four processes) | two-process: `{'t1':'reserved','t0':'refused SpendCapExceeded'}`, held `8.0` of `10.0`; four-process: one reserved, three refused; no `FileNotFoundError`; ledger parses cleanly | **closed** |
| F9 settle on a tolerance boundary | inline parametrisation over `delta ∈ {0, 1e-12, 5e-10, 1e-9, 2e-9, 1e-6}` with `reclamation=0` | `delta ≤ 1e-9` settles with no exception; `delta > 1e-9` takes the overrun branch (overrun visible); under-spend reclamation still enforced (`actual=4.0 reclaim=0.0` refused) | **closed** |
| F10 freeze hash drift for sets/bytearrays | `/tmp/kilo/spend-reverify/spend_frozen_probe.py` | nested dict/list/set: `pre == post` (`sha256:c20d…`), `equal: True`; scalars stable; `bytearray` normalised to immutable `bytes` (item assignment raises `TypeError`); manifest hash stable | **closed** |
| F11 ledger has no tamper evidence | `spend_durable_probe.py` case 7; `spend_misc_attacks.py` attack C2 | editing `experiment-spend.json` and reopening with the matching widened authorisation yields `available=999993.0` | **unchanged (informational)** |
| claim 5 dispatched prompt digest | `spend_adapter_probe_reverify.py` digest block | `sha256:unset` refused; digest of a different prompt refused; honest digest accepted | **closed** (for a dispatched prompt with content) |

### Gate and entry guarantees

| Guarantee | Method | Result |
| --- | --- | --- |
| `run_experiment` requires an owner authorisation | signature inspect; `spend_durable_probe.py` | `*`, `authorization` mandatory; opens the durable ledger first |
| `run_pilots` / `run_measured_comparison` require the ledger | signature inspect | `*`, `spend_ledger` mandatory (no default) |
| Experiment cap spans pilots, retries, in-flight reservations | `spend_durable_probe.py` cases 1–3 | second over-cap trial refused; in-flight reservation survives restart and keeps counting |
| Cap is restart-safe | `spend_misc_attacks.py` attack B | restart: `committed=4.0 reserved=3.0 available=3.0` unchanged |
| An over-cap trial cannot start | `spend_misc_attacks.py` attack A | refused before `os.makedirs`; no durable trial state |
| A changed authorisation on an existing directory is refused | `spend_misc_attacks.py` attack C | widened limit, changed owner, changed `authorized_at`, changed `method` all refused |

### Probe adaptations (recorded)

The original probes hard-code the main-repo `src` path and one uses a placeholder prompt digest.
Adaptations, applied only through copies under `/tmp/kilo/spend-reverify/`:

1. `sys.path.insert` retargeted to `/tmp/kilo/spend-reverify-3533c41/src` in every probe.
2. `spend_adapter_probe_reverify.py` computes the honest `sha256` digest of `base_request`'s prompt.
   The unadapted probe now fails every case with
   `ModelBudgetRefused: prompt_hash does not describe the prompt being dispatched`, because the
   claim-5 fix correctly refuses its placeholder `"sha256:abc"`. The rewrite only supplies an honest
   digest so the other boundaries are reachable; it does not weaken any assertion.
3. `spend_acceptance_probe.py`'s final store-level case now terminates in an uncaught
   `ReducerError` instead of printing `ADMITTED`: the bypass it asserts is the one that is fixed.
4. `spend_overrun_probe.py`'s "ACTUAL is additive" block passes `reclamation=0.0` for an under-spend
   (`actual=4.0`, commitment `5.0`), which the ledger has always rejected; this is a probe artefact,
   not a regression (the tolerance sweep replaces it).
5. `spend_runtrial_probe.py` passes `spend_ledger=None` explicitly; with the required keyword this
   raises `AttributeError` before any durable state, which is the intended fail-closed outcome.

---

## 3. F6 decision

**F6 does not block the SPEND gate for a tiny, explicitly capped, owner-authorised smoke test.**

What F6 is, precisely: the shipped `ExperimentModelClient` does not override `max_tokens`, so it
declares `(0, 0)`. The controller's pre-dispatch check is `consumed + required > limit`
(`controller.py:198`, `_enforce_run_limits`); with `required = 0` it only refuses once `consumed` is
already strictly greater than the ceiling. The `d24c505` fix closes the "no `limits` ⇒ unbounded"
half by refusing a model action whose run does not configure `root_model_input_tokens` and
`root_model_output_tokens`, but the last billable call before refusal is not bounded: with a ceiling
of 100 and a client reporting 100/call, the observed sequence is `call1:OK, call2:OK, call3:REFUSED`
with `consumed=200`. Exposure is therefore **at most one undeclared call per run**.

Why it does not block a capped smoke test:

- The token ceiling is not the spend ceiling. The authoritative money bounds are the per-run
  `Ledger` (`MODEL_COST` budget) and the durable experiment `ExperimentSpendLedger`. `run_trial`
  reserves `limits.model_cost` before any durable trial state and settles the authoritative
  `state.ledger.total_charged`; the cap spans pilots, retries, and in-flight reservations and
  survives restart (verified). The one-call token overshoot does not create a reservation, so it
  cannot enlarge the owner-authorised monetary ceiling.
- The overshoot call is money-bounded before dispatch: the adapter refuses `max_cost > commitment`,
  and `plan_attempt` refuses `amount > min(available, commitment)`. With the shipped profile the
  extra call's declared maximum is `cost_per_call = 1.0 COST_UNITS` against
  `per_attempt_commitment = 5.0` and `model_cost = 100.0`.
- The shipped `ExperimentModelClient` reports fixed usage (100 input, 20 output tokens, 1.0
  `COST_UNITS` per call) and a catalogued unit, so the overshoot is deterministic and bounded.

**Residual exposure in cost terms.** For the shipped frozen experiment, at most one extra model
call per run: ≤ 100 input + 20 output tokens and ≤ 1.0 `COST_UNITS` per run, i.e. bounded by the
per-attempt commitment (5.0 `COST_UNITS`) in the worst case that the client's declared max equals
its commitment. For an untrusted client that declares `(0, 0)` and reports unbounded token usage,
the *token/resource* overshoot is not bounded by this review, but the *money* charge remains capped
by the pre-dispatch commitment check and the run budget; only reported overruns beyond the
commitment are retained as liability.

**Cap under which the exposure is acceptable.** A tiny smoke test is acceptable if the owner cap
carries one extra call of headroom per trial — i.e. cap ≥ Σ over trials of
`(limits.model_cost + limits.per_attempt_commitment)` — and the owner accepts that the aggregate
token ceiling may be exceeded by one call per run. Under the shipped defaults that is an extra
`1.0 COST_UNITS` (and 120 tokens) per run.

**Minimal condition to close it** (both change the frozen calibration contract, so they are
deliberately deferred): either the client declares a per-call token ceiling
(`ModelClient.max_tokens`) that the controller can reserve before dispatch, or the calibration adds
headroom of one call to `root_model_input_tokens` / `root_model_output_tokens`.

---

## 4. New findings

### N1 — P3 (informational) — single-flight does not cache a completion that *raises* — **closed on `786e90c`**

- Status: **re-falsified on `3533c41`, re-verified closed on `786e90c`** (§4.1). The `786e90c` fix
  caches a raised completion as a failure under the attempt/token (`model_adapter.py:_failures`) and
  re-raises it for later deliveries, so exactly one invocation occurs.
- Invariant challenged: "two concurrent deliveries of one `(attempt_id, token)` invoke the
  client/executor exactly once" (in-scope claim 1).
- Cause on `3533c41`: the F1 fix cached the raw completion (`model_adapter.py:530-533`), but only once
  `client.complete()` *returns*. If it raised, nothing was cached and the waiting concurrent delivery
  invoked the client again.
- Minimal reproducer:
  ```
  /home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python - <<'PY'
  import hashlib, sys, threading
  sys.path.insert(0, "/tmp/kilo/spend-reverify-3533c41/src")
  from orchestrator.model_adapter import ModelAdapter, ModelClient, ModelCompletion, ModelOutput
  def digest(p): return "sha256:" + hashlib.sha256(p.encode()).hexdigest()
  prompt = "goal: do the task"
  req = {"run_id":"R1","action_id":"A1","attempt_id":"ATT-1","attempt_token":"tok-1",
         "node_id":"N1","action_type":"REVIEW","resolved_inputs":[],
         "budget_commitment":{"dimension":"MODEL_COST","hard_limit":5.0},
         "prompt":prompt,"prompt_hash":digest(prompt),
         "max_input_tokens":100,"max_output_tokens":100}
  class Flaky(ModelClient):
      def __init__(self): self.calls=0; self.lock=threading.Lock()
      def max_cost(self,r): return 1.0
      def max_tokens(self,r): return (10,10)
      def complete(self,r):
          with self.lock:
              self.calls+=1; first=self.calls==1
          if first: raise RuntimeError("transport error")
          return ModelCompletion(outputs=(ModelOutput("SEMANTIC_EVALUATION",
              {"subject_reference":"N1","verdict":"PASS","rationale":"r"}),),
              cost=1.0,units="USD",model_id="m",model_version="1",
              input_tokens=10,output_tokens=10)
  c=Flaky(); a=ModelAdapter(c, model_id="m", model_version="1"); a._tokens["ATT-1"]="tok-1"
  b=threading.Barrier(2); out=[]
  def w():
      b.wait()
      try: out.append(("ok", a.dispatch(req)["self_reported_status"]))
      except Exception as e: out.append(("raise", type(e).__name__))
  ts=[threading.Thread(target=w) for _ in range(2)]
  [t.start() for t in ts]; [t.join() for t in ts]
  print(out, c.calls)
  PY
  ```
- Observed on `3533c41`: `[('raise', 'RuntimeError'), ('ok', 'COMPLETED')] 2`.
- Expected: one client invocation for one `(attempt_id, token)`; if transport-error retry is
  intended, it must be explicit and controller-driven, not an uncontrolled duplicate.
- Assessment: did not re-open the F1 P1 (post-call *validation* failure is cached and gives
  `client.calls=1`). It mattered only for a provider that bills a request that then fails at the
  transport layer; the controller cancels the attempt after the first failure and the request carries
  `call_id`/`call_key` for provider-side idempotency, so the practical exposure was
  provider-dependent. The `786e90c` fix removes the duplicate invocation regardless of provider
  semantics.
- Proposed regression test: extend the single-flight test with a client whose first `complete` raises
  and assert a single invocation. Adopted as
  `tests/test_single_flight_concurrency.py::test_single_flight_holds_when_the_completion_raises`.

### N2 — P4 (trivial) — stale reducer docstring — **closed on `786e90c`**

On `3533c41`, `reducer.py:284-291` still stated the evidence form is "either admitted `evidence_ids`
or a legacy inline `evidence` mapping; both must carry a nonempty check set", while inline `checks`
alone was now refused (`reducer.py:296-303`). The `786e90c` doc-only edit corrects it to "Only
admitted `evidence_ids` referencing node-owned evidence records satisfy it; an inline checks list is
a declaration, not evidence, and is refused" (`reducer.py:288-291`). No behaviour change.

### 4.1 Re-confirmation on `786e90c`

Frozen worktree `/tmp/kilo/spend-reverify-786e90c` at
`786e90cf96aee823b90d78143742e42317ee9df5`. The N1 reproducer (unchanged) now reports:

```
cd /tmp/kilo/spend-reverify
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python spend_n1_reconfirm.py
# results = [('raise', 'RuntimeError'), ('raise', 'RuntimeError')] client.calls = 1
# sequential re-delivery: RuntimeError client.calls = 1
```

A stress variant with 2, 5, and 16 simultaneous deliveries of one `(attempt_id, token)` gives
`calls=1` and `outcomes=['RuntimeError']` in each case. The F1/F7/claim-5 adapter probe and the full
suite re-run clean on `786e90c` (`531 passed`; single-flight file `4 passed`). N2 is doc-only and the
docstring now matches the guard. No other finding is affected by `786e90c`.

---

## 5. Regression check (later commits did not re-open earlier SPEND findings)

Re-ran every original probe against `3533c41`, which includes `97c1891`, `d24c505`, the EXECUTION
fixes (`33945bb`, `85959ad`), R10 part 1 (`8ba7530`), R14 (`a9e6ba9`), and Batch 6 (`a2f0d86`).

- **F2 and R14/R10:** `_cancel_attempt` (`controller.py:474`) still captures the dispatched predicate
  before `CANCELLATION_CONFIRMED` and now routes dispatched attempts through
  `_recover_accounting`, preferring `_recorded_actual`. The cancellation probe, the recovery probe,
  and a forced `BUDGET_EXHAUSTION_RECORDED` derived cancel all retain `actual=9.0 / overrun=4.0`.
- **F4 and R10/R09:** `_admit_inline_evidence` still feeds the reducer's `evidence_ids` requirement;
  the reducer guard remains admitted-evidence-only. The R10 cycle-specific `VALIDATION_*` identities
  did not reintroduce an inline acceptance path.
- **F6 and `d24c505`:** the model-action ceiling requirement is present and consistent with
  `MODEL_ACTION_TYPES`; it closed the unbounded half without weakening the one-call-overshoot pin.
- **F7 and the completion-units catalogue:** `d24c505` replaced the substring check with
  `glossary.completion_units()` (`COST_UNITS`, `USD`); the token-shaped/unknown refusal is intact and
  the shipped client's `"COST_UNITS"` is catalogued.
- **F1/F3/F8/F9/F10:** the fix diffs in `model_adapter.py`, `model.py`, and `spend.py` are unchanged
  by later commits; probes still pass.
- No later commit reverts or bypasses a `9e657e5` fix. Full suite on `3533c41`: **530 passed**.

---

## 6. Residual unknowns and not covered

- **F11 tamper evidence.** Editing `experiment-spend.json` and reopening with a matching widened
  authorisation still yields the widened ceiling (C2). Acceptable only under the assumed single-owner
  filesystem threat model; there is no MAC/hash chain.
- **Trusted controller inline evidence.** `validate_and_accept` / `accept_parent` still admit a
  caller-declared inline check list (via `admit_evidence`) and `_normalise_inline_checks` defaults a
  named check to `passed=True`. A caller with controller API access can therefore declare passing
  evidence. This is the trusted in-process boundary, not the direct-event bypass F4 fixed; it was not
  counted as a finding.
- **`_admit_inline_evidence` fixed evidence id.** `f"{node_id}-acceptance-evidence"` is not
  cycle-scoped. A reachable second acceptance for the same node (accepted is terminal) or a
  conflicting re-admission would raise `IdempotencyConflict`; the normal deferred-resume path is
  idempotent and safe. Not exercised end-to-end; flagged for a re-validation-cycle check.
- **Real provider semantics.** All clients are synthetic. Whether a real backend can return a
  non-finite cost, unknown units, or a request that bills then fails at the transport layer is
  provider-dependent; the adapter is the intended defence. The `786e90c` failure cache also means a
  transport-error retry of the *same* attempt/token is permanently refused at the adapter, so
  recovery must use a fresh attempt (as the controller does) rather than re-delivering the token.
- **Cross-host / crash mid-`os.replace`.** Reopen was verified in-process and across processes on the
  same host, not an `fsync`-interrupted `os.replace` on a real network filesystem.
- **Provider-side idempotency.** After `786e90c`, the adapter itself invokes the client once per
  attempt/token even when the call raises; only a provider that bills a request the adapter never
  records could still double-charge across a process crash, which provider-side idempotency on
  `call_id`/`call_key` is expected to cover. Not tested against a real provider.
- **Host/sandbox limits and cgroups (R15).** Out of scope; only the accounting consequence was
  probed.
- **Full frozen experiment end-to-end.** Not run: it needs sandbox capabilities and would execute the
  fixed target. The gate/entry points were exercised structurally (over-cap refusal, required
  arguments, restart, authorisation binding) rather than by a complete paid trial.

---

## 7. Reproduce everything

```
cd /home/ruben/Projectos/meta-project/orchestrator
git worktree add --detach /tmp/kilo/spend-reverify-3533c41 3533c41
mkdir -p /tmp/kilo/spend-reverify
for f in /tmp/kilo/spend_*.py; do
  sed 's#/home/ruben/Projectos/meta-project/orchestrator/src#/tmp/kilo/spend-reverify-3533c41/src#g' \
    "$f" > "/tmp/kilo/spend-reverify/$(basename "$f")"
done

# Baseline (green suite is not a verdict)
cd /tmp/kilo/spend-reverify-3533c41 && \
  /home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python -m pytest -q     # 530 passed

# Original probes, adapted (see §2 "Probe adaptations")
cd /tmp/kilo/spend-reverify
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python spend_ledger_probe.py
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python spend_overrun_probe.py
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python spend_durable_probe.py
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python spend_boundary_probe.py
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python spend_controller_limits_probe.py
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python spend_runtrial_probe.py
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python spend_frozen_probe.py
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python spend_recovery_probe.py
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python spend_cancel_launder_probe.py
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python spend_transfer_overcommit_probe.py
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python spend_lostupdate_probe.py

# Re-verification-specific probes
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python spend_adapter_probe_reverify.py
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python spend_misc_attacks.py

# N1/N2 re-confirmation on the corrective revision
git worktree add --detach /tmp/kilo/spend-reverify-786e90c 786e90c
cd /tmp/kilo/spend-reverify-786e90c && \
  /home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python -m pytest -q     # 531 passed
cd /tmp/kilo/spend-reverify
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python spend_n1_reconfirm.py
```

`spend_acceptance_probe.py` is run as above; its final store-level case now ends in the expected
uncaught `ReducerError`, demonstrating the F4 fix.

No paid calls were made; every client is in-process/synthetic.
