diff --git a/docs/analysis/combined-rate-capability-ledger-2026-06-08.md b/docs/analysis/combined-rate-capability-ledger-2026-06-08.md
new file mode 100644
index 00000000..85f881d0
--- /dev/null
+++ b/docs/analysis/combined-rate-capability-ledger-2026-06-08.md
@@ -0,0 +1,300 @@
+# Combined-rate comprehension organ (R4) — v1 capability ledger
+
+**As of:** `main` @ `3381e031` (after CMB-a…CMB-d, #650–#656). This artifact
+**closes and freezes** the R4 combined-rate v1 claim. It is **docs only — no
+behavior change.** Nothing here adds, widens, or re-enables capability; it
+records exactly what shipped, the lane that proves each piece, and — at least as
+load-bearing — what R4 deliberately does **not** do (§8).
+
+R4 was built down the same fixed ladder as R1/R2/R3, off the sealed serving
+path: gold (ruler) → setup oracle → solver → reader → router/contemplation. No
+rung started before the one below it was green, and the reader was built **last**
+(CMB-c), against an already-proven solver and oracle — never reader-first.
+
+---
+
+## 1. The v1 capability claim (frozen)
+
+> **R4 v1 comprehends and solves a two-rate, single-compound-unit, exact-integer
+> combined-rate problem.** Concretely: two explicit rates each stated as
+> `<N> <plural> per <singular>` over **one shared compound unit**, combined by an
+> **explicitly cued** mode — **sum** (a cooperation cue: *together / combined /
+> both*) or **difference** (an opposing-flow cue: *fills … removes / drains*) —
+> after which it answers exactly one of {**net rate**, **accumulated quantity**,
+> **elapsed time**}, and **only when that answer is an exact positive integer.**
+>
+> Every input outside that envelope is **refused with a typed, closed-set
+> reason — never guessed.** Breadth is never bought with a wrong answer.
+
+**Safety claim (the reason this is allowed to exist).** R4 adds **no** capability
+to the served GSM8K path. The organ and its router/contemplation wiring import
+**neither** `generate.derivation` **nor** `core.reliability_gate` — checked by an
+AST import guard, not asserted (§9). It therefore *cannot, by construction*,
+change a single served answer or perturb the pinned eval-lane SHAs. `answer_wrong
+== 0` on R4's gold lane is held the same way every other organ holds it: by
+refusing everything outside §1, not by widening.
+
+**The envelope, precisely.** A problem is in R4's domain iff a 2-dimensional
+(rate-count × cue) gate admits it:
+
+| rates present | combination cue | outcome |
+|---|---|---|
+| two, same unit | clear sum/difference cue | **solved** (or a solver boundary, §3) |
+| two, same unit | no cue | refuse `combine_mode_ambiguous` (§4) |
+| one rate | combination cue present | refuse `missing_second_rate` (§4) |
+| one rate / foreign | no cue | **step aside** `not_combined_rate_shaped` (→ R3, §7) |
+
+Two same-unit rates make it R4's domain *even with no cue* (the missing direction
+is then the refusal); a single rate needs a combination cue to be R4's
+substantive domain rather than R3's single-rate domain.
+
+---
+
+## 2. Supported solved families
+
+The 6 `solved` gold fixtures are the **complete** `combine_mode × query` grid —
+both modes against all three derived slots — so "solved" means the whole grid, not
+a lucky cell:
+
+| query | sum (cooperation) | difference (opposing flow) |
+|---|---|---|
+| **net rate** (`effective_rate`) | cmb-06 hoses `6+4 = 10` | cmb-05 tank `9-4 = 5` |
+| **quantity** (`eff × time`) | cmb-01 paint `(3+2)×4 = 20` | cmb-02 tank `(5-2)×6 = 18` |
+| **time** (`quantity ÷ eff`) | cmb-03 paint `20÷(3+2) = 4` | cmb-04 tank `18÷(5-2) = 6` |
+
+The algebra is pure integer (`generate/combined_rate_comprehension/solver.py`):
+
+```text
+effective_rate = rate_a + rate_b           (combine_mode == "sum")
+effective_rate = rate_a - rate_b           (combine_mode == "difference")
+quantity       = effective_rate × time     (query == "quantity")
+time           = quantity ÷ effective_rate (query == "time", exact-int or refuse)
+effective_rate                              (query == "effective_rate")
+```
+
+**Model input contract** (`model.py`, the CMB-b wrong=0 fix): `rate_a`, `rate_b`,
+and any *known* time/quantity are **positive ints** — a non-positive input is
+unrepresentable, so the solver can never receive a path that yields a negative
+answer. The *net* rate, by contrast, **may** be `≤ 0` (difference mode with
+`rate_a ≤ rate_b`); that is a derived property and the **solver's** boundary
+(§3), not a malformed setup.
+
+---
+
+## 3. Solver boundaries (refuse, never guess)
+
+The solver (`solver.py`) has exactly **two** refusals — both `must_remain_refused`
+hard boundaries, both pure-integer, no float / no `Fraction`:
+
+- **`non_positive_net_rate`** — a `quantity` or `time` query whose net rate is
+  `≤ 0` cannot accumulate or finish; the solver refuses **before** dividing, so the
+  `eff == 0` time query never divides by zero, and the `eff < 0` quantity query
+  never returns a negative quantity. The `effective_rate` query is *exempt*: the
+  net rate is a well-defined answer even when `≤ 0` (cmb-05 returns the net
+  directly). Proven across all four cells by cmb-07 (`eff=0`/quantity),
+  cmb-07b (`eff<0`/quantity), cmb-07c (`eff=0`/time), cmb-07d (`eff<0`/time).
+- **`non_integer_solution`** — a `time` query that does not divide exactly
+  (cmb-08: `12 ÷ 5`); never rounds.
+
+Namespaced for the registry as `cmb_non_positive_net` / `cmb_non_integer` (§6).
+Both reach `REFUSED_KNOWN_BOUNDARY` in contemplation and — critically — **never a
+proposal**: the prose was understood, the math is simply outside v1, so it is a
+terminal boundary, not a coverage gap.
+
+---
+
+## 4. Reader boundaries (refuse, never guess)
+
+The reader (`reader.py`) emits a **closed** taxonomy of 8 refusal reasons. Two are
+non-substantive **step-asides**; three are **substantive boundaries that must stay
+refused**; three are **deferred capabilities** (§5).
+
+**Step-aside → `input_shape` (not-my-domain; cedes, never blocks):**
+
+- `empty`
+- `not_combined_rate_shaped` — a single explicit rate with no second rate and no
+  combination cue (R3 territory, cmb-15), **or** two same-unit rates whose query
+  attributes the answer to a *single agent* (cmb-16, "how many words does **Alice**
+  type"). R4 must step aside, never claim a substantive boundary on these.
+
+**Substantive boundaries (`must_remain_refused`):**
+
+- **`rate_unit_mismatch`** (cmb-09: rooms/hour vs liters/minute) → family
+  `cmb_unit_mismatch`. **Must remain refused UNTIL a dimension registry exists —
+  *not forever.*** R4 v1 has no representation of dimension, so it cannot
+  distinguish a *convertible* pair (gallons/min vs gallons/hour) from a
+  *dimensionally-incompatible* one; a "try conversion" proposal would be
+  wrong=0-unsafe. A convertible-unit split is named future work, not an
+  impossibility.
+- **`combine_mode_ambiguous`** (cmb-10: two same-unit rates, no licensed cue) →
+  `cmb_combine_ambiguous`. An **ambiguity**, not a coverage gap: no fixture can
+  teach which direction the text intended. Direction is never inferred from vibes.
+- **`missing_second_rate`** (cmb-11: cooperation cue but only one rate) →
+  `cmb_underdetermined`. An **under-specified input**, not a coverage gap: no
+  reader enhancement can invent the unstated rate.
+
+The boundary between §4-substantive and §5-deferred is deliberate and was
+operator-ratified: **proposals are for structural capability gaps, not for
+ambiguous or under-specified inputs.** `combine_mode_ambiguous` and
+`missing_second_rate` are *inputs the world cannot make well-formed*, so they stay
+refused with no growth signal.
+
+---
+
+## 5. Proposal-allowed deferrals (the only growth surfaces)
+
+Exactly **three** reader reasons are growth surfaces. They are emitted **only
+after positive combined-rate recognition** (two real rate clauses + a real
+combination shape), so they are always combined-rate-like — never arbitrary text.
+Each maps to a `proposal_allowed` family targeting `cmb_gold_fixture`:
+
+| reader reason | family | deferred capability |
+|---|---|---|
+| `three_or_more_rates` (cmb-12) | `cmb_unsupported_rate_count` | ≥3 contributing rates; v1 combines exactly two |
+| `reciprocal_work_rate_deferred` (cmb-13) | `cmb_unsupported_reciprocal` | "paint a house in 3 h" → `1/(1/3+1/6)`; reciprocal rates + rational arithmetic |
+| `clock_interval_deferred` (cmb-14) | `cmb_unsupported_clock_interval` | elapsed clock time ("2 pm to 5 pm"); the CMB twin of R3's `temporal_state` |
+
+A proposal here is **proposal-only**: `mounted:false`, `requires_review:true`,
+content-addressed, routed through the existing `teaching/*` HITL flywheel — never
+self-installed, never a parallel correction path.
+
+---
+
+## 6. Router / contemplation integration (CMB-d)
+
+R4 joined the deterministic multi-organ machinery in `core/comprehension_attempt/`:
+
+- **Router** (`route_setup`) now collects **four** attempts (r1 / r2 / r3 / r4)
+  and selects the unique `setup_correct`.
+- **Reason namespacing** (`classify.py::cmb_reason`): the failure registry is keyed
+  by reason-string alone (a partition), so R4's bare reasons are namespaced `cmb_*`
+  **before** the registry sees them. This stops R4 boundaries from inheriting
+  R2/R3 families for the same bare string (R3 `rate_unit_mismatch` → growth;
+  R2/R3 `non_integer_solution` → other owners). The two bare step-aside reasons
+  (`not_combined_rate_shaped`, `empty`) stay bare → the cross `input_shape` family.
+- **Contemplation** (`generate/contemplation/pass_manager.py`) routes a selected
+  R4 organ through `_solve_and_verify_cmb` and lands on a closed terminal:
+  `SOLVED_VERIFIED` · `REFUSED_KNOWN_BOUNDARY` (solver boundary or substantive
+  reader refusal) · `PROPOSAL_EMITTED` (a §5 deferral only).
+- **Router-organ hygiene.** R4 is pinned as an *organ* against R1/R2/R3 foreign
+  gold: on foreign text it must step aside as `input_shape`, never a substantive
+  boundary. (R4 is deliberately **not** in the hygiene test's `_GOLD` set, because
+  a combined-rate problem is *not foreign* to R3 — R3 genuinely co-recognizes the
+  rate clauses. That asymmetry is governed by §7, not by the strict hygiene rule.)
+
+---
+
+## 7. Domain-precedence adjudication (named precedent)
+
+> **A `setup_correct` from a broader organ is not automatically admissible if a
+> more specific organ positively recognizes load-bearing structure that the
+> broader organ would drop.**
+>
+> **Current concrete rule (`router.py::cmb_is_authoritative`):** when R4
+> *positively recognizes* combined-rate shape — either a combined setup, or a
+> *substantive* `cmb_*` refusal (a reason starting `cmb_`) — R4's recognition
+> **beats** R3's single-rate recognition of the same text, for **both** routing
+> (veto R3's `setup_correct`) **and** family attribution (suppress R3 so R4's
+> diagnosis owns the terminal/proposal). The one exception: if R4 merely stepped
+> aside as `input_shape` (`not_combined_rate_shaped`), it cedes and R3 proceeds.
+
+This is the first concrete router adjudication precedent in the comprehension
+stack. It generalizes to any specific↔broad organ pair (geometry+arithmetic,
+unit-conversion+rate, multi-equation+simple-arithmetic): the organ that recognized
+the load-bearing structure adjudicates over the organ that would answer by
+dropping it. R3 itself is **unchanged** — the adjudication lives entirely at the
+router/contemplation layer.
+
+**Proof cases** (pinned in `tests/test_cmb_router_contemplation.py`):
+
+- **cmb-11** (`missing_second_rate`) — a cooperation-cued, one-rate problem. R3
+  would over-read it as a single rate and **solve it wrong (12)**. R4's substantive
+  `cmb_missing_second_rate` recognition **vetoes** R3 → terminal
+  `REFUSED_KNOWN_BOUNDARY` (`cmb_underdetermined`), **never a wrong 12**, and — an
+  under-specified input — **no proposal**.
+- **cmb-15** (`not_combined_rate_shaped`) — a genuine single-rate problem
+  (`60 mph for 3 hours`). R4 merely steps aside (`input_shape`), so it **cedes**;
+  R3 solves the real answer **180**.
+- **cmb-12 / cmb-13 / cmb-14** — combined-rate text R4 positively recognizes but
+  defers (§5). R4 **owns** the proposal attribution; R3's broader single-rate
+  over-read is suppressed so the growth signal is filed under the correct
+  combined-rate family, not a misattributed R3 family. (A safe terminal with the
+  *wrong owner* is still a bad growth signal — hence attribution precedence, kept
+  narrow to R4-positive-recognized text only.)
+
+---
+
+## 8. Non-claims (read this before extending R4)
+
+**R4 v1 does NOT do any of the following.** Each is a hard edge, and "combined
+rate" must never be read more broadly than §1. If a future need touches one of
+these, it is a *new, scoped rung* — not an R4 v1 behavior:
+
+- ❌ **No reciprocal work-rate.** "Paint a house in 3 hours" → `1/(1/3 + 1/6)` is
+  **deferred** (cmb-13), not solved. v1 reads explicit per-unit rates only.
+- ❌ **No three-or-more rates.** v1 combines **exactly two**; ≥3 is deferred
+  (cmb-12).
+- ❌ **No mixed-unit / cross-dimension combination.** Two rates must share one
+  compound unit; incompatible units are **refused** (cmb-09). No unit conversion
+  exists in v1 (`time_unit` always equals the rate denominator).
+- ❌ **No clock-time intervals.** "From 2 pm to 5 pm" is **deferred** (cmb-14); v1
+  takes an explicit integer duration only.
+- ❌ **No sequential / phased segments.** No "works alone for 2 h, then together";
+  v1 is a single combined regime over one duration.
+- ❌ **No decimal or fractional rates / answers.** Pure integer in, exact-integer
+  out, or **refuse** (cmb-08). No rounding, ever.
+- ❌ **No arbitrary prose.** v1 recognizes the two explicit-rate shapes and their
+  cues; anything it does not positively recognize is **refused / stepped aside**,
+  not best-effort parsed.
+- ❌ **No single-agent attribution over two rates.** "How many words does *Alice*
+  type" with a distractor second rate **steps aside** (cmb-16) — a single-rate
+  question, not a combined query.
+- ❌ **No serving-path change.** R4 imports no `generate.derivation` and no
+  `core.reliability_gate`; it touches **zero** served answers and the pinned-SHA
+  lanes are unaffected.
+
+---
+
+## 9. Verification lanes
+
+| lane | command | state |
+|---|---|---|
+| gold ruler (oracle) | `python -m evals.combined_rate_oracle` | **19 fixtures: 6 solved / 5 solver_refuses / 8 reader_refuses**, all valid under the non-vacuous `_canonical_outcome` |
+| solver | `python -m evals.combined_rate_oracle solver` | 6 solved → gold int; 5 solver_refuses → `Refusal` w/ gold reason; 8 reader_refuses skipped (no setup) |
+| reader | `python -m evals.combined_rate_oracle reader` | **11 setup_correct / 0 wrong / 8 refused** (well-formed read to the gold signature; reader_refuses refuse with the gold reason) |
+| router + hygiene | `tests/test_setup_router.py`, `tests/test_router_organ_hygiene.py` | green — 4-organ routing, no foreign substantive boundary |
+| failure registry | `tests/test_failure_family.py` | green — partition; only the 3 `cmb_unsupported_*` are growth surfaces |
+| contemplation matrix | `tests/test_cmb_router_contemplation.py` | green — full terminal matrix + cmb-11 veto + cmb-15 cede + §5 proposal ownership |
+| off-serving | AST import guard in the contemplation test + architectural invariants | green — no `generate.derivation` / `core.reliability_gate` |
+
+**Answer-level outcome.** R4 answers **6 / 0 / 13** (6 solved, **0 wrong**, 13
+refused = 5 solver boundaries + 8 reader boundaries). The discipline holds: wrong
+== 0, breadth never bought with a wrong answer.
+
+**Non-vacuous oracle.** `_canonical_outcome` cross-checks every `solved` gold
+against the canonical arithmetic and every `solver_refuses` reason against the
+canonical refusal (per the CLAUDE.md proof-obligation rule) — the oracle is a
+ruler that fails loudly on its own incoherent gold, not a rubber stamp.
+
+**Honest test accounting.** The R4 dedicated lanes above are all green on the
+merged base (re-confirmed for this ledger: oracle 19/19, the seven R4 test files
+**93 passed**). The broader comprehension test net was **597 passing** as measured
+during CMB-d verification (this docs-only change touches no test code, so that
+count stands). There is **1 pre-existing red**,
+`tests/test_plan_contemplation_runtime.py::test_findings_reset_between_turns` — a
+discourse-contemplation test that is red on clean `origin/main`, **unrelated to
+R4**: it imports nothing from `combined_rate_comprehension` /
+`comprehension_attempt`, and was confirmed red on a clean base before any CMB
+work (one of main's known long-standing reds; `--suite full` only). No R4 lane
+depends on it.
+
+---
+
+## Status: v1 frozen
+
+R4 combined-rate v1 is **complete and frozen** at this claim. The next move is
+**not** more combined-rate capability — the deferrals in §5 are filed as
+proposal-targets, to be picked up only when a real fixture demands one. The
+project's next frontier is qualitatively different: the **served-surface
+epistemology** (graded disclosure / `VERIFIED`), which is scoped separately before
+any code.
diff --git a/docs/analysis/comprehension-organ-capability-ledger-2026-06-08.md b/docs/analysis/comprehension-organ-capability-ledger-2026-06-08.md
index cb8a9cde..ef03815d 100644
--- a/docs/analysis/comprehension-organ-capability-ledger-2026-06-08.md
+++ b/docs/analysis/comprehension-organ-capability-ledger-2026-06-08.md
@@ -1,12 +1,15 @@
 # Comprehension organ capability ledger
 
-**As of:** `main` @ `801f0e23` (after #646–#648). A take-stock record of the
-off-serving comprehension system built so far — what each organ does, where it
-lives, the lane that proves it, and what is deliberately deferred.
+**As of:** `main` @ `3381e031` (after #646–#648 and the CMB ladder #650–#656).
+A take-stock record of the off-serving comprehension system built so far — what
+each organ does, where it lives, the lane that proves it, and what is
+deliberately deferred.
 
 This is a **consolidation** artifact (docs only, no capability change). It exists
 so the next capability lands against a written whole rather than a stack of
-per-batch ledgers.
+per-batch ledgers. The R4 combined-rate organ has its own frozen v1 ledger
+(`docs/analysis/combined-rate-capability-ledger-2026-06-08.md`); it is summarized
+here as one organ among four.
 
 ## The shape of the work
 
@@ -80,22 +83,50 @@ router-hygiene + off-serving greps are part of each batch's acceptance.
 - **Ledger.** `docs/analysis/r3-rate-inventory-ledger-*.md`,
   `r3-2-unit-conversion-2026-06-08.md`.
 
+### R4 — combined (two-rate) integer rates
+
+- **Capability.** Two explicit `<N> <plural> per <singular>` rates over **one**
+  shared compound unit, combined by an **explicitly cued** mode — **sum**
+  (cooperation: *together / combined / both*) or **difference** (opposing flow:
+  *fills … removes / drains*) — answering one of {net rate, accumulated quantity,
+  elapsed time} **only when the result is an exact positive integer**. Everything
+  outside that envelope refuses with a closed-set reason. Built CMB-a (gold +
+  oracle) → CMB-b (exact integer solver) → CMB-c (reader, last) → CMB-d
+  (router/contemplation wiring + domain-precedence).
+- **Lives in.** `generate/combined_rate_comprehension/`
+  (`units` / `model` / `solver` / `reader`) + `evals/combined_rate_oracle/`
+  (gold `combined_rate_gold.jsonl`). Router/contemplation wiring in
+  `core/comprehension_attempt/` + `generate/contemplation/`.
+- **Lane.** gold **19 / 19 valid** (6 solved / 5 solver_refuses / 8 reader_refuses);
+  reader **11 setup_correct / 0 wrong / 8 refused** → answers **6 / 0 / 13**.
+- **Boundaries.** Solver: `non_positive_net_rate`, `non_integer_solution` (pure
+  integer, no float/Fraction). Reader substantive: `rate_unit_mismatch`
+  (`must_remain_refused` *until a dimension registry exists — not forever*),
+  `combine_mode_ambiguous`, `missing_second_rate`. Deferred (proposal surfaces):
+  `three_or_more_rates`, `reciprocal_work_rate_deferred`, `clock_interval_deferred`.
+- **Ledger.** `docs/analysis/combined-rate-capability-ledger-2026-06-08.md`
+  (frozen v1 claim + prominent non-claims), `cmb-lookback-review-2026-06-08.md`.
+
 ## Shared machinery
 
 ### Router + contemplation + proposal loop
 
 - **Router** (`core/comprehension_attempt/`) classifies text and routes to
-  **exactly one** organ (`r1_quantitative` / `r2_constraints` / `r3_rate`),
-  collecting one attempt per organ and selecting the unique `setup_correct`.
+  **exactly one** organ (`r1_quantitative` / `r2_constraints` / `r3_rate` /
+  `r4_combined_rate`), collecting one attempt per organ and selecting the unique
+  `setup_correct`. R4's reasons are namespaced `cmb_*` (`classify.py::cmb_reason`)
+  **before** the registry sees them, so an R4 boundary never inherits an R2/R3
+  family for the same bare string.
 - **Contemplation** (`generate/contemplation/pass_manager.py`) drives
   read→solve→verify and lands on one of a closed set of **terminals**
   (`SOLVED_VERIFIED` / `REFUSED_KNOWN_BOUNDARY` / `PROPOSAL_EMITTED` / …).
 - **Failure families** (`core/comprehension_attempt/failure_family.py`) map each
   closed-set refusal reason to a family with `must_remain_refused` /
-  `proposal_allowed` / `owner`. Only *rate-like growth surfaces*
-  (`unsupported_rate_duration`, the unsupported system/clause families) propose;
-  boundaries that must stay refused (non-integer, temporal-state, underdetermined)
-  do not.
+  `proposal_allowed` / `owner` (`r1` / `r2` / `r3` / `r4` / `cross`). Only
+  genuine, domain-recognized coverage gaps propose (the R2 `missing_*` totals; the
+  rate-like `unsupported_rate_duration`; the three R4 `cmb_unsupported_*`
+  deferrals → `cmb_gold_fixture`). Boundaries that must stay refused — non-integer,
+  temporal-state, underdetermined, ambiguous-combine, unit-mismatch — do not.
 
 ### Proposal-review reporter (RPT)
 
@@ -127,6 +158,38 @@ new organ must clear this lane before it ships.
 
 - **Ledger.** `docs/analysis/router-organ-hygiene-invariant-*.md`.
 
+## Standing precedent — domain-precedence adjudication
+
+The hygiene invariant governs *foreign* text (step aside as `input_shape`). Its
+companion governs the harder case: when a **specific** organ and a **broad** organ
+both legitimately recognize the *same* text.
+
+> **A `setup_correct` from a broader organ is not automatically admissible if a
+> more specific organ positively recognizes load-bearing structure that the
+> broader organ would drop.**
+>
+> **First concrete rule (CMB-d, `router.py::cmb_is_authoritative`):** when R4
+> positively recognizes combined-rate shape (a combined setup, or a *substantive*
+> `cmb_*` refusal), R4's recognition **beats** R3's single-rate read of the same
+> text — for both routing (veto R3's `setup_correct`) and family attribution
+> (suppress R3 so R4 owns the terminal/proposal). The exception: if R4 only
+> stepped aside (`not_combined_rate_shaped` → `input_shape`), it cedes to R3.
+
+**Proof cases** (`tests/test_cmb_router_contemplation.py`):
+
+- **cmb-11** — R4 `missing_second_rate` **vetoes** R3's wrong single-rate answer
+  (would-be `12`); terminal `REFUSED_KNOWN_BOUNDARY`, never a wrong answer.
+- **cmb-15** — R4 cedes (`input_shape`); R3 solves the genuine single rate (`180`).
+- **cmb-12 / 13 / 14** — R4 owns proposal attribution for specific combined-rate
+  deferrals; R3's broader over-read is suppressed so the growth signal is filed
+  under the correct combined-rate family.
+
+R3 is **unchanged**: the adjudication lives entirely at the router/contemplation
+layer. This precedent generalizes to any specific↔broad organ pair
+(geometry+arithmetic, unit-conversion+rate, multi-equation+simple-arithmetic).
+
+- **Ledger.** `docs/analysis/combined-rate-capability-ledger-2026-06-08.md` §7.
+
 ## Whole-system lane state (this commit)
 
 | Lane | State |
@@ -135,8 +198,11 @@ new organ must clear this lane before it ships.
 | R2 reader | 10 / 0 / 0 |
 | R3 gold | 13 / 13 valid (7 / 2 / 4) |
 | R3 reader → answers | 9 / 0 / 4 → 7 / 0 / 6 |
+| R4 gold | 19 / 19 valid (6 / 5 / 8) |
+| R4 reader → answers | 11 / 0 / 8 → 6 / 0 / 13 |
 | router-organ-hygiene | green |
-| off-serving (import grep) | clean — no `generate.derivation` / `core.reliability_gate` |
+| domain-precedence (CMB↔R3) | green |
+| off-serving (import grep + AST) | clean — no `generate.derivation` / `core.reliability_gate` |
 | GSM8K serving | unchanged (sealed) |
 
 `answer_wrong == 0` across every organ. The discipline is "6/0/6 over 11/2/0" —
@@ -147,16 +213,29 @@ breadth never bought with a single wrong answer.
 - **R3.3** — length (`mile ↔ km`) and currency (`dollar ↔ cent`) conversion.
   Build only if an existing R3 fixture/proposal needs it; the rational-conversion
   substrate is already proven for time.
-- **Combined / multi-rate** — two rates composing (work rates, closing speeds).
-  Next major capability; build down the full ladder
-  (gold + setup oracle → solver → reader → router/contemplation wiring), **not**
-  reader-first.
-- **Clock-time intervals**, compound conversions, percentage/ratio organs.
+- **R4 combined-rate deferrals** — the three filed growth surfaces (≥3 rates,
+  reciprocal work-rate, clock-interval) plus the dimension-registry work that
+  would let `cmb_rate_unit_mismatch` become a convertible-unit proposal. Picked up
+  only when a real fixture demands one; see the R4 v1 ledger §5/§8.
+- **Other organs** — percentage/ratio, geometry, n-variable systems, compound
+  conversions. Each is a new rung down the same ladder, never reader-first.
 
-## Next capability (decision pending operator go)
+## Next frontier — the served surface (not more comprehension)
 
-Per the standing plan: after this consolidation, either **R3.3** (only if an
-existing R3 fixture/proposal demands it) or, preferred, **combined-rate** down
-the ladder `CMB-a` (gold + setup oracle) → `CMB-b` (solver) → `CMB-c` (reader) →
-`CMB-d` (router/contemplation wiring + ledger). Do **not** start at the
-combined-rate reader.
+Combined-rate v1 is **frozen** (R4 v1 ledger). The off-serving comprehension organ
+stack now reads:
+
+```text
+R1 relational arithmetic · R2 finite-integer constraints ·
+R3 single-rate + exact conversion · R4 combined-rate v1
+shared: multi-organ routing · typed contemplation · proposal-only growth ·
+        idle/review boundary · router-organ hygiene · domain-precedence adjudication
+serving: unchanged (sealed)
+```
+
+The next move is **not** more off-serving comprehension. It is a qualitatively
+different frontier — the **served-surface epistemology**: *what may CORE disclose
+through the served surface?* (graded disclosure / a reserved `VERIFIED` reach
+level, activating ADR-0206 `govern_response` / `shape_surface` / `ReachLevel` and
+reusing `core/epistemic_state.py` — **not** a parallel correction/serving path).
+Because it touches serving epistemology, it is **scoped first, before any code.**