diff --git a/CLAUDE.md b/CLAUDE.md
index ce1b71c3e..73a10fb72 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -106,3 +106,9 @@ with the journal pointing to them.
 Update this guide in the same PR whenever the workspace layout, test
 commands, or release flow change. If you find it contradicting the repo,
 trust the repo and fix this file.
+
+UK size experiments use `tools/build_uk_rowwise_candidate.py --dataset-households`
+with the same pool inputs as the dense candidate. The flag changes exported
+support, not clone K. Sizes remain candidate-only until their matched comparison
+and promotion scorecard are adjudicated; see
+[the size plan](docs/uk-dataset-size-plan-355.md).
diff --git a/changelog.d/uk-dataset-sizes-355.added.md b/changelog.d/uk-dataset-sizes-355.added.md
new file mode 100644
index 000000000..eef55e134
--- /dev/null
+++ b/changelog.d/uk-dataset-sizes-355.added.md
@@ -0,0 +1,6 @@
+Add exact-household-count UK rowwise candidates using contribution-informed L0 initialization, protected target carriers, fixed-size sampling and refitting. Preserve the dense pool doctrine and local gates, export compact linked entities, and record selection provenance without promoting candidates to the certified dense release or changing dataset defaults.
+A size run also ships the dense joint solve it was cut from (`dense_reference_diagnostics.csv`, a `dense_reference` summary under `solve.dataset_size`) and the selection itself (`dataset_size_selection.csv`: pool row, design weight, inclusion probability, Horvitz–Thompson baseline, refit weight), and `--selection-seed` re-draws the selection on one pool and one dense reference. The exact-count draw's certainty threshold is a recorded candidate-run knob (`--selection-pi-hi`, default 1), and a refused draw carries the measured gate mass and the feasible alternatives instead of a bare error.
+Compose each bound PIPR mean monthly private rent into an annual total using 12 months and the matching A17-uprated private-renter household count, with the inputs and adjudication recorded in the cross-grain receipt.
+The size selection's L0 budget search stops only on a probe whose gate probabilities admit the exact-count draw at the requested certainty threshold (`feasible_draw_pi_hi`, verdicts from the new `exact_k_design_feasibility`), recording every probe in the size receipt; a size run checkpoints the dense solve and the search before the draw (`size_selection_checkpoint.{npz,json}`) and `--resume-size-checkpoint` continues at the draw on the re-derived pool after verifying the checkpoint's identity, rebuilding both results through the new `rebuild_calibration_result`.
+The UK doctrine solve reports progress through the calibrator's callback seam: a loss line every hundred epochs of the dense solve, each budget probe and the refit, one line per finished probe with its drawability verdict (new `budget_probe` and `budget_search_done` events), and one when the search stops; the candidate driver writes them to stderr.
+After review: the checkpoint identity carries the solve doctrine and a resume asserts the restored options against it; a stale checkpoint in `--out` refuses before the solve; `microcosm.calibrate.gates` and `microcosm.calibrate.initialization` join the attested seed-protocol sources and the pre-best-iterate oracle runs with a frozen gate module; the size receipt reports `certainty_share`, `boundary_draws` and `zero_target_rows`; the manifest distinguishes the realized stretch against the refit's reference from the stretch against the pool design.
diff --git a/docs/evidence/spec-engine/us-f0-coverage.json b/docs/evidence/spec-engine/us-f0-coverage.json
index a8d2d977f..45e73dcbb 100644
--- a/docs/evidence/spec-engine/us-f0-coverage.json
+++ b/docs/evidence/spec-engine/us-f0-coverage.json
@@ -736,8 +736,8 @@
         "legacy_sinks": [],
         "mode": "compiler_semantic",
         "pointer_class": "all",
-        "pointer_count": 824,
-        "pointer_sha256": "7537385c3fd399a2dbb7dcd8ed7cf1ff2481ed336db621eafcbfd741d5792f40",
+        "pointer_count": 826,
+        "pointer_sha256": "7ff2d5d1c2fd8026d17a57244f969dc0e9625a9e47304b693ad15df329041282",
         "rationale": null,
         "relative_sink_prefix": null,
         "source_prefix": "/resolved/seed_protocol",
@@ -772,21 +772,21 @@
         "verifier": "vintages"
       }
     ],
-    "configuration_field_count": 42154,
-    "consumed_field_count": 42154,
+    "configuration_field_count": 42156,
+    "consumed_field_count": 42156,
     "generation0_effect_counts": {
       "legacy_behavior": 38476,
-      "no_generation0_effect": 3678
+      "no_generation0_effect": 3680
     },
     "mode_counts": {
-      "compiler_semantic": 27715,
+      "compiler_semantic": 27717,
       "front_end_validation": 348,
       "identity_only": 103,
       "legacy_behavior": 13988
     },
     "multiple_primary_use_field_count": 0,
-    "pointer_inventory_sha256": "3fc6b9480ea81b9635bd0db56e180c2daf32a5cd2006a70d350586c570f96754",
-    "resolved_binding_field_count": 9770,
+    "pointer_inventory_sha256": "2c0423a08dc16bf5f142134804a1a6545f887e32ca5c991c856a2f8bcfaea0f0",
+    "resolved_binding_field_count": 9772,
     "unused_field_count": 0
   },
   "inventory_coverage": {
@@ -1656,13 +1656,13 @@
           "compiler_ir.node_slices"
         ],
         "expected": {
-          "map_sha256": "c94a5af8eb24866156b8cd4b77b93dc497b7df5b025204fe1022f80b1d8446ea",
-          "protocol_sha256": "1c53f1d9b3e185a41181fbe861f9b08d56c83880710fd1e18d7a4ceb5d6a354e"
+          "map_sha256": "87ba50531d9fa6683096ecb39a31655b331ab8acff3a5876c2f62b33562a0885",
+          "protocol_sha256": "fd3e4b06f11be4e8c13ea19fef9469ab95cbbe3e2dcfce351e860dd3e00709e4"
         },
         "failures": [],
         "observed": {
-          "map_sha256": "c94a5af8eb24866156b8cd4b77b93dc497b7df5b025204fe1022f80b1d8446ea",
-          "protocol_sha256": "1c53f1d9b3e185a41181fbe861f9b08d56c83880710fd1e18d7a4ceb5d6a354e"
+          "map_sha256": "87ba50531d9fa6683096ecb39a31655b331ab8acff3a5876c2f62b33562a0885",
+          "protocol_sha256": "fd3e4b06f11be4e8c13ea19fef9469ab95cbbe3e2dcfce351e860dd3e00709e4"
         },
         "status": "covered"
       },
@@ -1677,7 +1677,7 @@
           "compiler_ir.seed_stream_map"
         ],
         "expected": {
-          "implementation_sha256": "1c53f1d9b3e185a41181fbe861f9b08d56c83880710fd1e18d7a4ceb5d6a354e",
+          "implementation_sha256": "fd3e4b06f11be4e8c13ea19fef9469ab95cbbe3e2dcfce351e860dd3e00709e4",
           "protocol": "legacy-v1",
           "streams": [
             "build_model",
@@ -1698,7 +1698,7 @@
         },
         "failures": [],
         "observed": {
-          "implementation_sha256": "1c53f1d9b3e185a41181fbe861f9b08d56c83880710fd1e18d7a4ceb5d6a354e",
+          "implementation_sha256": "fd3e4b06f11be4e8c13ea19fef9469ab95cbbe3e2dcfce351e860dd3e00709e4",
           "protocol": "legacy-v1",
           "streams": [
             "build_model",
@@ -2599,7 +2599,7 @@
       "country": "us",
       "schema_id": "country_spec",
       "schema_version": 1,
-      "spec_sha256": "8b1546bc97b540afd525fe88f36a315de18b4d57bd9fab73035dacd8962e302e"
+      "spec_sha256": "35a02b6b19c921faba1407d441e0b9d9623c496e2cd5b711be014def281a95c6"
     }
   },
   "report_schema_version": 3,
@@ -2609,7 +2609,7 @@
     "country": "us",
     "schema_id": "country_spec",
     "schema_version": 1,
-    "spec_sha256": "8b1546bc97b540afd525fe88f36a315de18b4d57bd9fab73035dacd8962e302e"
+    "spec_sha256": "35a02b6b19c921faba1407d441e0b9d9623c496e2cd5b711be014def281a95c6"
   },
   "status": "pass"
 }
diff --git a/docs/uk-dataset-size-plan-355.md b/docs/uk-dataset-size-plan-355.md
new file mode 100644
index 000000000..4b2ce4b21
--- /dev/null
+++ b/docs/uk-dataset-size-plan-355.md
@@ -0,0 +1,187 @@
+# UK dataset sizes: implementation plan and operating boundary
+
+This implements the candidate-building part of [#355](https://github.com/PolicyEngine/microcosm/issues/355)
+on [#870](https://github.com/PolicyEngine/microcosm/pull/870)'s branch. The PR is still open as of
+2026-09-05 and itself stacks on #852. Do not base the work on the old issue's
+535,080-household 2023 dataset. The authoritative inputs are the current raw-FRS
+2024-25 spine, OA ladder, and pinned Chronicle facts used by the joint candidate.
+
+## Decisions retained
+
+- Pool generation keeps clone count **K=15**. Requested output households is a
+  different parameter, applied after cloning and materialization.
+- The joint surface retains national, constituency and local-authority rows,
+  the declared stretch bound **10**, loss cap **10**, **grain_equal** weighting,
+  and **1,500 epochs** per solve in the normal driver defaults.
+- Existing binding adjudications, signed deferrals, measure exclusions,
+  census-vintage uprating, and all local gates remain in force. Size selection
+  does not silently drop target rows, loosen ESS floors or change registers.
+- Population-normalized engine measures are frozen from the full pool. The
+  refit uses their selected household contributions rather than re-running
+  those formulas on a smaller population.
+- The Frame carries complete households, benefit units and people; every
+  non-dry attempt retains the existing Logbook recording envelope.
+
+## Implemented sequence
+
+1. Build the usual joint dense solve from the pinned inputs. This also supplies
+   the same-target reference loss for the size comparison.
+2. Compute each household's maximum absolute target-contribution share from
+   original pool weights and the compiled sparse matrix, following
+   [#346's correction](https://github.com/PolicyEngine/microcosm/issues/346#issuecomment-4902880142).
+   Protect the largest absolute weighted carrier of each nonzero target, with
+   first-column tie breaking. Initialize open probabilities with
+   `0.1 + 0.8 * score / (score + median_positive_score)`. This bounded smooth
+   prior is an implementation choice for candidate evaluation, not a measured
+   UK release ruling. Run L0 budget search; never select the largest prior scores.
+3. Use the existing exact-count Sampford sampler on learned probabilities.
+   Probability-one gates are certainties (`pi_hi=1`), including every protected
+   carrier. Refuse impossible budgets or sampling designs rather than clamp.
+   The certainty threshold is a candidate-run knob (`--selection-pi-hi`,
+   default 1). The first licensed rehearsal (2026-09-08, 55,000 of 792,690 at
+   100 epochs) was refused at the draw: the budget search meets its target on
+   the count of not-fully-closed gates while the exact-count design can only
+   draw from the open-probability mass, which fell a fifth short. The refusal
+   and the size receipt now carry a feasibility measurement (boundary mass and
+   largest gate, the largest feasible count at `pi_hi=1`, the smallest feasible
+   threshold on a grid). Ruling (María, 2026-09-08): the smoke accepts the
+   measured feasible count; the 55,000 candidate runs at `pi_hi=0.95` (the US
+   exact-k ladder's setting) and 2,000 epochs. A threshold below one promotes
+   learned near-certain gates and is recorded, never a release default.
+
+   The same 2026-09-08 ruling fixes the local private-rent binding: each 2025
+   PIPR calendar-year mean monthly rent is composed into the linear annual
+   total `12 × mean × renter households`, using the matching authority's
+   A17-uprated `ons.tenure.private_rent` count. The composed total remains the
+   bound `rent/private_rent` target, and its inputs ride the cross-grain receipt.
+4. Refit on the selected support through `microcosm.calibrate`, with no L0
+   penalty. Reuse the existing normalized Horvitz–Thompson `w/q` baseline.
+   The stretch multiplier remains 10 **relative to that inclusion-adjusted
+   baseline**; this is the shared exact-k refit's contract, not a claim that
+   sparse weights remain within 10 times the unexpanded pool-row weights.
+   The manifest names the reference explicitly. Its empirical suitability for
+   UK release remains to be assessed alongside the size scorecard.
+5. Restore the prepared carrier and export only selected linked entities.
+   Re-run the existing local gate battery on the compact frame. Each holdout
+   fold independently reruns selection on training targets; held targets do
+   not inform the prior or protected set.
+6. Record requested/realized counts, pool positions, inclusion probabilities,
+   protected count, seed, learned penalty, dense/refit loss and target change,
+   the gate reports, and ordinary byte-pinned output metadata.
+
+## Running a candidate
+
+Use the inputs and environment from the existing
+[UK dense assembly runbook](uk-dense-release-assembly-runbook-762.md).
+Pass the same pinned source arguments to the existing driver and add:
+
+```bash
+uv run python tools/build_uk_rowwise_candidate.py \
+  --input-h5 "$UK_SPINE_H5" --input-sha256 "$UK_SPINE_SHA256" \
+  --ladder "$UK_LADDER_NPZ" --ladder-sha256 "$UK_LADDER_SHA256" \
+  --ledger-facts "$UK_LEDGER_FACTS" \
+  --ledger-facts-sha256 "$UK_LEDGER_FACTS_SHA256" \
+  --ledger-manifest-sha256 "$UK_LEDGER_MANIFEST_SHA256" \
+  --dataset-households 50000 --seed 42 --out out/uk-k50000
+```
+
+Repeat with another positive household count and a fresh output directory to
+compare sizes. These are requested counts, not certified presets. Omit
+`--dataset-households` to retain the existing dense path. Add `--dry-run` to
+inspect input binding and parameters without solving or writing a candidate.
+Never reduce `--n-clones` to request a smaller output. Full builds still need
+the dense build's peak memory and add L0/refit work; the reduction is in the
+exported dataset's storage and downstream loading/simulation footprint.
+
+### The search stops on the draw's own feasibility; the solve is checkpointed before the draw (2026-09-09)
+
+S2 on spine-p (55,000 at `--selection-pi-hi 0.95`, 2,000 epochs) was refused at the
+exact-count draw after 4.8 hours. The mass-basis budget search had stopped inside its
+±5% band at an open mass of 54,834, 166 rows *under* the request; the draw's
+condition is one-sided (roughly "open mass at least the request", exactly
+`(k − certainties) × max(boundary π) ≤ Σ boundary π`), and with near-binary gates the
+tail below 0.95 held 291 rows of mass for 437 places. Two changes follow:
+
+- The size selection's search now stops only on a probe whose gate probabilities
+  admit the draw at the requested threshold (`calibrate(..., feasible_draw_pi_hi=…)`
+  on the mass basis; verdicts from `exact_k_design_feasibility`, the draw's own
+  inequality). An infeasible probe steers the bisection like a count miss (short
+  boundary mass → smaller penalty, surplus certainties → larger). Every probe and the
+  reason the search stopped are recorded under `selection_budget_search` in the size
+  receipt; if no probe is drawable within the ten-probe budget the closest run is
+  still returned and the draw refuses with its measurement, as before.
+- A size run writes `size_selection_checkpoint.{npz,json}` into `--out` after the
+  dense solve and the search, before the draw (the dense weights and trajectory, the
+  selection's weights, gate probabilities and search receipt, the protected-carrier
+  mask, and the identity of the pool, the target surface and the solve settings).
+  `--resume-size-checkpoint DIR` re-derives the pool and the surface, verifies that
+  identity, rebuilds both results through `rebuild_calibration_result`, and continues
+  at the draw; `--selection-pi-hi` may differ from the threshold the search stopped
+  on and both are recorded (`selection_pi_hi`, `selection_search_pi_hi`). A draw
+  refusal therefore costs a re-draw, not the pool solve. `--no-size-checkpoint`
+  opts out. The checkpoint is candidate evidence, never a release input.
+
+### The solve reports progress (2026-09-09)
+
+A size run used to be silent between "solving ... under the doctrine..." and its manifest, five
+hours later. The doctrine solve now takes a `progress` line sink (the driver writes it to stderr,
+so it lands in the run log): a timestamped loss line every hundred epochs and at the last epoch
+of the dense solve, of every budget probe and of the refit; one line per finished probe with its
+penalty, open mass, certainties, boundary draw and mass, and its drawability verdict
+(`budget_probe` events from the search); and one line when the search stops, naming why and
+what it selected (`budget_search_done`). Nothing else changes: the events ride the calibrator's
+existing `progress_callback` seam.
+
+### Review round on #877 (Vahid, 2026-09-09)
+
+Three should-fix items and two questions changed the machinery:
+
+- **A resume cannot drift from the doctrine.** The checkpoint identity now carries the solve doctrine
+  (`_doctrine_bounds()`: the stretch multiplier, the loss cap, the rule) beside the pins, seeds and sizes,
+  and the doctrine solve asserts the restored options (`max_weight_ratio`, `mass`, `target_loss_cap`)
+  against today's doctrine after the load, refusing by name. The writing run's code pin and build id ride
+  in the checkpoint's `provenance` and are reported on resume, not compared, so a receipts commit does
+  not invalidate a checkpoint.
+- **A stale checkpoint in `--out` refuses before the solve.** The driver checks for
+  `size_selection_checkpoint.{npz,json}` beside the other pre-solve output guards; the writer's own
+  refusal stays as the last line of defence.
+- **`gates.py` and `initialization.py` are attested and controlled.** Both join the seed-protocol
+  implementation digest (`seeds.py`), so a change to gate behaviour or the contribution prior moves the
+  attested identity; and the pre-best-iterate oracle now runs with a frozen copy of the gate module
+  (`tests/fixtures/pre_best_iterate/gates_<sha8>.py`) instead of the live one, so a gate-behaviour change
+  surfaces as a numeric mismatch on the gated control path rather than being absorbed on both sides.
+- **The draw's determinism is stated.** The size receipt carries `certainty_share` and `boundary_draws`:
+  on the two 55,000 candidates 99.3 % / 99.7 % of the count was decided by the threshold on learned π and
+  405 / 156 rows were drawn. The manifest's stretch keys are honest: `realized_max_weight_ratio_vs_stretch_reference`
+  is measured against the frame the refit started from (the HT baseline on a size run) and
+  `realized_max_weight_ratio_vs_design` against the pool design weights themselves.
+- **Zero-valued targets are counted.** `zero_target_rows` in the size receipt says how many compiled rows
+  carry a zero target, the case where the contribution prior uses a unit denominator.
+
+## Certification and publication still required
+
+The implementation produces **candidates**, not a new certified UK default.
+A size request refuses `--release-candidate`, and its manifest records
+`releasable=false` even if the diagnostic gate run passes. The dense assembler
+must not interpret a compact candidate as the already reviewed dense line.
+The existing registry, production pointers and pe.py default are unchanged.
+
+Before any size can be promoted:
+
+1. Run the licensed full-input build, retain all gate failures and measure
+   local ESS and fit. A nominal 50k size is not guaranteed to clear the floors
+   that motivated K=15.
+2. Run #355's matched sound-comparison protocol and the referenced promotion
+   scorecard, including reform/distributional validation and untargeted bases.
+   Calibration loss alone is not a certificate. The included same-target loss
+   comparison is a diagnostic, not a substitute for those protocols.
+3. Adjudicate any new size-specific acceptance decisions, including the
+   inclusion-adjusted stretch reference. A national-only product would need
+   its own explicit scope; this implementation does not downgrade local claims.
+4. Add size-specific certified release identities, assembly contracts and
+   downstream bundle entries against that evidence; publication remains the
+   repository's deliberate human step.
+
+Accordingly, this increment does not close #355's default-flip requirement.
+Synthetic CI checks prove code behavior and artifact structure; they do not
+establish licensed-data fit, storage measurements, or release eligibility.
diff --git a/experiments/355-uk-dataset-size-receipts.md b/experiments/355-uk-dataset-size-receipts.md
new file mode 100644
index 000000000..424851239
--- /dev/null
+++ b/experiments/355-uk-dataset-size-receipts.md
@@ -0,0 +1,732 @@
+# #355 dataset-size receipts: 55,000 households by informed L0 on the #877 machinery
+
+Plan of record: `repos/uk-355-size-experiment-plan.md` (approved 2026-09-08, two rounds). These
+receipts record what was run, on which pinned inputs, and what was measured. They are candidate
+evidence only: no size run is releasable (`--release-candidate` is refused with
+`--dataset-households`), no gate threshold is loosened, and nothing here promotes an artifact.
+Kept separate from the #762 receipts (`experiments/762-uk-rowwise-candidate-receipts.md`).
+
+Rulings carried in (María, 2026-09-08): K=15 cloning stays in front of the selection (the dense
+joint solve runs on the whole 792,690-row pool; the size machinery then keeps 55,000 of those
+rows); `--epochs 2000` on size runs (drives the dense solve, every L0 probe and the refit); skip
+holdout on the first 55k run; no dense baseline on the new inputs unless the rough comparison with
+R17 shows large deviations; engine policyengine-uk 2.94.0; Chronicle feed 6fb700e.
+
+## Step 0 — #877 CI green before any run
+
+CI run 34216367053 on 56aa4e25 (the spec-engine re-pin) was red in four jobs with one cause: the
+`solve.py` edit in #877 moved two more source-hashed identities.
+
+| lane | test | pin | fix |
+|---|---|---|---|
+| `fast (rest)` ×2 | `microcosm-graph/tests/test_acceptance_h_parity.py::test_h1_kernel_parity`, `test_graph_serialize.py::test_generated_parity_graphs_bind_real_kernels_and_direct_bytes` | `calibrate.adam@1` implementation hash a7a0330f… → d24fc41d… (`source_hash` over the calibrate modules) | H1 fixture regenerated on its authoring platform (arm64/darwin/py3.14; numpy 2.4.6, pandas 3.0.3, scipy 1.17.1, torch 2.12.0) with `tools/graph_parity_fixtures.py`; only `calibrate/pins.json` taken (direct bytes and graph unchanged). The generator also resets `fit.qrf/pins.json`'s platform map to the authoring platform, dropping its two linux pins; that file was reverted. |
+| `engine-us (us-am)` ×2 | `test_us_multispine_pool_tool.py::test_constants_adapter_equals_live_constants_and_stays_out_of_identities` | US `spec_sha256` 9db29b4d… → 9db2d6db… | re-pinned |
+
+Commit 1b0583b7. Local: graph 336 passed, multispine pool tool 187 passed, spec-engine pin files 50
+passed. Pushed with C1/C2 below as d4043ec7; CI run 34223080395.
+
+The run on d4043ec7 then failed in the `wheels` lane only (both Python versions): the size CLI test read
+the exported H5 through `pd.HDFStore`, and the wheels venv has no pytables (7,963 passed, 587 skipped, that
+one failure). The file's convention is `pytest.importorskip("tables")` + `importorskip("h5py")` at the top of
+every CLI test; the size test lacked them, and the two new evaluation test files write PyTables-format H5
+the same way. All three now skip without pytables (verified by blocking the import locally); the workspace
+and engine lanes, which have pytables, run them in full.
+
+The run on fb85c8fe then failed only in the two UK lanes on one new test: the evaluation command timed
+each downstream script with `/usr/bin/time -l`, a BSD flag GNU `time` rejects with exit 125, so on the
+linux runners a failing stub could not surface its own exit code. Replaced by an in-process rusage shim
+(the child script runs in a child interpreter that reports its own peak resident set in bytes on exit;
+wall time measured by the caller; exit code the script's own), commit e8f7c6f2, pushed with the
+`--selection-pi-hi` knob (a6b1e0ca) and the by-name refusal (b1d206d6); CI run 34239851890.
+
+## Code landed on the branch before the runs
+
+- **C1 (d4043ec7)** — a size run keeps the dense joint solve it was cut from: `UKRowwiseDoctrineSolve.dense_reference` (weights, initial weights, local and national diagnostics, losses, past-cap censuses; the evidence labelling moved into `_doctrine_solve_evidence` and runs for both results), written as `dense_reference_diagnostics.csv` (every target's dense estimate with a `grain` column) and summarised under `solve.dataset_size.dense_reference`; and the selection itself as `dataset_size_selection.csv` (`pool_row_index, household_id, clone_index, design_weight, inclusion_probability, certainty, ht_baseline_weight, refit_weight`). Both are listed under `outputs` with digests; dense runs are unchanged. The dense reference is byte-identical to a standalone dense run on the same inputs, seed and epochs, so the size-only delta needs no second full-pool solve.
+- **C2 (d4043ec7)** — `--selection-seed` (requires `--dataset-households`, defaults to `--seed`) seeds only the informed L0 search, the exact-count draw and the refit, threaded through the holdout as well; recorded as `parameters.selection_seed` and in the size receipt's `seed`. `--seed` still governs the ladder clone assignment and the dense solve, so two selections compare on one pool and one dense reference.
+- **C3/C4 (251e67d4)** — evaluation library `uk_runtime/size_evaluation.py` (`load_run`, `run_acceptance`, `fit_tables`, `weight_tables`, `area_support_tables`, `gate_table`, `paired_targets`, `dense_reference_deltas`, `frozen_vs_recomputed`, `footprint`, `summarize` with `PRE_REGISTERED_OUTCOMES_V1`) and the one command `tools/evaluate_uk_dataset_size.py` (steps `00-run-acceptance`, `10-dense-reference`, `20-vs-reference/<label>`, `30-incumbent-score`, `40-incumbent-surface`, `50-downstream`, `90-summary` into `<run>/evaluation/`, each with `receipt.json`); `_fit_by_family` lifted into `uk_runtime/diagnostics.py::uk_fit_by_family`. Implemented by Codex from `.codex-work/PLAN.md`; its final report was lost when the companion broker restarted, so the review was done on the diff directly (lift byte-for-byte; grain rule, `time -l` parsing, multiplier inference matching `id_multiplier_for_values` with the manifest self-check, red-row mapping through family/area/metric, the R18 evaluator's `national_rows`/`candidate_estimate` shape, flags exactly as pre-registered) and verified independently: ruff, format, `ci_test_groups --verify`, 88 tests across the four UK rowwise/evaluation files.
+- **Feasibility diagnostic (4bbd01f6)** — see S1 below.
+
+## Rebase onto main after #879 (María's instruction before any further push)
+
+Main moved by PR #879 (SPI income coherence, e07a4735; 13 commits, 42 files) after the branch was
+cut. Intersection with the branch: one file, one line — the UK country-bundle digest in
+`test_spec_engine_country_bundles.py`, which both sides had moved (#879 through `uk/spec/sources.yaml`
+and `country_package.json`; this branch through `solve.py`'s seed-protocol attestation). Rebased
+(`git rebase origin/main`), resolved that line, then re-cut it once for the combined tree:
+d57d248fe947c3215850020bb16c6def308e373c92afa433395c81e8eda91fce (commit 573c4b43). The am/be
+digests, the loader golden vector, the seed-protocol/seed-map digests and the committed US coverage
+report were unchanged by #879 (49/50 pin tests passed before the cut). Rebased heads: acbc6332 (size
+machinery), 08ae0caf (spec re-pin), 366b8263 (H1 + US spec re-pin), cfd57e03 (C1/C2), 12b9a7ce
+(feasibility diagnostic), 6ec596c3 (C3/C4), 573c4b43 (UK digest re-cut).
+
+Isolated re-verification instead of the full suite (her call: the conflict surface is minimal): the
+four spec-engine pin files; graph H1 parity and serialisation; the multispine pool-tool test (US spec
+digest); the branch's own suites (calibrate, local rowwise, rowwise candidate, informed gates, the two
+evaluation tests); and the battery neighbours #879 touched (country spec, local gate battery, gate
+battery contract pins, terminal gates, battery bindings). Results on the rebased tree: spec-engine pin
+files 50/50 after the one re-cut; graph H1 parity + serialisation + multispine pool tool 195 passed;
+calibrate + local rowwise + rowwise candidate + informed gates + the two evaluation tests 313 passed;
+battery neighbours 231 passed. Pushed 2026-09-08 (force-with-lease from d4043ec7 → 573c4b43); PR #877
+MERGEABLE on main with 7 commits; CI run 34230891965 (the earlier run 34223080395 on d4043ec7 had
+every engine lane and the fast trade/rest lanes green when superseded). CI runs the full lanes on the push.
+
+#879 also changed the SPI income spine stage (`hmrc_spi_income_spine` gained `donor_income_period`
+2022 and `income_uprating_variables` in `source_stages.json`; `spi_income.py`, `spi_spine.py`), so
+spine-o is stale on the rebased tree: **spine-p** is rebuilt from the clean tree at 573c4b43 (same
+recipe) and S0 re-run on it before any further size run.
+
+## P0 — inputs and pins
+
+| input | path | sha256 | note |
+|---|---|---|---|
+| Chronicle consumer artifact 6fb700e | `data/ukds/acceptance/chronicle-uk-artifact-6fb700e/consumer_facts.jsonl` | 6ae49d7d7ab297df25a0b9bfe2d6776827c672d284fbb360957fe8337089549f | 128,717 rows; manifest dcda51d6496aea67f768a284e7955c7520e7c8b91e2bed3569f247567b7153f0; the feed main's registers compile against. Upstream chronicle main is 7 commits ahead; the one fact change (#250, UC family-type totals 2023–2025, merged 2026-09-08) is not consumed by any register and is the next re-pin candidate, not part of this experiment. |
+| OA ladder | `populace-877/build/uk/uk_oa_ladder_2021.npz` | 9c6d56b90d2e975d750106b175020a54c5ec6acf42ef8909d304a9d7fc3868a7 | copied from `populace-762b/build/uk/` |
+| spine-o | `data/ukds/acceptance/spine-o-355/spine-o.h5` | 3ef32dfb3e8a86e1c93a8f74b463492fe8eeb81d10ebc746c7b396aa47c2eeca | built 2026-09-08 from the clean tree at d4043ec7 (`build_twin.sh` recipe, all licensed tabs; 352 s wall, 7.05 GB peak): 28 stages with `age_tail` second and `uc_deduction_attributes` present, policyengine-uk 2.94.0, 15/15 spine gates passed, `tax_free_childcare_spend_routed_share` nonzero share 1.0, 52,846 households / 61,234 benunits / 113,626 persons, mass 29,247,433.0; sidecar `spine-o.build.json`. Rebuilt because spine-m (R17) predates #850, #842 and #874; see below |
+
+| spine-p | `data/ukds/acceptance/spine-p-355/spine-p.h5` | ae83e3075d1fd99adf3dbb1ea8bbf96398fa48b8eb251b802ae682ada03fb19a | built 2026-09-08 from the clean tree at 573c4b43 (rebased onto #879; same recipe; 424 s wall, 3.84 GB peak): 28 stages, `age_tail` second, `uc_deduction_attributes`, policyengine-uk 2.94.0, 15/15 spine gates, TFC routed share 1.0, 52,846 households / 61,213 benunits / 113,590 persons (the #879 SPI donor change moves 21 benunits and 36 persons against spine-o), mass 29,247,433.0. **The spine every size run from here stands on.** |
+
+Why the spine was rebuilt: R17 stood on spine-m (27 stages, engine 2.92.1, feed 1cab809). Main since
+then added `uc_deduction_attributes` and the WAS debt columns (#850), moved `age_tail` second with
+int64 age (#842), and added `tax_free_childcare_spend_routed_share`, the `hmrc.tfc.*` and DfT bus
+targets, the 6fb700e feed pin and the 2.94.0 engine floor (#874). No spine on disk carried the TFC
+column.
+
+## Runs
+
+Runner: `data/ukds/acceptance/355-dataset-size/run_size_candidate.sh <name> [--prev <row>] <driver args>`
+(spine-o, ladder, 6fb700e feed, seed 42, `/usr/bin/time -l`, log copied into the run dir). Root
+`data/ukds/acceptance/355-dataset-size/spine-o/`. Preflight `--env` on the pins: OK.
+
+### S0 — dry run (`--dry-run --dataset-households 55000 --epochs 2000`)
+
+Exit 0, 96.9 s, 6.0 GB. Pins bound; plan reports the joint surface 20,430 targets × 792,690 households
+(K=15 clones of 52,846), `parameters.dataset_households 55000`, `epochs 2000`, `engine_blocks 1`, the
+resolved vintages (UC 2025-05, HMRC 2023, ONS housing 2021/2022/2025-12, ONS population 2024).
+No files written (dry runs never do).
+
+### S1 — rehearsal (`--dataset-households 55000 --epochs 100 --skip-holdout`, chained on R17's row)
+
+**Refused at the exact-count draw** after 1,542 s (25.7 min; 9.48 GB peak): the dense solve and the
+informed L0 budget search completed (100 epochs each; `git_dirty` true because the evaluation tool was
+being written in the same tree — a rehearsal, so noted and accepted), then
+`microcosm.calibrate.exact_k._draw_boundary` raised
+
+> degenerate boundary mass: proportional normalization would require a boundary inclusion
+> probability greater than one; adjust pi_hi or k.
+
+Logbook row d15c0224… (disposition `failed`, phases reached through `targets_bound`, error receipt
+`logbook-receipts/…/error.json`). Mechanism: `select_exact_k(pi, k, pi_hi=1.0)` treats only exact-one
+gates (the protected carriers) as certainties, scales every other gate's open probability to the
+remaining draw size `m`, and refuses when the largest scaled value exceeds one — i.e. when
+`m · max(pi_boundary) > Σ pi_boundary`. The L0 budget search stops when the **count** of
+not-fully-closed gates is within 5 % of 55,000; with gates only partly polarised that count sits above
+the open-probability **mass**, so the boundary mass fell short of the draw. The refusal carried no
+numbers, so a feasibility diagnostic was added to `refit_uk_dataset_size` (boundary mass, largest
+boundary gate, feasibility at `pi_hi=1`, the largest feasible household count at `pi_hi=1`, the
+smallest feasible `pi_hi` on a fixed grid, gate quantiles) — attached to the refusal and to the size
+receipt on success — and the rehearsal is re-run below. This is a design ruling for #877, not a run
+setting: the US exact-k ladder release runs with `pi_hi = 0.95` (`tools/build_us_exact_k_ladder_release.py`),
+while the UK size plan deliberately pins `pi_hi = 1` ("no post-hoc promotion of learned boundary scores").
+
+### S1b — rehearsal re-run with the feasibility numbers (same inputs, seed 42, epochs 100, chained on S1's row)
+
+**Refused at the same point** after 1,592 s (26.5 min; 8.49 GB peak; commit 4bbd01f6). The dense solve
+and the L0 budget search are deterministic on the same inputs, so the refusal is the same; the
+diagnostic now says why:
+
+| quantity | value |
+|---|---|
+| pool households | 792,690 |
+| requested households (k) | 55,000 |
+| protected carriers = certainties at `pi_hi = 1` | 9,869 |
+| boundary draw m = k − certainties | 45,131 |
+| budget search stopped at `n_nonzero` (count of not-fully-closed gates) | 52,490 (inside the ±5 % band round 55,000) |
+| total open-probability mass Σπ | 45,743 |
+| boundary mass Σπ (π < 1) | 35,874 |
+| largest boundary gate | 0.9982 |
+| gates with π ≥ 0.5 / 0.9 / 0.99 / 0.999 | 36,527 / 25,267 / 10,761 / 9,869 |
+| π quantiles p50 / p90 | 0.0063 / 0.053 |
+| learned λ | 4.2e-06 |
+| feasible at `pi_hi = 1`? | no: m · max π = 45,048 > 35,874 |
+| largest feasible k at `pi_hi = 1` on these gates | 45,809 |
+| smallest feasible `pi_hi` on the grid {0.999 … 0.5} | 0.5 (0.7 fails by 3 %: 22,664 × 0.7 = 15,865 > 15,329) |
+
+Reading: the budget search hit its target on the **count** of not-fully-closed gates (52,490), but the
+**expected number of open gates** — the mass the exact-count design can draw from — is 45,743, a fifth
+short of 55,000. Most of the 782,821 boundary gates are near-closed (median π 0.006) yet not closed,
+so they count towards `n_nonzero` while contributing almost no mass; the ~15,000 gates between 0.9 and
+0.99 carry most of the boundary mass and cannot be scaled up to fill a 45,131 draw. With `pi_hi = 1`
+the draw is feasible only up to ~45.8k households at this polarisation. The US precedent (`pi_hi =
+0.95`) would not rescue it either at 100 epochs — only thresholds at or below about 0.65 are feasible
+here. Whether 2,000 epochs polarises the gates enough to close the gap is unknown; the count-versus-
+mass mismatch in the stopping rule remains regardless of epochs. Ruling requested from María (see
+the session report): (A) expose `pi_hi` as a candidate-run knob; (B) make the size selection's budget
+search stop on open-probability mass Σπ ≈ k instead of `n_nonzero`, which keeps `pi_hi = 1` and makes
+the draw feasible by construction; (C) accept k ≈ Σπ; (D) spend the 2,000-epoch run to see. Nothing
+was clamped; Logbook row for S1b is chained on S1's.
+
+### S0 on spine-p — dry run after the rebase (`--dry-run --dataset-households 55000 --epochs 2000`)
+
+Exit 0, 97.7 s, 4.84 GB (2026-09-08 13:15Z, code 573c4b43, engine 2.94.0, preflight `--env` OK on
+`pins-spine-p.txt`). Plan: matrix 20,796 rows (20,430 local + 366 national) × 792,690 columns
+(K=15 clones of 52,846); `parameters` dataset_households 55,000, epochs 2,000, n_clones 15, seed 42,
+selection_seed 42, engine_blocks 1; `releasable` false; engine not run. The 7 extra national rows
+against spine-o's dry run are #879's SPI rows. Every size run from here stands on spine-p; the
+spine-o runs above (S0, S1, S1b) remain valid evidence about the L0 machinery, which #879 did not touch.
+
+### Ruling (María, 2026-09-08) and the knob it needed
+
+Smoke: accept the measured feasible count (45,800 at `pi_hi = 1` on the 100-epoch gates) so every
+mechanical piece downstream of the draw runs once at scale — the Sampford rejection path on 792,690
+gates, the frozen-target refit, the compact export with closed links, the six-gate battery on a compact
+frame, the dense-reference and selection sidecars, the manifest's size receipt, and then the evaluation
+command end to end (run acceptance, dense-reference deltas, the comparison with R17, the incumbent
+scorer on a compact candidate, the incumbent-surface evaluator re-resolving the engine on a compact
+rowwise frame, the eval-home scripts loading a compact H5 with their footprint timings, the summary).
+Its fit numbers are not evidence (100 epochs); its footprint numbers are.
+
+Full run: `--selection-pi-hi 0.95` (the US exact-k ladder's setting) with `--epochs 2000` at 55,000.
+Commit a6b1e0ca makes the certainty threshold a recorded candidate-run knob (default 1.0; bounded to
+(0, 1]; requires `--dataset-households`; recorded as `parameters.selection_pi_hi`, in the size receipt
+and in the feasibility measurement as `requested_pi_hi` / `feasible_at_requested_pi_hi`). Risk stated
+up front: at 100 epochs 0.95 was not feasible either (34,944 × 0.95 > 25,954); 2,000 epochs should
+polarise the gates, and if the draw still refuses, the receipt names the smallest feasible threshold.
+
+### Smoke — 45,800 on spine-p (`--dataset-households 45800 --epochs 100 --skip-holdout`, chained on S1b's row 399e1e7d…)
+
+**Refused before the selection**, 608 s in (10.1 min; 10.6 GB peak; code a6b1e0ca), inside
+`contribution_initialization`: `nonzero target at row 20648 has no support`. Row 20648 is national
+row 218 of the 366 the rebased tree binds; reproducing the driver's engine-free registry compile
+names it: `dwp/uc_payment_dist/COUPLE_NO_CHILDREN_annual_payment_27_600_to_28_800` (family
+`dwp_universal_credit`, benunit grain, target 746.3 units), whose constraint row is all zeros on
+the cloned pool. R17 had support for the same band on spine-m under the pre-#879 engine
+`family_type` (initial estimate 551 against a then-target of 654) and no national row without
+support at all; #879 re-points the payment-distribution rows to the relationship-based
+`uc_calibration_family_type` proxy, under which no benefit unit in the pool is a couple without
+children with an annual UC payment in that band. The dense solve carries such a row as a capped miss;
+a size selection cannot carry it. Logbook row 1c7f25dd… (failed).
+
+Response: `refit_uk_dataset_size` now refuses unsupported nonzero targets **by name**, all at once,
+before initialisation (commit b1d206d6, `unsupported_nonzero_targets()`), and the smoke is re-run to
+obtain the complete list. Handling is a ruling for María: a signed measure exclusion for the affected
+rows (the A16 register), a fix to the proxy or the band edges upstream in #879's register, or a
+recorded smoke-only drop of unsupported rows from the selection problem (the dense reference keeps them
+as misses). Nothing is selected around silently.
+
+Re-run (`f100-k15-h45800-e100-smoke2`, chained on 1c7f25dd…; 589 s to the check, 10.6 GB; code b1d206d6):
+the by-name pre-check refuses exactly two rows, both in `dwp_universal_credit`:
+
+- `dwp/uc_payment_dist/COUPLE_NO_CHILDREN_annual_payment_27_600_to_28_800@2025` (target 746.3)
+- `dwp/uc_payment_dist/COUPLE_NO_CHILDREN_annual_payment_28_800_to_30_000@2025`
+
+These are the same two rows #879's corrected-measurement comparison reports at −100 %
+(`experiments/879-corrected-calibration-comparison.md`, rows 112–113): under the relationship-based
+`uc_calibration_family_type` proxy no benefit unit in the spine is a couple without children with an
+annual UC award above £27,600. The national seam carries them as capped misses; the catalogue and
+upper-band repair is tracked in microcosm#736; 16 payment bands already sit in the reviewed measure
+exclusion register. **Proposed (unsigned) handling**: two entries in
+`calibration_measure_exclusions.json` on the zero-support-channel precedent
+(`slc.repayments.england_postgraduate`), approved by María if she rules so; until then no size run
+can start on the rebased tree. Logbook row for smoke2 chained on smoke's.
+
+**Ruling (María, 2026-09-08): sign the two exclusions; run the next round; rebase #877 later.** Signed as
+commit 2959e177 into `calibration_measure_exclusions.json` on the zero-support-channel precedent
+(approved_by juaristi22, approved_on 2026-09-08, expires_on 2026-12-08, tracking microcosm#736,
+adjudication microcosm#355); the register's census pins move with it (51 entries; 18 payment-band
+exclusions; 82 active payment bands). Smoke re-launched as `f100-k15-h45800-e100-smoke3`, chained on
+smoke2's row. No push until the later rebase.
+
+### Smoke3 — 45,800 on spine-p with the exclusions signed (`--epochs 100 --skip-holdout`, `pi_hi` 1.0)
+
+Passed the by-name check (364 national rows) and **refused at the draw** after 1,512 s (25.2 min;
+11.7 GB): on spine-p's 100-epoch gates the measured numbers are
+
+| quantity | spine-o (S1b, k 55,000) | spine-p (smoke3, k 45,800) |
+|---|---|---|
+| protected carriers = certainties at `pi_hi = 1` | 9,869 | 10,026 |
+| budget search `n_nonzero` | 52,490 | 43,938 |
+| total open-probability mass Σπ | 45,743 | 39,577 |
+| boundary draw m / boundary mass | 45,131 / 35,874 | 35,774 / 29,551 |
+| largest boundary gate | 0.998 | 0.998 |
+| largest feasible k at `pi_hi = 1` | 45,809 | 39,638 |
+| smallest feasible `pi_hi` on the grid | 0.5 | 0.7 (0.8 fails) |
+| `pi_hi = 0.95` | infeasible | infeasible (27,443 × 0.95 = 26,071 > 21,439) |
+
+Reading: the "largest feasible count at `pi_hi = 1`" is not a stable target. The budget search
+re-learns the gates for whatever count is requested and stops on the count of not-fully-closed gates;
+in both measurements the open-probability mass came out at 87–90 % of that count, so requesting the
+measured feasible count would only measure a new, lower one. What the measurement does guarantee is
+feasibility on the same gates at a lower certainty threshold. Smoke4 therefore runs 45,800 at
+`--selection-pi-hi 0.7` (the smallest grid value feasible on these gates), 100 epochs, chained on
+smoke3's row bd9ebb9b…; it is the first run to pass the draw. Risk carried forward to S2: at 100 epochs
+`pi_hi = 0.95` is infeasible by 18 %; whether 2,000 epochs polarise the gates enough is unknown, and
+the count-versus-mass mismatch in the stopping rule does not depend on epochs.
+
+### Smoke4 — 45,800 at `pi_hi 0.7` on spine-p: the first run through the whole size pipeline
+
+Exit 1 = gates failed with the evidence bundle written (the candidate outcome). 1,344 s (22.4 min),
+10.6 GB, code 27eb74a1 with a clean tree, engine 2.94.0 in one block. Draw: 27,858 certainties at
+`pi_hi 0.7` over a boundary pool of 764,832, Sampford, `feasible_at_requested_pi_hi` true; refit on
+the frozen surface; compact export 45,800 households (H5 187 MB against R17's 2.36 GB); the six-gate
+battery on the compact frame; both sidecars (`dense_reference_diagnostics.csv` 20,794 rows,
+`dataset_size_selection.csv` 45,800 rows) listed in `outputs` with digests; Logbook row 363c8c4f….
+Plumbing numbers, not evidence (100 epochs): dense reference loss 0.409 → 0.138, compact 0.613 →
+0.172; realised stretch 10.0 against the Horvitz–Thompson baseline; mass 29,247,433 → 27,974,030
+(−4.4 %); Kish ESS 9,034 (fraction 0.197); max/median positive weight 244; area support 960 of 1,011
+areas below floor (constituency ESS minimum 2.3); target fit 1,321 rows past 25 %.
+
+**Defect found in the surface, not the smoke: `ons.rent.private_rent` (314 local-authority rows, family
+`private_rent`, source ONS PIPR).** Every row sits at a relative error of 10^5 to 10^6 on both the dense
+reference and the compact fit: the target is a mean monthly rent (£552 to £3,633 per authority) while
+the metric `rent/private_rent` is `household_rent × is_private_renter` summed with weights, an annual
+rent total (10^8 to 10^9). R17's surface had no `private_rent` rows (19,105 local rows; this tree binds
+19,419). The rows became active with #874's re-pin of the local references to Chronicle 6fb700e; the
+census entry for the source is signed-deferred (`private_rent_pipr_partial_coverage_2025`: the feed's
+only PIPR period is 2026-06, after the 2025 target period) yet 314 of 673 candidates are active. At the
+loss cap these rows distort the dense solve as much as the selection, so they block S2 regardless of
+`pi_hi`. Ruling requested: extend the signed deferral to the whole target (the surface returns to R17's
+ten local families, making the comparison like for like) and fix the metric's semantics (a weighted
+mean among private renters, on the PIPR period policy) as its own change; or fix the metric first.
+
+**Evaluation plumbing pass on smoke4** (`evaluate_size_run.sh`, 1,446 s, 12.1 GB peak): every step ran or
+skipped for a stated reason and the tree `evaluation/00…90` came out as designed. 00 run acceptance,
+10 dense-reference deltas, 20 comparison with R17 (both manifest shapes read), 40 the incumbent-surface
+evaluator on the compact frame (98.9 s; frozen-versus-recomputed maximum divergence 0.125 on the
+population-normalised national rows, a signal to watch at S2), 50 downstream: T3 distributions
+(112 s, 7.5 GB; 191 variables: 151 pass / 28 attention / 11 fail / 1 expected), T4 admin benchmarks
+(65 s, 8.2 GB), T5 eight reforms (1,085 s, 12.1 GB), the #731 scorecard on the smoke (6 s, 3.3 GB) and
+on R17 (59 s, 11.1 GB), 90 the summary with the pre-registered table (all fit flags red, as a
+100-epoch smoke must be; footprint real: 187 MB H5, 22 min, 10.6 GB). Two findings: step 30 needs the
+frozen scoring register as an input (candidate runs never write it; R14 compiled it separately) — the
+command now takes `--scoring-registry`; and the #731 scorecard on the incumbent enhanced-FRS snapshot
+fails inside policyengine-uk 2.94.0's dataset loader (`load_dataset … UnboundLocalError: data`), so the
+incumbent leg of the three-way scorecard needs a snapshot that loader accepts (the R17 and smoke legs ran).
+
+**Ruling (María, 2026-09-08, evening): fix the rent metric (option b) and make the size selection's budget
+search stop on open-probability mass; then run S2.** Mass basis: `calibrate(..., budget_basis=
+"open_probability_mass")` measures each probe by Σπ (the gates' expected open count) instead of the count
+of not-fully-closed weights; the size refit uses it and records `selection_budget_basis`. On a 60-record
+toy problem the mass basis lands Σπ 20.2 for a budget of 20 where the count basis gives count 19 with
+mass 18.5. `solve.py` is an attested module, so the spec-engine identities are re-cut once more.
+Commit 2f7eb945 (mass basis + re-pin: bundle digests am 924bc8c6… / be 08f63f50… / uk 4fd5fc1b…, loader
+golden vector e155a712…, seed protocol 260446f1… and seed map f6834db8… with the regenerated US coverage
+report, the H1 calibrate parity fixture, the US spec digest b9b7068f… in the multispine pool-tool test; 245
+pin and parity tests pass).
+
+Rent fix, commit 0cfe1928 (implemented by Codex from `.codex-work/PLAN-rent.md`, reviewed and verified
+here: ruff clean, 137 tests): `uk_private_rent_mean_to_total` in `uk_runtime/ledger_targets.py`, applied
+in `uk_local_target_surface` after the A15/A17 uprating, composes each `rent/private_rent` value as
+`12 × mean monthly rent × the same authority's bound tenure/private_rent count`, keeps the mean and the
+count in the row's metadata, refuses by area when the count is missing or non-positive, and records every
+cell under `cross_grain.private_rent_mean_to_total`; the metric is unchanged; the census rationale for the
+PIPR source is corrected (the feed carries the 2025 months the reference averages) and its committed
+artifact regenerated. Dry run on spine-p with the composed surface: 314 cells composed (E06000001: £551.83
+× 12 × 7,435.5 renters = £49.2m), 364 national rows, 20,794 × 792,690.
+
+### S2 — the experiment: 55,000 households, `--selection-pi-hi 0.95 --epochs 2000 --skip-holdout`
+
+Launched 2026-09-08 17:32Z on spine-p from the clean tree at 1079ef87, chained on smoke4's Logbook row
+363c8c4f…, run `spine-p/f100-k15-h55000-e2000-p95-s42`, `/usr/bin/time -l`.
+
+**REFUSED at the draw after 4.8 h** (17,247 s wall, 20,855 s user, 10.9 GB peak RSS; exit 1 at 22:20Z;
+Logbook row d5a33c11… `disposition failed`, `phases_reached … targets_bound, error`, chained on 363c8c4f…;
+the next run chains on d5a33c11…). Same message as S1/S1b: `degenerate boundary mass … adjust pi_hi or k`,
+now with the feasibility receipt. Nothing beyond `run.log` and the error receipt was written: the driver
+keeps no checkpoint between the dense solve and the draw, so the 2,000-epoch dense reference and the L0
+probes are lost with the refusal.
+
+The stub above said the exact count was "feasible by construction" on the mass basis. That was wrong,
+and the numbers say why:
+
+- The budget search stops as soon as `|Σπ − k| ≤ tol` with `tol = max(1, round(0.05 × k))` = 2,750 rows
+  at 55,000 (`solve.py::_search_l0_lambda_for_budget`). It accepted Σπ = 54,834, i.e. 166 rows short of
+  the request, at `selection_l0_lambda` 1.3335e-06. The mass basis changed what each probe measures, not
+  the band that ends the search.
+- The gates are near-binary at 2,000 epochs: 10,026 protected carriers at π = 1 exactly, 44,537 gates
+  in [0.95, 1) averaging 0.9996 (54,446 above 0.99, 51,100 above 0.999), and the other 738,127 gates
+  averaging 0.0004 (π p50 0.00016, p90 0.0015). Σπ over that tail is 291 at `pi_hi` 0.95.
+- An exact-k draw at threshold h needs `(k − n_{π≥h}) × max_{π<h} ≤ Σ_{π<h} π`. At 0.95: 437 boundary
+  draws × 0.947 = 414 > 291. At 1.0: 44,974 × 0.999999 > 44,808 (Σπ < k, so infeasible outright; the
+  largest feasible k at `pi_hi` 1 is 54,834). Scan: 0.999 (3,900 draws / mass 3,745) no; 0.99 no; 0.98 no;
+  0.9 (428 / 282) no; 0.8 (421 / 276) no; 0.7 (415 × 0.691 = 287 vs 272) no by 15 mass units; **0.5
+  (405 × 0.463 = 188 vs 266) yes**, with 54,595 certainties. The feasible ceiling on this run's π vector
+  lies in (0.5, 0.7).
+- Had the search landed 166 rows above 55,000 instead of below, `pi_hi` 1.0 would have been feasible;
+  which side of the request the ±5% band lands on is chance, not design.
+
+What this means for the machinery: with the informed L0 at 2,000 epochs the selection is essentially
+deterministic (≈54.6k gates open, ≈400 rows drawn from a 738k tail), so `pi_hi` only decides whether the
+few dozen gates between 0.5 and 0.95 are certainties or boundary draws, and the exact-count draw is
+feasible only when the requested threshold sits below that shoulder. Honouring an arbitrary `pi_hi`
+would need the search to stop on the draw's feasibility condition at that threshold rather than on the
+±5% mass band (a further `solve.py` change, pins move again, one to three extra probes at ~1 h each),
+and a checkpoint of the dense solve and the gate probabilities before the draw would make a refusal
+cost a refit rerun rather than 4.8 h. Both are for María to rule on; neither was started.
+
+Options put to María (2026-09-09): (B) rerun S2 at `--selection-pi-hi 0.5`, no code change; the dense
+solve and the search are seeded and deterministic, so this run's scan is the feasibility evidence for
+the rerun (expected, not yet verified at scale); (A) the feasibility-aware stopping rule, then rerun at
+0.95; (C) the pre-draw checkpoint, independent of A/B.
+
+### Ruling (María, 2026-09-09) and the two fixes
+
+**Ruling:** launch the 55,000 run at `--selection-pi-hi 0.5` now, build both fixes in parallel, and
+launch the full 0.95 run on the fixed code as soon as it is ready, without a further go.
+
+**P50 = `spine-p/f100-k15-h55000-e2000-p50-s42`** launched 2026-09-08 23:13Z from the clean tree at
+e80112a4 (engine 2.94.0, spine-p ae83e307…, ladder 9c6d56b9…, feed 6fb700e), chained on S2's failed row
+d5a33c11…, `--dataset-households 55000 --epochs 2000 --selection-pi-hi 0.5 --skip-holdout`. The draw's
+feasibility at 0.5 on this pool is the S2 scan (405 boundary draws × 0.463 ≤ 266 mass; 54,595
+certainties), which the seeded search should reproduce. Driven by `355-dataset-size/chain-p50-p95.sh`:
+when P50 exits, the chain waits for `355-dataset-size/READY-p95` (a git ref), fast-forwards
+`populace-877` onto it, and launches `f100-k15-h55000-e2000-p95b-s42` at 0.95 chained on P50's row. One
+K=15 solve at a time (26 GB machine).
+
+**Fix A — the search stops on the draw's own feasibility** (built on branch `uk-355-fixes`, worktree
+`populace-877-fix`, while P50 ran). `exact_k_design_feasibility(pi, k, pi_hi)` in
+`microcosm.calibrate.exact_k` is the draw's inequality without the draw (verdicts `feasible`,
+`certainties_exceed_k`, `boundary_short_of_draw`, `boundary_mass_short`; 120 random polarised designs
+agree with `select_exact_k` on every one). `calibrate(..., feasible_draw_pi_hi=h)` (mass basis only)
+makes `_search_l0_lambda_for_budget` accept a probe only when the draw at `h` is feasible on its gate
+probabilities, steers an infeasible probe like a count miss (short mass → smaller penalty, surplus
+certainties → larger), prefers feasible probes when choosing the best run, and records every probe under
+`options["budget_search"]` (`probes[]`, `selected_feasible`, `stopped_on`). The size selection passes its
+`pi_hi`; the receipt carries `selection_budget_search`, and the feasibility scan carries each threshold's
+verdict and `search_pi_hi`. A synthetic S2 (stub optimiser, 1,000 gates, budget 500: first probe 485 open,
+inside the band, undrawable at 0.95) now continues to a drawable probe in five evaluations where the plain
+mass basis stopped at the first; when nothing is drawable within the budget the closest run is still
+returned and the draw refuses with its measurement. The feasibility scan and `_feasible_at` now use the
+same helper, so the scan and the draw can never disagree.
+
+**Fix C — checkpoint before the draw.** `refit_uk_dataset_size` is split into `select_uk_dataset_size`
+(unsupported-row refusal, protected carriers, the search) and the draw + refit, which accepts an existing
+`UKSizeSelection`. `uk_runtime/size_checkpoint.py` writes `size_selection_checkpoint.{npz,json}` (dense
+weights and trajectory, initial weights, loss weights and scales, the selection's weights, gate
+probabilities and trajectory, the protected mask; identity of the pool by household-id digest, of the
+target surface by names + values digest, of the solve settings and input pins by the caller's identity
+mapping, the options incl. the search receipt) and `load_uk_size_checkpoint` re-derives both results on the
+resumed run's freshly compiled pool through the new `microcosm.calibrate.rebuild_calibration_result`
+(compile, place weights under the recorded mass policy, rebuild diagnostics, recompute the closing loss and
+refuse if it disagrees), refusing by name on identity, pool or surface drift. The doctrine solve takes
+`size_checkpoint_dir` / `resume_size_checkpoint` / `checkpoint_identity`; the driver writes the
+checkpoint into `--out` by default on size runs (`--no-size-checkpoint` opts out), `--resume-size-checkpoint
+DIR` continues at the draw (`--selection-pi-hi` may differ; `selection_pi_hi` and
+`selection_search_pi_hi` both recorded; `selection_reused` true), Logbook phases
+`size_selection_checkpointed` / `size_selection_resumed`, manifest `parameters.size_checkpoint`,
+`parameters.resume_size_checkpoint`, `solve.dataset_size.checkpoint.{written|resumed_from}`. Tests: a
+synthetic run checkpoints, resumes byte-equal (support, weights, dense reference, selection CSV), re-draws
+at another threshold, and refuses a changed epoch, a foreign pool, a moved surface, an overwrite.
+
+`solve.py` and `exact_k.py` are attested: bundle digests am 09f6fffe… / be cbbabdbb… / uk d123633c…,
+seed protocol 6174167d…, seed map 892435cc…, loader golden vector b556379f…, US spec digest 47038847…
+(multispine pool-tool test), the regenerated US coverage report, the H1 calibrate parity fixture
+(regenerated on the authoring platform, `fit.qrf` platform map reverted).
+
+### P50 — 55,000 at `pi_hi 0.5`, 2,000 epochs: the first sized dataset at full fidelity
+
+**Completed 2026-09-09 04:06Z, exit 1 = candidate blocked by the gate battery** (17,543 s = 4.87 h wall,
+11.6 GB peak RSS; Logbook row 1b2a4d98…, chained on S2's d5a33c11…). Code e80112a4 clean (pre-fix; the
+0.95 run carries the fixes). Every stage ran: dense joint solve (20,794 × 792,690), informed L0 search,
+draw, refit, compact export, sidecars, battery, manifest.
+
+- **Determinism at scale:** the search landed on S2's λ 1.3335e-06 and Σπ 54,834 exactly, and the scan
+  matches S2's (54,595 certainties at 0.5, 405 boundary draws from 738,095 gates, mass 266, max 0.463).
+  The seeded dense solve and search reproduce bit-for-bit on the same inputs.
+- **Size:** requested = realized = 55,000; protected carriers 10,026; H5 **213 MB** (R17 dense 2,36 GB).
+- **Dense reference** (spine-p, feed 6fb700e, 2,000 epochs): loss 0.2934 → **0.01508** (R17 0.01425 at
+  1,500 epochs on spine-m and the old feed: within 6%, no D2 trigger); Kish ESS 125,324 (R17 129,236);
+  local rows within 10% / 25%: 98.9% / 99.75%, 53 rows past 25% (9 constituency, 41 LA, 3 national).
+- **Compact refit** (55k, HT baseline, stretch bound 10, realized max ratio 10.0): loss 1.0245 → **0.0347**
+  (2.3× the dense; pre-registered "≤ 2× expected, > 5× red"); median |rel err| 0.0079 (dense 0.0080);
+  within 10% / 25%: **93.0% / 97.7%**, **463 rows past 25%** (175 constituency, 288 LA); past-cap census
+  403 → 4 (399 escaped). `max_target_scaled_change` 153 on council_tax/band_g E09000002 (target 50, dense
+  2,408, compact 10,076): the handful of tiny council-tax band-F/G targets the dense already misses by 25–47×
+  dominate every maximum; the substantive losses are support collapses on cells whose dense support was
+  spread over many rows (uc_hh_3plus_children E14001096: 5,074 → 479; tenure/social_rent N09000005:
+  14,545 → 2,149; hmrc self-employment amounts in E14001310 / E09000020 at −93%).
+- **Area support (the headline):** constituencies 650, rows per area min/median 46/84 (1 below 50), Kish
+  ESS min/median **11.4 / 59.2, 211 of 650 below the 50 floor (32%)**, distinct sources median 78 (2 below
+  50); local authorities 361, rows 2/128, ESS 2.0/89.3, **42 of 361 below 50 (12%)**, sources 4 below 50.
+  The pre-registered response ("breaches > 25% of areas → S4 at 110k") is triggered.
+- **Six gates on the compact frame:** area_support FAILED (251 entries), target_fit FAILED (20 rows),
+  per_family_fit / weight_ess / weight_ratio / ladder PASSED. Unreleasable by construction.
+- Evaluation: light steps 00/10/20/90 run beside the 0.95 solve; 30/40/50 (engine, T3/T4/T5) when the
+  machine is free.
+
+**P95b = `spine-p/f100-k15-h55000-e2000-p95b-s42`** launched by the chain 04:06:10Z on the fixed code
+e2667da9 (clean; fast-forward of `uk-dataset-sizes-355` onto `uk-355-fixes`), chained on P50's row
+1b2a4d98…, `--selection-pi-hi 0.95`; writes `size_selection_checkpoint.{npz,json}` before the draw.
+
+**P50 evaluation, light steps** (`evaluate_size_run.sh … --steps 00-run-acceptance,10-dense-reference,
+20-vs-reference,90-summary`, 15 s, beside the 0.95 solve; heavy steps 30/40/50 deferred until no solve
+runs). Run acceptance: every check passed. Pre-registered table (P50 / its dense reference / R17):
+
+- dense reference loss 0.01508 / — / 0.01425 → watch (expected ≤ 0.014; red > 0.0285). Compact ÷ dense loss
+  2.30 → watch (≤ 2 expected; red > 5). Maximum target-scaled change 153 → red (< 0.5), carried by the tiny
+  council-tax band rows below.
+- national rows within 10%: **323** / 353 / 340 → red (≥ 335 expected, red < 330); within 25%: 352 / 361 /
+  356. Constituency share within 10%: 96.4% / 99.8% / 99.8% → watch; local-authority share: 90.7% / 97.7% /
+  97.7% → watch (red < 90%). Rows past 25%: **475** / 53 / 45 → red (≤ 60).
+- Kish ESS 33,672 / 125,324 / 129,236 → ok (20–40k expected). Maximum ÷ median positive weight **22.0** /
+  389 / 400 → the compact frame is far tighter than the dense (HT baseline + stretch 10). Share of rows
+  stretched above 100× the pool design 0.07% → ok.
+- minimum constituency ESS 11.4 (R17 63.8); area-support breach share **25.0%** (253 of 1,011 areas) → red
+  at the pre-registered 25% line; failed release-blocking gates 2 (area_support, target_fit; per-family,
+  ratio, ESS, ladder passed). Frozen-vs-recomputed: not measured (step 40).
+- wall 17,543 s / — / 11,122 s; peak RSS 11.6 GB / — / 11.1 GB; H5 **213 MB** / — / 2,356 MB.
+- Paired with R17 on 20,473 common rows (94 target values moved with the feed; 321 rows only in P50 = the
+  composed rent rows and the TFC/bus rows; 2 only in R17 = the two excluded UC bands): wins 9,541, ties
+  168, losses 10,764; of R17's 42 red rows 20 are now green; new red rows are the tiny council-tax band F/G
+  targets (E09000002 band G target 50 → 10,076; E08000028; E06000021 band F) and support collapses on
+  spread cells (see above).
+
+Reading: at 55,000 rows the exact count, the footprint (11× smaller H5) and the weight discipline (max ÷
+median 22 vs 400) are real; the price is support — a third of constituencies under the ESS floor, four
+families (ladder census_households, private_rent, council_tax, tenure) under 90% within 10%, and 475 rows
+past 25% against 53 in the same run's dense reference. The dense reference itself is close to R17 on the
+new inputs (loss +6%, national within 10% 353 vs 340), so no D2 is needed to explain the deltas: they are
+size effects. The pre-registered response is S4 at 110,000 to locate the support floor; María's call.
+
+**Progress tracker (María, 2026-09-09 ~08:40Z: "add the progress tracker to the branch").** The doctrine
+solve takes a `progress` line sink; the driver writes it to stderr, so the run log now shows a timestamped
+loss line every 100 epochs (and the last) of the dense solve, of each budget probe and of the refit, one
+line per finished probe with its penalty, open mass, certainties, boundary draw and mass and its drawability
+verdict, and one line when the search stops. The events (`budget_probe`, `budget_search_done`) ride the
+calibrator's existing `progress_callback` seam beside the per-epoch events (`uk_runtime/solve_progress.py`;
+tests at the calibrate, solve and driver levels). `solve.py` moved again, so the pins were re-cut a third
+time (bundles am 906e0a55… / be 39619d06… / uk 635f5e39…, loader golden 864f9799…, seed protocol 1daa63de…,
+seed map 8a8b353c…, US spec 0a5f4af6…, coverage report, H1 calibrate fixture). The running 0.95 solve
+predates this and stays silent until its checkpoint; S4 / S3 will show their probes as they finish.
+
+### P95b — 55,000 at `pi_hi 0.95` on the fixed code: the search trace
+
+Checkpoint `size_selection_checkpoint.{npz,json}` written 12:03Z, 7.95 h after launch (dense solve ≈ 1.1 h,
+then ten probes ≈ 41 min each). Dense closing loss 0.015083618… — bit-identical to P50's, the third
+reproduction of the same dense solve. The feasibility-aware search (`feasible_draw_pi_hi 0.95`, mass basis)
+spent its whole ten-probe budget and stopped `acceptable_within_tolerance` on the last one:
+
+- λ 1e-3 (bracket mid-point): mass 10,072, only the 10,026 protected gates open, tail max 0.0006 → drawable
+  but far below the request (steer: smaller penalty).
+- λ 1e-5: 22,864, certainties 22,753, 32,247 places from a tail mass of 118 (max 0.925) → boundary mass short.
+- λ 1e-6: 59,706, certainties 59,338 → certainties exceed k (steer: larger penalty).
+- λ 3.16e-6: 40,825 → short. λ 1.78e-6: 50,223 → short. **λ 1.334e-6: 54,834, certainties 54,563, 437 places
+  from mass 291 → short — S2's and P50's landing, now a rejected probe.** λ 1.15e-6: 57,276 → exceed.
+  λ 1.24e-6: 56,043 → exceed. λ 1.29e-6: 55,407, certainties 55,124 → exceed by 124.
+- **λ 1.3097e-6: mass 55,121, certainties 54,844, 156 places from a tail mass of 296 (max 0.9497 → 156 × 0.95
+  = 148 ≤ 296) → drawable, within the band → selected.**
+
+Reading: at 0.95 the drawable window on this pool is roughly Σπ ∈ [54,880, 55,130], about 0.5% of k, and the
+bisection on log λ needed all ten probes to land in it (S2's ±5% band had stopped after the first in-band
+probe). At 0.5 the first in-band probe was already drawable (P50). The threshold is therefore a cost knob
+as much as a design knob: 0.95 cost 6.7 h of probes for a selection that differs from P50's by ~250
+certainties and the tail draws. With the checkpoint, any further threshold on this pool is a re-draw.
+
+**P95b completed 12:06Z, exit 1 = candidate blocked by the battery** (28,825 s = 8.0 h wall, 33,048 s user,
+10.4 GB peak; Logbook row chained on P50's 1b2a4d98…; code e2667da9 clean). 55,000 exact; certainties
+54,844 at 0.95 from λ 1.3097e-06 (Σπ 55,121), 156 tail draws; checkpoint arrays sha 65d0a099….
+
+Pre-registered table (P95b / dense reference / R17; P50 in brackets): dense loss 0.01508 (same solve);
+compact ÷ dense **2.07** [2.30] → watch; maximum target-scaled change 166 [153] → red (the same tiny
+council-tax band rows); national rows within 10% **321** [323] / 353 / 340 → red; constituency share
+within 10% **97.0%** [96.4%] / 99.8%; local-authority share **91.7%** [90.7%] / 97.7%; rows past 25% **448**
+[475] / 53 / 45 → red; Kish ESS 34,526 [33,672]; maximum ÷ median positive weight **15.8** [22.0] / 389 /
+400; stretch share above 100× design 0.03% [0.07%]; minimum constituency ESS 13.7 [11.4]; area-support
+breach share **22.5%** [25.0%] (193 of 650 constituencies [211], 34 of 361 authorities [42]); failed
+release-blocking gates 2 (area_support 225 entries, target_fit 20; the other four passed); H5 213 MB; median
+|rel err| 0.0064 [0.0079]; by family within 10%: census_households 77.1 [76.0], private_rent 79.9 [77.1],
+council_tax 85.4 [84.2], tenure 86.4 [84.9], hmrc 95.3 [94.1], age 96.8 [96.4], uc 99.3 [98.9] — the same
+four families under 90%. Paired with R17 on 20,473 rows: wins 10,473 / ties 194 / losses 9,806 [9,541 /
+168 / 10,764]; 18 of R17's 42 red rows now green [20].
+
+**Selection stability across the threshold (P95b vs P50: one pool, one dense solve, two search landings
+λ 1.3097e-06 vs 1.3335e-06):** only **44,860 of 55,000 rows are common (81.6%)**, 10,140 swapped each way;
+44,811 rows are certainties in both. On the common rows the refit weights correlate 0.925, median relative
+change 3.7%, 90th percentile 84%. Per-area ESS correlates 0.957 across the two selections (207 areas under
+the floor in both, 46 only in P50, 20 only in P95b). On the 20,430 paired local rows P95b is better on
+11,262 and worse on 9,168; 371 rows are past 25% in both, 92 only in P50, 65 only in P95b. Reading: the
+near-binary gates make each selection deterministic in λ but not stable across λ — a 2% move of the
+penalty swaps a fifth of the rows — so S3 (a different selection seed) will mostly measure the same thing
+as this pair. The two datasets are statistically alike (fit, ESS, breach counts within a few percent) and
+P95b is marginally better on every headline, at the cost of 6.7 h of probes.
+
+Post-exit chain (`355-dataset-size/after-p95b.sh`): `populace-877` fast-forwarded onto `uk-355-fixes`
+(0ab86823, tracker included); P95b light evaluation 00/10/20/90 done 12:07Z; heavy steps 30/40/50 (+ 90)
+for P50 then P95b running with no solve on the machine.
+
+### Heavy evaluation steps on both 55k runs (30/40/50, 12:07–13:00Z, no solve running)
+
+**30 incumbent score: not measured.** `score_uk_local_candidate.py` refuses R17's frozen scoring register
+("requires the frozen active reference count 19419, got 19105"): the register was compiled on the pre-#874
+surface and the 55k runs bind 19,419 active local references (the composed rent rows and the re-pinned feed).
+Scoring against the incumbent needs a register compiled on the 6fb700e surface; candidate runs do not write
+one. Open item.
+
+**40 frozen-vs-recomputed (engine re-resolved on the compact frame, 99 s):** 340 of 364 national rows
+matched; maximum relative divergence **9.3% (P50) / 11.1% (P95b)** → the pre-registered red flag (> 5%)
+fires. Eleven / twelve rows exceed 1%: `isc.private_school_students` (frozen 557k, recomputed 523k, −6%) and
+the seven `voa.council_tax_stock.band_*` rows (recomputed +3% to +10% above frozen). The other 328 matched
+rows agree within 1%. This is the population-dependent-measure physics the plan said to size: the refit froze
+the pool's contributions; the engine on 55k rows resolves the council-tax band imputation and the private
+school flag differently.
+
+**50 downstream (uk-candidate-eval under 2.94.0; "incumbent" = R17's dense H5 on spine-m and the old feed, so
+input differences ride along):**
+
+- T3 variable distributions vs R17: P50 135 pass / 45 attention / 9 fail / 2 expected; P95b 137 / 44 / 9 / 1.
+  The same nine fail in both: `bsp_reported` (2.1× R17's total), `child_tax_credit_reported` (1.6×),
+  `jsa_income_reported` (1.6×), `education_consumption` (1.6×), `winter_fuel_allowance_reported` (0.65×),
+  `domestic_rates` (0.70×), `pension_credit` / `pension_credit_reported` (totals within 3%, shape), and
+  `uc_deduction_combination` (no ratio) — small reported-benefit populations the 55k support cannot carry.
+- T4 admin anchors: 3 pass (UC spend 73.9bn vs anchor 79.3bn, R17 75.6bn; UC caseload 6.70m vs 6.76m; carer
+  element), 5 fail, 9 pending, differentiators 0/4 — every failure is shared with R17 (LCWRA caseload 6.4m vs
+  anchor 2.4m, R17 7.6m; income tax 269bn vs 331bn, R17 268bn; population 68.4m vs 69.5m, R17 69.8m;
+  multi-family households; the social-rented housing-element probe errors in the tool for both).
+- T5 eight reforms (Δ government balance, bn): candidate 7 of 8 pass vs R17 6 of 8; both fail the UC taper
+  reform (−35 vs −17 expected); P50 and P95b agree with each other to 0.1bn on every reform and with R17 to
+  0.1–0.3bn on six (VAT +2pp 24.7 vs R17 21.1 vs expected 31.3).
+- #731 scorecard (engine 2.94.0 on each H5; the incumbent enhanced-FRS leg still fails in the 2.94.0 loader):
+  P50 / P95b / R17 — population 68.7 / 68.9 / 70.1m; **households 27.3 / 27.5 / 29.4m**; state pension
+  **127.1 / 127.5 / 137.3bn**; income tax 287.7 / 287.6 / 286.3bn; UC 77.8 / 78.1 / 79.5bn; council tax
+  46.2 / 46.5 / 48.6bn; poverty BHC 9.49 / 9.45 / 9.87%; top-1% net income share 7.49 / 7.49 / 6.72%;
+  **Gini 0.350 / 0.351 / 0.375**. The pre-registered downstream flags (totals ≤ 2%, poverty ≤ 0.5 pp, Gini
+  ≤ 0.005) fire on households, state pension, council tax and Gini.
+- Footprint per file (wall, peak RSS): T3 114 s / 6.9 GB; T4 64 s / 9.0 GB; T5 1,166 s / 11.3 GB; the #731
+  scorecard 6.6 s / 3.5 GB on the 55k H5 against 55 s / 11.7 GB on R17's — the eight-fold load-and-simulate
+  gain the issue is about.
+
+**The mechanism behind the downstream shifts is in the refit's own numbers, not in the inputs.** The
+Horvitz–Thompson baseline sums to 29.25m households (the pool total); the free-mass refit ends at
+**27.00m (P50) / 27.17m (P95b), −7% to −8%**, and the loss sits on specific groups: national
+`ons.household_composition.lone_households_over_65` −36.5% (dense 0.7%), `couple_non_dependent_children`
+−57.9% (dense 0.4%), `lone_parent_dependent_children` −50% (dense 23%), `ons.population.female_80_84` −31%
+(dense 0.9%), `obr.state_pension` −18.5% (dense −13.4%), the state-pension income bands 9–22% over on the
+compact. The selection keeps the rows the local targets need and sheds mass on older lone households, the
+oldest women and couples with adult children — which is why the compact frames show fewer households, a
+lower state-pension bill, lower poverty and a Gini 0.025 below the dense. National rows within 10%: 323 /
+321 against the dense reference's 353.
+
+Reading for the rulings: the 55k size reproduces national totals that are carried by many rows (income
+tax, UC, reforms) to within a few percent of the dense, and loses the ones carried by few rows or by the
+oldest households; the frozen-target refit cannot be told to hold the household total (mass is free) and
+the stretch bound 10 on the HT baseline stops it from re-weighting the few survivors. S4 at 110,000 tests
+whether doubling the support closes those gaps; a mass-conserving refit, or protecting a carrier per
+national composition row the way the local rows are protected, are the two machinery levers if it does not.
+
+### Rebase onto main and push (María, 2026-09-09 ~13:10Z)
+
+`uk-dataset-sizes-355` rebased onto main a19582bd (#881 policy-year rule, #883 UC claimant contracts with
+best-iterate retention in `_optimize`); 26 branch commits replayed (the three superseded re-pin commits fell
+away), two `solve.py` conflicts resolved by keeping both sides (main's `selection_receipt` kwarg beside the
+gate-initialisation splat; main's `iterate_selection_receipt` beside `budget_search`). Pins re-cut on the
+combined tree: bundles am 6352283c… / be 03b57d3f… / uk 1f4c6fd8…, loader golden 66d468c0…, seed map
+fbc9ca74…, seed protocol 28869ae8…, US spec 86ad8bb9… (the multispine test's live binding; its second
+`spec_sha256` is a fixture constant), the coverage report and the H1 calibrate fixture; main's new
+pre-best-iterate oracle attests `gates.py` bytes, re-pinned 379e4adb… → 14608a5e… because #355's gates
+changes (per-record initial probabilities, protected mask) move it. Main now locks policyengine-uk
+**2.97.0**; the run tree's venv was synced (`uv sync --locked --extra us --extra uk`). Green on the rebased
+tree at 2.97.0: calibrate 236, UK build suites 100, registers/ledger 84, spec pins + graph parity 58,
+multispine 187, engine re-run 120; ruff, format and the partition verification clean.
+
+Consequence for the next runs: S4 and any later size run execute on engine 2.97.0 with main's best-iterate
+dense solver, so their dense reference will not be bit-identical to the one P50 and P95b share (2.94.0,
+e2667da9). Comparisons across that line carry an input-and-solver difference, as the R17 comparison does.
+
+### Further evaluation legs (María, 2026-09-09 ~14:00Z: no S4 for now; evaluate the 55k datasets as far as possible)
+
+- **Admin scorecard on one engine (2.97.0, the rebased lock), four files:** P50 / P95b / R17 / enhanced FRS
+  7b0a06f0 — population 68.4 / 68.7 / 69.8 / 69.6 m; households 27.2 / 27.4 / 29.3 / 31.3 m; state pension
+  120.0 / 120.4 / 129.7 / 125.5 bn; income tax 269.0 / 269.0 / 267.9 / 293.2 bn; taxpayers 38.2 / 38.2 /
+  37.7 / 41.8 m; UC 73.9 / 74.3 / 75.8 / 75.3 bn; UC families 6.72 / 6.73 / 6.72 / 6.39 m; child benefit
+  16.4 / 16.5 / 16.5 / 16.9 bn; pension credit 6.20 / 6.22 / 6.25 / 6.19 bn; council tax 43.7 / 43.9 / 45.9
+  / 49.5 bn; poverty BHC 9.89 / 9.93 / 10.30 / 11.49 %; top-1 % share 7.47 / 7.48 / 6.70 / 6.95 %; Gini 0.350
+  / 0.351 / 0.376 / 0.376. Load-and-simulate 7 s / 8 s / 95 s / 7 s. (The incumbent leg loads under
+  2.97.0; it failed in the 2.94.0 loader.)
+- **Incumbent score (step 30):** the register problem is solved — a scoring register with the 19,419 active
+  local references is derivable from the run's own bound `local_target_registry.json` (ladder rows
+  excluded, `geography_level` mapped from `area_type`; written through `TargetRegistry.to_json`, so the
+  content hash holds). The scorer then refuses because "candidate rotated holdout declares no usable basis":
+  the rule-1 score needs the rotated holdout, which both runs skipped by ruling. It is measurable only on a
+  holdout run (S2h, 20–33 h).
+- **T6 dashboard replays** (`uk-candidate-eval/scripts/run_final_gate.sh`, the uk-data venv at
+  policyengine-uk 2.89.2, incumbent = R17): running for P50, then P95b; results appended when done.
+- **Exclusions:** the A16 register holds 51 entries, none expired on 2026-09-09; five expire 2026-10-03
+  (`ons.savings_interest_income` #866, `obr.housing_benefit` #867, the two SLC plan-2 borrower rows #868,
+  `dwp.jsa_claimants` #869 — spine gaps at initialization, not retirement candidates), five 2026-11-25, 39
+  2026-11-26, two 2026-12-08 (this PR's UC bands). Nothing was retired: the 46 `measure_excluded` national
+  rows the surface evaluator could resolve on the compact frame are still 15–95 % off with three exceptions
+  (`SINGLE_annual_payment_9_600_to_10_800` 3 %, `hmrc/state_pension_income_band_1_000_000_to_inf` 2 %,
+  `LONE_PARENT_annual_payment_18_000_to_19_200` 11 %), and a retirement decision needs the dense pool
+  measured on those rows, which no dense H5 on spine-p exists to do.
+
+- **T6 dashboard replays (`run_final_gate.sh`, uk-data venv at policyengine-uk 2.89.2, R17's dense H5 as the
+  comparison file): not measurable on this machine.** For both candidates the candidate legs ran (P95b
+  childcare baseline: Tax-Free Childcare £0.97bn, UC childcare element £2.11bn net / £9.18bn gross,
+  entitlements £5.45bn, total £8.67bn; the autumn-budget generator completed the candidate side) and every
+  comparison leg on the 792,690-row dense file died: the vendored `uk-budget-data generate` failed on it and
+  the RF-UC and childcare scripts were killed by the OS (out of memory, 26 GB machine). Roll-up "review" on
+  all three. A T6 against the default enhanced-FRS snapshot (a9e52499) would fit; not run.
+
+### eFRS legs and T6 replays (2026-09-09 14:48–16:07Z, `spine-p/efrs-legs/`)
+
+María asked whether the eFRS could be added to the downstream section rather than assumed. The three
+uk-candidate-eval instruments were re-run with the enhanced FRS (7b0a06f0) as the comparison file, and the
+P95b/R17 pair re-run beside them, all on policyengine-uk **2.97.0** (the rebased lock), so one table holds
+P50, P95b, R17 and the eFRS:
+
+- **T5 eight reforms** (impact on the government balance, £bn; expected = uk-data's published expectation,
+  tolerance 5): P50 / P95b / R17 / eFRS pass **7 / 7 / 6 / 8** of 8. The eFRS lands the UC taper reform at
+  −23.2 (expected −17.2, in tolerance) where P50 / P95b / R17 give −35.4 / −35.9 / −34.3 — the one reform the
+  microcosm family misses, dense and compact alike; VAT +2pp: eFRS 33.4 vs expected 31.3, P50 24.7, R17 21.1.
+  On the six income-tax and benefit reforms all four files agree within 0.5bn.
+- **T4 admin anchors**: P50 and P95b pass the same three (UC spend, UC caseload, carer element) and fail the
+  same five as R17; against the eFRS the differentiator "multi-family households" reads 6.3m on the
+  candidates and 2.9m on the eFRS (anchor 244k — all far off), income tax 269bn vs the eFRS 293bn (anchor
+  331bn), population 68.4m vs 69.6m (anchor 69.5m).
+- **T3 variable distributions against the eFRS**: P50 105 pass / 52 attention / 33 fail / 1 expected; P95b
+  103 / 53 / 34 / 1 (against R17 the same runs fail 9): the extra fails are variables the microcosm family
+  models differently from the eFRS (charitable gifts, corporate wealth, education spending, fuel spending,
+  AFCS/BSP reported), not size effects.
+- **T6 dashboard replays against the default eFRS snapshot (a9e52499), uk-data environment**: all three
+  dashboards ran for both candidates, roll-up "review" (the replay's only non-failing verdict when metrics
+  move). Autumn budget (vendored model 2.65.3): 1,302 metrics, P50 819 ok / 473 flagged (472 "move", 6
+  benchmark regressions, 3 band migrations), candidate closer to or level with the benchmark on 25 of 37
+  benchmarked metrics (bands close/moderate/divergent/none 6/10/13/8 vs the eFRS 3/7/19/8); combined
+  budgetary impact FY 2026-27 −4.0bn vs the eFRS −7.9bn. RF UC (2.89.2): 27 metrics, 13 ok / 14 flagged,
+  closer on 7 of 10; working-age adults in UC 8.69m vs the eFRS 7.93m (RF headline 8.5m). Childcare (2.89.2):
+  35 metrics, 18 ok / 15 flagged / 2 excluded, closer on 8 of 17; Tax-Free Childcare 0.97bn vs 1.23bn (HMRC
+  0.63bn), UC childcare element 2.13bn vs 1.84bn. P95b within a few percent of P50 on every dashboard.
+  Controls pass (income-curve identical-control 20,100 cells).
+
+All four files' numbers and the per-metric T6 tables are under `efrs-legs/` (JSON + markdown per
+dashboard and run); the evaluation page carries the four-file tables.
+
+### Rebase over #891 and Vahid's review of #877 (2026-09-09, evening)
+
+Rebased onto main cc9c953c (#891 UC paid targets: the register counts 51 / 18 / 82 held; the UK bundle
+digest moved). Vahid's pass at 37f81933: no blocking defects; three should-fix items, three questions,
+nits. Landed:
+
+1. **Doctrine drift on resume.** `_size_checkpoint_identity` carries `_doctrine_bounds()`; the doctrine
+   solve asserts the restored `max_weight_ratio`, `mass` and `target_loss_cap` against today's doctrine
+   after the load and refuses by name; the writing run's `code_pin` and `build_id` ride in the checkpoint's
+   `provenance`, reported on resume, not compared.
+2. **Stale checkpoint in `--out`** refused before the solve (`_refuse_stale_size_checkpoint`, beside the
+   output-path guard), naming the files and the `--resume-size-checkpoint` way out.
+3. **`gates.py` and `initialization.py`** join the seed-protocol implementation digest; the pre-best-iterate
+   oracle runs with a frozen copy of the gate module (`fixtures/pre_best_iterate/gates_14608a5e.py`,
+   loaded as `pre_best_iterate_gates`; the control asserts the oracle's `HardConcrete` is the frozen class).
+   Consequences re-cut: seed protocol fd3e4b06…, seed map 87ba5053…, pointer inventory 2c0423a0…, field
+   counts 42,156 / 9,772 and the `resolved_seed_protocol` claim 826 rows, mode and generation-0 counts,
+   bundles am d983a5e6… / be 2a7d8348… / uk 2269bc28…, loader golden 57026e58…, US spec 35a02b6b…, the
+   coverage report; the H1 calibrate fixture did not move.
+4. **The draw's determinism stated:** `certainty_share` and `boundary_draws` in the size receipt (P50 99.3 %
+   by threshold, 405 drawn; P95b 99.7 %, 156 drawn); manifest keys
+   `realized_max_weight_ratio_vs_stretch_reference` (the refit's reference) and
+   `realized_max_weight_ratio_vs_design` (the pool design weights).
+5. **`zero_target_rows`** in the size receipt (0 on the licensed surface).
+6. The two register changes stay, as their own paragraph in the PR body.
+Nits: the written-checkpoint receipt carries no timestamp and no absolute path; the four `options` keys are
+additive. Green on the rebased tree: calibrate 236 (with the frozen gates control), UK build suites 100,
+local rowwise 52, registers 93, spec pins + parity + coverage tool, multispine 187; ruff and the partition
+verification clean. Reply to Vahid drafted for María's go.
+
diff --git a/packages/microcosm-build/src/microcosm/build/spec_engine/field_usage.py b/packages/microcosm-build/src/microcosm/build/spec_engine/field_usage.py
index aa6039e3a..107265aeb 100644
--- a/packages/microcosm-build/src/microcosm/build/spec_engine/field_usage.py
+++ b/packages/microcosm-build/src/microcosm/build/spec_engine/field_usage.py
@@ -27,8 +27,8 @@
 from .schemas import load_schema_registry
 
 EXPECTED_AUTHORED_FIELD_COUNT = 32_384
-EXPECTED_RESOLVED_BINDING_FIELD_COUNT = 9_770
-EXPECTED_CONFIGURATION_FIELD_COUNT = 42_154
+EXPECTED_RESOLVED_BINDING_FIELD_COUNT = 9_772
+EXPECTED_CONFIGURATION_FIELD_COUNT = 42_156
 
 
 class FieldUsageError(AssertionError):
@@ -249,13 +249,9 @@ def is_stacked_geography_source_identity(pointer: str) -> bool:
         )
 
     if claim.pointer_class == "stacked_geography_source_identity":
-        return [
-            row for row in rows if is_stacked_geography_source_identity(row[0])
-        ]
+        return [row for row in rows if is_stacked_geography_source_identity(row[0])]
     if claim.pointer_class == "source_validation":
-        return [
-            row for row in rows if not is_stacked_geography_source_identity(row[0])
-        ]
+        return [row for row in rows if not is_stacked_geography_source_identity(row[0])]
     raise FieldUsageError(f"{claim.id}: unknown pointer class {claim.pointer_class!r}")
 
 
@@ -457,8 +453,8 @@ def _path_inventory(rows: Sequence[tuple[str, object]]) -> tuple[int, str]:
         "6a781915fd491d2c4b16d2b7d482f69cf362c904130093c59f9629f7a319269b",
     ),
     "resolved_seed_protocol": (
-        824,
-        "7537385c3fd399a2dbb7dcd8ed7cf1ff2481ed336db621eafcbfd741d5792f40",
+        826,
+        "7ff2d5d1c2fd8026d17a57244f969dc0e9625a9e47304b693ad15df329041282",
     ),
     "resolved_seed_site_bindings": (
         277,
@@ -1125,7 +1121,9 @@ def _verify_source_pins(context: _VerificationContext, claim: UsageClaim) -> Non
         if isinstance(row, Mapping) and isinstance(row.get("id"), str)
     ]
     if len(ids) != len(rows) or len(ids) != len(set(ids)):
-        raise FieldUsageError("source_pins: source ids are not an exact unique registry")
+        raise FieldUsageError(
+            "source_pins: source ids are not an exact unique registry"
+        )
 
     expected_refs: set[tuple[str, str, str]] = set()
     for index, value in enumerate(rows):
@@ -1468,9 +1466,7 @@ def _verify_claim(context: _VerificationContext, claim: UsageClaim) -> None:
         "legacy": lambda: _verify_legacy(context, claim),
         "source_pins": lambda: _verify_source_pins(context, claim),
         "spine_channels": lambda: _verify_spine_channels(context, claim),
-        "spine_assembly_legacy": lambda: _verify_spine_assembly_legacy(
-            context, claim
-        ),
+        "spine_assembly_legacy": lambda: _verify_spine_assembly_legacy(context, claim),
         "spine_assembly_validation": lambda: _verify_spine_assembly_validation(
             context, claim
         ),
diff --git a/packages/microcosm-build/src/microcosm/build/spec_engine/inventory_coverage.py b/packages/microcosm-build/src/microcosm/build/spec_engine/inventory_coverage.py
index d9413007e..89171055c 100644
--- a/packages/microcosm-build/src/microcosm/build/spec_engine/inventory_coverage.py
+++ b/packages/microcosm-build/src/microcosm/build/spec_engine/inventory_coverage.py
@@ -359,8 +359,8 @@
     "late_schedule": "e59c019d3d454eac99ac0ac209b6c5b6faaf9bdfcaeee18c36a25be19bf7da2f",
     "ownership": "5f64f0aac49e2313177564f71876bffc8c81b3ded4df701e70930e60e9c98356",
     "primary_tuples": "987b501c695e31f45521c4a178528f75ab3df22c09bc407b182213b2de99ee57",
-    "seed_map": "c94a5af8eb24866156b8cd4b77b93dc497b7df5b025204fe1022f80b1d8446ea",
-    "seed_protocol": "1c53f1d9b3e185a41181fbe861f9b08d56c83880710fd1e18d7a4ceb5d6a354e",
+    "seed_map": "87ba50531d9fa6683096ecb39a31655b331ab8acff3a5876c2f62b33562a0885",
+    "seed_protocol": "fd3e4b06f11be4e8c13ea19fef9469ab95cbbe3e2dcfce351e860dd3e00709e4",
     "source_manifest": "cd5ba8924d64da5425ee14cca82a774e3f4b2bb5aabe06df291cc3cc457287a9",
     "take_up": "fa186daea0f8dd641cc470e41d1a2953f887d45282ec990201298f47bedf8d4d",
     "tail": "ac92829c88a1a4fb6460d61190918d5d99c6c377fc8dd8f62f02b332d09bf59c",
diff --git a/packages/microcosm-build/src/microcosm/build/spec_engine/seeds.py b/packages/microcosm-build/src/microcosm/build/spec_engine/seeds.py
index 04fb87ad8..e837a009e 100644
--- a/packages/microcosm-build/src/microcosm/build/spec_engine/seeds.py
+++ b/packages/microcosm-build/src/microcosm/build/spec_engine/seeds.py
@@ -346,6 +346,8 @@ def _site(
     "microcosm.build.us_runtime.wic_claim",
     "microcosm.build.us_runtime.workers_compensation",
     "microcosm.calibrate.exact_k",
+    "microcosm.calibrate.gates",
+    "microcosm.calibrate.initialization",
     "microcosm.calibrate.solve",
 )
 _QRF_KERNEL_MODULES = (
diff --git a/packages/microcosm-build/src/microcosm/build/uk/calibration_measure_exclusions.json b/packages/microcosm-build/src/microcosm/build/uk/calibration_measure_exclusions.json
index 8902b6f7f..3ce5d4cfd 100644
--- a/packages/microcosm-build/src/microcosm/build/uk/calibration_measure_exclusions.json
+++ b/packages/microcosm-build/src/microcosm/build/uk/calibration_measure_exclusions.json
@@ -441,6 +441,24 @@
       "adjudication": "microcosm#762 (A16, ruling 2026-09-03; receipts R8-R10 in experiments/762-uk-rowwise-candidate-receipts.md)",
       "approved_on": "2026-09-03",
       "expires_on": "2026-10-03"
+    },
+    {
+      "name": "dwp/uc_payment_dist/COUPLE_NO_CHILDREN_annual_payment_27_600_to_28_800",
+      "reason": "Zero-support channel under the corrected UC composition proxy: since #879 the payment-distribution rows are measured on the relationship-based uc_calibration_family_type, and no benefit unit in the spine is a couple without children with an annual UC award in this band (final estimate 0.0, -100% on #879's corrected comparison; no pool carrier on the K=15 rowwise clone of spine-p either, where the #355 size selection refuses the row by name). The dense seam carries the row as a capped miss; a size selection cannot carry it. The band catalogue and the unbounded top band are tracked in microcosm#736; the sibling 26,400-27,600 band already sits in this register.",
+      "tracking": "microcosm#736",
+      "approved_by": "juaristi22",
+      "adjudication": "microcosm#355 (dataset-size experiment; ruling by María 2026-09-08 after the 45,800 smoke's by-name refusal)",
+      "approved_on": "2026-09-08",
+      "expires_on": "2026-12-08"
+    },
+    {
+      "name": "dwp/uc_payment_dist/COUPLE_NO_CHILDREN_annual_payment_28_800_to_30_000",
+      "reason": "Zero-support channel under the corrected UC composition proxy: since #879 the payment-distribution rows are measured on the relationship-based uc_calibration_family_type, and no benefit unit in the spine is a couple without children with an annual UC award in this band (final estimate 0.0, -100% on #879's corrected comparison; no pool carrier on the K=15 rowwise clone of spine-p either, where the #355 size selection refuses the row by name). The dense seam carries the row as a capped miss; a size selection cannot carry it. The band catalogue and the unbounded top band are tracked in microcosm#736; the sibling 26,400-27,600 band already sits in this register.",
+      "tracking": "microcosm#736",
+      "approved_by": "juaristi22",
+      "adjudication": "microcosm#355 (dataset-size experiment; ruling by María 2026-09-08 after the 45,800 smoke's by-name refusal)",
+      "approved_on": "2026-09-08",
+      "expires_on": "2026-12-08"
     }
   ]
 }
diff --git a/packages/microcosm-build/src/microcosm/build/uk/uk_local_target_census.json b/packages/microcosm-build/src/microcosm/build/uk/uk_local_target_census.json
index 7c2140eec..63f402b09 100644
--- a/packages/microcosm-build/src/microcosm/build/uk/uk_local_target_census.json
+++ b/packages/microcosm-build/src/microcosm/build/uk/uk_local_target_census.json
@@ -708,10 +708,10 @@
         "source_commit": "6fb700e",
         "source_repo": "PolicyEngine/chronicle"
       },
-      "notes": "PIPR publishes average rent price levels, not additive rent totals. All 361 local-authority cells remain signed deferred for the 2025 compile: 314 are after-period, four English cells have no matching LA id, 32 Scottish cells are represented only at BRMA grain without a signed translation, and 11 Northern Ireland cells are absent.",
+      "notes": "PIPR publishes average rent price levels, not additive rent totals; a bound cell composes the level into a total (see the signed rationale). Of the 361 local-authority cells, 314 bind for the 2025 compile and 47 remain signed deferred: four English cells have no matching LA id, 32 Scottish cells are represented only at BRMA grain without a signed translation, and 11 Northern Ireland cells are absent.",
       "product": "Price Index of Private Rents (PIPR), UK: monthly price statistics \u2014 rent indices, annual change, and price levels.",
       "publisher": "Office for National Statistics",
-      "signed_rationale": "The pinned Ledger fact feed carries one PIPR period, 2026-06, with 348 facts: 314 crosswalk England/Wales LA rows, two English LA ids outside the crosswalk, 18 Scottish BRMA rows, nine region rows, and five country rows. None is at or before the 2025 target period; four English crosswalk authorities are absent, Scotland has no LA rows, and Northern Ireland has no rows at any grain.",
+      "signed_rationale": "The pinned Ledger fact feed carries 2025 PIPR months; compiled rows resolve at 2025-12 with 36 facts at or before the target period. Four English crosswalk authorities are absent, Scotland has no LA rows, and Northern Ireland has no rows at any grain. The bound price level is composed as 12 months times the mean times A17-uprated private-renter households under microcosm#355 (ruling 2026-09-08).",
       "signed_reason_id": "private_rent_pipr_partial_coverage_2025",
       "source_id": "ons_pipr_private_rents",
       "status": "signed_deferred",
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/__init__.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/__init__.py
index f09ddc90e..07d05bec4 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/__init__.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/__init__.py
@@ -34,6 +34,7 @@
     UK_DIAGNOSTICS_SCHEMA_VERSION,
     UK_TARGET_GEOGRAPHY_LEVELS,
     uk_calibration_diagnostics_payload,
+    uk_fit_by_family,
     uk_support_limited_misses,
     uk_weakest_areas_by_fit,
     uk_weakest_families,
@@ -449,6 +450,21 @@
     prepare_geography_crosswalk,
     validate_geography_coverage,
 )
+from microcosm.build.uk_runtime.size_evaluation import (
+    PRE_REGISTERED_OUTCOMES_V1,
+    RowwiseRun,
+    area_support_tables,
+    dense_reference_deltas,
+    fit_tables,
+    footprint,
+    frozen_vs_recomputed,
+    gate_table,
+    load_run,
+    paired_targets,
+    run_acceptance,
+    summarize,
+    weight_tables,
+)
 from microcosm.build.uk_runtime.spi_income import (
     SPI_DONOR_DOI,
     SPI_DONOR_FILENAME,
@@ -533,6 +549,8 @@
 )
 
 __all__ = [
+    "PRE_REGISTERED_OUTCOMES_V1",
+    "RowwiseRun",
     "UK_AGE_TAIL_BANDS",
     "UK_AGE_TAIL_BAND_POPULATIONS_RESOURCE",
     "UK_AGE_TAIL_DECLARED_SEEDS",
@@ -759,6 +777,7 @@
     "apply_uk_release_identity",
     "apply_uk_source_lineage_modulus",
     "area_groups_from_codes",
+    "area_support_tables",
     "assemble_uk_oa_ladder",
     "concat_uk_ladder_frames",
     "assert_uk_hmrc_income_source_contract_current",
@@ -769,6 +788,7 @@
     "assign_household_geography",
     "assert_frs_hmrc_auxiliary_crosswalk_available",
     "derive_hmrc_income_auxiliaries",
+    "dense_reference_deltas",
     "assign_uk_geography_ladder",
     "assign_vat_flags",
     "build_firm_target_matrix",
@@ -806,7 +826,10 @@
     "drop_injected_measure_inputs",
     "employment_band_name",
     "fill_support_channel_from_source",
+    "fit_tables",
+    "footprint",
     "format_uk_release_id",
+    "frozen_vs_recomputed",
     "impute_uk_spi_income_support",
     "replace_uk_spi_support_tables",
     "retain_uk_frs_hmrc_leaves",
@@ -821,6 +844,7 @@
     "generate_input_values",
     "generate_uk_firm_population",
     "geography_coverage_summary",
+    "gate_table",
     "hmrc_band_name",
     "id_multiplier_for_values",
     "infer_ni_dz_constituencies_from_postcodes",
@@ -836,6 +860,7 @@
     "load_efrs_parity_known_gaps",
     "load_efrs_parity_reference",
     "load_lad_itl_lookup",
+    "load_run",
     "load_ni_dz_hierarchy",
     "load_ni_dz_households",
     "load_ni_dz_population",
@@ -862,6 +887,7 @@
     "metric_names_from_target_profile",
     "metric_tables_by_area_group",
     "optimize_firm_weights",
+    "paired_targets",
     "prepare_uk_target_frame",
     "prepare_geography_crosswalk",
     "read_uk_single_year_weight_metadata",
@@ -869,14 +895,17 @@
     "solve_firm_weights",
     "past_cap_census",
     "rowwise_area_support_summary",
+    "run_acceptance",
     "solve_uk_rowwise_weights_under_doctrine",
     "support_channel_column",
     "support_clone_index_column",
     "support_source_id_column",
+    "summarize",
     "target_diagnostics",
     "uk_firm_source_data_from_frames",
     "uk_firm_source_data_from_ledger_facts",
     "uk_calibration_diagnostics_payload",
+    "uk_fit_by_family",
     "uk_support_limited_misses",
     "uk_spine_source_family_units",
     "uk_frame_content_identity",
@@ -923,6 +952,7 @@
     "spine_provenance_from_sidecar",
     "load_uk_rowwise_dataset",
     "write_uk_rowwise_dataset",
+    "weight_tables",
     "write_hmrc_replay_report",
     "UK_DEFAULT_ZERO_WEIGHT_STRATA",
     "EDUCQUAL_MAP",
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/dataset_size.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/dataset_size.py
new file mode 100644
index 000000000..a358d5fd8
--- /dev/null
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/dataset_size.py
@@ -0,0 +1,536 @@
+"""Exact household-count UK candidates on a fixed, materialized target surface."""
+
+import json
+from collections.abc import Callable
+from dataclasses import dataclass, replace
+from typing import Any
+
+import numpy as np
+import pandas as pd
+from scipy import sparse
+
+from microcosm.calibrate import (
+    CalibrationResult,
+    TargetSet,
+    assert_exact_k_support,
+    calibrate,
+    exact_k_design_feasibility,
+    refit_l0_selection,
+    select_exact_k,
+)
+from microcosm.calibrate.initialization import contribution_initialization
+from microcosm.calibrate.solve import BUDGET_BASIS_OPEN_PROBABILITY_MASS
+from microcosm.frame import Frame
+
+
+@dataclass(frozen=True)
+class UKDatasetSize:
+    """A compact refit with its full-pool row identities and selection evidence."""
+
+    result: CalibrationResult
+    support: np.ndarray
+    receipt: dict[str, object]
+
+
+@dataclass(frozen=True)
+class UKSizeSelection:
+    """The informed L0 search a size draw starts from.
+
+    Kept apart from the draw and the refit so a run can checkpoint the dense
+    solve and this search before the exact-count draw: a draw refusal then
+    costs a re-draw, not the hours the pool solve took (microcosm#355, S2
+    2026-09-08). ``search_pi_hi`` is the certainty threshold the budget
+    search stopped on; a later draw may use another threshold, recorded
+    beside it in the size receipt.
+    """
+
+    selection: CalibrationResult
+    protected: np.ndarray
+    households: int
+    epochs: int
+    learning_rate: float
+    seed: int
+    search_pi_hi: float
+
+
+ProgressCallback = Callable[[dict[str, object]], None]
+
+
+def _phased(
+    progress_callback: ProgressCallback | None, phase: str
+) -> ProgressCallback | None:
+    """Tag every progress event with the size stage it belongs to."""
+    if progress_callback is None:
+        return None
+
+    def callback(event: dict[str, object]) -> None:
+        progress_callback({"phase": phase, **event})
+
+    return callback
+
+
+def _check_size_inputs(frame: Frame, dense: CalibrationResult, households: int) -> int:
+    n = frame.n("household")
+    if (
+        isinstance(households, bool)
+        or not isinstance(households, int)
+        or not 0 < households <= n
+    ):
+        raise ValueError(f"households must be an integer in [1, {n}]; never clamped.")
+    if (
+        dense.skipped
+        or len(dense.weights) != n
+        or dense.l0_lambda != 0
+        or dense.weight_entity != "household"
+        or not np.array_equal(
+            frame.table("household")["household_id"].to_numpy(),
+            dense.frame.table("household")["household_id"].to_numpy(),
+        )
+        or not np.array_equal(
+            frame.weights_for("household").values, dense.initial_weights
+        )
+    ):
+        raise ValueError(
+            "size selection requires an aligned, fully compiled dense solve."
+        )
+    return n
+
+
+def _check_pi_hi(pi_hi: object) -> float:
+    if not isinstance(pi_hi, float | int) or isinstance(pi_hi, bool):
+        raise ValueError("pi_hi must be a number in (0, 1].")
+    value = float(pi_hi)
+    if not (0.0 < value <= 1.0):
+        raise ValueError("pi_hi must be a number in (0, 1].")
+    return value
+
+
+def _solver_common(
+    dense: CalibrationResult, *, epochs: int, learning_rate: float, seed: int
+) -> dict[str, Any]:
+    return dict(
+        weight_entity="household",
+        epochs=epochs,
+        learning_rate=learning_rate,
+        mass=dense.options["mass"],
+        max_weight_ratio=dense.options["max_weight_ratio"],
+        seed=seed,
+        target_loss_weights=dense.target_loss_weights,
+        target_loss_scales=dense.target_loss_scales,
+        target_loss_cap=dense.target_loss_cap,
+    )
+
+
+def select_uk_dataset_size(
+    frame: Frame,
+    dense: CalibrationResult,
+    *,
+    households: int,
+    epochs: int,
+    learning_rate: float,
+    seed: int,
+    pi_hi: float = 1.0,
+    progress_callback: ProgressCallback | None = None,
+) -> UKSizeSelection:
+    """Run the informed L0 budget search for an exact-count draw of ``households``.
+
+    Refuses by name any nonzero target no pool household supports, protects
+    each remaining target's largest carrier, and searches the L0 penalty on
+    the gates' open-probability mass until a draw of ``households`` at
+    ``pi_hi`` is feasible on the learned probabilities (or the probe budget
+    is spent; then the draw refuses with the measurement).
+    """
+    n = _check_size_inputs(frame, dense, households)
+    pi_hi = _check_pi_hi(pi_hi)
+    if households == n:
+        raise ValueError("a full-pool size needs no selection.")
+    problem = dense.problem
+    unsupported = unsupported_nonzero_targets(problem)
+    if unsupported:
+        shown = ", ".join(unsupported[:12])
+        more = "" if len(unsupported) <= 12 else f" (+{len(unsupported) - 12} more)"
+        raise ValueError(
+            f"{len(unsupported)} nonzero target(s) have no supporting household in "
+            f"the pool, so no selection can carry them: {shown}{more}. The dense "
+            "solve tolerates such rows as misses; a size selection refuses them "
+            "by name so the binding defect is fixed or the row is excluded with "
+            "a signed reason, never selected around."
+        )
+    # Input weights are the pool design, not the concentrated dense weights.
+    init = contribution_initialization(
+        problem.matrix, dense.initial_weights, problem.target_vector
+    )
+    if int(init.protected.sum()) > households:
+        raise ValueError(
+            f"requested {households} households cannot retain {int(init.protected.sum())} protected target carriers."
+        )
+    # The exact-count draw can only draw from the gates' open-probability
+    # mass, so the budget search targets that mass, not the count of
+    # not-fully-closed gates (microcosm#355 ruling 2026-09-08), and it stops
+    # only on a probe whose gates make the draw at ``pi_hi`` feasible: the
+    # draw's inequality is one-sided, the budget band is not, and S2 (2026-09-08)
+    # landed 166 rows under the request inside the band and was refused.
+    selection = calibrate(
+        frame,
+        TargetSet(problem.targets),
+        target_records=households,
+        gate_initialization=init,
+        mass_reason=dense.options["mass_reason"],
+        budget_basis=BUDGET_BASIS_OPEN_PROBABILITY_MASS,
+        feasible_draw_pi_hi=pi_hi,
+        progress_callback=_phased(progress_callback, "size_search"),
+        **_solver_common(dense, epochs=epochs, learning_rate=learning_rate, seed=seed),
+    )
+    if selection.gate_open_probabilities is None:
+        raise RuntimeError("informed L0 returned no selection probabilities.")
+    return UKSizeSelection(
+        selection=selection,
+        protected=np.asarray(init.protected, dtype=bool),
+        households=households,
+        epochs=epochs,
+        learning_rate=learning_rate,
+        seed=seed,
+        search_pi_hi=pi_hi,
+    )
+
+
+def refit_uk_dataset_size(
+    frame: Frame,
+    dense: CalibrationResult,
+    *,
+    households: int,
+    epochs: int,
+    learning_rate: float,
+    seed: int,
+    pi_hi: float = 1.0,
+    selection: UKSizeSelection | None = None,
+    progress_callback: ProgressCallback | None = None,
+) -> UKDatasetSize:
+    """Run informed L0, a fixed-size draw, and refit under the dense doctrine.
+
+    Freeze the already compiled household contributions, including engine
+    measures that depend on the full population. Re-evaluating those formulas
+    on a subset would change the target system. Target values, order, loss
+    weights, cap and stretch bound remain those of the dense solve.
+
+    ``pi_hi`` is the exact-count draw's certainty threshold: gates whose
+    learned open probability reaches it are taken with certainty and only the
+    rest are drawn. The default ``1.0`` keeps exactly the protected carriers
+    as certainties; a lower threshold (the US exact-k ladder runs 0.95)
+    promotes learned near-certain gates and is a reviewed candidate-run
+    setting recorded in the size receipt, never a release default.
+
+    ``selection`` skips the informed L0 search and draws from an existing
+    :class:`UKSizeSelection` (a checkpoint restored by
+    :mod:`microcosm.build.uk_runtime.size_checkpoint`); it must have been
+    searched for the same size, epochs, learning rate and seed on this pool.
+    """
+    n = _check_size_inputs(frame, dense, households)
+    pi_hi = _check_pi_hi(pi_hi)
+    if households == n:
+        return UKDatasetSize(
+            dense,
+            np.arange(n),
+            {
+                "method": "full_pool",
+                "requested_households": n,
+                "realized_households": n,
+                "pool_households": n,
+                "seed": seed,
+            },
+        )
+    problem = dense.problem
+    if selection is None:
+        selection = select_uk_dataset_size(
+            frame,
+            dense,
+            households=households,
+            epochs=epochs,
+            learning_rate=learning_rate,
+            seed=seed,
+            pi_hi=pi_hi,
+            progress_callback=progress_callback,
+        )
+        reused = False
+    else:
+        reused = True
+        expected = {
+            "households": households,
+            "epochs": epochs,
+            "learning_rate": learning_rate,
+            "seed": seed,
+        }
+        mismatched = sorted(
+            f"{key}: selection {getattr(selection, key)!r} != {value!r}"
+            for key, value in expected.items()
+            if getattr(selection, key) != value
+        )
+        probabilities_given = selection.selection.gate_open_probabilities
+        if (
+            probabilities_given is None
+            or len(probabilities_given) != n
+            or len(selection.protected) != n
+            or len(selection.selection.weights) != n
+            or selection.selection.l0_lambda <= 0.0
+        ):
+            mismatched.append("pool: the selection was not searched on this pool")
+        if mismatched:
+            raise ValueError(
+                "cannot draw from a selection searched for different inputs: "
+                + "; ".join(mismatched)
+                + "."
+            )
+    init_protected = selection.protected
+    common = _solver_common(
+        dense, epochs=epochs, learning_rate=learning_rate, seed=seed
+    )
+    probabilities = selection.selection.gate_open_probabilities
+    assert probabilities is not None
+    search_result = selection.selection
+    feasibility = selection_feasibility(
+        probabilities,
+        households,
+        protected=init_protected,
+        n_nonzero=int(search_result.n_nonzero),
+        l0_lambda=float(search_result.l0_lambda),
+        requested_pi_hi=pi_hi,
+        budget_search=search_result.options.get("budget_search"),
+        search_pi_hi=selection.search_pi_hi,
+    )
+    try:
+        support, sampling, q = select_exact_k(
+            probabilities, households, pi_hi=pi_hi, seed=seed
+        )
+    except ValueError as error:
+        # The draw refuses rather than clamps; carry the measured gate mass
+        # with the refusal so the ruling it needs can be made from the receipt.
+        raise ValueError(
+            f"{error} Selection feasibility (requested pi_hi={pi_hi:g}): "
+            f"{json.dumps(feasibility, sort_keys=True)}"
+        ) from error
+    support = assert_exact_k_support(support, households, pool_size=n)
+    if not np.isin(np.flatnonzero(init_protected), support).all():
+        raise RuntimeError("exact-count selection lost a protected carrier.")
+    frozen = _frozen_targets(frame, dense, support)
+    refit = refit_l0_selection(
+        frame,
+        frozen,
+        search_result,
+        support=support,
+        k=households,
+        support_inclusion_probabilities=q,
+        mass_reason=dense.options["mass_reason"],
+        progress_callback=_phased(progress_callback, "size_refit"),
+        **common,
+    ).refit
+    if (
+        refit.skipped
+        or refit.frame.n("household") != households
+        or (refit.weights <= 0).any()
+    ):
+        raise RuntimeError("compact refit lost targets or positive household support.")
+    if not np.array_equal(refit.problem.target_vector, problem.target_vector):
+        raise RuntimeError("compact refit changed target values.")
+    errors_dense = np.asarray([d.final_estimate for d in dense.diagnostics])
+    errors_small = np.asarray([d.final_estimate for d in refit.diagnostics])
+    return UKDatasetSize(
+        refit,
+        support,
+        {
+            "method": "contribution_informed_l0_exact_count_refit",
+            "requested_households": households,
+            "realized_households": households,
+            "pool_households": n,
+            "seed": seed,
+            "protected_carriers": int(init_protected.sum()),
+            # How much of the count the threshold decided versus the draw: with
+            # polarised gates the "draw" is mostly a threshold on learned pi.
+            "certainty_share": float(sampling["certainty_count"]) / float(households),
+            "boundary_draws": int(households - sampling["certainty_count"]),
+            # Rows whose target is exactly zero: the contribution prior uses a
+            # unit denominator there, so a survivor would saturate the prior.
+            "zero_target_rows": int(np.count_nonzero(problem.target_vector == 0.0)),
+            "selection_receipt": sampling,
+            "selection_pi_hi": pi_hi,
+            "selection_search_pi_hi": selection.search_pi_hi,
+            "selection_reused": reused,
+            "selection_budget_basis": BUDGET_BASIS_OPEN_PROBABILITY_MASS,
+            "selection_budget_search": search_result.options.get("budget_search"),
+            "selection_feasibility": feasibility,
+            "selection_l0_lambda": search_result.l0_lambda,
+            "selection_epochs": epochs,
+            "refit_epochs": epochs,
+            "pool_row_indices": support.tolist(),
+            "inclusion_probabilities": q.tolist(),
+            "refit_baseline": "normalized_horvitz_thompson_w_over_q",
+            "stretch_reference": "normalized_horvitz_thompson_w_over_q",
+            "dense_loss": dense.final_loss,
+            "compact_loss": refit.final_loss,
+            "max_target_scaled_change": float(
+                np.max(np.abs(errors_small - errors_dense) / dense.target_loss_scales)
+            ),
+            "certification": "candidate_only_pending_matched_comparison_and_promotion_scorecard",
+        },
+    )
+
+
+def unsupported_nonzero_targets(problem: Any) -> list[str]:
+    """Names of nonzero targets whose constraint row has no nonzero entry.
+
+    ``contribution_initialization`` refuses such a row by index; a size run
+    should refuse it by name, because the cure is upstream (a measure that
+    resolves to zero on the cloned pool, or a filter no pool household
+    satisfies), not in the selection.
+    """
+
+    matrix = sparse.csr_array(problem.matrix)
+    targets = np.asarray(problem.target_vector, dtype=np.float64)
+    support = np.diff(matrix.indptr)
+    nonzero_entries = np.asarray(
+        [
+            int(np.count_nonzero(matrix.data[matrix.indptr[i] : matrix.indptr[i + 1]]))
+            for i in range(matrix.shape[0])
+        ]
+    )
+    names = list(getattr(problem, "names", [str(i) for i in range(matrix.shape[0])]))
+    return [
+        str(names[i])
+        for i in range(matrix.shape[0])
+        if targets[i] != 0.0 and (support[i] == 0 or nonzero_entries[i] == 0)
+    ]
+
+
+_FEASIBILITY_PI_HI_GRID = (0.999, 0.99, 0.98, 0.95, 0.9, 0.8, 0.7, 0.5)
+
+
+def selection_feasibility(
+    probabilities: np.ndarray,
+    households: int,
+    *,
+    protected: np.ndarray,
+    n_nonzero: int,
+    l0_lambda: float,
+    requested_pi_hi: float = 1.0,
+    budget_search: dict[str, object] | None = None,
+    search_pi_hi: float | None = None,
+) -> dict[str, object]:
+    """Measure whether an exact-count draw is feasible on these gate probabilities.
+
+    ``select_exact_k`` with ``pi_hi=1.0`` keeps every gate below one in the
+    boundary and scales its open probabilities to the remaining draw size
+    ``m``; the scaled value of the largest boundary gate must not exceed one,
+    i.e. ``m * max(pi_boundary) <= sum(pi_boundary)``. The L0 budget search
+    stops on the count of not-fully-closed gates, which can sit well above the
+    open-probability mass when gates are only partly polarised, so the draw
+    can refuse. This records the measured mass and the two ways out — the
+    smallest certainty threshold on a fixed grid that makes the design
+    feasible, and the largest household count feasible at ``pi_hi=1.0`` — so
+    the refusal is a ruling with numbers, never a silent clamp.
+    Every verdict comes from :func:`exact_k_design_feasibility`, the draw's own
+    inequality, so the scan and the draw can never disagree. ``budget_search``
+    is the search receipt (probes, the verdict each stopped on) when the
+    selection was searched with a feasibility-aware stop.
+    """
+
+    pi = np.asarray(probabilities, dtype=np.float64)
+    protected_mask = np.asarray(protected, dtype=bool)
+    if pi.shape != protected_mask.shape:
+        raise ValueError("selection feasibility needs aligned probabilities and mask.")
+    certainty = pi >= 1.0
+    boundary = pi[~certainty]
+    positive = boundary[boundary > 0.0]
+    m = int(households) - int(certainty.sum())
+    boundary_mass = float(positive.sum()) if positive.size else 0.0
+    boundary_max = float(positive.max()) if positive.size else 0.0
+    at_one = exact_k_design_feasibility(pi, int(households), 1.0)
+    feasible = bool(at_one["feasible"])
+    max_feasible_k = (
+        int(certainty.sum()) + int(np.floor(boundary_mass / boundary_max))
+        if boundary_max > 0.0
+        else int(certainty.sum())
+    )
+    scan: dict[str, object] = {}
+    smallest_feasible_pi_hi: float | None = 1.0 if feasible else None
+    for threshold in _FEASIBILITY_PI_HI_GRID:
+        design = exact_k_design_feasibility(pi, int(households), threshold)
+        ok = bool(design["feasible"])
+        scan[f"{threshold:g}"] = {
+            "certainties": int(design["certainty_count"]),
+            "boundary_draw": int(design["boundary_draw"]),
+            "boundary_mass": float(design["boundary_mass"]),
+            "boundary_max": float(design["boundary_max"]),
+            "feasible": ok,
+            "reason": str(design["reason"]),
+        }
+        if ok and smallest_feasible_pi_hi is None:
+            smallest_feasible_pi_hi = threshold
+    quantiles = (
+        {f"p{q * 100:g}": float(np.quantile(pi, q)) for q in (0.5, 0.9, 0.99, 0.999)}
+        if pi.size
+        else {}
+    )
+    requested = exact_k_design_feasibility(pi, int(households), float(requested_pi_hi))
+    return {
+        "requested_households": int(households),
+        "requested_pi_hi": float(requested_pi_hi),
+        "feasible_at_requested_pi_hi": bool(requested["feasible"]),
+        "requested_pi_hi_verdict": str(requested["reason"]),
+        "search_pi_hi": search_pi_hi,
+        "budget_search": budget_search,
+        "pool_households": int(pi.size),
+        "protected_carriers": int(protected_mask.sum()),
+        "certainties_at_pi_hi_1": int(certainty.sum()),
+        "boundary_draw": m,
+        "boundary_positive_gates": int(positive.size),
+        "boundary_mass": boundary_mass,
+        "boundary_max": boundary_max,
+        "feasible_at_pi_hi_1": bool(feasible),
+        "max_feasible_households_at_pi_hi_1": max_feasible_k,
+        "smallest_feasible_pi_hi_on_grid": smallest_feasible_pi_hi,
+        "pi_hi_scan": scan,
+        "pi_sum": float(pi.sum()),
+        "pi_quantiles": quantiles,
+        "gates_above": {
+            f"{t:g}": int((pi >= t).sum()) for t in (0.5, 0.9, 0.99, 0.999)
+        },
+        "budget_search_n_nonzero": int(n_nonzero),
+        "budget_search_basis": BUDGET_BASIS_OPEN_PROBABILITY_MASS,
+        "selection_l0_lambda": float(l0_lambda),
+    }
+
+
+def _feasible_at(pi: np.ndarray, households: int, threshold: float) -> bool:
+    return bool(exact_k_design_feasibility(pi, households, threshold)["feasible"])
+
+
+def _frozen_targets(
+    frame: Frame, dense: CalibrationResult, support: np.ndarray
+) -> TargetSet:
+    """Bind sparse contribution rows to selected ids, with one shared id join."""
+    ids = pd.Index(frame.table("household")["household_id"].iloc[support])
+    matrix = dense.problem.matrix[:, support].tocsr()
+    cached_ids = None
+    cached_positions = None
+
+    def positions(subset):
+        nonlocal cached_ids, cached_positions
+        current = subset.table("household")["household_id"]
+        if cached_ids is None or not current.equals(cached_ids):
+            cached_positions = ids.get_indexer(current)
+            if (cached_positions < 0).any():
+                raise ValueError("frozen target requested unknown household ids.")
+            cached_ids = current.copy()
+        return cached_positions
+
+    def measure(row):
+        def values(subset):
+            return np.asarray(matrix[[row], :].toarray()).reshape(-1)[positions(subset)]
+
+        return values
+
+    return TargetSet(
+        [
+            replace(target, entity="household", measure=measure(row), filter=None)
+            for row, target in enumerate(dense.problem.targets)
+        ]
+    )
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/diagnostics.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/diagnostics.py
index 313d3e48d..2c8bbc4a3 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/diagnostics.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/diagnostics.py
@@ -38,6 +38,7 @@
     "UK_DIAGNOSTICS_SCHEMA_VERSION",
     "UK_TARGET_GEOGRAPHY_LEVELS",
     "uk_calibration_diagnostics_payload",
+    "uk_fit_by_family",
     "uk_support_limited_misses",
     "uk_target_geography_levels",
     "uk_weakest_areas_by_fit",
@@ -476,6 +477,33 @@ def uk_weight_summary(
     }
 
 
+def uk_fit_by_family(
+    diagnostics: pd.DataFrame,
+    *,
+    name_column: str = "target_name",
+) -> list[dict[str, object]]:
+    """Summarize target-fit diagnostics by family."""
+
+    if diagnostics.empty:
+        return []
+    rows = []
+    for family, group in diagnostics.groupby("family", sort=True):
+        errors = group["abs_relative_error"].to_numpy(dtype=np.float64)
+        worst_index = int(np.argmax(errors))
+        worst = group.iloc[worst_index]
+        rows.append(
+            {
+                "family": str(family),
+                "n_targets": len(group),
+                "share_within_10pct": float((errors <= 0.10).mean()),
+                "share_within_25pct": float((errors <= 0.25).mean()),
+                "worst_abs_relative_error": float(errors[worst_index]),
+                "worst_cell": str(worst.get(name_column, worst.get("name", "unknown"))),
+            }
+        )
+    return rows
+
+
 def _json_scalar(value: object, *, column: str) -> object:
     """Normalize one stratum value to strict, stable JSON."""
 
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/ledger_targets.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/ledger_targets.py
index cd6067fb8..bb8f9b9b5 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/ledger_targets.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/ledger_targets.py
@@ -1028,6 +1028,126 @@ def uk_ladder_household_uprating(
     }
 
 
+def uk_private_rent_mean_to_total(
+    target_frame: pd.DataFrame,
+    *,
+    months: int | float = 12,
+) -> tuple[pd.DataFrame, dict[str, Any]]:
+    """Compose PIPR monthly price levels into annual private-rent totals.
+
+    The rowwise calibration surface is linear in household weights, so each
+    ``rent/private_rent`` price level is multiplied by the matching authority's
+    bound ``tenure/private_rent`` household count and the months in a year.
+    """
+
+    rent_positions = np.flatnonzero(
+        target_frame["metric"].astype(str).to_numpy() == "rent/private_rent"
+    )
+    if not len(rent_positions):
+        return target_frame.copy(deep=True), {
+            "applied": False,
+            "reason": "no private_rent rows on the surface",
+        }
+
+    tenure_positions_by_area = {
+        str(target_frame.iloc[position]["area_code"]): position
+        for position in np.flatnonzero(
+            target_frame["metric"].astype(str).to_numpy() == "tenure/private_rent"
+        )
+    }
+    rent_areas = [
+        str(target_frame.iloc[position]["area_code"]) for position in rent_positions
+    ]
+    missing_areas = sorted(set(rent_areas) - set(tenure_positions_by_area))
+    if missing_areas:
+        raise ValueError(
+            "private-rent price levels have no tenure/private_rent row for "
+            f"area(s) {missing_areas}."
+        )
+
+    def _positive_finite(value: Any) -> float | None:
+        try:
+            numeric = float(value)
+        except (TypeError, ValueError):
+            return None
+        return numeric if np.isfinite(numeric) and numeric > 0 else None
+
+    invalid_mean_areas = sorted(
+        {
+            str(target_frame.iloc[position]["area_code"])
+            for position in rent_positions
+            if _positive_finite(target_frame.iloc[position]["value"]) is None
+        }
+    )
+    if invalid_mean_areas:
+        raise ValueError(
+            "private-rent monthly mean must be positive and finite for area(s) "
+            f"{invalid_mean_areas}."
+        )
+    invalid_tenure_areas = sorted(
+        {
+            area_code
+            for area_code in rent_areas
+            if _positive_finite(
+                target_frame.iloc[tenure_positions_by_area[area_code]]["value"]
+            )
+            is None
+        }
+    )
+    if invalid_tenure_areas:
+        raise ValueError(
+            "tenure/private_rent value must be positive and finite for area(s) "
+            f"{invalid_tenure_areas}."
+        )
+
+    composed = target_frame.copy(deep=True)
+    if "metadata" not in composed.columns:
+        composed["metadata"] = None
+    cells_detail: list[dict[str, Any]] = []
+    for position, area_code in zip(rent_positions, rent_areas, strict=True):
+        tenure_position = tenure_positions_by_area[area_code]
+        mean = float(target_frame.iloc[position]["value"])
+        renter_households = float(target_frame.iloc[tenure_position]["value"])
+        total = float(months) * mean * renter_households
+        existing_metadata = target_frame.iloc[position].get("metadata")
+        metadata = (
+            dict(existing_metadata) if isinstance(existing_metadata, Mapping) else {}
+        )
+        metadata.update(
+            {
+                "price_level_mean_monthly": mean,
+                "renter_households": renter_households,
+                "renter_households_target_name": str(
+                    target_frame.iloc[tenure_position]["target_name"]
+                ),
+            }
+        )
+        composed.iat[int(position), composed.columns.get_loc("value")] = total
+        composed.iat[int(position), composed.columns.get_loc("metadata")] = metadata
+        cells_detail.append(
+            {
+                "area_code": area_code,
+                "mean_monthly_rent": mean,
+                "renter_households": renter_households,
+                "total": total,
+            }
+        )
+    return composed, {
+        "applied": True,
+        "months": months,
+        "cells": len(cells_detail),
+        "adjudication": "microcosm#355 (ruling 2026-09-08)",
+        "reason": (
+            "PIPR supplies monthly private-rent price levels while the bound "
+            "metric is an annual weighted total; compose each mean with the "
+            "same authority's A17-uprated private-renter household count."
+        ),
+        "price_level_source": ("ons_pipr_private_rents calendar_year_average 2025"),
+        "renter_count_source": "ons.tenure.private_rent (A17-uprated)",
+        "cells_detail": cells_detail,
+    }
+
+
 def _census_vintage_years(oa_vintage: Any) -> frozenset[int]:
     """The census years named by the ladder's ``oa_vintage`` metadata.
 
@@ -1373,7 +1493,11 @@ def uk_local_target_surface(
         output_position = reconciliation.iloc[position]["_output_position"]
         if pd.notna(output_position):
             output_rows[int(output_position)]["value"] = float(value)
-    return pd.DataFrame(output_rows), receipt
+    surface, private_rent_receipt = uk_private_rent_mean_to_total(
+        pd.DataFrame(output_rows)
+    )
+    receipt["private_rent_mean_to_total"] = private_rent_receipt
+    return surface, receipt
 
 
 def _validate_uk_cross_grain_declarations() -> None:
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/local_rowwise.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/local_rowwise.py
index a38650ef8..33f25cc2b 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/local_rowwise.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/local_rowwise.py
@@ -24,6 +24,7 @@
 from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass, replace
 from datetime import date
+from pathlib import Path
 from typing import Any
 
 import numpy as np
@@ -151,6 +152,44 @@ class UKRowwiseDoctrineSolve:
     national_past_cap_census: Mapping[str, Any]
     all_past_cap_census: Mapping[str, Any]
     binding_adjudications: Mapping[str, Any]
+    selected_support: np.ndarray | None = None
+    size_receipt: Mapping[str, Any] | None = None
+    dense_reference: UKRowwiseDenseReference | None = None
+
+
+@dataclass(frozen=True)
+class UKRowwiseDenseReference:
+    """The dense joint solve a size selection started from, kept as evidence.
+
+    A ``dataset_households`` solve replaces its calibration product with the
+    compact refit; the full-pool solve it was cut from is byte-identical to
+    a standalone dense run on the same inputs, seed and epochs, so keeping
+    its evidence lets a size candidate be compared with its own dense
+    reference without a second run. Same vocabulary as the solve product:
+    labelled local and national diagnostics on the doctrine's scale rule,
+    the microcosm#492 past-cap censuses, the closing loss.
+    """
+
+    weights: np.ndarray
+    initial_weights: np.ndarray
+    diagnostics: pd.DataFrame
+    national_diagnostics: pd.DataFrame
+    initial_loss: float
+    final_loss: float
+    n_nonzero: int
+    past_cap_census: Mapping[str, Any]
+    national_past_cap_census: Mapping[str, Any]
+    all_past_cap_census: Mapping[str, Any]
+
+
+@dataclass(frozen=True)
+class _DoctrineSolveEvidence:
+    diagnostics: pd.DataFrame
+    national_diagnostics: pd.DataFrame
+    past_cap_census: Mapping[str, Any]
+    national_past_cap_census: Mapping[str, Any]
+    all_past_cap_census: Mapping[str, Any]
+    initial_loss: float
 
 
 def past_cap_census(
@@ -1008,12 +1047,38 @@ def solve_uk_rowwise_weights_under_doctrine(
     learning_rate: float = 0.15,
     conserve_mass: bool = False,
     target_records: int | None = None,
+    dataset_households: int | None = None,
     l0_lambda: float = 0.0,
     budget_iters: int = 10,
     seed: int = 0,
+    selection_seed: int | None = None,
+    selection_pi_hi: float = 1.0,
+    size_checkpoint_dir: Path | None = None,
+    resume_size_checkpoint: Path | None = None,
+    checkpoint_identity: Mapping[str, Any] | None = None,
+    checkpoint_provenance: Mapping[str, Any] | None = None,
+    progress: Callable[[str], None] | None = None,
 ) -> UKRowwiseDoctrineSolve:
     """Solve rowwise household weights under the reviewed doctrine.
 
+    ``selection_seed`` (default ``seed``) seeds only the size selection —
+    the informed L0 search, the exact-count draw and the refit — so two
+    selections can be compared on one pool and one dense reference.
+
+    ``size_checkpoint_dir`` persists the dense solve and the informed L0
+    search of a ``dataset_households`` solve before the exact-count draw
+    (:mod:`microcosm.build.uk_runtime.size_checkpoint`), stamped with
+    ``checkpoint_identity``; ``resume_size_checkpoint`` restores such a
+    checkpoint instead of solving and searching again, refusing when the
+    identity, the pool or the target surface differ. The draw's threshold
+    (``selection_pi_hi``) may differ from the one the search stopped on; the
+    size receipt records both.
+
+    ``progress`` receives one readable line per hundred epochs of the dense
+    solve, of every budget probe and of the refit, one line per finished
+    probe with its drawability verdict, and one when the search stops
+    (:func:`~microcosm.build.uk_runtime.solve_progress.uk_solve_progress_callback`).
+
     Structurally knob-free like before the ``calibrate()`` migration: no
     per-target parameters and no doctrine parameter — the bounds always come
     from :data:`UK_LOCAL_SOLVE_DOCTRINE` and ride into the public front door
@@ -1126,22 +1191,292 @@ def solve_uk_rowwise_weights_under_doctrine(
         grain_labels,
         rule=target_weight_rule,
     )
-    result = calibrate(
-        frame,
-        target_set,
-        weight_entity="household",
-        epochs=epochs,
-        learning_rate=learning_rate,
-        mass=CONSERVE_MASS if conserve_mass else FREE_MASS,
-        mass_reason=None if conserve_mass else mass_reason,
-        max_weight_ratio=doctrine.max_weight_ratio,
-        target_records=target_records,
-        l0_lambda=l0_lambda,
-        budget_iters=budget_iters,
-        seed=seed,
+    if (size_checkpoint_dir is not None or resume_size_checkpoint is not None) and (
+        dataset_households is None
+    ):
+        raise ValueError("size checkpoints apply to a dataset_households solve.")
+    if size_checkpoint_dir is not None and resume_size_checkpoint is not None:
+        raise ValueError("a resumed solve does not write a second checkpoint.")
+    progress_callback = None
+    if progress is not None:
+        from microcosm.build.uk_runtime.solve_progress import (
+            uk_solve_progress_callback,
+        )
+
+        progress_callback = uk_solve_progress_callback(progress)
+    restored = None
+    if resume_size_checkpoint is not None:
+        from microcosm.build.uk_runtime.size_checkpoint import load_uk_size_checkpoint
+
+        restored = load_uk_size_checkpoint(
+            resume_size_checkpoint,
+            frame=frame,
+            target_set=target_set,
+            identity={} if checkpoint_identity is None else checkpoint_identity,
+        )
+        result = restored.dense
+        # The checkpoint's identity carries the doctrine it was solved under;
+        # this is the second lock: the restored options must equal today's.
+        expected_options = {
+            "max_weight_ratio": doctrine.max_weight_ratio,
+            "mass": CONSERVE_MASS if conserve_mass else FREE_MASS,
+        }
+        drift = sorted(
+            f"{key}: checkpoint {result.options.get(key)!r} != doctrine {value!r}"
+            for key, value in expected_options.items()
+            if result.options.get(key) != value
+        )
+        if result.target_loss_cap != doctrine.target_loss_cap:
+            drift.append(
+                f"target_loss_cap: checkpoint {result.target_loss_cap!r} != doctrine "
+                f"{doctrine.target_loss_cap!r}"
+            )
+        if drift:
+            raise ValueError(
+                "resumed size checkpoint was solved under a different doctrine: "
+                + "; ".join(drift)
+                + "."
+            )
+    else:
+        result = calibrate(
+            frame,
+            target_set,
+            weight_entity="household",
+            epochs=epochs,
+            learning_rate=learning_rate,
+            mass=CONSERVE_MASS if conserve_mass else FREE_MASS,
+            mass_reason=None if conserve_mass else mass_reason,
+            max_weight_ratio=doctrine.max_weight_ratio,
+            target_records=target_records,
+            l0_lambda=l0_lambda,
+            budget_iters=budget_iters,
+            seed=seed,
+            target_loss_weights=target_loss_weights,
+            target_loss_cap=doctrine.target_loss_cap,
+            progress_callback=progress_callback,
+        )
+    selected_support = None
+    size_receipt = None
+    dense_result = None
+    if dataset_households is not None:
+        if target_records is not None or l0_lambda != 0:
+            raise ValueError(
+                "dataset_households requires an unpruned dense reference solve."
+            )
+        from microcosm.build.uk_runtime.dataset_size import (
+            refit_uk_dataset_size,
+            select_uk_dataset_size,
+        )
+
+        size_seed = seed if selection_seed is None else selection_seed
+        checkpoint_receipt: dict[str, Any] | None = None
+        if restored is not None:
+            size_selection = restored.selection
+            checkpoint_receipt = {"resumed_from": restored.receipt}
+        else:
+            size_selection = select_uk_dataset_size(
+                frame,
+                result,
+                households=dataset_households,
+                epochs=epochs,
+                learning_rate=learning_rate,
+                seed=size_seed,
+                pi_hi=selection_pi_hi,
+                progress_callback=progress_callback,
+            )
+            if size_checkpoint_dir is not None:
+                from microcosm.build.uk_runtime.size_checkpoint import (
+                    write_uk_size_checkpoint,
+                )
+
+                checkpoint_receipt = {
+                    "written": write_uk_size_checkpoint(
+                        size_checkpoint_dir,
+                        frame=frame,
+                        dense=result,
+                        selection=size_selection,
+                        identity=(
+                            {} if checkpoint_identity is None else checkpoint_identity
+                        ),
+                        provenance=checkpoint_provenance,
+                    )
+                }
+        sized = refit_uk_dataset_size(
+            frame,
+            result,
+            households=dataset_households,
+            epochs=epochs,
+            learning_rate=learning_rate,
+            seed=size_seed,
+            pi_hi=selection_pi_hi,
+            selection=size_selection,
+            progress_callback=progress_callback,
+        )
+        dense_result = result
+        result = sized.result
+        selected_support = sized.support
+        size_receipt = dict(sized.receipt)
+        # At this level "reused" means restored from a checkpoint: the solve
+        # always hands the refit the selection it just searched or restored.
+        size_receipt["selection_reused"] = restored is not None
+        size_receipt["checkpoint"] = checkpoint_receipt
+    evidence = _doctrine_solve_evidence(
+        result,
+        target_set=target_set,
+        problem=problem,
+        national_rows=national_rows,
+        local_count=local_count,
         target_loss_weights=target_loss_weights,
-        target_loss_cap=doctrine.target_loss_cap,
+        doctrine=doctrine,
     )
+    diagnostics = evidence.diagnostics
+    national_diagnostics = evidence.national_diagnostics
+    census = evidence.past_cap_census
+    national_census = evidence.national_past_cap_census
+    all_census = evidence.all_past_cap_census
+    initial_loss = evidence.initial_loss
+    dense_reference = None
+    if dense_result is not None:
+        dense_evidence = _doctrine_solve_evidence(
+            dense_result,
+            target_set=target_set,
+            problem=problem,
+            national_rows=national_rows,
+            local_count=local_count,
+            target_loss_weights=target_loss_weights,
+            doctrine=doctrine,
+        )
+        dense_reference = UKRowwiseDenseReference(
+            weights=np.asarray(dense_result.weights, dtype=np.float64),
+            initial_weights=np.asarray(dense_result.initial_weights, dtype=np.float64),
+            diagnostics=dense_evidence.diagnostics,
+            national_diagnostics=dense_evidence.national_diagnostics,
+            initial_loss=dense_evidence.initial_loss,
+            final_loss=float(dense_result.final_loss),
+            n_nonzero=int(dense_result.n_nonzero),
+            past_cap_census=dense_evidence.past_cap_census,
+            national_past_cap_census=dense_evidence.national_past_cap_census,
+            all_past_cap_census=dense_evidence.all_past_cap_census,
+        )
+
+    # The UK carrier persists the weight column, and the kernel product is
+    # immutable with no table-refresh operation, so the finished frame is
+    # *rebuilt* through the canonical assembler from the kernel product's
+    # tables, mass log, and period. A rebuild can silently drop kernel
+    # surfaces the assembler does not carry, so the guards below refuse to
+    # ship if the kernel product held strata or metadata the rebuilt frame
+    # lost (both trivially equal today; the guard is the boundary marker
+    # for the day they are not).
+    if selected_support is None:
+        clean_result = result.frame if restore is None else restore(result.frame)
+        expected_ids = problem.household_ids
+    else:
+        # Restore the full prepared carrier before selecting: legacy restorers
+        # retain full original tables and cannot accept compact weight arrays.
+        clean_pool = frame if restore is None else restore(frame)
+        expected_ids = tuple(problem.household_ids[i] for i in selected_support)
+        clean_subset = clean_pool.select(
+            clean_pool.table("person")["person_household_id"]
+            .isin(expected_ids)
+            .to_numpy()
+        )
+        clean_result = Frame(
+            {entity: clean_subset.table(entity) for entity in clean_subset.entities},
+            clean_subset.schema,
+            {
+                entity: result.frame.weights_for(entity)
+                for entity in result.frame.weighted_entities
+            },
+            clean_subset.strata,
+            mass_log=result.frame.mass_log,
+            metadata=result.frame.metadata,
+        )
+    restored_ids = tuple(clean_result.table("household")["household_id"].tolist())
+    if restored_ids != expected_ids:
+        raise ValueError(
+            "restore returned households that do not match the problem's rows "
+            "(same ids, same order); weights are written back by position, so a "
+            "reordering restore would misattribute them silently."
+        )
+    slash_columns = {
+        entity: [
+            str(column)
+            for column in clean_result.table(entity).columns
+            if "/" in str(column)
+        ]
+        for entity in clean_result.entities
+    }
+    slash_columns = {
+        entity: columns for entity, columns in slash_columns.items() if columns
+    }
+    if slash_columns:
+        raise ValueError(
+            "prepared slash-named measure columns survived the rowwise solve "
+            f"restore and cannot reach an H5 writer: {slash_columns}."
+        )
+    calibrated_household = clean_result.table("household").copy()
+    calibrated_household["household_weight"] = np.asarray(
+        result.weights, dtype=np.float64
+    )
+    finished = uk_national_frame(
+        person=clean_result.table("person"),
+        benunit=clean_result.table("benunit"),
+        household=calibrated_household,
+        time_period=uk_time_period(clean_result),
+        weight_kind=WeightKind.CALIBRATED,
+        mass_log=clean_result.mass_log,
+    )
+    validate_uk_national_frame(finished)
+    if not clean_result.strata.equals(finished.strata):
+        raise ValueError(
+            "the calibrated frame carries strata the rebuilt UK national "
+            "frame would drop; extend uk_national_frame to carry them "
+            "before shipping a strata-bearing local solve."
+        )
+    if dict(clean_result.metadata) != dict(finished.metadata):
+        raise ValueError(
+            "the calibrated frame carries metadata beyond the UK time "
+            "period; the rebuild would drop it, so the solve refuses "
+            "instead."
+        )
+    return UKRowwiseDoctrineSolve(
+        frame=finished,
+        calibration_result=result,
+        weights=np.asarray(result.weights, dtype=np.float64),
+        initial_weights=np.asarray(result.initial_weights, dtype=np.float64),
+        diagnostics=diagnostics,
+        national_diagnostics=national_diagnostics,
+        loss_trajectory=np.asarray(result.loss_trajectory, dtype=np.float64),
+        initial_loss=initial_loss,
+        final_loss=float(result.final_loss),
+        n_nonzero=int(result.n_nonzero),
+        past_cap_census=census,
+        national_past_cap_census=national_census,
+        all_past_cap_census=all_census,
+        binding_adjudications=binding_adjudications,
+        selected_support=selected_support,
+        size_receipt=size_receipt,
+        dense_reference=dense_reference,
+    )
+
+
+def _doctrine_solve_evidence(
+    result: CalibrationResult,
+    *,
+    target_set: TargetSet,
+    problem: UKRowwiseLocalMatrix,
+    national_rows: UKRowwiseNationalRows | None,
+    local_count: int,
+    target_loss_weights: np.ndarray,
+    doctrine: Any,
+) -> _DoctrineSolveEvidence:
+    """Label one front-door result against the declared joint surface.
+
+    Shared by the shipped solve and, on a size run, the dense reference it
+    was cut from: both must compile the whole surface, align by name, and
+    reproduce the declared target values exactly.
+    """
+
     if result.skipped:
         reasons = [
             f"{skipped.target.name}: {skipped.reason}" for skipped in result.skipped[:5]
@@ -1271,79 +1606,13 @@ def solve_uk_rowwise_weights_under_doctrine(
             target_loss_cap=doctrine.target_loss_cap,
         )
     )
-
-    # The UK carrier persists the weight column, and the kernel product is
-    # immutable with no table-refresh operation, so the finished frame is
-    # *rebuilt* through the canonical assembler from the kernel product's
-    # tables, mass log, and period. A rebuild can silently drop kernel
-    # surfaces the assembler does not carry, so the guards below refuse to
-    # ship if the kernel product held strata or metadata the rebuilt frame
-    # lost (both trivially equal today; the guard is the boundary marker
-    # for the day they are not).
-    clean_result = result.frame if restore is None else restore(result.frame)
-    restored_ids = tuple(clean_result.table("household")["household_id"].tolist())
-    if restored_ids != problem.household_ids:
-        raise ValueError(
-            "restore returned households that do not match the problem's rows "
-            "(same ids, same order); weights are written back by position, so a "
-            "reordering restore would misattribute them silently."
-        )
-    slash_columns = {
-        entity: [
-            str(column)
-            for column in clean_result.table(entity).columns
-            if "/" in str(column)
-        ]
-        for entity in clean_result.entities
-    }
-    slash_columns = {
-        entity: columns for entity, columns in slash_columns.items() if columns
-    }
-    if slash_columns:
-        raise ValueError(
-            "prepared slash-named measure columns survived the rowwise solve "
-            f"restore and cannot reach an H5 writer: {slash_columns}."
-        )
-    calibrated_household = clean_result.table("household").copy()
-    calibrated_household["household_weight"] = np.asarray(
-        result.weights, dtype=np.float64
-    )
-    finished = uk_national_frame(
-        person=clean_result.table("person"),
-        benunit=clean_result.table("benunit"),
-        household=calibrated_household,
-        time_period=uk_time_period(clean_result),
-        weight_kind=WeightKind.CALIBRATED,
-        mass_log=clean_result.mass_log,
-    )
-    validate_uk_national_frame(finished)
-    if not clean_result.strata.equals(finished.strata):
-        raise ValueError(
-            "the calibrated frame carries strata the rebuilt UK national "
-            "frame would drop; extend uk_national_frame to carry them "
-            "before shipping a strata-bearing local solve."
-        )
-    if dict(clean_result.metadata) != dict(finished.metadata):
-        raise ValueError(
-            "the calibrated frame carries metadata beyond the UK time "
-            "period; the rebuild would drop it, so the solve refuses "
-            "instead."
-        )
-    return UKRowwiseDoctrineSolve(
-        frame=finished,
-        calibration_result=result,
-        weights=np.asarray(result.weights, dtype=np.float64),
-        initial_weights=np.asarray(result.initial_weights, dtype=np.float64),
+    return _DoctrineSolveEvidence(
         diagnostics=diagnostics,
         national_diagnostics=national_diagnostics,
-        loss_trajectory=np.asarray(result.loss_trajectory, dtype=np.float64),
-        initial_loss=initial_loss,
-        final_loss=float(result.final_loss),
-        n_nonzero=int(result.n_nonzero),
         past_cap_census=census,
         national_past_cap_census=national_census,
         all_past_cap_census=all_census,
-        binding_adjudications=binding_adjudications,
+        initial_loss=initial_loss,
     )
 
 
@@ -1380,9 +1649,12 @@ def rotated_uk_local_holdout(
     learning_rate: float = 0.15,
     conserve_mass: bool = False,
     target_records: int | None = None,
+    dataset_households: int | None = None,
     l0_lambda: float = 0.0,
     budget_iters: int = 10,
     solve_seed: int = 0,
+    selection_seed: int | None = None,
+    selection_pi_hi: float = 1.0,
 ) -> dict[str, object]:
     """Run five local-row rotations with national rows fixed in training."""
 
@@ -1424,13 +1696,22 @@ def rotated_uk_local_holdout(
             learning_rate=learning_rate,
             conserve_mass=conserve_mass,
             target_records=target_records,
+            dataset_households=dataset_households,
             l0_lambda=l0_lambda,
             budget_iters=budget_iters,
             seed=solve_seed,
+            selection_seed=selection_seed,
+            selection_pi_hi=selection_pi_hi,
         )
         held_targets = problem.targets[holdout_indices]
         held_estimates = np.asarray(
-            problem.matrix[holdout_indices] @ train_solve.weights,
+            problem.matrix[holdout_indices][
+                :,
+                np.arange(problem.n_households)
+                if train_solve.selected_support is None
+                else train_solve.selected_support,
+            ]
+            @ train_solve.weights,
             dtype=np.float64,
         ).reshape(-1)
         held_weights = uk_local_target_loss_weights(
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/local_target_census.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/local_target_census.py
index 5cdbccca6..34a72d20d 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/local_target_census.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/local_target_census.py
@@ -437,21 +437,23 @@
         "ledger_fact_pin": _LEDGER_FACT_FEED_PIN,
         "signed_reason_id": "private_rent_pipr_partial_coverage_2025",
         "signed_rationale": (
-            "The pinned Ledger fact feed carries one PIPR period, 2026-06, "
-            "with 348 facts: 314 crosswalk England/Wales LA rows, two English "
-            "LA ids outside the crosswalk, 18 Scottish BRMA rows, nine region "
-            "rows, and five country rows. None is at or before the 2025 target "
-            "period; four English crosswalk authorities are absent, Scotland "
-            "has no LA rows, and Northern Ireland has no rows at any grain."
+            "The pinned Ledger fact feed carries 2025 PIPR months; compiled "
+            "rows resolve at 2025-12 with 36 facts at or before the target "
+            "period. Four English crosswalk authorities are absent, Scotland "
+            "has no LA rows, and Northern Ireland has no rows at any grain. "
+            "The bound price level is composed as 12 months times the mean "
+            "times A17-uprated private-renter households under microcosm#355 "
+            "(ruling 2026-09-08)."
         ),
         "verified_on": _SOURCES_VERIFIED_ON,
         "notes": (
             "PIPR publishes average rent price levels, not additive rent "
-            "totals. All 361 local-authority cells remain signed deferred for "
-            "the 2025 compile: 314 are after-period, four English cells have "
-            "no matching LA id, 32 Scottish cells are represented only at "
-            "BRMA grain without a signed translation, and 11 Northern Ireland "
-            "cells are absent."
+            "totals; a bound cell composes the level into a total (see the "
+            "signed rationale). Of the 361 local-authority cells, 314 bind "
+            "for the 2025 compile and 47 remain signed deferred: four English "
+            "cells have no matching LA id, 32 Scottish cells are represented "
+            "only at BRMA grain without a signed translation, and 11 Northern "
+            "Ireland cells are absent."
         ),
     },
     {
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/size_checkpoint.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/size_checkpoint.py
new file mode 100644
index 000000000..6f659849d
--- /dev/null
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/size_checkpoint.py
@@ -0,0 +1,345 @@
+"""Checkpoint a size run's dense solve and informed L0 search before the draw.
+
+A ``--dataset-households`` run spends hours on the K-cloned pool: the dense
+joint solve, then up to ten L0 budget probes, each a full optimisation. The
+exact-count draw that follows can refuse (S2, microcosm#355, 2026-09-08:
+"degenerate boundary mass" after 4.8 hours, nothing written). This module
+persists everything the draw and the refit need — the dense weights and loss
+trajectory, the selection's weights, gate probabilities and search receipt,
+the protected-carrier mask — with the identity of the pool and the target
+surface they were cut from, so a resumed run re-derives the pool and the
+surface (minutes), verifies the identity, rebuilds both results through
+:func:`microcosm.calibrate.rebuild_calibration_result`, and continues at the
+draw. The checkpoint is candidate-run evidence, never a release input.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from collections.abc import Mapping
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+from microcosm.build.uk_runtime.dataset_size import UKSizeSelection
+from microcosm.calibrate import (
+    CalibrationProblem,
+    CalibrationResult,
+    TargetSet,
+    rebuild_calibration_result,
+)
+from microcosm.frame import Frame
+
+SIZE_CHECKPOINT_ARRAYS_FILENAME = "size_selection_checkpoint.npz"
+SIZE_CHECKPOINT_MANIFEST_FILENAME = "size_selection_checkpoint.json"
+SIZE_CHECKPOINT_KIND = "microcosm_uk_size_selection_checkpoint"
+SIZE_CHECKPOINT_SCHEMA_VERSION = 1
+
+_DENSE_ARRAYS = (
+    "dense_weights",
+    "dense_loss_trajectory",
+    "initial_weights",
+    "target_loss_weights",
+    "target_loss_scales",
+)
+_SELECTION_ARRAYS = (
+    "selection_weights",
+    "selection_probabilities",
+    "selection_loss_trajectory",
+    "protected",
+)
+
+
+@dataclass(frozen=True)
+class UKSizeCheckpointRestore:
+    """A checkpoint's dense solve and selection, rebuilt on the re-derived pool."""
+
+    dense: CalibrationResult
+    selection: UKSizeSelection
+    receipt: dict[str, Any]
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1 << 20), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _array_digest(values: np.ndarray) -> str:
+    contiguous = np.ascontiguousarray(values)
+    digest = hashlib.sha256()
+    digest.update(f"{contiguous.dtype.str}{contiguous.shape}".encode())
+    digest.update(contiguous.tobytes())
+    return digest.hexdigest()
+
+
+def _household_ids_digest(frame: Frame) -> str:
+    ids = frame.table("household")["household_id"].to_numpy()
+    return _array_digest(np.asarray(ids, dtype=np.int64))
+
+
+def _target_surface_digest(problem: CalibrationProblem) -> str:
+    digest = hashlib.sha256()
+    digest.update("\n".join(problem.names).encode())
+    digest.update(b"\0")
+    digest.update(
+        np.ascontiguousarray(problem.target_vector, dtype=np.float64).tobytes()
+    )
+    return digest.hexdigest()
+
+
+def _json_safe(value: Any) -> Any:
+    if isinstance(value, Mapping):
+        return {str(key): _json_safe(item) for key, item in value.items()}
+    if isinstance(value, list | tuple):
+        return [_json_safe(item) for item in value]
+    if isinstance(value, np.generic):
+        return value.item()
+    if isinstance(value, np.ndarray):
+        return value.tolist()
+    if isinstance(value, Path):
+        return str(value)
+    return value
+
+
+def _normalised(value: Any) -> Any:
+    return json.loads(json.dumps(_json_safe(value), sort_keys=True))
+
+
+def write_uk_size_checkpoint(
+    directory: Path,
+    *,
+    frame: Frame,
+    dense: CalibrationResult,
+    selection: UKSizeSelection,
+    identity: Mapping[str, Any],
+    provenance: Mapping[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Persist ``dense`` and ``selection`` under ``directory`` with their identity.
+
+    ``identity`` is the caller's pin/parameter mapping (input digests, seeds,
+    epochs, size, the solve doctrine...); :func:`load_uk_size_checkpoint`
+    refuses a resume whose caller identity differs on any key. ``provenance``
+    (the writing run's code pin and build id) is recorded and reported on
+    resume, not compared. Refuses to overwrite an existing checkpoint. Returns
+    a receipt with both file names and digests; the receipt carries nothing
+    that differs between identical runs (no timestamp, no absolute path), so
+    manifests of identical runs still match.
+    """
+    directory = Path(directory)
+    directory.mkdir(parents=True, exist_ok=True)
+    arrays_path = directory / SIZE_CHECKPOINT_ARRAYS_FILENAME
+    manifest_path = directory / SIZE_CHECKPOINT_MANIFEST_FILENAME
+    for existing in (arrays_path, manifest_path):
+        if existing.exists():
+            raise FileExistsError(f"refusing to overwrite checkpoint {existing}.")
+    search = selection.selection
+    if search.gate_open_probabilities is None:
+        raise ValueError("a size checkpoint needs the selection's gate probabilities.")
+    n = frame.n("household")
+    if len(dense.weights) != n or len(search.weights) != n:
+        raise ValueError("checkpoint weights must align with the pool households.")
+    np.savez(
+        arrays_path,
+        dense_weights=np.asarray(dense.weights, dtype=np.float64),
+        dense_loss_trajectory=np.asarray(dense.loss_trajectory, dtype=np.float64),
+        initial_weights=np.asarray(dense.initial_weights, dtype=np.float64),
+        target_loss_weights=np.asarray(dense.target_loss_weights, dtype=np.float64),
+        target_loss_scales=np.asarray(dense.target_loss_scales, dtype=np.float64),
+        selection_weights=np.asarray(search.weights, dtype=np.float64),
+        selection_probabilities=np.asarray(
+            search.gate_open_probabilities, dtype=np.float64
+        ),
+        selection_loss_trajectory=np.asarray(search.loss_trajectory, dtype=np.float64),
+        protected=np.asarray(selection.protected, dtype=bool),
+    )
+    arrays_sha256 = _sha256_file(arrays_path)
+    payload = {
+        "artifact_kind": SIZE_CHECKPOINT_KIND,
+        "schema_version": SIZE_CHECKPOINT_SCHEMA_VERSION,
+        "written_at": datetime.now(UTC).isoformat(timespec="seconds"),
+        "arrays_file": SIZE_CHECKPOINT_ARRAYS_FILENAME,
+        "arrays_sha256": arrays_sha256,
+        "identity": _normalised(identity),
+        "provenance": _normalised({} if provenance is None else provenance),
+        "pool": {
+            "households": int(n),
+            "household_ids_sha256": _household_ids_digest(frame),
+            "weight_entity": "household",
+            "targets": int(dense.problem.n_targets),
+            "targets_sha256": _target_surface_digest(dense.problem),
+        },
+        "dense": {
+            "closing_loss": float(dense.final_loss),
+            "n_nonzero": int(dense.n_nonzero),
+            "l0_lambda": float(dense.l0_lambda),
+            "target_loss_cap": float(dense.target_loss_cap),
+            "options": _normalised(dense.options),
+        },
+        "selection": {
+            "closing_loss": float(search.final_loss),
+            "n_nonzero": int(search.n_nonzero),
+            "l0_lambda": float(search.l0_lambda),
+            "target_loss_cap": float(search.target_loss_cap),
+            "options": _normalised(search.options),
+            "households": int(selection.households),
+            "epochs": int(selection.epochs),
+            "learning_rate": float(selection.learning_rate),
+            "seed": int(selection.seed),
+            "search_pi_hi": float(selection.search_pi_hi),
+            "protected_carriers": int(np.count_nonzero(selection.protected)),
+        },
+    }
+    manifest_path.write_text(
+        json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+    )
+    return {
+        "arrays_file": SIZE_CHECKPOINT_ARRAYS_FILENAME,
+        "arrays_sha256": arrays_sha256,
+        "manifest_file": SIZE_CHECKPOINT_MANIFEST_FILENAME,
+        "manifest_sha256": _sha256_file(manifest_path),
+        "stage": "before_exact_count_draw",
+    }
+
+
+def _check_closing_loss(stage: str, stored: float, recomputed: float) -> None:
+    if not math.isclose(stored, recomputed, rel_tol=1e-9, abs_tol=1e-12):
+        raise ValueError(
+            f"size checkpoint {stage} closing loss {stored!r} disagrees with the "
+            f"loss recomputed on this run's compiled system ({recomputed!r})."
+        )
+
+
+def load_uk_size_checkpoint(
+    directory: Path,
+    *,
+    frame: Frame,
+    target_set: TargetSet,
+    identity: Mapping[str, Any],
+) -> UKSizeCheckpointRestore:
+    """Rebuild a checkpoint's dense solve and selection on ``frame``.
+
+    Refuses, naming the field, when the arrays' digest, the caller identity,
+    the pool's household ids or the compiled target surface differ from what
+    the checkpoint recorded, or when the persisted closing losses disagree
+    with the losses recomputed on the compiled system.
+    """
+    directory = Path(directory)
+    arrays_path = directory / SIZE_CHECKPOINT_ARRAYS_FILENAME
+    manifest_path = directory / SIZE_CHECKPOINT_MANIFEST_FILENAME
+    for required in (arrays_path, manifest_path):
+        if not required.is_file():
+            raise FileNotFoundError(f"size checkpoint file missing: {required}.")
+    payload = json.loads(manifest_path.read_text(encoding="utf-8"))
+    if payload.get("artifact_kind") != SIZE_CHECKPOINT_KIND:
+        raise ValueError(f"{manifest_path} is not a size selection checkpoint.")
+    if payload.get("schema_version") != SIZE_CHECKPOINT_SCHEMA_VERSION:
+        raise ValueError(
+            f"unsupported size checkpoint schema {payload.get('schema_version')!r}."
+        )
+    arrays_sha256 = _sha256_file(arrays_path)
+    if arrays_sha256 != payload.get("arrays_sha256"):
+        raise ValueError("size checkpoint arrays do not match their recorded digest.")
+    stored_identity = payload.get("identity", {})
+    requested_identity = _normalised(identity)
+    mismatched = sorted(
+        f"{key}: checkpoint {stored_identity.get(key)!r} != run {value!r}"
+        for key, value in requested_identity.items()
+        if stored_identity.get(key) != value
+    )
+    missing = sorted(set(requested_identity) - set(stored_identity))
+    if mismatched or missing:
+        raise ValueError(
+            "size checkpoint identity differs from this run: "
+            + "; ".join(
+                mismatched + [f"{key}: absent in checkpoint" for key in missing]
+            )
+            + "."
+        )
+    pool = payload["pool"]
+    if pool["households"] != frame.n("household") or pool[
+        "household_ids_sha256"
+    ] != _household_ids_digest(frame):
+        raise ValueError(
+            "size checkpoint pool differs from this run's pool "
+            f"({pool['households']} checkpointed vs {frame.n('household')} households)."
+        )
+    with np.load(arrays_path) as arrays:
+        stored = {name: np.asarray(arrays[name]) for name in arrays.files}
+    for name in (*_DENSE_ARRAYS, *_SELECTION_ARRAYS):
+        if name not in stored:
+            raise ValueError(f"size checkpoint arrays lack {name!r}.")
+    dense_meta = payload["dense"]
+    # Rebuild without the loss check first: a surface that moved must be named
+    # as such, not as a loss disagreement it would also cause.
+    dense = rebuild_calibration_result(
+        frame,
+        target_set,
+        weights=stored["dense_weights"],
+        loss_trajectory=stored["dense_loss_trajectory"],
+        l0_lambda=float(dense_meta["l0_lambda"]),
+        n_nonzero=int(dense_meta["n_nonzero"]),
+        target_loss_weights=stored["target_loss_weights"],
+        target_loss_scales=stored["target_loss_scales"],
+        target_loss_cap=float(dense_meta["target_loss_cap"]),
+        options=dense_meta["options"],
+    )
+    if not np.array_equal(dense.initial_weights, stored["initial_weights"]):
+        raise ValueError("size checkpoint initial weights differ from the pool's.")
+    if pool["targets"] != dense.problem.n_targets or pool[
+        "targets_sha256"
+    ] != _target_surface_digest(dense.problem):
+        raise ValueError(
+            "size checkpoint target surface differs from this run's surface "
+            f"({pool['targets']} checkpointed vs {dense.problem.n_targets} rows)."
+        )
+    _check_closing_loss("dense", float(dense_meta["closing_loss"]), dense.final_loss)
+    selection_meta = payload["selection"]
+    search = rebuild_calibration_result(
+        frame,
+        target_set,
+        weights=stored["selection_weights"],
+        loss_trajectory=stored["selection_loss_trajectory"],
+        l0_lambda=float(selection_meta["l0_lambda"]),
+        n_nonzero=int(selection_meta["n_nonzero"]),
+        target_loss_weights=stored["target_loss_weights"],
+        target_loss_scales=stored["target_loss_scales"],
+        target_loss_cap=float(selection_meta["target_loss_cap"]),
+        options=selection_meta["options"],
+        gate_open_probabilities=stored["selection_probabilities"],
+    )
+    _check_closing_loss(
+        "selection", float(selection_meta["closing_loss"]), search.final_loss
+    )
+    protected = np.asarray(stored["protected"], dtype=bool)
+    if int(np.count_nonzero(protected)) != int(selection_meta["protected_carriers"]):
+        raise ValueError("size checkpoint protected-carrier mask is inconsistent.")
+    selection = UKSizeSelection(
+        selection=search,
+        protected=protected,
+        households=int(selection_meta["households"]),
+        epochs=int(selection_meta["epochs"]),
+        learning_rate=float(selection_meta["learning_rate"]),
+        seed=int(selection_meta["seed"]),
+        search_pi_hi=float(selection_meta["search_pi_hi"]),
+    )
+    receipt = {
+        "directory": str(directory),
+        "arrays_file": SIZE_CHECKPOINT_ARRAYS_FILENAME,
+        "arrays_sha256": arrays_sha256,
+        "manifest_file": SIZE_CHECKPOINT_MANIFEST_FILENAME,
+        "manifest_sha256": _sha256_file(manifest_path),
+        "identity": stored_identity,
+        "provenance": payload.get("provenance", {}),
+        "dense_closing_loss": float(dense.final_loss),
+        "selection_l0_lambda": float(search.l0_lambda),
+        "search_pi_hi": float(selection.search_pi_hi),
+    }
+    return UKSizeCheckpointRestore(dense=dense, selection=selection, receipt=receipt)
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/size_evaluation.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/size_evaluation.py
new file mode 100644
index 000000000..017082a3f
--- /dev/null
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/size_evaluation.py
@@ -0,0 +1,1309 @@
+"""Pure evaluation helpers for UK rowwise dataset-size experiments."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import re
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+from microcosm.build.uk_runtime.diagnostics import (
+    uk_fit_by_family,
+    uk_weight_summary,
+)
+from microcosm.build.uk_runtime.rowwise_geography import id_multiplier_for_values
+
+__all__ = [
+    "PRE_REGISTERED_OUTCOMES_V1",
+    "RowwiseRun",
+    "area_support_tables",
+    "dense_reference_deltas",
+    "fit_tables",
+    "footprint",
+    "frozen_vs_recomputed",
+    "gate_table",
+    "load_run",
+    "paired_targets",
+    "run_acceptance",
+    "summarize",
+    "weight_tables",
+]
+
+_MANIFEST = "rowwise_candidate_manifest.json"
+_SOLVE_DIAGNOSTICS = "solve_diagnostics.csv"
+_CALIBRATION_DIAGNOSTICS = "calibration_diagnostics.json"
+_AREA_SUPPORT = "area_support_summary.csv"
+_DENSE_DIAGNOSTICS = "dense_reference_diagnostics.csv"
+_SELECTION = "dataset_size_selection.csv"
+_GATE_IDS = (
+    "uk_local_geography_ladder_post_calibration",
+    "uk_local_area_support",
+    "uk_local_target_fit",
+    "uk_local_per_family_fit",
+    "uk_local_weight_ratio",
+    "uk_local_weight_ess",
+)
+
+
+@dataclass(frozen=True)
+class RowwiseRun:
+    """The evaluation inputs loaded from one rowwise-candidate run directory."""
+
+    label: str
+    path: Path
+    manifest: dict[str, Any]
+    targets: pd.DataFrame
+    local_diagnostics: pd.DataFrame
+    dense_reference_diagnostics: pd.DataFrame | None
+    selection: pd.DataFrame | None
+    area_support: pd.DataFrame
+    gates: dict[str, Any]
+    holdout: dict[str, Any] | None
+    weights: pd.DataFrame | None
+    runtime: dict[str, int | float | None]
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    with path.open(encoding="utf-8") as file:
+        value = json.load(file)
+    if not isinstance(value, dict):
+        raise ValueError(f"{path.name} must contain a JSON object.")
+    return value
+
+
+def _require(path: Path) -> Path:
+    if not path.is_file():
+        raise ValueError(f"required run file is missing: {path.name}")
+    return path
+
+
+def _mapping(value: object) -> Mapping[str, Any]:
+    return value if isinstance(value, Mapping) else {}
+
+
+def _optional_float(value: object) -> float | None:
+    if value is None:
+        return None
+    try:
+        result = float(value)
+    except (TypeError, ValueError):
+        return None
+    return result if math.isfinite(result) else None
+
+
+def _target_grain(row: Mapping[str, Any]) -> str:
+    metadata = _mapping(row.get("metadata"))
+    family = str(metadata.get("family") or row.get("family") or "")
+    name = str(row.get("name") or "")
+    if not metadata.get("area_code"):
+        return "national"
+    if family == "census_households" and name.startswith("external:"):
+        return "ladder"
+    area_type = str(metadata.get("area_type") or "")
+    return "local_authority" if area_type == "la" else area_type
+
+
+def _targets_frame(rows: object) -> pd.DataFrame:
+    records: list[dict[str, Any]] = []
+    for raw in rows if isinstance(rows, list) else []:
+        if not isinstance(raw, Mapping):
+            continue
+        metadata = _mapping(raw.get("metadata"))
+        relative_error = _optional_float(raw.get("relative_error"))
+        records.append(
+            {
+                "name": str(raw.get("name") or ""),
+                "target_name": str(raw.get("target_name") or ""),
+                "grain": _target_grain(raw),
+                "family": str(metadata.get("family") or raw.get("family") or ""),
+                "area_type": metadata.get("area_type"),
+                "area_code": metadata.get("area_code"),
+                "metric": metadata.get("metric"),
+                "target": _optional_float(raw.get("target")),
+                "initial_estimate": _optional_float(raw.get("initial_estimate")),
+                "final_estimate": _optional_float(raw.get("final_estimate")),
+                "relative_error": relative_error,
+                "abs_relative_error": (
+                    abs(relative_error) if relative_error is not None else None
+                ),
+                "target_loss_scale": _optional_float(raw.get("target_loss_scale")),
+            }
+        )
+    columns = [
+        "name",
+        "target_name",
+        "grain",
+        "family",
+        "area_type",
+        "area_code",
+        "metric",
+        "target",
+        "initial_estimate",
+        "final_estimate",
+        "relative_error",
+        "abs_relative_error",
+        "target_loss_scale",
+    ]
+    return pd.DataFrame.from_records(records, columns=columns)
+
+
+_TIME_RE = re.compile(
+    r"^\s*([0-9]+(?:\.[0-9]+)?)\s+real\s+"
+    r"[0-9]+(?:\.[0-9]+)?\s+user\s+[0-9]+(?:\.[0-9]+)?\s+sys\s*$"
+)
+_RSS_RE = re.compile(r"^\s*([0-9]+)\s+maximum resident set size\s*$")
+
+
+def _runtime(path: Path, h5_path: Path | None) -> dict[str, int | float | None]:
+    wall: float | None = None
+    rss: int | None = None
+    log = path / "run.log"
+    if log.is_file():
+        for line in log.read_text(encoding="utf-8", errors="replace").splitlines():
+            time_match = _TIME_RE.match(line)
+            if time_match:
+                wall = float(time_match.group(1))
+            rss_match = _RSS_RE.match(line)
+            if rss_match:
+                rss = int(rss_match.group(1))
+    if wall is None:
+        for receipt_path in sorted((path / "logbook-spool").glob("*.json")):
+            try:
+                receipt = _read_json(receipt_path)
+            except (OSError, ValueError, json.JSONDecodeError):
+                continue
+            candidate = _optional_float(receipt.get("wall_seconds"))
+            if candidate is not None:
+                wall = candidate
+                break
+    return {
+        "wall_seconds": wall,
+        "peak_rss_bytes": rss,
+        "h5_bytes": h5_path.stat().st_size if h5_path is not None else None,
+    }
+
+
+def _find_h5(path: Path, manifest: Mapping[str, Any]) -> Path | None:
+    outputs = _mapping(manifest.get("outputs"))
+    for record in outputs.values():
+        candidate_name = Path(str(_mapping(record).get("path") or "")).name
+        if candidate_name.endswith(".h5"):
+            candidate = path / candidate_name
+            if candidate.is_file():
+                return candidate
+    candidates = sorted(path.glob("microcosm_uk_*_local.h5"))
+    return candidates[0] if candidates else None
+
+
+def load_run(path: str | Path, *, label: str, skip_h5: bool = False) -> RowwiseRun:
+    """Load one run using only the documented run-directory basenames."""
+
+    run_path = Path(path).resolve()
+    manifest = _read_json(_require(run_path / _MANIFEST))
+    local = pd.read_csv(_require(run_path / _SOLVE_DIAGNOSTICS))
+    calibration = _read_json(_require(run_path / _CALIBRATION_DIAGNOSTICS))
+    support = pd.read_csv(_require(run_path / _AREA_SUPPORT))
+    gate_paths = sorted(run_path.glob("*.local_gates.json"))
+    if not gate_paths:
+        raise ValueError("required run file is missing: *.local_gates.json")
+    gates = _read_json(gate_paths[0])
+
+    dense_path = run_path / _DENSE_DIAGNOSTICS
+    selection_path = run_path / _SELECTION
+    dense = pd.read_csv(dense_path) if dense_path.is_file() else None
+    selection = pd.read_csv(selection_path) if selection_path.is_file() else None
+    h5_path = _find_h5(run_path, manifest)
+    weights = None
+    if not skip_h5 and h5_path is not None:
+        weights = pd.read_hdf(
+            h5_path,
+            "household",
+            columns=["household_id", "household_weight", "clone_index"],
+        )
+    uk_diagnostics = _mapping(calibration.get("uk_diagnostics"))
+    holdout_value = uk_diagnostics.get("rotated_holdout")
+    holdout = dict(holdout_value) if isinstance(holdout_value, Mapping) else None
+    return RowwiseRun(
+        label=label,
+        path=run_path,
+        manifest=manifest,
+        targets=_targets_frame(calibration.get("targets")),
+        local_diagnostics=local,
+        dense_reference_diagnostics=dense,
+        selection=selection,
+        area_support=support,
+        gates=gates,
+        holdout=holdout,
+        weights=weights,
+        runtime=_runtime(run_path, h5_path),
+    )
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as file:
+        for block in iter(lambda: file.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def run_acceptance(
+    run: RowwiseRun,
+    *,
+    expected_households: int | None = None,
+    expected_pool: int | None = None,
+    expected_epochs: int | None = None,
+) -> dict[str, Any]:
+    """Evaluate the mechanical acceptance contract recorded by one run."""
+
+    manifest = run.manifest
+    parameters = _mapping(manifest.get("parameters"))
+    solve = _mapping(manifest.get("solve"))
+    size = solve.get("dataset_size")
+    size_receipt = _mapping(size)
+    is_size = isinstance(size, Mapping)
+    weights_manifest = _mapping(manifest.get("weights"))
+    release_posture = _mapping(manifest.get("release_posture"))
+    checks: list[dict[str, Any]] = []
+
+    def add(
+        check_id: str,
+        passed: bool | None,
+        observed: object,
+        expected: object,
+    ) -> None:
+        checks.append(
+            {
+                "id": check_id,
+                "status": (
+                    "not_applicable" if passed is None else "pass" if passed else "fail"
+                ),
+                "observed": observed,
+                "expected": expected,
+            }
+        )
+
+    add(
+        "releasable_false",
+        manifest.get("releasable") is False if is_size else None,
+        manifest.get("releasable"),
+        False,
+    )
+    add(
+        "size_certification_absent",
+        release_posture.get("size_certification_present") is False if is_size else None,
+        release_posture.get("size_certification_present"),
+        False,
+    )
+    requested = size_receipt.get("requested_households")
+    realized = size_receipt.get("realized_households")
+    wanted_households = (
+        expected_households if expected_households is not None else realized
+    )
+    add(
+        "dataset_households",
+        requested == realized == wanted_households if is_size else None,
+        {"requested": requested, "realized": realized},
+        wanted_households,
+    )
+    pool = size_receipt.get("pool_households", solve.get("pool_households"))
+    add(
+        "pool_households",
+        pool == expected_pool if is_size and expected_pool is not None else None,
+        pool,
+        expected_pool,
+    )
+    add("n_clones", parameters.get("n_clones") == 15, parameters.get("n_clones"), 15)
+    epochs = parameters.get("epochs")
+    epoch_values = {
+        "epochs": epochs,
+        "selection_epochs": size_receipt.get("selection_epochs"),
+        "refit_epochs": size_receipt.get("refit_epochs"),
+    }
+    epoch_expected = expected_epochs if expected_epochs is not None else epochs
+    epoch_pass = epochs == epoch_expected
+    if is_size:
+        epoch_pass = epoch_pass and all(
+            value == epochs for value in epoch_values.values()
+        )
+    add("epochs", epoch_pass, epoch_values if is_size else epochs, epoch_expected)
+    measure = _mapping(solve.get("measure_resolution"))
+    add("engine_blocks", measure.get("blocks") == 1, measure.get("blocks"), 1)
+    stretch_reference = weights_manifest.get(
+        "stretch_reference", "pool_design" if not is_size else None
+    )
+    add(
+        "stretch_reference",
+        stretch_reference == "normalized_horvitz_thompson_w_over_q"
+        if is_size
+        else None,
+        stretch_reference,
+        "normalized_horvitz_thompson_w_over_q",
+    )
+    selection_receipt = _mapping(size_receipt.get("selection_receipt"))
+    add(
+        "protected_carriers",
+        selection_receipt.get("certainty_count")
+        == size_receipt.get("protected_carriers")
+        if is_size
+        else None,
+        selection_receipt.get("certainty_count"),
+        size_receipt.get("protected_carriers"),
+    )
+    add(
+        "selection_design",
+        selection_receipt.get("design") == "sampford" if is_size else None,
+        selection_receipt.get("design"),
+        "sampford",
+    )
+    l0 = _optional_float(size_receipt.get("selection_l0_lambda"))
+    add("selection_l0_lambda", l0 is not None if is_size else None, l0, "finite")
+    dense = _mapping(size_receipt.get("dense_reference"))
+    add(
+        "dense_loss",
+        dense.get("final_loss") == size_receipt.get("dense_loss") if is_size else None,
+        dense.get("final_loss"),
+        size_receipt.get("dense_loss"),
+    )
+    expected_rows = realized if is_size else solve.get("n_households")
+    add(
+        "h5_households",
+        len(run.weights) == expected_rows if run.weights is not None else None,
+        len(run.weights) if run.weights is not None else None,
+        expected_rows,
+    )
+    add(
+        "positive_weights",
+        bool((run.weights["household_weight"] > 0).all())
+        if run.weights is not None
+        else None,
+        (
+            int((run.weights["household_weight"] <= 0).sum())
+            if run.weights is not None
+            else None
+        ),
+        0,
+    )
+    add(
+        "selection_rows",
+        (run.selection is not None and len(run.selection) == realized)
+        if is_size
+        else None,
+        len(run.selection) if run.selection is not None else None,
+        realized,
+    )
+    bad_outputs: list[str] = []
+    for name, raw_record in _mapping(manifest.get("outputs")).items():
+        record = _mapping(raw_record)
+        output_path = run.path / Path(str(record.get("path") or name)).name
+        if not output_path.is_file() or _sha256(output_path) != record.get("sha256"):
+            bad_outputs.append(str(name))
+    add("output_sha256", not bad_outputs, bad_outputs, [])
+    return {
+        "checks": checks,
+        "passed": all(check["status"] != "fail" for check in checks),
+    }
+
+
+def _distribution(values: pd.Series) -> dict[str, float | int | None]:
+    numeric = pd.to_numeric(values, errors="coerce").dropna().astype(float)
+    if numeric.empty:
+        return {"min": None, "p10": None, "median": None}
+    return {
+        "min": float(numeric.min()),
+        "p10": float(numeric.quantile(0.10)),
+        "median": float(numeric.median()),
+    }
+
+
+def _fit_frame(frame: pd.DataFrame) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    by_grain: dict[str, Any] = {}
+    for grain, group in frame.groupby("grain", sort=True):
+        errors = pd.to_numeric(group["abs_relative_error"], errors="coerce")
+        valid = group.loc[errors.notna()].copy()
+        valid_errors = errors.loc[errors.notna()]
+        worst_name = None
+        if not valid.empty:
+            worst_name = str(valid.loc[valid_errors.idxmax(), "name"])
+        by_grain[str(grain)] = {
+            "n": int(len(valid_errors)),
+            "within_10pct": int((valid_errors <= 0.10).sum()),
+            "within_25pct": int((valid_errors <= 0.25).sum()),
+            "median_abs": float(valid_errors.median()) if len(valid_errors) else None,
+            "max_abs": float(valid_errors.max()) if len(valid_errors) else None,
+            "worst_name": worst_name,
+        }
+    past = frame.loc[
+        pd.to_numeric(frame["abs_relative_error"], errors="coerce") > 0.25,
+        ["name", "abs_relative_error"],
+    ].sort_values(["abs_relative_error", "name"], ascending=[False, True])
+    return by_grain, past.to_dict("records")
+
+
+def fit_tables(run: RowwiseRun) -> dict[str, Any]:
+    """Return loss and target-fit summaries for one run."""
+
+    solve = _mapping(run.manifest.get("solve"))
+    by_grain, past = _fit_frame(run.targets)
+    return {
+        "loss": {
+            "initial": solve.get("initial_loss"),
+            "final": solve.get("final_loss"),
+        },
+        "by_grain": by_grain,
+        "by_family": uk_fit_by_family(run.targets, name_column="name"),
+        "rows_past_25pct": past,
+        "past_cap": solve.get("past_cap"),
+    }
+
+
+def _source_multiplier(
+    weights: pd.DataFrame,
+    spine_weights: pd.DataFrame | None,
+) -> tuple[int, str]:
+    if spine_weights is not None:
+        return (
+            id_multiplier_for_values(spine_weights["household_id"].tolist()),
+            "spine",
+        )
+    originals = weights.loc[weights["clone_index"] == 0, "household_id"]
+    if originals.empty:
+        raise ValueError("cannot infer source-id multiplier without clone_index == 0")
+    return 10 ** len(str(int(originals.max()))), "inferred_from_clone_zero_ids"
+
+
+def _ratio_summary(ratios: Sequence[float] | np.ndarray) -> dict[str, float]:
+    values = np.asarray(ratios, dtype=np.float64)
+    if values.size == 0 or not np.isfinite(values).all():
+        raise ValueError("weight stretch ratios must be finite and non-empty")
+    return {
+        "max": float(values.max()),
+        "p99": float(np.quantile(values, 0.99)),
+        "p50": float(np.quantile(values, 0.50)),
+        "share_gt_10": float((values > 10).mean()),
+        "share_gt_100": float((values > 100).mean()),
+    }
+
+
+def weight_tables(
+    run: RowwiseRun,
+    *,
+    spine_weights: pd.DataFrame | None = None,
+    n_clones: int | None = None,
+) -> dict[str, Any]:
+    """Summarize shipped weights, source support, and design stretch."""
+
+    manifest_weights = _mapping(run.manifest.get("weights"))
+    reference = manifest_weights.get("stretch_reference", "pool_design")
+    result: dict[str, Any] = {
+        "summary": None,
+        "distinct_source_households": None,
+        "source_id_multiplier": None,
+        "source_id_multiplier_basis": None,
+        "stretch": {
+            "reference": reference,
+            "vs_ht_baseline_max": manifest_weights.get(
+                "realized_max_weight_ratio_vs_design"
+            ),
+            "vs_pool_design": None,
+        },
+        "clones_per_source": None,
+    }
+    weight_frame = run.weights
+    if weight_frame is None and run.selection is not None:
+        weight_frame = run.selection[
+            ["household_id", "refit_weight", "clone_index"]
+        ].rename(columns={"refit_weight": "household_weight"})
+    if weight_frame is not None:
+        values = weight_frame["household_weight"].to_numpy(dtype=np.float64)
+        result["summary"] = uk_weight_summary(values)
+        multiplier, basis = _source_multiplier(weight_frame, spine_weights)
+        base_ids = (
+            weight_frame["household_id"].to_numpy(dtype=np.int64)
+            - weight_frame["clone_index"].to_numpy(dtype=np.int64) * multiplier
+        )
+        result["distinct_source_households"] = int(np.unique(base_ids).size)
+        result["source_id_multiplier"] = multiplier
+        result["source_id_multiplier_basis"] = basis
+        if run.selection is not None:
+            counts = pd.Series(base_ids).value_counts()
+            result["clones_per_source"] = {
+                "n_sources": int(len(counts)),
+                "min": int(counts.min()),
+                "p10": float(counts.quantile(0.10)),
+                "median": float(counts.median()),
+                "p90": float(counts.quantile(0.90)),
+                "max": int(counts.max()),
+                "by_clone_count": {
+                    str(int(key)): int(value)
+                    for key, value in counts.value_counts().sort_index().items()
+                },
+            }
+    if run.selection is not None:
+        design = run.selection["design_weight"].to_numpy(dtype=np.float64)
+        if (design <= 0).any():
+            raise ValueError(
+                "dataset_size_selection.csv design weights must be positive"
+            )
+        result["stretch"]["vs_pool_design"] = _ratio_summary(
+            run.selection["refit_weight"].to_numpy(dtype=np.float64) / design
+        )
+    elif spine_weights is not None and weight_frame is not None:
+        clones = n_clones or int(
+            _mapping(run.manifest.get("parameters")).get("n_clones")
+        )
+        multiplier = int(result["source_id_multiplier"])
+        source_map = spine_weights.set_index("household_id")["household_weight"]
+        base_ids = (
+            weight_frame["household_id"].to_numpy(dtype=np.int64)
+            - weight_frame["clone_index"].to_numpy(dtype=np.int64) * multiplier
+        )
+        try:
+            design = source_map.loc[base_ids].to_numpy(dtype=np.float64) / clones
+        except KeyError as exc:
+            raise ValueError(
+                "spine weights do not cover every source household"
+            ) from exc
+        ratios = weight_frame["household_weight"].to_numpy(dtype=np.float64) / design
+        summary = _ratio_summary(ratios)
+        recorded = _optional_float(
+            manifest_weights.get("realized_max_weight_ratio_vs_design")
+        )
+        if recorded is not None and not math.isclose(
+            summary["max"], recorded, rel_tol=1e-9, abs_tol=1e-9
+        ):
+            raise ValueError(
+                "dense-run spine stretch does not match "
+                "realized_max_weight_ratio_vs_design"
+            )
+        result["stretch"]["vs_pool_design"] = summary
+    return result
+
+
+def area_support_tables(run: RowwiseRun) -> dict[str, Any]:
+    """Summarize area rows, ESS, source support, and floor breaches."""
+
+    by_level: dict[str, Any] = {}
+    for level, group in run.area_support.groupby("geography_level", sort=True):
+        rows = pd.to_numeric(group["assigned_households"], errors="coerce")
+        ess = pd.to_numeric(group["effective_sample_size"], errors="coerce")
+        sources = pd.to_numeric(group["nonzero_source_households"], errors="coerce")
+        rows_bad = rows < 50
+        ess_bad = ess < 50
+        sources_bad = sources < 50
+        any_bad = rows_bad | ess_bad | sources_bad
+        by_level[str(level)] = {
+            "n_areas": int(len(group)),
+            "rows": _distribution(rows),
+            "ess": _distribution(ess),
+            "sources": _distribution(sources),
+            "breaches": {
+                "rows_lt_50": int(rows_bad.sum()),
+                "ess_lt_50": int(ess_bad.sum()),
+                "sources_lt_50": int(sources_bad.sum()),
+                "any": int(any_bad.sum()),
+                "codes": sorted(group.loc[any_bad, "area_code"].astype(str).tolist()),
+            },
+        }
+    support_gate = _mapping(
+        _mapping(run.gates.get("gates")).get("uk_local_area_support")
+    )
+    reviewed = _mapping(support_gate.get("details")).get("reviewed_exclusions", {})
+    return {"by_geography_level": by_level, "reviewed_exclusions": reviewed}
+
+
+def gate_table(run: RowwiseRun) -> list[dict[str, Any]]:
+    """Return the six pre-registered gates in a stable order."""
+
+    gates = _mapping(run.gates.get("gates"))
+    rows = []
+    for gate_id in _GATE_IDS:
+        payload = _mapping(gates.get(gate_id))
+        rows.append(
+            {
+                "id": gate_id,
+                "status": payload.get("status", "absent"),
+                "criticality": payload.get("criticality"),
+                "failures": payload.get("failures"),
+            }
+        )
+    return rows
+
+
+def _delta_summary(values: pd.Series) -> dict[str, float | None]:
+    numeric = pd.to_numeric(values, errors="coerce").dropna()
+    return {
+        "mean": float(numeric.mean()) if len(numeric) else None,
+        "median": float(numeric.median()) if len(numeric) else None,
+        "p90": float(numeric.quantile(0.90)) if len(numeric) else None,
+    }
+
+
+def _paired_breakdown(joined: pd.DataFrame, column: str) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    for key, group in joined.groupby(column, dropna=False, sort=True):
+        delta = group["_delta"]
+        result[str(key)] = {
+            "n": int(len(group)),
+            "abs_err_delta": _delta_summary(delta),
+            "wins": int((delta <= -1e-4).sum()),
+            "ties": int((delta.abs() < 1e-4).sum()),
+            "losses": int((delta >= 1e-4).sum()),
+        }
+    return result
+
+
+def _pair_frames(
+    run_rows: pd.DataFrame,
+    reference_rows: pd.DataFrame,
+    *,
+    run_key: str = "name",
+    reference_key: str = "name",
+) -> tuple[dict[str, Any], pd.DataFrame]:
+    left = run_rows.copy()
+    right = reference_rows.copy()
+    common_columns = [
+        column
+        for column in (
+            "grain",
+            "family",
+            "target",
+            "relative_error",
+            "abs_relative_error",
+        )
+        if column in right.columns
+    ]
+    joined = left.merge(
+        right[[reference_key, *common_columns]],
+        left_on=run_key,
+        right_on=reference_key,
+        how="inner",
+        suffixes=("_run", "_reference"),
+    )
+    joined["_delta"] = pd.to_numeric(
+        joined["abs_relative_error_run"], errors="coerce"
+    ) - pd.to_numeric(joined["abs_relative_error_reference"], errors="coerce")
+    target_run = pd.to_numeric(joined["target_run"], errors="coerce")
+    target_ref = pd.to_numeric(joined["target_reference"], errors="coerce")
+    changed = ~np.isclose(target_run, target_ref, rtol=1e-9, atol=0.0, equal_nan=True)
+    result = {
+        "n_common": int(len(joined)),
+        "n_only_run": int(len(set(left[run_key]) - set(right[reference_key]))),
+        "n_only_reference": int(len(set(right[reference_key]) - set(left[run_key]))),
+        "n_target_value_changed": int(changed.sum()),
+        "abs_err_delta": _delta_summary(joined["_delta"]),
+        "wins": int((joined["_delta"] <= -1e-4).sum()),
+        "ties": int((joined["_delta"].abs() < 1e-4).sum()),
+        "losses": int((joined["_delta"] >= 1e-4).sum()),
+        "by_grain": _paired_breakdown(joined, "grain_run"),
+        "by_family": _paired_breakdown(joined, "family_run"),
+    }
+    return result, joined
+
+
+def _red_target_names(run: RowwiseRun) -> set[str]:
+    gate = _mapping(_mapping(run.gates.get("gates")).get("uk_local_target_fit"))
+    failures = _mapping(_mapping(gate.get("details")).get("failing_targets"))
+    names: set[str] = set()
+    diagnostics = run.local_diagnostics
+    for key in failures:
+        pieces = str(key).split("/", 2)
+        if len(pieces) != 3:
+            continue
+        family, area_code, metric = pieces
+        matched = diagnostics.loc[
+            (diagnostics["family"].astype(str) == family)
+            & (diagnostics["area_code"].astype(str) == area_code)
+            & (diagnostics["metric"].astype(str) == metric)
+        ]
+        for target_name in matched["target_name"].astype(str):
+            target_rows = run.targets.loc[run.targets["target_name"] == target_name]
+            names.update(target_rows["name"].astype(str))
+    return names
+
+
+def paired_targets(run: RowwiseRun, reference: RowwiseRun) -> dict[str, Any]:
+    """Compare matched target rows and preserve the reference's red-row ledger."""
+
+    result, joined = _pair_frames(run.targets, reference.targets)
+    reference_red = _red_target_names(reference)
+    red_rows = joined.loc[joined["name"].isin(reference_red)]
+    red_output = [
+        {
+            "name": str(row["name"]),
+            "reference_error": float(row["relative_error_reference"]),
+            "run_error": float(row["relative_error_run"]),
+        }
+        for _, row in red_rows.sort_values("name").iterrows()
+    ]
+    result["reference_red_rows"] = {
+        "n": len(red_output),
+        "still_red": sum(abs(row["run_error"]) > 0.25 for row in red_output),
+        "now_green": sum(abs(row["run_error"]) <= 0.25 for row in red_output),
+        "rows": red_output,
+    }
+    new_red = joined.loc[
+        (pd.to_numeric(joined["abs_relative_error_run"], errors="coerce") > 0.25)
+        & ~joined["name"].isin(reference_red)
+    ].sort_values(["abs_relative_error_run", "name"], ascending=[False, True])
+    result["new_red_rows"] = [
+        {
+            "name": str(row["name"]),
+            "reference_error": float(row["relative_error_reference"]),
+            "run_error": float(row["relative_error_run"]),
+        }
+        for _, row in new_red.head(50).iterrows()
+    ]
+    worst = joined.sort_values(
+        ["abs_relative_error_run", "name"], ascending=[False, True]
+    ).head(25)
+    result["worst_rows"] = [
+        {
+            "name": str(row["name"]),
+            "target_run": float(row["target_run"]),
+            "target_reference": float(row["target_reference"]),
+            "run_error": float(row["relative_error_run"]),
+            "reference_error": float(row["relative_error_reference"]),
+        }
+        for _, row in worst.iterrows()
+    ]
+    return result
+
+
+def _dense_targets(frame: pd.DataFrame) -> tuple[pd.DataFrame, str, str]:
+    dense = frame.copy()
+    if "abs_relative_error" not in dense:
+        dense["abs_relative_error"] = pd.to_numeric(
+            dense["relative_error"], errors="coerce"
+        ).abs()
+    if "grain" not in dense:
+        dense["grain"] = np.where(dense.get("area_code").isna(), "national", "")
+    dense["grain"] = dense["grain"].replace({"la": "local_authority"})
+    if "family" not in dense:
+        dense["family"] = ""
+    if "target" not in dense:
+        dense["target"] = np.nan
+    dense["_join"] = np.where(
+        dense["grain"].astype(str) == "national",
+        dense.get("name", pd.Series(index=dense.index, dtype=object)),
+        dense.get("target_name", pd.Series(index=dense.index, dtype=object)),
+    )
+    return dense, "_join", "_join"
+
+
+def dense_reference_deltas(run: RowwiseRun) -> dict[str, Any] | None:
+    """Compare a compact run with the dense solve embedded in its size receipt."""
+
+    if run.dense_reference_diagnostics is None:
+        return None
+    dense, _, _ = _dense_targets(run.dense_reference_diagnostics)
+    compact = run.targets.copy()
+    compact["_join"] = np.where(
+        compact["grain"] == "national", compact["name"], compact["target_name"]
+    )
+    paired, joined = _pair_frames(
+        compact,
+        dense,
+        run_key="_join",
+        reference_key="_join",
+    )
+    paired["reference_red_rows"] = {"n": 0, "still_red": 0, "now_green": 0, "rows": []}
+    paired["new_red_rows"] = []
+    paired["worst_rows"] = [
+        {
+            "name": str(row["name"]),
+            "run_error": float(row["relative_error_run"]),
+            "reference_error": float(row["relative_error_reference"]),
+        }
+        for _, row in joined.sort_values("abs_relative_error_run", ascending=False)
+        .head(25)
+        .iterrows()
+    ]
+    size = _mapping(_mapping(run.manifest.get("solve")).get("dataset_size"))
+    dense_summary = _mapping(size.get("dense_reference"))
+    return {
+        **paired,
+        "dense_loss": size.get("dense_loss"),
+        "compact_loss": size.get("compact_loss"),
+        "max_target_scaled_change": size.get("max_target_scaled_change"),
+        "weights": {
+            "dense": dense_summary.get("weights"),
+            "compact": (
+                uk_weight_summary(
+                    run.weights["household_weight"].to_numpy(dtype=np.float64)
+                )
+                if run.weights is not None
+                else None
+            ),
+        },
+    }
+
+
+def _surface_rows(payload: Mapping[str, Any]) -> list[Mapping[str, Any]]:
+    """Find national recomputation rows.
+
+    Current evaluator output uses ``national_rows`` with ``our_name`` and
+    ``candidate_estimate``.  The fallback contract accepts ``rows`` entries
+    with ``name``, ``estimate``, and ``target``.
+    """
+
+    for key in ("national_rows", "rows"):
+        value = payload.get(key)
+        if isinstance(value, list):
+            return [row for row in value if isinstance(row, Mapping)]
+    return []
+
+
+def frozen_vs_recomputed(
+    run: RowwiseRun,
+    surface_evaluation: str | Path | Mapping[str, Any],
+) -> dict[str, Any]:
+    """Compare frozen national contributions with recomputed surface values."""
+
+    payload = (
+        _read_json(Path(surface_evaluation))
+        if isinstance(surface_evaluation, (str, Path))
+        else surface_evaluation
+    )
+    recomputed: dict[str, float] = {}
+    for row in _surface_rows(payload):
+        name = next(
+            (
+                str(row[key])
+                for key in (
+                    "name",
+                    "our_name",
+                    "contract_target_id",
+                    "target_name",
+                    "id",
+                )
+                if row.get(key)
+            ),
+            "",
+        )
+        estimate = next(
+            (
+                _optional_float(row.get(key))
+                for key in (
+                    "estimate",
+                    "candidate_estimate",
+                    "recomputed_estimate",
+                    "final_estimate",
+                )
+                if row.get(key) is not None
+            ),
+            None,
+        )
+        if name and estimate is not None:
+            recomputed[name] = recomputed.get(name, 0.0) + estimate
+    national = run.targets.loc[run.targets["grain"] == "national"]
+    output_rows: list[dict[str, Any]] = []
+    divergences: list[float] = []
+    for _, row in national.iterrows():
+        candidates = (str(row["name"]), str(row["target_name"]))
+        matched_name = next((name for name in candidates if name in recomputed), None)
+        frozen = _optional_float(row["final_estimate"])
+        if matched_name is None or frozen is None:
+            continue
+        value = recomputed[matched_name]
+        divergence = abs(value - frozen) / max(abs(frozen), 1e-12)
+        divergences.append(divergence)
+        if divergence > 0.01:
+            output_rows.append(
+                {
+                    "name": str(row["name"]),
+                    "frozen": frozen,
+                    "recomputed": value,
+                }
+            )
+    return {
+        "n_rows": int(len(national)),
+        "n_matched": len(divergences),
+        "max_abs_rel_divergence": max(divergences) if divergences else None,
+        "rows_over_1pct": output_rows,
+    }
+
+
+def footprint(run: RowwiseRun) -> dict[str, int | float | None]:
+    """Return the captured wall time, peak RSS, and household H5 size."""
+
+    return dict(run.runtime)
+
+
+PRE_REGISTERED_OUTCOMES_V1: tuple[dict[str, Any], ...] = (
+    {
+        "id": "dense_reference_loss",
+        "label": "Dense reference loss",
+        "reference": 0.01425,
+        "expectation": "≤ 0.014",
+        "red_flag": "> 0.0285",
+    },
+    {
+        "id": "compact_loss_ratio",
+        "label": "Compact / dense loss",
+        "reference": None,
+        "expectation": "≤ 2",
+        "red_flag": "> 5",
+    },
+    {
+        "id": "max_target_scaled_change",
+        "label": "Maximum target-scaled change",
+        "reference": None,
+        "expectation": "< 0.5",
+        "red_flag": "≥ 0.5",
+    },
+    {
+        "id": "national_within_10pct",
+        "label": "National rows within 10%",
+        "reference": "340 of 359",
+        "expectation": "≥ 335",
+        "red_flag": "< 330",
+    },
+    {
+        "id": "constituency_within_10pct",
+        "label": "Constituency share within 10%",
+        "reference": 0.9978,
+        "expectation": "≥ 0.98",
+        "red_flag": "< 0.90",
+    },
+    {
+        "id": "local_authority_within_10pct",
+        "label": "Local-authority share within 10%",
+        "reference": 0.9774,
+        "expectation": "≥ 0.95",
+        "red_flag": "< 0.90",
+    },
+    {
+        "id": "rows_past_25pct",
+        "label": "Rows past 25%",
+        "reference": 42,
+        "expectation": "≤ 60",
+        "red_flag": "> 60",
+    },
+    {
+        "id": "kish_ess",
+        "label": "Kish effective sample size",
+        "reference": 129236,
+        "expectation": "20000–40000",
+        "red_flag": "< 10000",
+    },
+    {
+        "id": "max_to_median_positive_weight",
+        "label": "Maximum / median positive weight",
+        "reference": 400.03,
+        "expectation": "report against 100",
+        "red_flag": None,
+    },
+    {
+        "id": "stretch_vs_pool_design_share_gt_100",
+        "label": "Pool-design stretch share above 100",
+        "reference": 0,
+        "expectation": "report",
+        "red_flag": "> 0.01",
+    },
+    {
+        "id": "constituency_ess_min",
+        "label": "Minimum constituency ESS",
+        "reference": 63.9,
+        "expectation": "~20",
+        "red_flag": None,
+    },
+    {
+        "id": "area_support_breach_share",
+        "label": "Area-support breach share",
+        "reference": "0.002 (2 of 1011, both excluded)",
+        "expectation": "> 0 likely",
+        "red_flag": "> 0.25",
+    },
+    {
+        "id": "gates_release_blocking_failed",
+        "label": "Failed release-blocking gates",
+        "reference": "2 (as diagnostic)",
+        "expectation": "area_support + ratio",
+        "red_flag": "ladder gate failed",
+    },
+    {
+        "id": "frozen_vs_recomputed_max",
+        "label": "Maximum frozen/recomputed divergence",
+        "reference": None,
+        "expectation": "≤ 0.01",
+        "red_flag": "> 0.05",
+    },
+    {
+        "id": "wall_seconds",
+        "label": "Wall seconds",
+        "reference": 11122,
+        "expectation": "+1–5 h",
+        "red_flag": None,
+    },
+    {
+        "id": "peak_rss_bytes",
+        "label": "Peak RSS bytes",
+        "reference": 11103666176,
+        "expectation": "+0.3 GB",
+        "red_flag": "> 20e9",
+    },
+    {
+        "id": "h5_bytes",
+        "label": "H5 bytes",
+        "reference": 2355789273,
+        "expectation": "~165 MB",
+        "red_flag": None,
+    },
+)
+
+
+def _outcome_observed(
+    metric_id: str,
+    *,
+    fit: Mapping[str, Any],
+    weights: Mapping[str, Any],
+    areas: Mapping[str, Any],
+    gates: Sequence[Mapping[str, Any]],
+    dense: Mapping[str, Any],
+    surface: Mapping[str, Any],
+    run_footprint: Mapping[str, Any],
+) -> object:
+    grains = _mapping(fit.get("by_grain"))
+    if metric_id == "dense_reference_loss":
+        return dense.get("dense_loss")
+    if metric_id == "compact_loss_ratio":
+        dense_loss = _optional_float(dense.get("dense_loss"))
+        compact_loss = _optional_float(dense.get("compact_loss"))
+        return (
+            compact_loss / dense_loss
+            if dense_loss and compact_loss is not None
+            else None
+        )
+    if metric_id == "max_target_scaled_change":
+        return dense.get("max_target_scaled_change")
+    if metric_id == "national_within_10pct":
+        return _mapping(grains.get("national")).get("within_10pct")
+    if metric_id in {"constituency_within_10pct", "local_authority_within_10pct"}:
+        grain = metric_id.removesuffix("_within_10pct")
+        row = _mapping(grains.get(grain))
+        n = row.get("n")
+        return row.get("within_10pct") / n if n else None
+    if metric_id == "rows_past_25pct":
+        return len(fit.get("rows_past_25pct") or [])
+    if metric_id == "kish_ess":
+        return _mapping(weights.get("summary")).get("effective_sample_size")
+    if metric_id == "max_to_median_positive_weight":
+        return _mapping(weights.get("summary")).get("max_to_median_positive_weight")
+    if metric_id == "stretch_vs_pool_design_share_gt_100":
+        return _mapping(_mapping(weights.get("stretch")).get("vs_pool_design")).get(
+            "share_gt_100"
+        )
+    if metric_id == "constituency_ess_min":
+        return _mapping(
+            _mapping(_mapping(areas.get("by_geography_level")).get("constituency")).get(
+                "ess"
+            )
+        ).get("min")
+    if metric_id == "area_support_breach_share":
+        levels = _mapping(areas.get("by_geography_level"))
+        count = sum(
+            int(_mapping(_mapping(row).get("breaches")).get("any") or 0)
+            for row in levels.values()
+        )
+        total = sum(int(_mapping(row).get("n_areas") or 0) for row in levels.values())
+        return count / total if total else None
+    if metric_id == "gates_release_blocking_failed":
+        return sum(
+            row.get("criticality") == "release_blocking"
+            and row.get("status") != "passed"
+            for row in gates
+        )
+    if metric_id == "frozen_vs_recomputed_max":
+        return surface.get("max_abs_rel_divergence")
+    if metric_id in {"wall_seconds", "peak_rss_bytes", "h5_bytes"}:
+        return run_footprint.get(metric_id)
+    return None
+
+
+def _flag(metric_id: str, value: object, gates: Sequence[Mapping[str, Any]]) -> str:
+    numeric = _optional_float(value)
+    if numeric is None:
+        return "not_measured"
+    if metric_id == "dense_reference_loss":
+        return "red" if numeric > 0.0285 else "ok" if numeric <= 0.014 else "watch"
+    if metric_id == "compact_loss_ratio":
+        return "red" if numeric > 5 else "ok" if numeric <= 2 else "watch"
+    if metric_id == "max_target_scaled_change":
+        return "red" if numeric >= 0.5 else "ok"
+    if metric_id == "national_within_10pct":
+        return "red" if numeric < 330 else "ok" if numeric >= 335 else "watch"
+    if metric_id == "constituency_within_10pct":
+        return "red" if numeric < 0.90 else "ok" if numeric >= 0.98 else "watch"
+    if metric_id == "local_authority_within_10pct":
+        return "red" if numeric < 0.90 else "ok" if numeric >= 0.95 else "watch"
+    if metric_id == "rows_past_25pct":
+        return "red" if numeric > 60 else "ok"
+    if metric_id == "kish_ess":
+        return (
+            "red" if numeric < 10000 else "ok" if 20000 <= numeric <= 40000 else "watch"
+        )
+    if metric_id == "max_to_median_positive_weight":
+        return "ok" if numeric <= 100 else "watch"
+    if metric_id == "stretch_vs_pool_design_share_gt_100":
+        return "red" if numeric > 0.01 else "ok"
+    if metric_id == "area_support_breach_share":
+        return "red" if numeric > 0.25 else "watch" if numeric == 0 else "ok"
+    if metric_id == "gates_release_blocking_failed":
+        ladder = next((row for row in gates if row.get("id") == _GATE_IDS[0]), {})
+        if ladder.get("status") not in {"passed", "absent"}:
+            return "red"
+        return "ok" if numeric == 2 else "watch"
+    if metric_id == "frozen_vs_recomputed_max":
+        return "red" if numeric > 0.05 else "ok" if numeric <= 0.01 else "watch"
+    if metric_id == "peak_rss_bytes":
+        return "red" if numeric > 20e9 else "ok"
+    return "ok"
+
+
+def summarize(
+    run: RowwiseRun,
+    *,
+    references: Mapping[str, RowwiseRun],
+    dense_deltas: Mapping[str, Any] | None,
+    incumbent_score: Mapping[str, Any] | None = None,
+    surface: Mapping[str, Any] | None = None,
+    downstream: Mapping[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Assemble the candidate-only scorecard without applying a release verdict."""
+
+    fit = fit_tables(run)
+    weights = weight_tables(run)
+    areas = area_support_tables(run)
+    gates = gate_table(run)
+    dense = _mapping(dense_deltas)
+    surface_map = _mapping(surface)
+    run_footprint = footprint(run)
+    outcomes = []
+    for definition in PRE_REGISTERED_OUTCOMES_V1:
+        observed = _outcome_observed(
+            str(definition["id"]),
+            fit=fit,
+            weights=weights,
+            areas=areas,
+            gates=gates,
+            dense=dense,
+            surface=surface_map,
+            run_footprint=run_footprint,
+        )
+        outcomes.append(
+            {
+                **definition,
+                "observed": observed,
+                "flag": _flag(str(definition["id"]), observed, gates),
+            }
+        )
+    reference_tables: dict[str, Any] = {}
+    reference_observed: dict[str, dict[str, object]] = {}
+    for label, reference in references.items():
+        reference_fit = fit_tables(reference)
+        reference_weights = weight_tables(reference)
+        reference_areas = area_support_tables(reference)
+        reference_gates = gate_table(reference)
+        reference_footprint = footprint(reference)
+        paired = paired_targets(run, reference)
+        reference_tables[label] = {
+            "fit": reference_fit,
+            "weights": reference_weights,
+            "area_support": reference_areas,
+            "gates": reference_gates,
+            "footprint": reference_footprint,
+            "paired_targets": paired,
+        }
+        reference_observed[label] = {
+            str(definition["id"]): _outcome_observed(
+                str(definition["id"]),
+                fit=reference_fit,
+                weights=reference_weights,
+                areas=reference_areas,
+                gates=reference_gates,
+                dense={
+                    "dense_loss": _mapping(reference.manifest.get("solve")).get(
+                        "final_loss"
+                    )
+                },
+                surface={},
+                run_footprint=reference_footprint,
+            )
+            for definition in PRE_REGISTERED_OUTCOMES_V1
+        }
+    dense_observed: dict[str, object] = {}
+    if run.dense_reference_diagnostics is not None:
+        dense_frame, _, _ = _dense_targets(run.dense_reference_diagnostics)
+        if "name" not in dense_frame:
+            dense_frame["name"] = dense_frame["_join"]
+        else:
+            dense_frame["name"] = dense_frame["name"].fillna(dense_frame["_join"])
+        dense_by_grain, dense_past = _fit_frame(dense_frame)
+        dense_fit = {"by_grain": dense_by_grain, "rows_past_25pct": dense_past}
+        dense_weights = {"summary": _mapping(dense.get("weights")).get("dense")}
+        dense_observed = {
+            str(definition["id"]): _outcome_observed(
+                str(definition["id"]),
+                fit=dense_fit,
+                weights=dense_weights,
+                areas={},
+                gates=[],
+                dense={"dense_loss": dense.get("dense_loss")},
+                surface={},
+                run_footprint={},
+            )
+            for definition in PRE_REGISTERED_OUTCOMES_V1
+        }
+    run_observed = {str(row["id"]): row["observed"] for row in outcomes}
+    scorecard_columns = [run.label, "dense_reference", *references]
+    scorecard = {
+        "columns": scorecard_columns,
+        "rows": [
+            {
+                "id": definition["id"],
+                "label": definition["label"],
+                "values": {
+                    run.label: run_observed.get(str(definition["id"])),
+                    "dense_reference": dense_observed.get(str(definition["id"])),
+                    **{
+                        label: values.get(str(definition["id"]))
+                        for label, values in reference_observed.items()
+                    },
+                },
+            }
+            for definition in PRE_REGISTERED_OUTCOMES_V1
+        ],
+    }
+    return {
+        "identity": {
+            "label": run.label,
+            "path": str(run.path),
+            "git_commit": run.manifest.get("git_commit"),
+            "identity": run.manifest.get("identity"),
+            "parameters": run.manifest.get("parameters"),
+        },
+        "fit": fit,
+        "weights": weights,
+        "area_support": areas,
+        "gates": gates,
+        "footprint": run_footprint,
+        "dense_reference": dense_deltas,
+        "references": {
+            label: tables["paired_targets"]
+            for label, tables in reference_tables.items()
+        },
+        "reference_tables": reference_tables,
+        "scorecard": scorecard,
+        "incumbent_score": incumbent_score,
+        "surface": surface,
+        "downstream": downstream,
+        "pre_registered_outcomes": outcomes,
+    }
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/solve_progress.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/solve_progress.py
new file mode 100644
index 000000000..124398d7d
--- /dev/null
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/solve_progress.py
@@ -0,0 +1,85 @@
+"""Readable progress lines for a UK doctrine solve and its size selection.
+
+The calibrator reports one ``calibration_epoch`` event per epoch and, under a
+budget search, one ``budget_probe`` event per finished probe and a closing
+``budget_search_done`` event. A five-hour size run is otherwise silent between
+"solving..." and its manifest (microcosm#355), so this turns those events into
+timestamped lines a log reader can follow: a loss line every ``every`` epochs
+and at the last epoch, one line per probe with its penalty, open mass and
+drawability verdict, and one line when the search stops.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from datetime import UTC, datetime
+
+ProgressLine = Callable[[str], None]
+ProgressEvent = Mapping[str, object]
+
+DEFAULT_PROGRESS_EVERY = 100
+
+
+def _stage(event: ProgressEvent) -> str:
+    if event.get("budget_search"):
+        return (
+            f"probe {event.get('budget_iteration')}/{event.get('budget_iters')} "
+            f"(lambda {float(event.get('l0_lambda', float('nan'))):.3g})"
+        )
+    phase = event.get("phase")
+    if phase == "size_refit":
+        return "refit"
+    if phase == "size_search":
+        return "search"
+    return "dense solve"
+
+
+def _stamp() -> str:
+    return datetime.now(UTC).strftime("%H:%M:%SZ")
+
+
+def uk_solve_progress_callback(
+    sink: ProgressLine, *, every: int = DEFAULT_PROGRESS_EVERY
+) -> Callable[[dict[str, object]], None]:
+    """Build a calibrator progress callback that writes lines to ``sink``."""
+    if isinstance(every, bool) or not isinstance(every, int) or every <= 0:
+        raise ValueError(f"every must be a positive integer, got {every!r}.")
+
+    def callback(event: dict[str, object]) -> None:
+        kind = event.get("kind")
+        if kind == "calibration_epoch":
+            epoch = int(event["epoch"])
+            epochs = int(event["epochs"])
+            if epoch % every == 0 or epoch == epochs:
+                sink(
+                    f"{_stamp()} {_stage(event)}: epoch {epoch}/{epochs} "
+                    f"loss {float(event['loss']):.5g}"
+                )
+        elif kind == "budget_probe":
+            measure = event.get("measure")
+            detail = ""
+            if event.get("certainty_count") is not None:
+                detail = (
+                    f", certainties {event.get('certainty_count')}, boundary draw "
+                    f"{event.get('boundary_draw')} from mass "
+                    f"{float(event.get('boundary_mass', 0.0)):.1f} "
+                    f"(max {float(event.get('boundary_max', 0.0)):.3f})"
+                )
+            sink(
+                f"{_stamp()} probe {event.get('budget_iteration')}/"
+                f"{event.get('budget_iters')} done: lambda "
+                f"{float(event.get('l0_lambda', float('nan'))):.4g}, "
+                f"{event.get('budget_basis')} {measure} for "
+                f"{event.get('target_records')} requested, verdict "
+                f"{event.get('verdict')}{detail}"
+            )
+        elif kind == "budget_search_done":
+            sink(
+                f"{_stamp()} search stopped: {event.get('stopped_on')} after "
+                f"{event.get('evaluations')}/{event.get('budget_iters')} probes; "
+                f"selected lambda {event.get('selected_l0_lambda')}, measure "
+                f"{event.get('selected_measure')} for {event.get('target_records')}, "
+                f"drawable {event.get('selected_feasible')}"
+            )
+
+    return callback
diff --git a/packages/microcosm-build/tests/test_spec_engine_country_bundles.py b/packages/microcosm-build/tests/test_spec_engine_country_bundles.py
index 87df2dbe0..1169547c3 100644
--- a/packages/microcosm-build/tests/test_spec_engine_country_bundles.py
+++ b/packages/microcosm-build/tests/test_spec_engine_country_bundles.py
@@ -25,7 +25,7 @@
     "spine",
     "vintages",
 }
-AM_SPEC_SHA256 = "b081464d575f63e54e13ce7a2a7c9009ed0bea62289b4f9ab5dd3bc214544b16"
+AM_SPEC_SHA256 = "d983a5e6bb2f91f9abd44669fe5b1c795d1a7597c4b6acbe9282eaa956bb326d"
 
 
 @pytest.mark.parametrize(
@@ -45,7 +45,7 @@
         ),
         (
             "be",
-            "70fc6b15de937f3d88c173d586bbe4856070644eb9e1c850bcdc93501a3534f9",
+            "2a7d83483c90abe31108f8c3a77c053b4e6f2fd50d3cf3290a85e63ea3b9fbac",
             {
                 "household.household_id",
                 "person.person_id",
@@ -55,7 +55,7 @@
         ),
         (
             "uk",
-            "6a8003d9246f8e4c7bd60b95f3f9ff599dfb5e4ffdc4323f6603f75a46f611b6",
+            "2269bc281ada99dce077730657e3868972e025b48be5f9db8c11b3cc63285bac",
             {
                 "benunit.benunit_id",
                 "household.household_id",
diff --git a/packages/microcosm-build/tests/test_spec_engine_coverage_tool.py b/packages/microcosm-build/tests/test_spec_engine_coverage_tool.py
index 189ae4df5..9fb08bea1 100644
--- a/packages/microcosm-build/tests/test_spec_engine_coverage_tool.py
+++ b/packages/microcosm-build/tests/test_spec_engine_coverage_tool.py
@@ -88,22 +88,22 @@ def test_us_coverage_is_exact_complete_and_honest(
     assert_coverage_complete(coverage_report)
     assert coverage_report["status"] == "pass"
     fields = coverage_report["field_usage"]
-    assert fields["configuration_field_count"] == 42_154
+    assert fields["configuration_field_count"] == 42_156
     assert fields["authored_normative_field_count"] == 32_384
-    assert fields["resolved_binding_field_count"] == 9_770
-    assert fields["consumed_field_count"] == 42_154
+    assert fields["resolved_binding_field_count"] == 9_772
+    assert fields["consumed_field_count"] == 42_156
     assert fields["unused_field_count"] == 0
     assert fields["multiple_primary_use_field_count"] == 0
     assert fields["claim_count"] == 49
     assert fields["mode_counts"] == {
         "legacy_behavior": 13_988,
-        "compiler_semantic": 27_715,
+        "compiler_semantic": 27_717,
         "front_end_validation": 348,
         "identity_only": 103,
     }
     assert fields["generation0_effect_counts"] == {
         "legacy_behavior": 38_476,
-        "no_generation0_effect": 3_678,
+        "no_generation0_effect": 3_680,
     }
 
     inventory = coverage_report["inventory_coverage"]
diff --git a/packages/microcosm-build/tests/test_spec_engine_loader.py b/packages/microcosm-build/tests/test_spec_engine_loader.py
index a98f9cd15..0b583de0a 100644
--- a/packages/microcosm-build/tests/test_spec_engine_loader.py
+++ b/packages/microcosm-build/tests/test_spec_engine_loader.py
@@ -236,7 +236,7 @@ def test_semantic_hash_has_golden_vector_and_surface_separation(tmp_path) -> Non
     # Pin the domain separator, normalization rules, schema-set receipt, and
     # exact normative projection as one reviewable golden vector.
     assert first.spec_sha256 == (
-        "8761376e420bf184dcd4623185a876e4453f7d0d567ed687009ac3533752a88c"
+        "57026e5896dd52a382746fe7641f615dcc4c55965a1f50bea5971a8f92710d71"
     )
 
     second_root = _rich_minimal(tmp_path / "xy", note="second", store="local:b")
diff --git a/packages/microcosm-build/tests/test_uk_evaluate_dataset_size_tool.py b/packages/microcosm-build/tests/test_uk_evaluate_dataset_size_tool.py
new file mode 100644
index 000000000..9d4aa3e3a
--- /dev/null
+++ b/packages/microcosm-build/tests/test_uk_evaluate_dataset_size_tool.py
@@ -0,0 +1,214 @@
+"""End-to-end tests for the UK dataset-size evaluation command."""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import sys
+from pathlib import Path
+
+
+def _load_module(name: str, path: Path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    assert spec.loader is not None
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def _load_tool():
+    path = Path(__file__).resolve().parents[3] / "tools/evaluate_uk_dataset_size.py"
+    return _load_module("evaluate_uk_dataset_size", path)
+
+
+def _write_run_dir(tmp_path: Path, label: str, *, size_run: bool) -> Path:
+    fixtures = _load_module(
+        "_uk_size_evaluation_fixtures",
+        Path(__file__).with_name("test_uk_size_evaluation.py"),
+    )
+    return fixtures._write_run_dir(tmp_path, label, size_run=size_run)
+
+
+def test_main_writes_selected_tree_receipts_manifest_and_summary(
+    tmp_path: Path,
+) -> None:
+    tool = _load_tool()
+    run = _write_run_dir(tmp_path, "candidate", size_run=True)
+    reference = _write_run_dir(tmp_path, "reference", size_run=False)
+    out = tmp_path / "evaluation"
+
+    assert (
+        tool.main(
+            [
+                "--run",
+                str(run),
+                "--reference",
+                f"R17={reference}",
+                "--steps",
+                "00-run-acceptance,10-dense-reference,20-vs-reference,90-summary",
+                "--out",
+                str(out),
+            ]
+        )
+        == 0
+    )
+
+    expected = (
+        out / "00-run-acceptance/run_acceptance.json",
+        out / "10-dense-reference/size_only_deltas.json",
+        out / "10-dense-reference/size_only_deltas.md",
+        out / "20-vs-reference/R17/comparison.json",
+        out / "20-vs-reference/R17/comparison.md",
+        out / "90-summary/evaluation_summary.json",
+        out / "90-summary/EVALUATION.md",
+    )
+    assert all(path.is_file() for path in expected)
+    for step in (
+        "00-run-acceptance",
+        "10-dense-reference",
+        "20-vs-reference",
+        "90-summary",
+    ):
+        receipt = json.loads((out / step / "receipt.json").read_text())
+        assert receipt["status"] == "ran"
+        assert receipt["step"] == step
+        assert receipt["argv"]
+    manifest = json.loads((out / "evaluation_manifest.json").read_text())
+    assert manifest["schema_version"] == 1
+    assert manifest["run"]["label"] == "candidate"
+    assert manifest["references"][0]["label"] == "R17"
+    assert manifest["steps"]["30-incumbent-score"]["status"] == "skipped"
+    summary = json.loads(expected[-2].read_text())
+    assert summary["references"]["R17"]["n_common"] == 10
+    assert "00-run-acceptance/run_acceptance.json" in summary["files"]
+    markdown = expected[-1].read_text()
+    assert "candidate evaluations and untargeted diagnostics" in markdown
+    assert "--release-candidate" in markdown
+
+
+def test_absent_incumbent_inputs_skip_steps_30_and_40(tmp_path: Path) -> None:
+    tool = _load_tool()
+    run = _write_run_dir(tmp_path, "candidate", size_run=True)
+    out = tmp_path / "evaluation"
+
+    assert (
+        tool.main(
+            [
+                "--run",
+                str(run),
+                "--steps",
+                "30-incumbent-score,40-incumbent-surface",
+                "--out",
+                str(out),
+            ]
+        )
+        == 0
+    )
+
+    score = json.loads((out / "30-incumbent-score/receipt.json").read_text())
+    surface = json.loads((out / "40-incumbent-surface/receipt.json").read_text())
+    assert score["status"] == surface["status"] == "skipped"
+    assert "--incumbent-dir" in score["reason"]
+    assert "--ledger-facts" in surface["reason"]
+
+
+def _write_downstream_stubs(eval_home: Path) -> None:
+    scripts = eval_home / "scripts"
+    config = eval_home / "config"
+    scripts.mkdir(parents=True)
+    config.mkdir()
+    (config / "expected_divergences.json").write_text("{}\n")
+    (config / "anchors_2025.json").write_text("{}\n")
+    body = """\
+import json
+import sys
+from pathlib import Path
+import pytest
+
+# The evaluation reads and writes PyTables-format H5 through pandas; the wheels
+# lane's venv has no pytables, so these tests skip there like the other H5 tests.
+pytest.importorskip("tables", exc_type=ModuleNotFoundError)
+
+for flag in ("--out-json", "--out-md", "--out"):
+    if flag not in sys.argv:
+        continue
+    output = Path(sys.argv[sys.argv.index(flag) + 1])
+    if output.suffix == ".md":
+        output.write_text("# stub\\n")
+    else:
+        output.write_text(json.dumps({"script": Path(__file__).stem}) + "\\n")
+if Path(__file__).stem == "t4_admin_benchmarks":
+    print("intentional t4 failure", file=sys.stderr)
+    raise SystemExit(7)
+"""
+    for name in (
+        "compare_uk_datasets.py",
+        "t4_admin_benchmarks.py",
+        "t5_reforms.py",
+        "scorecard_731.py",
+    ):
+        (scripts / name).write_text(body)
+
+
+def test_downstream_continues_after_a_failing_stub(tmp_path: Path) -> None:
+    tool = _load_tool()
+    run = _write_run_dir(tmp_path, "candidate", size_run=True)
+    reference = _write_run_dir(tmp_path, "reference", size_run=False)
+    eval_home = tmp_path / "eval-home"
+    _write_downstream_stubs(eval_home)
+    reforms = tmp_path / "reforms.json"
+    reforms.write_text("{}\n")
+    out = tmp_path / "evaluation"
+
+    assert (
+        tool.main(
+            [
+                "--run",
+                str(run),
+                "--reference",
+                f"R17={reference}",
+                "--eval-home",
+                str(eval_home),
+                "--reforms-config",
+                str(reforms),
+                "--steps",
+                "50-downstream",
+                "--out",
+                str(out),
+            ]
+        )
+        == 0
+    )
+
+    receipt = json.loads((out / "50-downstream/receipt.json").read_text())
+    footprint = json.loads((out / "50-downstream/footprint.json").read_text())
+    assert receipt["status"] == "failed"
+    assert receipt["exit_code"] == 7
+    assert "intentional t4 failure" in receipt["reason"]
+    assert footprint["t4_admin_benchmarks"]["status"] == "failed"
+    assert footprint["t5_reforms"]["status"] == "ran"
+    assert footprint["scorecard_731:candidate"]["status"] == "ran"
+    assert footprint["scorecard_731:R17"]["status"] == "ran"
+    assert (out / "50-downstream/t3_distribution.json").is_file()
+    assert (out / "50-downstream/t5_reforms.json").is_file()
+    assert (out / "50-downstream/scorecard_731_candidate.json").is_file()
+
+
+def test_rerunning_one_step_rewrites_only_its_folder(tmp_path: Path) -> None:
+    tool = _load_tool()
+    run = _write_run_dir(tmp_path, "candidate", size_run=True)
+    out = tmp_path / "evaluation"
+    common = ["--run", str(run), "--out", str(out)]
+
+    assert tool.main([*common, "--steps", "00-run-acceptance,10-dense-reference"]) == 0
+    rewritten = out / "00-run-acceptance/rewrite-me"
+    preserved = out / "10-dense-reference/preserve-me"
+    rewritten.write_text("old")
+    preserved.write_text("old")
+
+    assert tool.main([*common, "--steps", "00-run-acceptance"]) == 0
+    assert not rewritten.exists()
+    assert preserved.read_text() == "old"
+    manifest = json.loads((out / "evaluation_manifest.json").read_text())
+    assert manifest["steps"]["10-dense-reference"]["status"] == "ran"
diff --git a/packages/microcosm-build/tests/test_uk_ledger_targets.py b/packages/microcosm-build/tests/test_uk_ledger_targets.py
index 1a011a760..aaebed3fc 100644
--- a/packages/microcosm-build/tests/test_uk_ledger_targets.py
+++ b/packages/microcosm-build/tests/test_uk_ledger_targets.py
@@ -21,6 +21,7 @@
     uk_ladder_household_uprating,
     uk_ledger_households_total,
     uk_local_target_surface,
+    uk_private_rent_mean_to_total,
 )
 from microcosm.calibrate import TargetRegistry, TargetSpec
 
@@ -1673,6 +1674,205 @@ def tenure_spec(name, value, **metadata):
         )
 
 
+def _private_rent_target_frame() -> pd.DataFrame:
+    return pd.DataFrame(
+        [
+            {
+                "area_type": "la",
+                "area_code": "E06000001",
+                "metric": "rent/private_rent",
+                "family": "private_rent",
+                "value": 1_000.0,
+                "target_name": "ons.rent.private_rent@E06000001@2025",
+            },
+            {
+                "area_type": "la",
+                "area_code": "E06000001",
+                "metric": "tenure/private_rent",
+                "family": "tenure",
+                "value": 20.0,
+                "target_name": "ons.tenure.private_rent@E06000001@2025",
+            },
+            {
+                "area_type": "la",
+                "area_code": "E06000002",
+                "metric": "rent/private_rent",
+                "family": "private_rent",
+                "value": 750.0,
+                "target_name": "ons.rent.private_rent@E06000002@2025",
+            },
+            {
+                "area_type": "la",
+                "area_code": "E06000002",
+                "metric": "tenure/private_rent",
+                "family": "tenure",
+                "value": 30.0,
+                "target_name": "ons.tenure.private_rent@E06000002@2025",
+            },
+            {
+                "area_type": "la",
+                "area_code": "E06000003",
+                "metric": "tenure/private_rent",
+                "family": "tenure",
+                "value": 40.0,
+                "target_name": "ons.tenure.private_rent@E06000003@2025",
+            },
+        ]
+    )
+
+
+def test_uk_private_rent_mean_to_total_composes_and_receipts_cells() -> None:
+    composed, receipt = uk_private_rent_mean_to_total(_private_rent_target_frame())
+
+    rent_rows = composed.loc[composed["metric"] == "rent/private_rent"]
+    assert rent_rows["value"].tolist() == [12 * 1_000.0 * 20.0, 12 * 750.0 * 30.0]
+    assert rent_rows["metadata"].tolist() == [
+        {
+            "price_level_mean_monthly": 1_000.0,
+            "renter_households": 20.0,
+            "renter_households_target_name": ("ons.tenure.private_rent@E06000001@2025"),
+        },
+        {
+            "price_level_mean_monthly": 750.0,
+            "renter_households": 30.0,
+            "renter_households_target_name": ("ons.tenure.private_rent@E06000002@2025"),
+        },
+    ]
+    assert receipt == {
+        "applied": True,
+        "months": 12,
+        "cells": 2,
+        "adjudication": "microcosm#355 (ruling 2026-09-08)",
+        "reason": (
+            "PIPR supplies monthly private-rent price levels while the bound "
+            "metric is an annual weighted total; compose each mean with the "
+            "same authority's A17-uprated private-renter household count."
+        ),
+        "price_level_source": "ons_pipr_private_rents calendar_year_average 2025",
+        "renter_count_source": "ons.tenure.private_rent (A17-uprated)",
+        "cells_detail": [
+            {
+                "area_code": "E06000001",
+                "mean_monthly_rent": 1_000.0,
+                "renter_households": 20.0,
+                "total": 240_000.0,
+            },
+            {
+                "area_code": "E06000002",
+                "mean_monthly_rent": 750.0,
+                "renter_households": 30.0,
+                "total": 270_000.0,
+            },
+        ],
+    }
+
+
+def test_uk_private_rent_mean_to_total_refuses_missing_tenure_by_area() -> None:
+    frame = _private_rent_target_frame().loc[
+        lambda rows: (
+            ~(
+                (rows["area_code"] == "E06000002")
+                & (rows["metric"] == "tenure/private_rent")
+            )
+        )
+    ]
+
+    with pytest.raises(ValueError, match="E06000002"):
+        uk_private_rent_mean_to_total(frame)
+
+
+@pytest.mark.parametrize(
+    ("metric", "value"),
+    [("tenure/private_rent", 0.0), ("rent/private_rent", float("nan"))],
+)
+def test_uk_private_rent_mean_to_total_refuses_invalid_inputs_by_area(
+    metric, value
+) -> None:
+    frame = _private_rent_target_frame()
+    frame.loc[
+        (frame["area_code"] == "E06000001") & (frame["metric"] == metric), "value"
+    ] = value
+
+    with pytest.raises(ValueError, match="E06000001"):
+        uk_private_rent_mean_to_total(frame)
+
+
+def test_uk_private_rent_mean_to_total_reports_no_rent_rows() -> None:
+    frame = _private_rent_target_frame().loc[
+        lambda rows: rows["metric"] != "rent/private_rent"
+    ]
+
+    unchanged, receipt = uk_private_rent_mean_to_total(frame)
+
+    pd.testing.assert_frame_equal(unchanged, frame)
+    assert receipt == {
+        "applied": False,
+        "reason": "no private_rent rows on the surface",
+    }
+
+
+def test_uk_local_target_surface_composes_rent_after_a17_uprating() -> None:
+    def spec(name, metric, value):
+        return TargetSpec(
+            name=name,
+            entity="household",
+            value=value,
+            measure=metric,
+            period=2025,
+            source="ONS",
+            family="ons_housing",
+            metadata={
+                "contract_target_id": name.split("@", 1)[0],
+                "geography_level": "local_authority",
+                "geography_id": "E06000001",
+                "uprating_from_period": 2021,
+                "uprating_to_period": 2025,
+            },
+        )
+
+    registry = TargetRegistry(
+        [
+            spec(
+                "ons.rent.private_rent@E06000001@2025",
+                "rent/private_rent",
+                1_000.0,
+            ),
+            spec(
+                "ons.tenure.private_rent@E06000001@2025",
+                "tenure/private_rent",
+                20.0,
+            ),
+        ],
+        country="uk",
+    )
+    ladder = SimpleNamespace(
+        households=np.asarray([10.0]),
+        constituency_code=np.asarray(["E14000001"]),
+        local_authority_code=np.asarray(["E06000001"]),
+        metadata={"oa_vintage": "ew:2021_census"},
+    )
+    reference = uk_ledger_households_total(
+        (_households_total_fact(2025, 11.0),), period=2025
+    )
+    uprating = uk_ladder_household_uprating(ladder, reference, period=2025)
+
+    surface, cross_grain = uk_local_target_surface(
+        registry,
+        ladder,
+        bound_national_target_ids=(),
+        period=2025,
+        ladder_household_uprating=uprating,
+    )
+
+    rent = surface.loc[surface["metric"] == "rent/private_rent"].iloc[0]
+    assert rent["value"] == pytest.approx(12 * 1_000.0 * 22.0)
+    assert rent["metadata"]["price_level_mean_monthly"] == 1_000.0
+    assert rent["metadata"]["renter_households"] == pytest.approx(22.0)
+    receipt = cross_grain["private_rent_mean_to_total"]
+    assert receipt["applied"] is True
+    assert receipt["cells_detail"][0]["renter_households"] == pytest.approx(22.0)
+
+
 def test_census_vintage_hold_follows_the_ladder_vintage_not_a_constant() -> None:
     from microcosm.build.uk_runtime.ledger_targets import (
         _census_vintage_years,
diff --git a/packages/microcosm-build/tests/test_uk_local_rowwise.py b/packages/microcosm-build/tests/test_uk_local_rowwise.py
index faecd4975..a88acc76e 100644
--- a/packages/microcosm-build/tests/test_uk_local_rowwise.py
+++ b/packages/microcosm-build/tests/test_uk_local_rowwise.py
@@ -651,7 +651,7 @@ def test_rotated_holdout_keeps_national_rows_in_every_training_fold(
 
     def fake_solve(frame, training_problem, **kwargs):
         calls.append(kwargs["national_rows"])
-        return type("Solve", (), {"weights": np.ones(3)})()
+        return type("Solve", (), {"weights": np.ones(3), "selected_support": None})()
 
     monkeypatch.setattr(
         local_rowwise, "solve_uk_rowwise_weights_under_doctrine", fake_solve
@@ -1220,3 +1220,743 @@ def reordering_restore(frame):
             restore=reordering_restore,
             epochs=2,
         )
+
+
+def test_exact_size_preserves_targets_and_household_links():
+    from microcosm.build.uk_runtime.dataset_size import refit_uk_dataset_size
+    from microcosm.calibrate import Target, TargetSet, calibrate
+
+    frame = _clone_frame()
+    dense = calibrate(
+        frame,
+        TargetSet(
+            [Target("count", "household", lambda f: np.ones(f.n("household")), 3)]
+        ),
+        epochs=2,
+    )
+    sized = refit_uk_dataset_size(
+        frame, dense, households=2, epochs=2, learning_rate=0.02, seed=7
+    )
+    assert sized.result.frame.n("household") == 2
+    assert sized.result.frame.n("person") == 2
+    assert sized.result.frame.n("benunit") == 2
+    assert sized.result.problem.names == dense.problem.names
+    assert sized.result.initial_weights.sum() == pytest.approx(
+        dense.initial_weights.sum()
+    )
+    assert (sized.result.weights <= 10 * sized.result.initial_weights).all()
+    again = refit_uk_dataset_size(
+        frame, dense, households=2, epochs=2, learning_rate=0.02, seed=7
+    )
+    np.testing.assert_array_equal(sized.support, again.support)
+
+
+@pytest.mark.parametrize("size", [0, -1, True, 4, 1.5])
+def test_exact_size_refuses_invalid_sizes(size):
+    from microcosm.build.uk_runtime.dataset_size import refit_uk_dataset_size
+    from microcosm.calibrate import Target, TargetSet, calibrate
+
+    frame = _clone_frame()
+    dense = calibrate(
+        frame,
+        TargetSet(
+            [Target("count", "household", lambda f: np.ones(f.n("household")), 3)]
+        ),
+        epochs=1,
+    )
+    with pytest.raises(ValueError, match="integer"):
+        refit_uk_dataset_size(
+            frame, dense, households=size, epochs=1, learning_rate=0.02, seed=7
+        )
+
+
+def test_size_solve_restores_full_prepared_tables_before_subsetting():
+    frame = _clone_frame()
+    metrics = pd.DataFrame({"households": [1.0, 1.0, 1.0]}, index=[101, 102, 103])
+    problem = build_uk_rowwise_local_matrix(
+        metrics,
+        _assigned(),
+        pd.DataFrame({"code": ["E001", "S001"], "households": [2.0, 1.0]}),
+    )
+    restored_counts = []
+
+    def restore(full):
+        restored_counts.append(full.n("household"))
+        return full
+
+    result = solve_uk_rowwise_weights_under_doctrine(
+        frame,
+        problem,
+        bound_families=["census_households/constituency"],
+        dataset_households=2,
+        epochs=2,
+        seed=7,
+        restore=restore,
+    )
+    assert restored_counts == [3]
+    assert result.frame.n("household") == 2
+    assert result.frame.n("person") == 2
+    assert len(result.diagnostics) == 2
+    assert "census_households/constituency" in result.frame.mass_log[-1].reason
+    assert result.selected_support.tolist() == [0, 2]
+
+
+def test_size_solve_keeps_its_dense_reference_and_selection_seed_moves_only_the_draw():
+    frame = _clone_frame()
+    metrics = pd.DataFrame({"households": [1.0, 1.0, 1.0]}, index=[101, 102, 103])
+    problem = build_uk_rowwise_local_matrix(
+        metrics,
+        _assigned(),
+        pd.DataFrame({"code": ["E001", "S001"], "households": [2.0, 1.0]}),
+    )
+    common = dict(
+        bound_families=["census_households/constituency"],
+        epochs=2,
+        seed=7,
+    )
+    dense = solve_uk_rowwise_weights_under_doctrine(frame, problem, **common)
+    sized = solve_uk_rowwise_weights_under_doctrine(
+        frame, problem, dataset_households=2, **common
+    )
+    assert dense.dense_reference is None
+    reference = sized.dense_reference
+    assert reference is not None
+    # The reference is the standalone dense solve, byte for byte.
+    np.testing.assert_array_equal(reference.weights, dense.weights)
+    np.testing.assert_array_equal(reference.initial_weights, dense.initial_weights)
+    assert reference.final_loss == dense.final_loss
+    assert reference.final_loss == sized.size_receipt["dense_loss"]
+    assert reference.initial_loss == dense.initial_loss
+    assert reference.n_nonzero == dense.n_nonzero
+    pd.testing.assert_frame_equal(reference.diagnostics, dense.diagnostics)
+    pd.testing.assert_frame_equal(
+        reference.national_diagnostics, dense.national_diagnostics
+    )
+    assert dict(reference.past_cap_census) == dict(dense.past_cap_census)
+    assert dict(reference.all_past_cap_census) == dict(dense.all_past_cap_census)
+    # The shipped product is the compact refit, not the reference.
+    assert sized.weights.size == 2
+    assert reference.weights.size == 3
+    # A selection seed moves the draw only: same pool, same dense reference.
+    other = solve_uk_rowwise_weights_under_doctrine(
+        frame, problem, dataset_households=2, selection_seed=11, **common
+    )
+    np.testing.assert_array_equal(other.dense_reference.weights, reference.weights)
+    assert other.size_receipt["seed"] == 11
+    assert sized.size_receipt["seed"] == 7
+    assert other.size_receipt["dense_loss"] == sized.size_receipt["dense_loss"]
+
+
+def test_selection_feasibility_measures_boundary_mass_and_the_ways_out():
+    from microcosm.build.uk_runtime.dataset_size import selection_feasibility
+
+    # Two protected certainties, then a boundary whose largest gate (0.9)
+    # cannot be scaled to a draw of 5 out of mass 0.9 + 4 * 0.2 = 1.7.
+    pi = np.array([1.0, 1.0, 0.9, 0.2, 0.2, 0.2, 0.2, 0.0])
+    protected = np.array([True, True, False, False, False, False, False, False])
+    report = selection_feasibility(
+        pi, 7, protected=protected, n_nonzero=7, l0_lambda=0.5
+    )
+    assert report["certainties_at_pi_hi_1"] == 2
+    assert report["boundary_draw"] == 5
+    assert report["boundary_positive_gates"] == 5
+    assert report["boundary_mass"] == pytest.approx(1.7)
+    assert report["boundary_max"] == pytest.approx(0.9)
+    assert report["feasible_at_pi_hi_1"] is False
+    # At pi_hi=1 the boundary supports floor(1.7 / 0.9) = 1 draw: k <= 3.
+    assert report["max_feasible_households_at_pi_hi_1"] == 3
+    # Promoting the 0.9 gate to a certainty (pi_hi <= 0.9) leaves a draw of 4
+    # over four equal 0.2 gates: feasible; 0.99 and above are not.
+    assert report["pi_hi_scan"]["0.99"]["feasible"] is False
+    assert report["pi_hi_scan"]["0.99"]["reason"] == "boundary_mass_short"
+    assert report["pi_hi_scan"]["0.9"]["feasible"] is True
+    assert report["pi_hi_scan"]["0.9"]["reason"] == "feasible"
+    assert report["smallest_feasible_pi_hi_on_grid"] == 0.9
+    assert report["requested_pi_hi_verdict"] == "boundary_mass_short"
+    assert report["budget_search"] is None
+    assert report["gates_above"]["0.5"] == 3
+    assert report["budget_search_n_nonzero"] == 7
+    assert report["selection_l0_lambda"] == 0.5
+    assert report["requested_pi_hi"] == 1.0
+    assert report["feasible_at_requested_pi_hi"] is False
+    at_half = selection_feasibility(
+        pi, 7, protected=protected, n_nonzero=7, l0_lambda=0.5, requested_pi_hi=0.9
+    )
+    assert at_half["requested_pi_hi"] == 0.9
+    assert at_half["feasible_at_requested_pi_hi"] is True
+
+    feasible = selection_feasibility(
+        np.array([1.0, 0.5, 0.5, 0.5, 0.5]),
+        3,
+        protected=np.array([True, False, False, False, False]),
+        n_nonzero=5,
+        l0_lambda=0.1,
+    )
+    assert feasible["feasible_at_pi_hi_1"] is True
+    assert feasible["smallest_feasible_pi_hi_on_grid"] == 1.0
+
+
+def test_size_refit_pi_hi_promotes_learned_certainties_and_is_recorded():
+    from microcosm.build.uk_runtime.dataset_size import refit_uk_dataset_size
+    from microcosm.calibrate import Target, TargetSet, calibrate
+
+    frame = _clone_frame()
+    dense = calibrate(
+        frame,
+        TargetSet(
+            [Target("count", "household", lambda f: np.ones(f.n("household")), 3)]
+        ),
+        epochs=2,
+    )
+    sized = refit_uk_dataset_size(
+        frame, dense, households=2, epochs=2, learning_rate=0.02, seed=7, pi_hi=0.5
+    )
+    receipt = sized.receipt
+    assert receipt["selection_pi_hi"] == 0.5
+    assert receipt["selection_receipt"]["pi_hi"] == 0.5
+    assert receipt["selection_budget_basis"] == "open_probability_mass"
+    assert (
+        receipt["selection_feasibility"]["budget_search_basis"]
+        == "open_probability_mass"
+    )
+    assert receipt["selection_feasibility"]["requested_pi_hi"] == 0.5
+    assert receipt["selection_feasibility"]["feasible_at_requested_pi_hi"] is True
+    # The budget search stopped on the draw's own feasibility at the requested
+    # threshold and recorded every probe (microcosm#355, S2 refusal).
+    search = receipt["selection_budget_search"]
+    assert search["feasible_draw_pi_hi"] == 0.5
+    assert search["selected_feasible"] is True
+    assert search["stopped_on"] == "acceptable_within_tolerance"
+    assert search["probes"][-1]["verdict"] == "feasible"
+    assert receipt["selection_feasibility"]["budget_search"] is search
+    # Certainties at 0.5 can only grow relative to the exact-one set.
+    assert (
+        receipt["selection_receipt"]["certainty_count"] >= receipt["protected_carriers"]
+    )
+    assert sized.result.frame.n("household") == 2
+    for bad in (0.0, 1.5, -0.1, True):
+        with pytest.raises(ValueError, match="pi_hi"):
+            refit_uk_dataset_size(
+                frame,
+                dense,
+                households=2,
+                epochs=2,
+                learning_rate=0.02,
+                seed=7,
+                pi_hi=bad,
+            )
+
+
+def test_size_refit_refuses_unsupported_nonzero_targets_by_name():
+    from microcosm.build.uk_runtime.dataset_size import (
+        refit_uk_dataset_size,
+        unsupported_nonzero_targets,
+    )
+    from microcosm.calibrate import Target, TargetSet, calibrate
+
+    frame = _clone_frame()
+    dense = calibrate(
+        frame,
+        TargetSet(
+            [
+                Target("count", "household", lambda f: np.ones(f.n("household")), 3),
+                Target("nobody", "household", lambda f: np.zeros(f.n("household")), 5),
+            ]
+        ),
+        epochs=2,
+    )
+    assert [
+        name.split("@")[0] for name in unsupported_nonzero_targets(dense.problem)
+    ] == ["nobody"]
+    with pytest.raises(ValueError, match="no supporting household.*nobody"):
+        refit_uk_dataset_size(
+            frame, dense, households=2, epochs=2, learning_rate=0.02, seed=7
+        )
+
+
+def test_size_refusal_at_the_draw_carries_the_feasibility_numbers(monkeypatch):
+    import microcosm.build.uk_runtime.dataset_size as sizing
+    from microcosm.calibrate import Target, TargetSet, calibrate
+
+    frame = _clone_frame()
+    dense = calibrate(
+        frame,
+        TargetSet(
+            [Target("count", "household", lambda f: np.ones(f.n("household")), 3)]
+        ),
+        epochs=2,
+    )
+
+    def refuse(*_args, **_kwargs):
+        raise ValueError("degenerate boundary mass: synthetic refusal.")
+
+    monkeypatch.setattr(sizing, "select_exact_k", refuse)
+    with pytest.raises(ValueError) as caught:
+        sizing.refit_uk_dataset_size(
+            frame, dense, households=2, epochs=2, learning_rate=0.02, seed=7
+        )
+    message = str(caught.value)
+    assert message.startswith("degenerate boundary mass: synthetic refusal.")
+    assert "Selection feasibility (requested pi_hi=1): " in message
+    payload = json.loads(
+        message.split("Selection feasibility (requested pi_hi=1): ", 1)[1]
+    )
+    assert payload["requested_pi_hi"] == 1.0
+    assert payload["requested_households"] == 2
+    assert payload["pool_households"] == 3
+    assert "pi_hi_scan" in payload
+
+
+def test_size_holdout_uses_compact_support_and_reselects_each_fold(monkeypatch):
+    import microcosm.build.uk_runtime.local_rowwise as runtime
+
+    metrics = pd.DataFrame({"households": [1.0, 2.0, 3.0]}, index=[101, 102, 103])
+    calls = []
+
+    def solve(frame, training, **kwargs):
+        calls.append((len(training.targets), kwargs["dataset_households"]))
+        return type(
+            "Solve",
+            (),
+            {"weights": np.array([1.0, 1.0]), "selected_support": np.array([0, 2])},
+        )()
+
+    monkeypatch.setattr(runtime, "solve_uk_rowwise_weights_under_doctrine", solve)
+    # The holdout helper needs at least one target in each of five folds.
+    richer = build_uk_rowwise_local_matrix(
+        pd.DataFrame(
+            {
+                name: [1.0, 2.0, 3.0]
+                for name in ("households", "tenure/social_rent", "tenure/private_rent")
+            },
+            index=metrics.index,
+        ),
+        _assigned(),
+        pd.DataFrame(
+            {
+                "code": ["E001", "S001"],
+                **{
+                    name: [3.0, 3.0]
+                    for name in (
+                        "households",
+                        "tenure/social_rent",
+                        "tenure/private_rent",
+                    )
+                },
+            }
+        ),
+    )
+    monkeypatch.setattr(
+        runtime, "_derive_uk_local_bound_families_from_target_frame", lambda *a, **k: ()
+    )
+    receipt = rotated_uk_local_holdout(
+        _clone_frame(), richer, dataset_households=2, epochs=1
+    )
+    assert len(calls) == 5
+    assert all(n < len(richer.targets) and k == 2 for n, k in calls)
+    assert np.isfinite(receipt["mean_holdout_loss"])
+
+
+def test_size_refit_freezes_population_dependent_measures():
+    from microcosm.build.uk_runtime.dataset_size import refit_uk_dataset_size
+    from microcosm.calibrate import Target, TargetSet, calibrate
+
+    frame = _clone_frame()
+    # A population-normalized measure changes if evaluated on two instead of
+    # three households. The refit must retain the full-pool value of 1/3.
+    targets = TargetSet(
+        [
+            Target(
+                "normalized",
+                "household",
+                lambda f: np.full(f.n("household"), 1 / f.n("household")),
+                1,
+            )
+        ]
+    )
+    dense = calibrate(frame, targets, epochs=2)
+    small = refit_uk_dataset_size(
+        frame, dense, households=2, epochs=2, learning_rate=0.02, seed=7
+    )
+    np.testing.assert_allclose(small.result.problem.matrix.toarray(), [[1 / 3, 1 / 3]])
+
+
+def test_full_size_returns_dense_reference_without_search():
+    from microcosm.build.uk_runtime.dataset_size import refit_uk_dataset_size
+    from microcosm.calibrate import Target, TargetSet, calibrate
+
+    frame = _clone_frame()
+    dense = calibrate(
+        frame,
+        TargetSet(
+            [Target("count", "household", lambda f: np.ones(f.n("household")), 3)]
+        ),
+        epochs=1,
+    )
+    full = refit_uk_dataset_size(
+        frame, dense, households=3, epochs=1, learning_rate=0.02, seed=7
+    )
+    assert full.result is dense
+    assert full.support.tolist() == [0, 1, 2]
+
+
+def test_size_refuses_budget_smaller_than_protected_carriers():
+    from microcosm.build.uk_runtime.dataset_size import refit_uk_dataset_size
+    from microcosm.calibrate import Target, TargetSet, calibrate
+
+    frame = _clone_frame()
+    targets = TargetSet(
+        [
+            Target(
+                str(i),
+                "household",
+                lambda f, i=i: (
+                    f.table("household").household_id.to_numpy() == i
+                ).astype(float),
+                1,
+            )
+            for i in [101, 102, 103]
+        ]
+    )
+    dense = calibrate(frame, targets, epochs=1)
+    with pytest.raises(ValueError, match="3 protected target carriers"):
+        refit_uk_dataset_size(
+            frame, dense, households=2, epochs=1, learning_rate=0.02, seed=7
+        )
+
+
+def _size_problem():
+    metrics = pd.DataFrame({"households": [1.0, 1.0, 1.0]}, index=[101, 102, 103])
+    return build_uk_rowwise_local_matrix(
+        metrics,
+        _assigned(),
+        pd.DataFrame({"code": ["E001", "S001"], "households": [2.0, 1.0]}),
+    )
+
+
+def test_size_selection_can_be_searched_once_and_drawn_from_again():
+    from microcosm.build.uk_runtime.dataset_size import (
+        refit_uk_dataset_size,
+        select_uk_dataset_size,
+    )
+    from microcosm.calibrate import Target, TargetSet, calibrate
+
+    frame = _clone_frame()
+    dense = calibrate(
+        frame,
+        TargetSet(
+            [Target("count", "household", lambda f: np.ones(f.n("household")), 3)]
+        ),
+        epochs=2,
+    )
+    one_shot = refit_uk_dataset_size(
+        frame, dense, households=2, epochs=2, learning_rate=0.02, seed=7, pi_hi=0.5
+    )
+    selection = select_uk_dataset_size(
+        frame, dense, households=2, epochs=2, learning_rate=0.02, seed=7, pi_hi=0.5
+    )
+    assert selection.search_pi_hi == 0.5
+    assert selection.selection.l0_lambda == one_shot.receipt["selection_l0_lambda"]
+    reused = refit_uk_dataset_size(
+        frame,
+        dense,
+        households=2,
+        epochs=2,
+        learning_rate=0.02,
+        seed=7,
+        pi_hi=0.5,
+        selection=selection,
+    )
+    np.testing.assert_array_equal(reused.support, one_shot.support)
+    np.testing.assert_array_equal(reused.result.weights, one_shot.result.weights)
+    assert one_shot.receipt["selection_reused"] is False
+    assert reused.receipt["selection_reused"] is True
+    assert reused.receipt["selection_search_pi_hi"] == 0.5
+    # A different draw threshold on the same search is allowed and recorded.
+    redrawn = refit_uk_dataset_size(
+        frame,
+        dense,
+        households=2,
+        epochs=2,
+        learning_rate=0.02,
+        seed=7,
+        pi_hi=1.0,
+        selection=selection,
+    )
+    assert redrawn.receipt["selection_pi_hi"] == 1.0
+    assert redrawn.receipt["selection_search_pi_hi"] == 0.5
+    assert redrawn.receipt["selection_feasibility"]["search_pi_hi"] == 0.5
+    # Different search inputs refuse by name.
+    with pytest.raises(ValueError, match="epochs: selection 2 != 3"):
+        refit_uk_dataset_size(
+            frame,
+            dense,
+            households=2,
+            epochs=3,
+            learning_rate=0.02,
+            seed=7,
+            selection=selection,
+        )
+    with pytest.raises(ValueError, match="full-pool"):
+        select_uk_dataset_size(
+            frame, dense, households=3, epochs=2, learning_rate=0.02, seed=7
+        )
+
+
+def test_size_checkpoint_resumes_the_draw_on_the_rederived_pool(tmp_path):
+    from microcosm.build.uk_runtime.size_checkpoint import (
+        SIZE_CHECKPOINT_ARRAYS_FILENAME,
+        SIZE_CHECKPOINT_MANIFEST_FILENAME,
+        load_uk_size_checkpoint,
+    )
+
+    frame = _clone_frame()
+    problem = _size_problem()
+    identity = {"input_sha256": "abc", "seed": 7, "epochs": 2, "households": 2}
+    common = dict(
+        bound_families=["census_households/constituency"],
+        dataset_households=2,
+        epochs=2,
+        seed=7,
+    )
+    checkpoint_dir = tmp_path / "run-a"
+    first = solve_uk_rowwise_weights_under_doctrine(
+        frame,
+        problem,
+        selection_pi_hi=0.5,
+        size_checkpoint_dir=checkpoint_dir,
+        checkpoint_identity=identity,
+        **common,
+    )
+    assert (checkpoint_dir / SIZE_CHECKPOINT_ARRAYS_FILENAME).is_file()
+    manifest = json.loads(
+        (checkpoint_dir / SIZE_CHECKPOINT_MANIFEST_FILENAME).read_text()
+    )
+    assert manifest["identity"] == identity
+    assert manifest["selection"]["search_pi_hi"] == 0.5
+    assert manifest["pool"]["households"] == 3
+    written = first.size_receipt["checkpoint"]["written"]
+    assert written["stage"] == "before_exact_count_draw"
+    assert written["arrays_sha256"] == manifest["arrays_sha256"]
+    # Nothing in the receipt differs between identical runs (Vahid, #877):
+    # no timestamp, no absolute path.
+    assert "written_at" not in written and "directory" not in written
+    assert first.size_receipt["certainty_share"] == pytest.approx(
+        first.size_receipt["selection_receipt"]["certainty_count"] / 2
+    )
+    assert (
+        first.size_receipt["boundary_draws"]
+        == 2 - (first.size_receipt["selection_receipt"]["certainty_count"])
+    )
+    assert first.size_receipt["zero_target_rows"] == 0
+
+    # Resume: no dense solve, no search; the draw and refit reproduce the run.
+    resumed = solve_uk_rowwise_weights_under_doctrine(
+        frame,
+        problem,
+        selection_pi_hi=0.5,
+        resume_size_checkpoint=checkpoint_dir,
+        checkpoint_identity=identity,
+        **common,
+    )
+    np.testing.assert_array_equal(resumed.selected_support, first.selected_support)
+    np.testing.assert_array_equal(resumed.weights, first.weights)
+    assert resumed.final_loss == first.final_loss
+    assert resumed.dense_reference is not None
+    assert resumed.dense_reference.final_loss == first.dense_reference.final_loss
+    np.testing.assert_array_equal(
+        resumed.dense_reference.weights, first.dense_reference.weights
+    )
+    assert resumed.size_receipt["selection_reused"] is True
+    assert resumed.size_receipt["checkpoint"]["resumed_from"]["identity"] == identity
+    assert (
+        resumed.size_receipt["selection_l0_lambda"]
+        == (first.size_receipt["selection_l0_lambda"])
+    )
+    # Another draw threshold on the same checkpoint is a candidate knob, recorded.
+    redrawn = solve_uk_rowwise_weights_under_doctrine(
+        frame,
+        problem,
+        selection_pi_hi=1.0,
+        resume_size_checkpoint=checkpoint_dir,
+        checkpoint_identity=identity,
+        **common,
+    )
+    assert redrawn.size_receipt["selection_pi_hi"] == 1.0
+    assert redrawn.size_receipt["selection_search_pi_hi"] == 0.5
+
+    # A resume under a changed doctrine refuses even when the identity was
+    # not asked to carry it (the second lock, Vahid's should-fix 1).
+    import dataclasses
+
+    from microcosm.build.uk_runtime import local_rowwise as lr_module
+
+    drifted_doctrine = dataclasses.replace(
+        lr_module.UK_LOCAL_SOLVE_DOCTRINE,
+        max_weight_ratio=lr_module.UK_LOCAL_SOLVE_DOCTRINE.max_weight_ratio * 2,
+    )
+    original_doctrine = lr_module.UK_LOCAL_SOLVE_DOCTRINE
+    lr_module.UK_LOCAL_SOLVE_DOCTRINE = drifted_doctrine
+    try:
+        with pytest.raises(ValueError, match="different doctrine.*max_weight_ratio"):
+            solve_uk_rowwise_weights_under_doctrine(
+                frame,
+                problem,
+                resume_size_checkpoint=checkpoint_dir,
+                checkpoint_identity=identity,
+                **common,
+            )
+    finally:
+        lr_module.UK_LOCAL_SOLVE_DOCTRINE = original_doctrine
+    provenance_run = solve_uk_rowwise_weights_under_doctrine(
+        frame,
+        problem,
+        resume_size_checkpoint=checkpoint_dir,
+        checkpoint_identity=identity,
+        **common,
+    )
+    assert provenance_run.size_receipt["checkpoint"]["resumed_from"]["provenance"] == {}
+
+    # Identity, pool and surface drift refuse by name.
+    with pytest.raises(ValueError, match="epochs: checkpoint 2 != run 3"):
+        solve_uk_rowwise_weights_under_doctrine(
+            frame,
+            problem,
+            resume_size_checkpoint=checkpoint_dir,
+            checkpoint_identity={**identity, "epochs": 3},
+            **common,
+        )
+    with pytest.raises(ValueError, match="absent in checkpoint"):
+        solve_uk_rowwise_weights_under_doctrine(
+            frame,
+            problem,
+            resume_size_checkpoint=checkpoint_dir,
+            checkpoint_identity={**identity, "ladder_sha256": "x"},
+            **common,
+        )
+    from microcosm.build.uk_runtime.local_rowwise import _rowwise_target_set
+
+    other_pool = uk_national_frame(
+        person=pd.DataFrame(
+            {
+                "person_id": [1, 2, 3],
+                "person_household_id": [101, 102, 104],
+                "person_benunit_id": [11, 12, 13],
+            }
+        ),
+        benunit=pd.DataFrame({"benunit_id": [11, 12, 13]}),
+        household=pd.DataFrame(
+            {"household_id": [101, 102, 104], "household_weight": [1.0, 1.0, 1.0]}
+        ),
+        time_period="2023",
+        weight_kind=WeightKind.IMPORTANCE,
+    )
+    with pytest.raises(ValueError, match="pool differs"):
+        load_uk_size_checkpoint(
+            checkpoint_dir,
+            frame=other_pool,
+            target_set=_rowwise_target_set(problem),
+            identity=identity,
+        )
+    drifted = build_uk_rowwise_local_matrix(
+        pd.DataFrame({"households": [1.0, 1.0, 1.0]}, index=[101, 102, 103]),
+        _assigned(),
+        pd.DataFrame({"code": ["E001", "S001"], "households": [2.5, 1.0]}),
+    )
+    with pytest.raises(ValueError, match="target surface differs"):
+        solve_uk_rowwise_weights_under_doctrine(
+            frame,
+            drifted,
+            resume_size_checkpoint=checkpoint_dir,
+            checkpoint_identity=identity,
+            **common,
+        )
+    with pytest.raises(FileExistsError, match="refusing to overwrite"):
+        solve_uk_rowwise_weights_under_doctrine(
+            frame,
+            problem,
+            size_checkpoint_dir=checkpoint_dir,
+            checkpoint_identity=identity,
+            **common,
+        )
+    with pytest.raises(ValueError, match="dataset_households"):
+        solve_uk_rowwise_weights_under_doctrine(
+            frame,
+            problem,
+            bound_families=["census_households/constituency"],
+            epochs=2,
+            seed=7,
+            size_checkpoint_dir=tmp_path / "no-size",
+        )
+
+
+def test_progress_lines_cover_the_dense_solve_the_probes_and_the_refit():
+    from microcosm.build.uk_runtime.solve_progress import uk_solve_progress_callback
+
+    frame = _clone_frame()
+    problem = _size_problem()
+    lines: list[str] = []
+    solve_uk_rowwise_weights_under_doctrine(
+        frame,
+        problem,
+        bound_families=["census_households/constituency"],
+        dataset_households=2,
+        epochs=2,
+        seed=7,
+        selection_pi_hi=0.5,
+        progress=lines.append,
+    )
+    text = "\n".join(lines)
+    # The dense solve, each probe's epochs, the probe verdicts, the stop line
+    # and the refit all appear, timestamped, in that order.
+    dense = next(i for i, line in enumerate(lines) if "dense solve: epoch 2/2" in line)
+    probe_epoch = next(
+        i for i, line in enumerate(lines) if "probe 1/10 (lambda" in line
+    )
+    probe_done = next(i for i, line in enumerate(lines) if "probe 1/10 done:" in line)
+    stopped = next(i for i, line in enumerate(lines) if "search stopped:" in line)
+    refit = next(i for i, line in enumerate(lines) if "refit: epoch 2/2" in line)
+    assert dense < probe_epoch < probe_done < stopped < refit
+    assert "open_probability_mass" in lines[probe_done]
+    assert "verdict feasible" in text
+    assert "drawable True" in lines[stopped]
+    assert all(line[8] == "Z" for line in lines), lines[:2]
+
+    # The formatter itself: a loss line only every ``every`` epochs and at the
+    # last epoch; probe and stop events in one line each.
+    sink: list[str] = []
+    callback = uk_solve_progress_callback(sink.append, every=3)
+    for epoch in range(1, 8):
+        callback(
+            {"kind": "calibration_epoch", "epoch": epoch, "epochs": 7, "loss": 0.5}
+        )
+    assert [line.split("epoch ")[1].split(" ")[0] for line in sink] == [
+        "3/7",
+        "6/7",
+        "7/7",
+    ]
+    callback(
+        {
+            "kind": "budget_probe",
+            "budget_iteration": 2,
+            "budget_iters": 10,
+            "l0_lambda": 1e-6,
+            "measure": 54834,
+            "target_records": 55000,
+            "budget_basis": "open_probability_mass",
+            "verdict": "boundary_mass_short",
+            "certainty_count": 54563,
+            "boundary_draw": 437,
+            "boundary_mass": 290.6,
+            "boundary_max": 0.947,
+        }
+    )
+    assert sink[-1].endswith(
+        "probe 2/10 done: lambda 1e-06, open_probability_mass 54834 for 55000 "
+        "requested, verdict boundary_mass_short, certainties 54563, boundary draw "
+        "437 from mass 290.6 (max 0.947)"
+    )
+    callback({"kind": "something_else"})
+    assert len(sink) == 4
+    with pytest.raises(ValueError, match="every"):
+        uk_solve_progress_callback(sink.append, every=0)
diff --git a/packages/microcosm-build/tests/test_uk_measure_simulation.py b/packages/microcosm-build/tests/test_uk_measure_simulation.py
index da0eeddba..a031cd6c1 100644
--- a/packages/microcosm-build/tests/test_uk_measure_simulation.py
+++ b/packages/microcosm-build/tests/test_uk_measure_simulation.py
@@ -322,7 +322,7 @@ def test_exclusion_applier_warns_within_week_of_expiry():
     "hmrc.salary_sacrifice.": 5,
     "_1_000_000_to_inf": 11,
     "slc.": 5,
-    "dwp/uc_payment_dist/": 16,
+    "dwp/uc_payment_dist/": 18,
     "obr.universal_credit_": 2,
     "ons.household_composition.": 3,
     "obr.fuel_duties": 1,
@@ -349,7 +349,7 @@ def test_exclusion_applier_warns_within_week_of_expiry():
 def test_packaged_exclusions_load():
     exclusions = load_uk_calibration_measure_exclusions()
     names = [entry["name"] for entry in exclusions]
-    assert len(names) == len(set(names)) == 49
+    assert len(names) == len(set(names)) == 51
 
     for marker, expected in _PACKAGED_EXCLUSION_CENSUS.items():
         matched = [name for name in names if marker in name]
diff --git a/packages/microcosm-build/tests/test_uk_rowwise_candidate.py b/packages/microcosm-build/tests/test_uk_rowwise_candidate.py
index 8bd053f90..f60de8a43 100644
--- a/packages/microcosm-build/tests/test_uk_rowwise_candidate.py
+++ b/packages/microcosm-build/tests/test_uk_rowwise_candidate.py
@@ -1822,3 +1822,375 @@ def test_candidate_multi_block_engine_run_is_never_releasable(
         "single_block_engine": False,
         "release_blocking_gates_passed": True,
     }
+
+
+def test_size_candidate_exports_compact_links_and_cannot_claim_dense_release(
+    monkeypatch, tmp_path
+):
+    pytest.importorskip("tables")
+    pytest.importorskip("h5py")
+    builder = _load_builder_module()
+    input_h5 = tmp_path / "spine.h5"
+    ladder_path = tmp_path / "ladder.npz"
+    out = tmp_path / "k300"
+    _write_staging_h5(input_h5, households_per_region=52)
+    ladder = _write_ladder(ladder_path)
+    import microcosm.build.uk_runtime.battery_bindings as bindings
+
+    monkeypatch.setattr(
+        bindings,
+        "_local_area_roster",
+        lambda _resource, levels: {
+            "constituency": tuple(sorted(set(ladder.constituency_code))),
+            "local_authority": tuple(sorted(set(ladder.local_authority_code))),
+        },
+    )
+    status = builder.main(
+        [
+            "--input-h5",
+            str(input_h5),
+            "--ladder",
+            str(ladder_path),
+            "--out",
+            str(out),
+            "--n-clones",
+            "2",
+            "--dataset-households",
+            "300",
+            "--selection-seed",
+            "11",
+            "--epochs",
+            "2",
+            "--skip-holdout",
+            "--seed",
+            "7",
+        ]
+    )
+    assert status in (0, 1)  # Gate failures remain reportable candidates.
+    manifest = json.loads((out / builder.MANIFEST_FILENAME).read_text())
+    assert manifest["releasable"] is False
+    assert manifest["release_posture"]["size_certification_present"] is False
+    size = manifest["solve"]["dataset_size"]
+    assert size["requested_households"] == size["realized_households"] == 300
+    assert size["pool_households"] == 416
+    assert manifest["parameters"]["n_clones"] == 2
+    assert (
+        manifest["weights"]["stretch_reference"]
+        == "normalized_horvitz_thompson_w_over_q"
+    )
+    path = out / builder.CANDIDATE_FILENAME_TEMPLATE.format(calibration_year=2025)
+    with pd.HDFStore(path, "r") as store:
+        households = store["household"]
+        persons = store["person"]
+        benunits = store["benunit"]
+    assert len(households) == 300
+    assert set(persons.person_household_id) == set(households.household_id)
+    assert set(persons.person_benunit_id) == set(benunits.benunit_id)
+    assert len(_spool_rows(out)) == 1
+
+    # The selection seed moves the draw only; the manifest records both seeds.
+    assert manifest["parameters"]["seed"] == 7
+    assert manifest["parameters"]["selection_seed"] == 11
+    assert size["seed"] == 11
+    assert manifest["parameters"]["selection_pi_hi"] == 1.0
+    assert size["selection_pi_hi"] == 1.0
+    assert size["selection_receipt"]["pi_hi"] == 1.0
+    assert size["selection_feasibility"]["requested_pi_hi"] == 1.0
+    assert size["selection_feasibility"]["feasible_at_requested_pi_hi"] is True
+
+    # The dense solve the selection was cut from ships as evidence.
+    dense = size["dense_reference"]
+    assert dense["final_loss"] == size["dense_loss"]
+    assert dense["n_households"] == 416
+    assert dense["weights"]["n_records"] == 416
+    assert {"effective_sample_size", "max_to_median_positive_weight"} <= set(
+        dense["weights"]
+    )
+    assert dense["diagnostics_file"] == builder.DENSE_REFERENCE_DIAGNOSTICS_FILENAME
+    outputs = manifest["outputs"]
+    dense_csv = out / builder.DENSE_REFERENCE_DIAGNOSTICS_FILENAME
+    selection_csv = out / builder.DATASET_SIZE_SELECTION_FILENAME
+    assert Path(outputs["dense_reference_diagnostics"]["path"]) == dense_csv.resolve()
+    assert Path(outputs["dataset_size_selection"]["path"]) == selection_csv.resolve()
+    assert (
+        outputs["dataset_size_selection"]["sha256"]
+        == hashlib.sha256(selection_csv.read_bytes()).hexdigest()
+    )
+    dense_rows = pd.read_csv(dense_csv)
+    assert len(dense_rows) == manifest["solve"]["n_targets"]
+    assert dense_rows.columns[0] == "grain"
+    assert {"target", "final_estimate", "abs_relative_error"} <= set(dense_rows.columns)
+    selection = pd.read_csv(selection_csv)
+    assert list(selection.columns) == [
+        "pool_row_index",
+        "household_id",
+        "clone_index",
+        "design_weight",
+        "inclusion_probability",
+        "certainty",
+        "ht_baseline_weight",
+        "refit_weight",
+    ]
+    assert len(selection) == 300
+    assert selection["pool_row_index"].is_unique
+    assert selection["pool_row_index"].max() < 416
+    assert set(selection["household_id"]) == set(households.household_id)
+    assert (selection["refit_weight"] > 0).all()
+    assert (selection["design_weight"] > 0).all()
+    assert (
+        int(selection["certainty"].sum())
+        == size["selection_receipt"]["certainty_count"]
+    )
+    assert int(selection["certainty"].sum()) == size["protected_carriers"]
+
+
+def test_selection_seed_requires_a_dataset_size(tmp_path):
+    builder = _load_builder_module()
+    args = builder._parse_args(
+        [
+            "--input-h5",
+            str(tmp_path / "spine.h5"),
+            "--ladder",
+            str(tmp_path / "ladder.npz"),
+            "--out",
+            str(tmp_path / "out"),
+            "--selection-seed",
+            "11",
+        ]
+    )
+    with pytest.raises(ValueError, match="requires --dataset-households"):
+        builder._validate_cli_args(args)
+
+
+@pytest.mark.parametrize(
+    ("argv_tail", "message"),
+    [
+        (["--selection-pi-hi", "0.95"], "requires --dataset-households"),
+        (["--dataset-households", "10", "--selection-pi-hi", "0"], r"in \(0, 1\]"),
+        (["--dataset-households", "10", "--selection-pi-hi", "1.5"], r"in \(0, 1\]"),
+    ],
+)
+def test_selection_pi_hi_is_candidate_only_and_bounded(tmp_path, argv_tail, message):
+    builder = _load_builder_module()
+    args = builder._parse_args(
+        [
+            "--input-h5",
+            str(tmp_path / "spine.h5"),
+            "--ladder",
+            str(tmp_path / "ladder.npz"),
+            "--out",
+            str(tmp_path / "out"),
+            *argv_tail,
+        ]
+    )
+    with pytest.raises(ValueError, match=message):
+        builder._validate_cli_args(args)
+
+
+def test_dense_candidate_manifest_has_no_size_sidecars(tmp_path):
+    builder = _load_builder_module()
+    paths = builder._output_paths(tmp_path, source_year=2024, calibration_year=2025)
+    assert paths["dense_reference"].name == builder.DENSE_REFERENCE_DIAGNOSTICS_FILENAME
+    assert paths["selection"].name == builder.DATASET_SIZE_SELECTION_FILENAME
+    assert builder._SIZE_RUN_ONLY_OUTPUTS == {"dense_reference", "selection"}
+
+
+def test_size_cli_refuses_promotion_without_separate_certification(tmp_path):
+    builder = _load_builder_module()
+    args = builder._parse_args(
+        [
+            "--input-h5",
+            str(tmp_path / "spine.h5"),
+            "--ladder",
+            str(tmp_path / "ladder.npz"),
+            "--out",
+            str(tmp_path / "out"),
+            "--dataset-households",
+            "50000",
+            "--release-candidate",
+        ]
+    )
+    with pytest.raises(ValueError, match="candidate-only"):
+        builder._validate_cli_args(args)
+
+
+def test_size_candidate_checkpoints_before_the_draw_and_resumes_from_it(
+    monkeypatch, tmp_path, capsys
+):
+    pytest.importorskip("tables")
+    pytest.importorskip("h5py")
+    builder = _load_builder_module()
+    from microcosm.build.uk_runtime.size_checkpoint import (
+        SIZE_CHECKPOINT_ARRAYS_FILENAME,
+        SIZE_CHECKPOINT_MANIFEST_FILENAME,
+    )
+
+    input_h5 = tmp_path / "spine.h5"
+    ladder_path = tmp_path / "ladder.npz"
+    _write_staging_h5(input_h5, households_per_region=52)
+    ladder = _write_ladder(ladder_path)
+    import microcosm.build.uk_runtime.battery_bindings as bindings
+
+    monkeypatch.setattr(
+        bindings,
+        "_local_area_roster",
+        lambda _resource, levels: {
+            "constituency": tuple(sorted(set(ladder.constituency_code))),
+            "local_authority": tuple(sorted(set(ladder.local_authority_code))),
+        },
+    )
+    common = [
+        "--input-h5",
+        str(input_h5),
+        "--ladder",
+        str(ladder_path),
+        "--n-clones",
+        "2",
+        "--dataset-households",
+        "300",
+        "--epochs",
+        "2",
+        "--skip-holdout",
+        "--seed",
+        "7",
+    ]
+    first = tmp_path / "first"
+    status = builder.main([*common, "--out", str(first), "--selection-pi-hi", "0.5"])
+    assert status in (0, 1)
+    # The solve is no longer silent: probe verdicts and the search stop reach
+    # stderr as they happen, beside the phase lines.
+    err = capsys.readouterr().err
+    assert "probe 1/10 done:" in err and "search stopped:" in err
+    assert "dense solve: epoch 2/2" in err and "refit: epoch 2/2" in err
+    assert "size selection checkpoint written to" in err
+    assert (first / SIZE_CHECKPOINT_ARRAYS_FILENAME).is_file()
+    checkpoint = json.loads((first / SIZE_CHECKPOINT_MANIFEST_FILENAME).read_text())
+    assert checkpoint["selection"]["households"] == 300
+    assert checkpoint["selection"]["search_pi_hi"] == 0.5
+    assert checkpoint["identity"]["dataset_households"] == 300
+    assert checkpoint["identity"]["epochs"] == 2
+    # The identity carries the solve doctrine; the provenance names the
+    # writing run (reported on resume, not compared).
+    assert checkpoint["identity"]["doctrine"] == builder._doctrine_bounds()
+    assert set(checkpoint["provenance"]) == {"code_pin", "build_id"}
+    manifest = json.loads((first / builder.MANIFEST_FILENAME).read_text())
+    written = manifest["solve"]["dataset_size"]["checkpoint"]["written"]
+    assert "written_at" not in written and "directory" not in written
+    size_first = manifest["solve"]["dataset_size"]
+    assert 0 < size_first["certainty_share"] <= 1
+    assert (
+        size_first["boundary_draws"]
+        == 300 - (size_first["selection_receipt"]["certainty_count"])
+    )
+    assert size_first["zero_target_rows"] >= 0
+    weights_block = manifest["weights"]
+    assert weights_block["stretch_reference"] == "normalized_horvitz_thompson_w_over_q"
+    assert weights_block["realized_max_weight_ratio_vs_stretch_reference"] > 0
+    assert weights_block["realized_max_weight_ratio_vs_design"] > 0
+    assert manifest["parameters"]["size_checkpoint"] is True
+    assert manifest["parameters"]["resume_size_checkpoint"] is None
+    written = manifest["solve"]["dataset_size"]["checkpoint"]["written"]
+    assert written["arrays_sha256"] == checkpoint["arrays_sha256"]
+    assert manifest["solve"]["dataset_size"]["selection_reused"] is False
+    rows = _spool_rows(first)
+    assert len(rows) == 1
+    assert "size_selection_checkpointed" in rows[0].phases_reached
+
+    # Resume on the same inputs: no dense solve, no search, same draw and refit.
+    second = tmp_path / "second"
+    status = builder.main(
+        [
+            *common,
+            "--out",
+            str(second),
+            "--selection-pi-hi",
+            "0.5",
+            "--resume-size-checkpoint",
+            str(first),
+        ]
+    )
+    assert status in (0, 1)
+    assert not (second / SIZE_CHECKPOINT_ARRAYS_FILENAME).exists()
+    resumed = json.loads((second / builder.MANIFEST_FILENAME).read_text())
+    assert resumed["parameters"]["size_checkpoint"] is False
+    assert resumed["parameters"]["resume_size_checkpoint"] == str(first.resolve())
+    size = resumed["solve"]["dataset_size"]
+    assert size["selection_reused"] is True
+    assert size["selection_search_pi_hi"] == 0.5
+    assert (
+        size["checkpoint"]["resumed_from"]["arrays_sha256"]
+        == (checkpoint["arrays_sha256"])
+    )
+    assert size["dense_loss"] == manifest["solve"]["dataset_size"]["dense_loss"]
+    assert (
+        size["selection_l0_lambda"]
+        == (manifest["solve"]["dataset_size"]["selection_l0_lambda"])
+    )
+    first_selection = pd.read_csv(first / builder.DATASET_SIZE_SELECTION_FILENAME)
+    second_selection = pd.read_csv(second / builder.DATASET_SIZE_SELECTION_FILENAME)
+    pd.testing.assert_frame_equal(first_selection, second_selection)
+    assert "size_selection_resumed" in _spool_rows(second)[0].phases_reached
+
+    # Another threshold re-draws from the same checkpoint and records both.
+    third = tmp_path / "third"
+    status = builder.main(
+        [
+            *common,
+            "--out",
+            str(third),
+            "--selection-pi-hi",
+            "1.0",
+            "--resume-size-checkpoint",
+            str(first),
+        ]
+    )
+    assert status in (0, 1)
+    redrawn = json.loads((third / builder.MANIFEST_FILENAME).read_text())
+    assert redrawn["solve"]["dataset_size"]["selection_pi_hi"] == 1.0
+    assert redrawn["solve"]["dataset_size"]["selection_search_pi_hi"] == 0.5
+
+    # A resume whose inputs differ refuses by name, before any solve.
+    different_epochs = list(common)
+    different_epochs[different_epochs.index("--epochs") + 1] = "3"
+    with pytest.raises(ValueError, match="epochs: checkpoint 2 != run 3"):
+        builder.main(
+            [
+                *different_epochs,
+                "--out",
+                str(tmp_path / "fourth"),
+                "--resume-size-checkpoint",
+                str(first),
+            ]
+        )
+    with pytest.raises(ValueError, match="requires --dataset-households"):
+        builder.main(
+            [
+                "--input-h5",
+                str(input_h5),
+                "--ladder",
+                str(ladder_path),
+                "--out",
+                str(tmp_path / "fifth"),
+                "--resume-size-checkpoint",
+                str(first),
+            ]
+        )
+    # An --out that already holds a checkpoint refuses before any solve
+    # (Vahid's should-fix 2): the checkpoint writer's own refusal came hours
+    # too late.
+    stale = tmp_path / "stale"
+    stale.mkdir()
+    (stale / SIZE_CHECKPOINT_ARRAYS_FILENAME).write_bytes(b"stale")
+    (stale / SIZE_CHECKPOINT_MANIFEST_FILENAME).write_text("{}")
+    with pytest.raises(FileExistsError, match="already holds a size checkpoint"):
+        builder.main([*common, "--out", str(stale)])
+    assert not (stale / builder.MANIFEST_FILENAME).exists()
+    assert manifest["solve"]["dataset_size"]["checkpoint"]["written"]["stage"] == (
+        "before_exact_count_draw"
+    )
+    resumed_receipt = resumed["solve"]["dataset_size"]["checkpoint"]["resumed_from"]
+    assert (
+        resumed_receipt["provenance"]["build_id"]
+        == checkpoint["provenance"]["build_id"]
+    )
+    assert "written_at" not in resumed_receipt
diff --git a/packages/microcosm-build/tests/test_uk_size_evaluation.py b/packages/microcosm-build/tests/test_uk_size_evaluation.py
new file mode 100644
index 000000000..6797dea6d
--- /dev/null
+++ b/packages/microcosm-build/tests/test_uk_size_evaluation.py
@@ -0,0 +1,681 @@
+"""Synthetic contract tests for UK dataset-size evaluation helpers."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from microcosm.build.uk_runtime.size_evaluation import (
+    area_support_tables,
+    dense_reference_deltas,
+    footprint,
+    frozen_vs_recomputed,
+    gate_table,
+    load_run,
+    paired_targets,
+    run_acceptance,
+    summarize,
+    weight_tables,
+)
+
+# The evaluation reads and writes PyTables-format H5 through pandas; the wheels
+# lane's venv has no pytables, so these tests skip there like the other H5 tests.
+pytest.importorskip("tables", exc_type=ModuleNotFoundError)
+
+from microcosm.calibrate.solve import effective_sample_size
+
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def _write_run_dir(
+    tmp_path: Path,
+    label: str,
+    *,
+    size_run: bool,
+    red_rows: tuple[str, ...] = (),
+) -> Path:
+    """Write every documented run artifact as a small deterministic fixture."""
+
+    run = tmp_path / label
+    run.mkdir()
+    reference = "reference" in label
+    rows = [
+        (
+            "local/council-tax/E1",
+            "constituency",
+            "E1",
+            "council_tax/band_c",
+            "council_tax",
+            100.0,
+            0.40 if reference else 0.30,
+        ),
+        ("local/income/E1", "constituency", "E1", "income/pay", "income", 100.0, 0.05),
+        (
+            "local/employment/E2",
+            "constituency",
+            "E2",
+            "employment/count",
+            "employment",
+            100.0,
+            0.05 if reference else 0.10,
+        ),
+        (
+            "local/age/E2",
+            "constituency",
+            "E2",
+            "age/20_30",
+            "age",
+            100.0,
+            0.03 if reference else 0.02,
+        ),
+        (
+            "local/income/LA1",
+            "local_authority",
+            "LA1",
+            "income/pay",
+            "income",
+            100.0,
+            0.20,
+        ),
+        (
+            "local/benefit/LA1",
+            "local_authority",
+            "LA1",
+            "benefit/count",
+            "benefit",
+            100.0,
+            0.02 if reference else 0.01,
+        ),
+        (
+            "external:households/E1",
+            "constituency",
+            "E1",
+            "households",
+            "census_households",
+            100.0,
+            0.04 if reference else 0.05,
+        ),
+        (
+            "external:households/E2",
+            "constituency",
+            "E2",
+            "households",
+            "census_households",
+            100.0,
+            0.10,
+        ),
+    ]
+    national = [
+        ("national/a", "national_a", 100.0, 0.10 if reference else 0.05),
+        (
+            "national/b",
+            "national_b",
+            100.0 if reference else 101.0,
+            0.20 if reference else 0.30,
+        ),
+    ]
+    diagnostics_rows = []
+    targets = []
+    for index, (
+        target_name,
+        area_type,
+        area_code,
+        metric,
+        family,
+        target,
+        error,
+    ) in enumerate(rows):
+        estimate = target * (1 + error)
+        diagnostics_rows.append(
+            {
+                "target_index": index,
+                "area_type": area_type,
+                "area_code": area_code,
+                "area_index": index,
+                "metric": metric,
+                "metric_index": index,
+                "value": target,
+                "target_name": target_name,
+                "family": family,
+                "source_family": family,
+                "source": "fixture",
+                "period": 2025,
+                "contract_target_id": f"contract-{index}",
+                "target": target,
+                "initial_estimate": target * 0.5,
+                "final_estimate": estimate,
+                "relative_error": error,
+                "abs_relative_error": abs(error),
+            }
+        )
+        targets.append(
+            {
+                "name": f"{target_name}@2025",
+                "target_name": target_name,
+                "period": 2025,
+                "target": target,
+                "initial_estimate": target * 0.5,
+                "final_estimate": estimate,
+                "relative_error": error,
+                "target_loss_scale": target,
+                "target_loss_weight": 1.0,
+                "metadata": {
+                    "area_type": area_type,
+                    "area_code": area_code,
+                    "metric": metric,
+                    "family": family,
+                    "contract_target_id": f"contract-{index}",
+                },
+            }
+        )
+    for offset, (name, family, target, error) in enumerate(national, start=len(rows)):
+        estimate = target * (1 + error)
+        targets.append(
+            {
+                "name": f"{name}@2025",
+                "target_name": name,
+                "period": 2025,
+                "target": target,
+                "initial_estimate": target * 0.5,
+                "final_estimate": estimate,
+                "relative_error": error,
+                "target_loss_scale": target,
+                "target_loss_weight": 1.0,
+                "metadata": {
+                    "family": family,
+                    "contract_target_id": f"contract-{offset}",
+                    "ledger_source": "fixture",
+                },
+            }
+        )
+    diagnostics = pd.DataFrame(diagnostics_rows)
+    diagnostics_path = run / "solve_diagnostics.csv"
+    diagnostics.to_csv(diagnostics_path, index=False)
+
+    calibration = {
+        "schema_version": 6,
+        "targets": targets,
+        "uk_diagnostics": {
+            "weights": {"effective_sample_size": 5.0},
+            "rotated_holdout": {
+                "mean_holdout_loss": 0.1,
+                "worst_holdout_loss": 0.2,
+                "fold_losses": [0.1, 0.2],
+                "n_folds": 2,
+                "report_only": True,
+            },
+        },
+    }
+    calibration_path = run / "calibration_diagnostics.json"
+    calibration_path.write_text(json.dumps(calibration), encoding="utf-8")
+
+    support = pd.DataFrame(
+        {
+            "geography_level": ["constituency", "constituency", "local_authority"],
+            "area_code": ["E1", "E2", "LA1"],
+            "assigned_households": [40, 60, 70],
+            "nonzero_households": [40, 60, 70],
+            "nonzero_source_households": [40, 60, 40],
+            "weight_sum": [100.0, 100.0, 100.0],
+            "max_weight": [4.0, 4.0, 4.0],
+            "effective_sample_size": [55.0, 45.0, 60.0],
+            "support_below_floor": [True, True, True],
+        }
+    )
+    support_path = run / "area_support_summary.csv"
+    support.to_csv(support_path, index=False)
+
+    gate_ids = (
+        "uk_local_geography_ladder_post_calibration",
+        "uk_local_area_support",
+        "uk_local_target_fit",
+        "uk_local_per_family_fit",
+        "uk_local_weight_ratio",
+        "uk_local_weight_ess",
+    )
+    gates = {}
+    for gate_id in gate_ids:
+        details = {}
+        if gate_id == "uk_local_area_support":
+            details = {
+                "areas_checked": 3,
+                "areas_failed": 3,
+                "by_geography_level": {},
+                "reviewed_exclusions": {"constituency/E1": {"reason": "fixture"}},
+            }
+        if gate_id == "uk_local_target_fit":
+            details = {
+                "failing_targets": {row: 0.4 for row in red_rows},
+                "max_abs_relative_error": 0.4,
+                "targets_checked": 8,
+            }
+        gates[gate_id] = {
+            "criticality": "diagnostic" if reference else "release_blocking",
+            "details": details,
+            "failures": ["fixture"] if details.get("failing_targets") else None,
+            "gate": gate_id,
+            "phase": "post_calibration",
+            "reason": None,
+            "status": "failed" if details.get("failing_targets") else "passed",
+        }
+    gate_report = {
+        "gates": gates,
+        "shippable": False,
+        "posture": "diagnostic",
+        "release_candidate": False,
+        "policy_sha256": "a" * 64,
+        "gates_manifest_sha256": "b" * 64,
+    }
+    gate_path = run / "microcosm_uk_2025_local.local_gates.json"
+    gate_path.write_text(json.dumps(gate_report), encoding="utf-8")
+
+    if size_run:
+        household = pd.DataFrame(
+            {
+                "household_id": [1, 11, 21, 2, 12, 22],
+                "household_weight": [1.0, 2.0, 3.0, 1.0, 2.0, 3.0],
+                "clone_index": [0, 1, 2, 0, 1, 2],
+            }
+        )
+    else:
+        household = pd.DataFrame(
+            {
+                "household_id": [1, 11, 2],
+                "household_weight": [5.0, 5.0, 5.0],
+                "clone_index": [0, 1, 0],
+            }
+        )
+    h5_path = run / "microcosm_uk_2025_local.h5"
+    with pd.HDFStore(h5_path, mode="w") as store:
+        store.put("household", household, format="table")
+
+    dense_path = run / "dense_reference_diagnostics.csv"
+    selection_path = run / "dataset_size_selection.csv"
+    if size_run:
+        dense_local = diagnostics.copy()
+        dense_local.insert(
+            0,
+            "grain",
+            np.where(
+                dense_local["target_name"].str.startswith("external:"),
+                "ladder",
+                dense_local["area_type"],
+            ),
+        )
+        dense_national = pd.DataFrame(
+            [
+                {
+                    "grain": "national",
+                    "name": f"{name}@2025",
+                    "family": family,
+                    "target": target,
+                    "initial_estimate": target * 0.5,
+                    "final_estimate": target * (1 + error / 2),
+                    "relative_error": error / 2,
+                    "abs_relative_error": abs(error / 2),
+                }
+                for name, family, target, error in national
+            ]
+        )
+        pd.concat([dense_local, dense_national], ignore_index=True, sort=False).to_csv(
+            dense_path, index=False
+        )
+        pd.DataFrame(
+            {
+                "pool_row_index": range(6),
+                "household_id": household["household_id"],
+                "clone_index": household["clone_index"],
+                "design_weight": [1.0] * 6,
+                "inclusion_probability": [0.5] * 6,
+                "certainty": [True, False, False, True, False, False],
+                "ht_baseline_weight": [2.0] * 6,
+                "refit_weight": household["household_weight"],
+            }
+        ).to_csv(selection_path, index=False)
+
+    (run / "run.log").write_text(
+        "    11122.00 real     13204.25 user       179.23 sys\n"
+        "         11103666176  maximum resident set size\n",
+        encoding="utf-8",
+    )
+    registry_path = run / "scoring_registry_compiled.json"
+    registry_path.write_text("{}\n", encoding="utf-8")
+
+    output_paths = [
+        diagnostics_path,
+        calibration_path,
+        support_path,
+        gate_path,
+        h5_path,
+    ]
+    if size_run:
+        output_paths.extend([dense_path, selection_path])
+    outputs = {
+        path.stem: {
+            "path": f"/old/machine/{path.name}",
+            "sha256": _sha256(path),
+            "bytes": path.stat().st_size,
+        }
+        for path in output_paths
+    }
+    dense_summary = {
+        "initial_loss": 0.03,
+        "final_loss": 0.01,
+        "n_nonzero": 6,
+        "n_households": 6,
+        "max_abs_relative_error": 0.20,
+        "median_abs_relative_error": 0.04,
+        "national_max_abs_relative_error": 0.15,
+        "past_cap": {"past_at_final": 0},
+        "weights": {"effective_sample_size": 6.0},
+        "local_by_family": [],
+        "national_by_family": [],
+        "diagnostics_file": dense_path.name,
+    }
+    size_receipt = (
+        {
+            "method": "sampford_pps_fixed_size",
+            "requested_households": 6,
+            "realized_households": 6,
+            "pool_households": 30,
+            "seed": 2025,
+            "protected_carriers": 2,
+            "selection_receipt": {
+                "k": 6,
+                "pi_hi": 1.0,
+                "seed": 2025,
+                "certainty_count": 2,
+                "boundary_pool_size": 4,
+                "design": "sampford",
+            },
+            "selection_l0_lambda": 0.1,
+            "selection_epochs": 10,
+            "refit_epochs": 10,
+            "pool_row_indices": list(range(6)),
+            "inclusion_probabilities": [0.5] * 6,
+            "refit_baseline": "normalized_horvitz_thompson",
+            "stretch_reference": "normalized_horvitz_thompson_w_over_q",
+            "dense_loss": 0.01,
+            "compact_loss": 0.02,
+            "max_target_scaled_change": 0.6,
+            "certification": None,
+            "dense_reference": dense_summary,
+        }
+        if size_run
+        else None
+    )
+    manifest = {
+        "git_commit": "fixture-commit",
+        "identity": {"spine": {}, "ledger": {}, "runtime": {}},
+        "parameters": {
+            "n_clones": 15,
+            "seed": 2025,
+            "epochs": 10,
+            "engine_blocks": 1,
+            "sample_fraction": 1.0,
+            "dataset_households": 6 if size_run else None,
+            "selection_seed": 2025 if size_run else None,
+        },
+        "solve": {
+            "n_targets": 10,
+            "n_targets_by_kind": {"local": 6, "ladder": 2, "national": 2},
+            "n_households": len(household),
+            "pool_households": 30 if size_run else len(household),
+            "initial_loss": 0.04,
+            "final_loss": 0.02,
+            "max_abs_relative_error": 0.30,
+            "median_abs_relative_error": 0.08,
+            "n_nonzero": len(household),
+            "past_cap": {"past_at_final": 2},
+            "measure_resolution": {
+                "blocks": 1,
+                "engine_version": "fixture",
+                "mode": "fixture",
+            },
+            "dataset_size": size_receipt,
+        },
+        "weights": {
+            "declared_stretch_bound": 100.0,
+            "realized_max_weight_ratio_vs_design": 3.0 if size_run else 1.0,
+            **(
+                {"stretch_reference": "normalized_horvitz_thompson_w_over_q"}
+                if size_run
+                else {}
+            ),
+            "calibration_mass_change": {"old_total": 12.0, "new_total": 12.0},
+        },
+        "fit": {
+            "local_by_family": [],
+            "national_by_family": [],
+            "rotated_holdout": calibration["uk_diagnostics"]["rotated_holdout"],
+        },
+        "releasable": False if size_run else True,
+        **(
+            {"release_posture": {"size_certification_present": False}}
+            if size_run
+            else {}
+        ),
+        "outputs": outputs,
+    }
+    (run / "rowwise_candidate_manifest.json").write_text(
+        json.dumps(manifest), encoding="utf-8"
+    )
+    return run
+
+
+def test_load_run_shapes_and_grains(tmp_path: Path) -> None:
+    size_path = _write_run_dir(tmp_path, "candidate", size_run=True)
+    dense_path = _write_run_dir(tmp_path, "dense", size_run=False)
+
+    size = load_run(size_path, label="candidate")
+    dense = load_run(dense_path, label="dense")
+
+    assert len(size.targets) == 10
+    assert size.targets["grain"].value_counts().to_dict() == {
+        "constituency": 4,
+        "local_authority": 2,
+        "ladder": 2,
+        "national": 2,
+    }
+    assert len(size.local_diagnostics) == 8
+    assert size.dense_reference_diagnostics is not None
+    assert size.selection is not None
+    assert dense.dense_reference_diagnostics is None
+    assert dense.selection is None
+
+
+def test_paired_targets_counts_red_mapping_and_changed_target(tmp_path: Path) -> None:
+    run = load_run(
+        _write_run_dir(tmp_path, "candidate", size_run=True), label="candidate"
+    )
+    reference = load_run(
+        _write_run_dir(
+            tmp_path,
+            "reference",
+            size_run=False,
+            red_rows=("council_tax/E1/council_tax/band_c",),
+        ),
+        label="reference",
+    )
+
+    result = paired_targets(run, reference)
+
+    assert result["n_common"] == 10
+    assert result["n_only_run"] == result["n_only_reference"] == 0
+    assert result["n_target_value_changed"] == 1
+    assert (result["wins"], result["ties"], result["losses"]) == (4, 3, 3)
+    assert result["reference_red_rows"]["n"] == 1
+    assert result["reference_red_rows"]["rows"][0]["name"] == (
+        "local/council-tax/E1@2025"
+    )
+    assert result["reference_red_rows"]["still_red"] == 1
+    assert any(row["name"] == "national/b@2025" for row in result["new_red_rows"])
+
+
+def test_weight_tables_size_and_dense_spine_paths(tmp_path: Path) -> None:
+    size = load_run(
+        _write_run_dir(tmp_path, "candidate", size_run=True), label="candidate"
+    )
+    result = weight_tables(size)
+
+    values = np.array([1.0, 2.0, 3.0, 1.0, 2.0, 3.0])
+    assert result["summary"]["effective_sample_size"] == pytest.approx(
+        effective_sample_size(values)
+    )
+    assert result["distinct_source_households"] == 2
+    assert result["source_id_multiplier_basis"] == "inferred_from_clone_zero_ids"
+    assert result["stretch"]["vs_pool_design"]["max"] == pytest.approx(3.0)
+    assert result["clones_per_source"]["by_clone_count"] == {"3": 2}
+    skipped = load_run(size.path, label="candidate", skip_h5=True)
+    assert weight_tables(skipped)["summary"]["effective_sample_size"] == pytest.approx(
+        effective_sample_size(values)
+    )
+
+    dense = load_run(_write_run_dir(tmp_path, "dense", size_run=False), label="dense")
+    spine = pd.DataFrame(
+        {"household_id": [1, 2, 3], "household_weight": [75.0, 75.0, 75.0]}
+    )
+    dense_result = weight_tables(dense, spine_weights=spine)
+    assert dense_result["stretch"]["reference"] == "pool_design"
+    assert dense_result["stretch"]["vs_pool_design"]["max"] == pytest.approx(1.0)
+    dense.manifest["weights"]["realized_max_weight_ratio_vs_design"] = 2.0
+    with pytest.raises(ValueError, match="does not match"):
+        weight_tables(dense, spine_weights=spine)
+
+
+def test_area_support_and_gate_tables(tmp_path: Path) -> None:
+    run = load_run(
+        _write_run_dir(tmp_path, "candidate", size_run=True), label="candidate"
+    )
+    areas = area_support_tables(run)
+
+    assert areas["by_geography_level"]["constituency"]["breaches"] == {
+        "rows_lt_50": 1,
+        "ess_lt_50": 1,
+        "sources_lt_50": 1,
+        "any": 2,
+        "codes": ["E1", "E2"],
+    }
+    assert "constituency/E1" in areas["reviewed_exclusions"]
+    gates = gate_table(run)
+    assert gates[0]["criticality"] == "release_blocking"
+    del run.gates["gates"]["uk_local_weight_ess"]
+    assert gate_table(run)[-1]["status"] == "absent"
+
+
+def test_run_acceptance_statuses_and_bad_digest(tmp_path: Path) -> None:
+    path = _write_run_dir(tmp_path, "candidate", size_run=True)
+    run = load_run(path, label="candidate")
+    result = run_acceptance(
+        run, expected_households=6, expected_pool=30, expected_epochs=10
+    )
+    assert result["passed"]
+    assert {row["status"] for row in result["checks"]} <= {
+        "pass",
+        "not_applicable",
+    }
+
+    (path / "solve_diagnostics.csv").write_text("wrong\n", encoding="utf-8")
+    bad = run_acceptance(run)
+    assert not bad["passed"]
+    digest = next(row for row in bad["checks"] if row["id"] == "output_sha256")
+    assert digest["status"] == "fail"
+
+    dense_path = _write_run_dir(tmp_path, "dense", size_run=False)
+    dense = load_run(dense_path, label="dense")
+    dense_result = run_acceptance(dense)
+    assert (
+        next(
+            row for row in dense_result["checks"] if row["id"] == "dataset_households"
+        )["status"]
+        == "not_applicable"
+    )
+
+
+def test_footprint_parsing_and_null_fallback(tmp_path: Path) -> None:
+    path = _write_run_dir(tmp_path, "candidate", size_run=True)
+    run = load_run(path, label="candidate")
+    assert footprint(run) == {
+        "wall_seconds": 11122.0,
+        "peak_rss_bytes": 11103666176,
+        "h5_bytes": (path / "microcosm_uk_2025_local.h5").stat().st_size,
+    }
+
+    (path / "run.log").unlink()
+    no_runtime = load_run(path, label="candidate", skip_h5=True)
+    assert footprint(no_runtime)["wall_seconds"] is None
+    assert footprint(no_runtime)["peak_rss_bytes"] is None
+
+
+def test_dense_deltas_and_frozen_surface(tmp_path: Path) -> None:
+    run = load_run(
+        _write_run_dir(tmp_path, "candidate", size_run=True), label="candidate"
+    )
+    dense = dense_reference_deltas(run)
+    assert dense is not None
+    assert dense["n_common"] == 10
+    assert dense["dense_loss"] == pytest.approx(0.01)
+    assert dense["compact_loss"] == pytest.approx(0.02)
+
+    surface_path = tmp_path / "surface.json"
+    surface_path.write_text(
+        json.dumps(
+            {
+                "national_rows": [
+                    {"our_name": "national/a@2025", "candidate_estimate": 107.1},
+                    {"our_name": "national/b@2025", "candidate_estimate": 131.3},
+                ]
+            }
+        ),
+        encoding="utf-8",
+    )
+    surface = frozen_vs_recomputed(run, surface_path)
+    assert surface["n_rows"] == surface["n_matched"] == 2
+    assert surface["max_abs_rel_divergence"] == pytest.approx(0.02)
+    assert [row["name"] for row in surface["rows_over_1pct"]] == ["national/a@2025"]
+
+
+def test_summarize_outcome_flags(tmp_path: Path) -> None:
+    run = load_run(
+        _write_run_dir(tmp_path, "candidate", size_run=True), label="candidate"
+    )
+    result = summarize(
+        run,
+        references={},
+        dense_deltas=dense_reference_deltas(run),
+        surface=None,
+    )
+    outcomes = {row["id"]: row for row in result["pre_registered_outcomes"]}
+    assert outcomes["dense_reference_loss"]["flag"] == "ok"
+    assert outcomes["max_target_scaled_change"]["flag"] == "red"
+    assert outcomes["frozen_vs_recomputed_max"]["flag"] == "not_measured"
+
+
+@pytest.mark.parametrize(
+    "missing",
+    [
+        "rowwise_candidate_manifest.json",
+        "solve_diagnostics.csv",
+        "calibration_diagnostics.json",
+        "area_support_summary.csv",
+        "microcosm_uk_2025_local.local_gates.json",
+    ],
+)
+def test_load_run_refuses_missing_required_file(tmp_path: Path, missing: str) -> None:
+    path = _write_run_dir(tmp_path, "candidate", size_run=True)
+    (path / missing).unlink()
+    expected = (
+        r"\*\.local_gates\.json"
+        if missing.endswith(".local_gates.json")
+        else re.escape(missing)
+    )
+    with pytest.raises(ValueError, match=expected):
+        load_run(path, label="candidate")
diff --git a/packages/microcosm-build/tests/test_uk_uc_family.py b/packages/microcosm-build/tests/test_uk_uc_family.py
index ff2d9d5ae..88bda9de3 100644
--- a/packages/microcosm-build/tests/test_uk_uc_family.py
+++ b/packages/microcosm-build/tests/test_uk_uc_family.py
@@ -492,8 +492,8 @@ def test_full_uc_payment_registry_matches_independent_relationship_and_band_case
     full_registry = TargetRegistry(specs, country="uk")
     active = [spec for spec in specs if spec.name not in excluded]
     assert len(specs) == 100
-    assert len(active) == 84
-    assert len({s.name for s in specs} & excluded) == 16
+    assert len(active) == 82
+    assert len({s.name for s in specs} & excluded) == 18
     registry = TargetRegistry(active, country="uk")
     result = materialize_uk_ledger_targets(
         adapter, registry, period=2025, band_edge_registry=full_registry
@@ -503,7 +503,7 @@ def test_full_uc_payment_registry_matches_independent_relationship_and_band_case
         adapter.to_frame(), registry.to_target_set(), weight_entity="household"
     )
     assert not problem.skipped
-    assert len(problem.names) == 84
+    assert len(problem.names) == 82
     assert not {f"{name}@2025" for name in excluded}.intersection(problem.names)
     expected_family = np.asarray(expected_families)[bu.benunit_id.to_numpy()]
     uc = bu.universal_credit.to_numpy()
diff --git a/packages/microcosm-build/tests/test_us_multispine_pool_tool.py b/packages/microcosm-build/tests/test_us_multispine_pool_tool.py
index 91811e9e8..019e495d4 100644
--- a/packages/microcosm-build/tests/test_us_multispine_pool_tool.py
+++ b/packages/microcosm-build/tests/test_us_multispine_pool_tool.py
@@ -2504,7 +2504,7 @@ def capture_equality(expected: object, actual: object) -> None:
             "country": "us",
             "schema_id": "country_spec",
             "schema_version": 1,
-            "spec_sha256": "8b1546bc97b540afd525fe88f36a315de18b4d57bd9fab73035dacd8962e302e",
+            "spec_sha256": "35a02b6b19c921faba1407d441e0b9d9623c496e2cd5b711be014def281a95c6",
         },
     }
 
diff --git a/packages/microcosm-calibrate/src/microcosm/calibrate/__init__.py b/packages/microcosm-calibrate/src/microcosm/calibrate/__init__.py
index 5aa9db083..b08bc8741 100644
--- a/packages/microcosm-calibrate/src/microcosm/calibrate/__init__.py
+++ b/packages/microcosm-calibrate/src/microcosm/calibrate/__init__.py
@@ -93,6 +93,7 @@ def _assert_frame_compatible(version: str, required: tuple[int, int]) -> None:
 )
 from microcosm.calibrate.exact_k import (  # noqa: E402 - after the compat gate
     assert_exact_k_support,
+    exact_k_design_feasibility,
     select_exact_k,
 )
 from microcosm.calibrate.matrix import (  # noqa: E402 - after the compat gate
@@ -121,6 +122,7 @@ def _assert_frame_compatible(version: str, required: tuple[int, int]) -> None:
     calibrate_l0_refit,
     default_target_loss_scales,
     effective_sample_size,
+    rebuild_calibration_result,
     refit_l0_selection,
     relative_error_loss,
 )
@@ -153,8 +155,10 @@ def _assert_frame_compatible(version: str, required: tuple[int, int]) -> None:
     "calibrate",
     "calibrate_l0_refit",
     "assert_exact_k_support",
+    "exact_k_design_feasibility",
     "default_target_loss_scales",
     "effective_sample_size",
+    "rebuild_calibration_result",
     "refit_l0_selection",
     "diagnostics_payload",
     "past_cap_census",
diff --git a/packages/microcosm-calibrate/src/microcosm/calibrate/exact_k.py b/packages/microcosm-calibrate/src/microcosm/calibrate/exact_k.py
index 82a745b11..781998af1 100644
--- a/packages/microcosm-calibrate/src/microcosm/calibrate/exact_k.py
+++ b/packages/microcosm-calibrate/src/microcosm/calibrate/exact_k.py
@@ -49,7 +49,7 @@
 
 import numpy as np
 
-__all__ = ["assert_exact_k_support", "select_exact_k"]
+__all__ = ["assert_exact_k_support", "exact_k_design_feasibility", "select_exact_k"]
 
 SelectionReceipt = dict[str, int | float | str]
 _INDEX_DTYPE = np.dtype("<i8")
@@ -421,27 +421,10 @@ def _draw_boundary(
     )
 
 
-def select_exact_k(
-    pi: Sequence[float] | np.ndarray,
-    k: int,
-    pi_hi: float,
-    seed: int,
-    *,
-    group_ids: np.ndarray | None = None,
-) -> tuple[np.ndarray, SelectionReceipt, np.ndarray]:
-    """Select exactly ``k`` records from hard-concrete open probabilities.
-
-    The result is deterministic for identical ``(pi, k, pi_hi, seed,
-    group_ids)`` inputs and uses a fresh NumPy ``Generator(PCG64(seed))``; global
-    random state is never read or changed. Returned indices are sorted. The
-    third return value contains their aligned first-order inclusion
-    probabilities after the boundary's ulp correction; declared certainty
-    units and deterministic take-all units have probability one. The receipt
-    remains a separate six-scalar mapping suitable for a release manifest.
-
-    See the module docstring for the Sampford design, boundary normalization,
-    and the deliberately minimal ``group_ids`` contract.
-    """
+def _coerce_design(
+    pi: Sequence[float] | np.ndarray, k: int, pi_hi: float
+) -> tuple[np.ndarray, int, float]:
+    """Validate ``(pi, k, pi_hi)`` exactly as :func:`select_exact_k` does."""
     try:
         supplied_probabilities = np.asarray(pi)
     except (TypeError, ValueError):
@@ -476,6 +459,94 @@ def select_exact_k(
         ) from None
     if not np.isfinite(certainty_threshold) or not (0.0 <= certainty_threshold <= 1.0):
         raise ValueError(f"pi_hi must be a finite value in [0, 1], got {pi_hi!r}.")
+    return probabilities, target, certainty_threshold
+
+
+FEASIBLE = "feasible"
+CERTAINTIES_EXCEED_K = "certainties_exceed_k"
+BOUNDARY_SHORT_OF_DRAW = "boundary_short_of_draw"
+BOUNDARY_MASS_SHORT = "boundary_mass_short"
+
+
+def exact_k_design_feasibility(
+    pi: Sequence[float] | np.ndarray, k: int, pi_hi: float
+) -> dict[str, int | float | bool | str]:
+    """Report whether :func:`select_exact_k` would accept ``(pi, k, pi_hi)``.
+
+    The same validation and the same boundary arithmetic as the draw, without
+    drawing. Units with ``pi_i >= pi_hi`` are certainties; the remaining
+    ``m = k - certainties`` places must be covered by positive boundary units
+    whose proportional normalization ``m * pi_i / sum(pi_boundary)`` never
+    exceeds one beyond the ulp tolerance the draw itself allows. ``reason``
+    is ``"feasible"``, ``"certainties_exceed_k"`` (the draw would refuse to
+    drop declared certainties), ``"boundary_short_of_draw"`` (fewer positive
+    boundary units than places) or ``"boundary_mass_short"`` (the largest
+    boundary unit would need an inclusion probability above one, the
+    "degenerate boundary mass" refusal). The verdict is the draw's own
+    inequality, so a budget search that stops on it hands the draw a design
+    that is feasible by construction rather than by the side of the budget
+    band the search happened to land on.
+    """
+    probabilities, target, certainty_threshold = _coerce_design(pi, k, pi_hi)
+    certainty_mask = probabilities >= certainty_threshold
+    certainty_count = int(np.count_nonzero(certainty_mask))
+    boundary = probabilities[~certainty_mask]
+    boundary_draw = target - certainty_count
+    positive = boundary[boundary > 0.0]
+    boundary_mass = float(np.sum(positive, dtype=np.float64)) if positive.size else 0.0
+    boundary_max = float(positive.max()) if positive.size else 0.0
+    max_normalized = 0.0
+    if boundary_draw < 0:
+        feasible, reason = False, CERTAINTIES_EXCEED_K
+    elif boundary_draw == 0 or boundary_draw == len(boundary):
+        feasible, reason = True, FEASIBLE
+    elif positive.size < boundary_draw or boundary_mass <= 0.0:
+        feasible, reason = False, BOUNDARY_SHORT_OF_DRAW
+    else:
+        max_normalized = boundary_max * (boundary_draw / boundary_mass)
+        if max_normalized > 1.0 + _PROBABILITY_ONE_TOLERANCE:
+            feasible, reason = False, BOUNDARY_MASS_SHORT
+        else:
+            feasible, reason = True, FEASIBLE
+    return {
+        "k": target,
+        "pi_hi": certainty_threshold,
+        "pool_size": int(len(probabilities)),
+        "certainty_count": certainty_count,
+        "boundary_draw": int(boundary_draw),
+        "boundary_pool_size": int(len(boundary)),
+        "boundary_positive": int(positive.size),
+        "boundary_mass": boundary_mass,
+        "boundary_max": boundary_max,
+        "max_normalized_probability": float(max_normalized),
+        "feasible": bool(feasible),
+        "reason": reason,
+    }
+
+
+def select_exact_k(
+    pi: Sequence[float] | np.ndarray,
+    k: int,
+    pi_hi: float,
+    seed: int,
+    *,
+    group_ids: np.ndarray | None = None,
+) -> tuple[np.ndarray, SelectionReceipt, np.ndarray]:
+    """Select exactly ``k`` records from hard-concrete open probabilities.
+
+    The result is deterministic for identical ``(pi, k, pi_hi, seed,
+    group_ids)`` inputs and uses a fresh NumPy ``Generator(PCG64(seed))``; global
+    random state is never read or changed. Returned indices are sorted. The
+    third return value contains their aligned first-order inclusion
+    probabilities after the boundary's ulp correction; declared certainty
+    units and deterministic take-all units have probability one. The receipt
+    remains a separate six-scalar mapping suitable for a release manifest.
+
+    See the module docstring for the Sampford design, boundary normalization,
+    and the deliberately minimal ``group_ids`` contract.
+    """
+    probabilities, target, certainty_threshold = _coerce_design(pi, k, pi_hi)
+    pool_size = len(probabilities)
     random_seed = _integer(seed, name="seed")
     _validate_group_ids(group_ids, probabilities.shape)
 
diff --git a/packages/microcosm-calibrate/src/microcosm/calibrate/gates.py b/packages/microcosm-calibrate/src/microcosm/calibrate/gates.py
index 306d42615..5874d3803 100644
--- a/packages/microcosm-calibrate/src/microcosm/calibrate/gates.py
+++ b/packages/microcosm-calibrate/src/microcosm/calibrate/gates.py
@@ -19,6 +19,7 @@
 
 import math
 
+import numpy as np
 import torch
 from torch import nn
 
@@ -66,6 +67,10 @@ class HardConcrete(nn.Module):
             penalty close them). Must lie in ``(0, 1)``.
         temperature: Concrete-distribution temperature; lower is closer to a
             hard Bernoulli.
+        initial_probabilities: Optional per-record actual open probabilities
+            in (0, 1); overrides the historical scalar initialization.
+        protected_mask: Optional boolean vector. These records have gates
+            fixed at one during training and evaluation.
 
     Raises:
         ValueError: If ``init_mean`` is not strictly between 0 and 1, or
@@ -78,6 +83,8 @@ def __init__(
         *,
         init_mean: float = 0.999,
         temperature: float = 0.25,
+        initial_probabilities: np.ndarray | None = None,
+        protected_mask: np.ndarray | None = None,
     ) -> None:
         super().__init__()
         if not (0.0 < init_mean < 1.0):
@@ -88,6 +95,22 @@ def __init__(
             raise ValueError(
                 f"HardConcrete.temperature must be positive, got {temperature!r}."
             )
+        if initial_probabilities is not None:
+            probabilities = np.asarray(initial_probabilities, dtype=np.float64)
+            if (
+                probabilities.shape != (n,)
+                or not np.isfinite(probabilities).all()
+                or ((probabilities <= 0) | (probabilities >= 1)).any()
+            ):
+                raise ValueError(
+                    "initial_probabilities must align with gates and lie in (0, 1)."
+                )
+        if protected_mask is None:
+            protected_mask = np.zeros(n, dtype=bool)
+        protected_mask = np.asarray(protected_mask)
+        if protected_mask.shape != (n,) or protected_mask.dtype != np.bool_:
+            raise ValueError("protected_mask must be an aligned boolean vector.")
+        self.register_buffer("protected_mask", torch.tensor(protected_mask))
         self.temperature = float(temperature)
         self.gamma = _GAMMA
         self.zeta = _ZETA
@@ -95,6 +118,12 @@ def __init__(
         init_val = math.log(init_mean / (1.0 - init_mean))
         with torch.no_grad():
             self.qz_logits.fill_(init_val)
+            if initial_probabilities is not None:
+                # The new vector is an actual open probability, unlike the
+                # historical scalar init_mean's sigmoid-logit convention.
+                shift = self.temperature * math.log(-self.gamma / self.zeta)
+                logits = np.log(probabilities / (1 - probabilities)) + shift
+                self.qz_logits.copy_(torch.tensor(logits, dtype=self.qz_logits.dtype))
 
     def forward(self) -> torch.Tensor:
         """Return the current gates: sampled in training, deterministic in eval."""
@@ -105,7 +134,7 @@ def forward(self) -> torch.Tensor:
         else:
             s = torch.sigmoid(self.qz_logits)
         stretched = s * (self.zeta - self.gamma) + self.gamma
-        return torch.clamp(stretched, 0.0, 1.0)
+        return torch.where(self.protected_mask, 1.0, torch.clamp(stretched, 0.0, 1.0))
 
     def get_penalty(self) -> torch.Tensor:
         """Expected number of open gates — the differentiable L0 surrogate.
@@ -116,9 +145,13 @@ def get_penalty(self) -> torch.Tensor:
             ``l0_lambda`` and adds to the loss.
         """
         shift = self.temperature * math.log(-self.gamma / self.zeta)
-        return torch.sigmoid(self.qz_logits - shift).sum()
+        return torch.where(
+            self.protected_mask, 1.0, torch.sigmoid(self.qz_logits - shift)
+        ).sum()
 
     def get_active_prob(self) -> torch.Tensor:
         """Per-gate open-probability (the per-record version of the penalty)."""
         shift = self.temperature * math.log(-self.gamma / self.zeta)
-        return torch.sigmoid(self.qz_logits - shift)
+        return torch.where(
+            self.protected_mask, 1.0, torch.sigmoid(self.qz_logits - shift)
+        )
diff --git a/packages/microcosm-calibrate/src/microcosm/calibrate/initialization.py b/packages/microcosm-calibrate/src/microcosm/calibrate/initialization.py
new file mode 100644
index 000000000..f8d15d2ab
--- /dev/null
+++ b/packages/microcosm-calibrate/src/microcosm/calibrate/initialization.py
@@ -0,0 +1,64 @@
+"""Contribution-informed L0 initialization (microcosm#346, #355)."""
+
+from dataclasses import dataclass
+
+import numpy as np
+from scipy import sparse
+
+
+@dataclass(frozen=True)
+class GateInitialization:
+    """Aligned open probabilities and records excluded from gate pruning."""
+
+    probabilities: np.ndarray
+    protected: np.ndarray
+
+
+def contribution_initialization(
+    matrix: sparse.sparray,
+    weights: np.ndarray,
+    targets: np.ndarray,
+) -> GateInitialization:
+    """Initialize search from maximum absolute target-contribution share.
+
+    Protect the largest absolute weighted carrier of each nonzero target
+    (first column breaks ties deterministically). The smooth bounded prior
+    uses the median positive share as its scale. It only initializes L0;
+    neither these scores nor their ranks select the final support. Zero
+    targets use a unit denominator, matching the default calibration scale.
+    Work and storage are sparse in the target matrix, never targets x pool.
+    """
+    matrix = sparse.csr_array(matrix, dtype=np.float64, copy=True)
+    matrix.sum_duplicates()
+    matrix.eliminate_zeros()
+    weights = np.asarray(weights, dtype=np.float64)
+    targets = np.asarray(targets, dtype=np.float64)
+    if weights.shape != (matrix.shape[1],) or targets.shape != (matrix.shape[0],):
+        raise ValueError("matrix, weights and targets must align.")
+    if (
+        not np.isfinite(matrix.data).all()
+        or not np.isfinite(weights).all()
+        or not np.isfinite(targets).all()
+        or (weights <= 0).any()
+    ):
+        raise ValueError(
+            "contribution initialization requires finite inputs and positive weights."
+        )
+    scores = np.zeros(len(weights))
+    protected = np.zeros(len(weights), dtype=bool)
+    for row, target in enumerate(targets):
+        start, stop = matrix.indptr[row : row + 2]
+        indices = matrix.indices[start:stop]
+        contributions = np.abs(matrix.data[start:stop]) * weights[indices]
+        if not len(indices):
+            if target != 0:
+                raise ValueError(f"nonzero target at row {row} has no support.")
+            continue
+        shares = contributions / (abs(target) if target != 0 else 1.0)
+        np.maximum.at(scores, indices, shares)
+        if target != 0:
+            protected[indices[np.argmax(contributions)]] = True
+    positive = scores[scores > 0]
+    scale = float(np.median(positive)) if len(positive) else 1.0
+    probabilities = 0.1 + 0.8 * scores / (scores + scale)
+    return GateInitialization(probabilities, protected)
diff --git a/packages/microcosm-calibrate/src/microcosm/calibrate/solve.py b/packages/microcosm-calibrate/src/microcosm/calibrate/solve.py
index c37ed85c9..4bda636c1 100644
--- a/packages/microcosm-calibrate/src/microcosm/calibrate/solve.py
+++ b/packages/microcosm-calibrate/src/microcosm/calibrate/solve.py
@@ -75,8 +75,16 @@
 import numpy as np
 import torch
 
-from microcosm.calibrate.exact_k import assert_exact_k_support
+from microcosm.calibrate.exact_k import (
+    BOUNDARY_MASS_SHORT,
+    BOUNDARY_SHORT_OF_DRAW,
+    CERTAINTIES_EXCEED_K,
+    FEASIBLE,
+    assert_exact_k_support,
+    exact_k_design_feasibility,
+)
 from microcosm.calibrate.gates import HardConcrete
+from microcosm.calibrate.initialization import GateInitialization
 from microcosm.calibrate.matrix import (
     CalibrationProblem,
     SkippedTarget,
@@ -88,6 +96,7 @@
 __all__ = [
     "calibrate",
     "calibrate_l0_refit",
+    "rebuild_calibration_result",
     "refit_l0_selection",
     "default_target_loss_scales",
     "effective_sample_size",
@@ -122,6 +131,12 @@
 #: the search's cost at ``budget_iters`` optimizations; ~10 bisection steps cut
 #: the ``log10`` bracket by 2^10, far finer than the count is resolvable.
 _DEFAULT_BUDGET_ITERS = 10
+#: What the ``target_records`` budget search measures against the budget.
+BUDGET_BASIS_NONZERO_COUNT = "nonzero_count"
+BUDGET_BASIS_OPEN_PROBABILITY_MASS = "open_probability_mass"
+BUDGET_BASES = frozenset(
+    {BUDGET_BASIS_NONZERO_COUNT, BUDGET_BASIS_OPEN_PROBABILITY_MASS}
+)
 
 # Per-target contribution cap for weighted MAPE. A target can contribute at most
 # a 1000% scaled miss to the objective.
@@ -757,6 +772,7 @@ def _optimize(
     target_loss_cap: float,
     initial_weights: np.ndarray,
     *,
+    gate_initialization: GateInitialization | None = None,
     warm_start_weights: np.ndarray | None = None,
     epochs: int,
     learning_rate: float,
@@ -810,7 +826,19 @@ def _optimize(
     gates: HardConcrete | None = None
     params: list[torch.Tensor] = [log_w]
     if l0_lambda > 0.0 or target_records is not None:
-        gates = HardConcrete(len(w0), init_mean=init_mean, temperature=temperature)
+        gates = HardConcrete(
+            len(w0),
+            init_mean=init_mean,
+            temperature=temperature,
+            **(
+                {}
+                if gate_initialization is None
+                else {
+                    "initial_probabilities": gate_initialization.probabilities,
+                    "protected_mask": gate_initialization.protected,
+                }
+            ),
+        )
         params = [log_w, *gates.parameters()]
 
     optimizer = torch.optim.Adam(params, lr=learning_rate)
@@ -1098,6 +1126,7 @@ def _search_l0_lambda_for_budget(
     target_loss_cap: float,
     initial_weights: np.ndarray,
     *,
+    gate_initialization: GateInitialization | None = None,
     target_records: int,
     epochs: int,
     learning_rate: float,
@@ -1114,11 +1143,23 @@ def _search_l0_lambda_for_budget(
     progress_callback: Callable[[dict[str, object]], None] | None = None,
     budget_iters: int = _DEFAULT_BUDGET_ITERS,
     return_gate_open_probabilities: bool = False,
+    budget_basis: str = BUDGET_BASIS_NONZERO_COUNT,
+    feasible_draw_pi_hi: float | None = None,
+    search_receipt: dict[str, object] | None = None,
 ) -> (
     tuple[np.ndarray, np.ndarray, float, int]
     | tuple[np.ndarray, np.ndarray, float, int, np.ndarray]
 ):
-    """Search ``l0_lambda`` so the achieved non-zero count tracks the budget.
+    """Search ``l0_lambda`` so the achieved budget measure tracks the budget.
+
+    ``budget_basis`` names what the search measures against
+    ``target_records``: the historical non-zero *count* of surviving weights
+    (``BUDGET_BASIS_NONZERO_COUNT``), or the gates' expected open count, the
+    sum of their open probabilities (``BUDGET_BASIS_OPEN_PROBABILITY_MASS``).
+    An exact-count draw on the learned probabilities can only draw from that
+    mass, so a selection that targets a count with the mass basis is feasible
+    by construction; the count basis can leave partly polarised gates counted
+    as survivors while carrying a fraction of a record each.
 
     The realized non-zero count is monotone *decreasing* in ``l0_lambda`` (a
     stronger penalty closes more gates), so a bisection on ``log10(l0_lambda)``
@@ -1135,6 +1176,25 @@ def _search_l0_lambda_for_budget(
     honest contract. Stops early once the achieved count is within ``tol`` of the
     budget, where ``tol = max(1, round(0.05 * target_records))``.
 
+    ``feasible_draw_pi_hi`` (mass basis only) adds the exact-count draw's own
+    inequality to the stopping rule: a probe counts as acceptable only when
+    :func:`~microcosm.calibrate.exact_k.exact_k_design_feasibility` says a
+    draw of ``target_records`` at that certainty threshold is feasible on its
+    gate probabilities. The band is two-sided but the draw's condition is
+    one-sided (roughly "open mass at least the budget"), so without it a
+    search can stop inside the band on the wrong side and the draw refuses
+    (microcosm#355, 2026-09-08: 54,834 open mass for 55,000 requested). An
+    infeasible probe steers the bisection like a count miss would: short
+    boundary mass toward a smaller penalty, too many certainties toward a
+    larger one. Feasible probes are preferred over infeasible ones when the
+    best run is chosen; if no probe is feasible within the iteration budget the
+    closest run is still returned and the draw refuses with its measurement.
+    ``search_receipt``, when supplied, is filled in place with every probe's
+    penalty, measure and verdict and the reason the search stopped. Beside the
+    per-epoch ``calibration_epoch`` events, ``progress_callback`` receives one
+    ``budget_probe`` event per finished probe (the same fields as the receipt's
+    probe entry) and a closing ``budget_search_done`` event.
+
     Args:
         matrix: The constraint matrix ``A`` (dense or sparse-CSR torch tensor), as
             :func:`_optimize` consumes it.
@@ -1159,6 +1219,28 @@ def _search_l0_lambda_for_budget(
         existing workspace callers.
     """
     lo_u, hi_u = math.log10(_L0_SEARCH_LO), math.log10(_L0_SEARCH_HI)
+    if budget_basis not in BUDGET_BASES:
+        raise ValueError(
+            f"budget_basis must be one of {sorted(BUDGET_BASES)}, got {budget_basis!r}."
+        )
+    if budget_basis == BUDGET_BASIS_OPEN_PROBABILITY_MASS:
+        return_gate_open_probabilities = True
+    if feasible_draw_pi_hi is not None:
+        if budget_basis != BUDGET_BASIS_OPEN_PROBABILITY_MASS:
+            raise ValueError(
+                "feasible_draw_pi_hi requires the open-probability-mass budget basis."
+            )
+        if (
+            isinstance(feasible_draw_pi_hi, bool)
+            or not isinstance(feasible_draw_pi_hi, int | float)
+            or not math.isfinite(feasible_draw_pi_hi)
+            or not (0.0 < float(feasible_draw_pi_hi) <= 1.0)
+        ):
+            raise ValueError(
+                "feasible_draw_pi_hi must be a finite value in (0, 1], got "
+                f"{feasible_draw_pi_hi!r}."
+            )
+        feasible_draw_pi_hi = float(feasible_draw_pi_hi)
     tol = max(1, round(0.05 * target_records))
 
     evaluation = 0
@@ -1189,6 +1271,8 @@ def evaluate(
                 "l0_lambda": lam,
             },
         }
+        if gate_initialization is not None:
+            optimize_kwargs["gate_initialization"] = gate_initialization
         if return_gate_open_probabilities:
             weights, trajectory, gate_open_probabilities = _optimize(
                 matrix,
@@ -1217,27 +1301,87 @@ def evaluate(
                 **optimize_kwargs,
             )
             gate_open_probabilities = None
-        n_nonzero = int((weights > prune_atol).sum())
+        if budget_basis == BUDGET_BASIS_OPEN_PROBABILITY_MASS:
+            if gate_open_probabilities is None:  # pragma: no cover - guarded above
+                raise RuntimeError("mass-basis budget search needs gate probabilities.")
+            n_nonzero = int(round(float(np.sum(gate_open_probabilities))))
+        else:
+            n_nonzero = int((weights > prune_atol).sum())
         return weights, trajectory, n_nonzero, gate_open_probabilities
 
     best: tuple[np.ndarray, np.ndarray, float, int, np.ndarray | None] | None = None
+    # (0 for a feasible/unconstrained probe, 1 for an infeasible one; distance
+    # to the budget): feasible probes always beat infeasible ones.
+    best_key: tuple[int, int] | None = None
+    probes: list[dict[str, object]] = []
     # Sentinel: a probe whose penalty over-pruned past the cap-feasible floor
     # (the conserve+cap projection raised). It is *more* pruning than feasible,
     # so it steers the search the same way "too few survivors" does — toward a
     # smaller penalty — without crashing the whole search or polluting ``best``.
     _over_pruned = -1
+    _not_required = "not_required"
+    _steer_smaller = "smaller_penalty"
+    _steer_larger = "larger_penalty"
+    _steer_stop = "stop"
 
-    def consider(lam: float) -> int:
-        nonlocal best
+    def consider(lam: float) -> tuple[int, str]:
+        nonlocal best, best_key
         try:
             weights, trajectory, n_nonzero, gate_open_probabilities = evaluate(lam)
         except ValueError as exc:
             if "Infeasible combination" in str(exc):
-                return _over_pruned
+                probes.append(
+                    {"l0_lambda": lam, "measure": None, "verdict": "over_pruned"}
+                )
+                if progress_callback is not None:
+                    progress_callback(
+                        {
+                            "kind": "budget_probe",
+                            "budget_iteration": evaluation,
+                            "budget_iters": budget_iters,
+                            "target_records": target_records,
+                            "budget_basis": budget_basis,
+                            **probes[-1],
+                        }
+                    )
+                return _over_pruned, "over_pruned"
             raise
-        if best is None or abs(n_nonzero - target_records) < abs(
-            best[3] - target_records
-        ):
+        probe: dict[str, object] = {"l0_lambda": lam, "measure": int(n_nonzero)}
+        verdict = _not_required
+        if feasible_draw_pi_hi is not None:
+            if gate_open_probabilities is None:  # pragma: no cover - guarded above
+                raise RuntimeError("feasibility-aware search needs gate probabilities.")
+            design = exact_k_design_feasibility(
+                gate_open_probabilities, target_records, feasible_draw_pi_hi
+            )
+            verdict = str(design["reason"])
+            probe.update(
+                certainty_count=int(design["certainty_count"]),
+                boundary_draw=int(design["boundary_draw"]),
+                boundary_mass=float(design["boundary_mass"]),
+                boundary_max=float(design["boundary_max"]),
+                feasible=bool(design["feasible"]),
+            )
+        probe["verdict"] = verdict
+        probes.append(probe)
+        if progress_callback is not None:
+            # One event per finished probe, beside the per-epoch stream, so a
+            # long search is readable from a log: penalty, measure, verdict.
+            progress_callback(
+                {
+                    "kind": "budget_probe",
+                    "budget_iteration": evaluation,
+                    "budget_iters": budget_iters,
+                    "target_records": target_records,
+                    "budget_basis": budget_basis,
+                    **probe,
+                }
+            )
+        key = (
+            0 if verdict in (_not_required, FEASIBLE) else 1,
+            abs(n_nonzero - target_records),
+        )
+        if best_key is None or key < best_key:
             best = (
                 weights,
                 trajectory,
@@ -1245,7 +1389,32 @@ def consider(lam: float) -> int:
                 n_nonzero,
                 gate_open_probabilities,
             )
-        return n_nonzero
+            best_key = key
+        return n_nonzero, verdict
+
+    def steer(n_nonzero: int, verdict: str) -> str:
+        # An infeasible draw steers like a count miss: short boundary mass needs
+        # more open mass (smaller penalty); surplus certainties need less.
+        if n_nonzero == _over_pruned or verdict in (
+            BOUNDARY_MASS_SHORT,
+            BOUNDARY_SHORT_OF_DRAW,
+        ):
+            return _steer_smaller
+        if verdict == CERTAINTIES_EXCEED_K:
+            return _steer_larger
+        if n_nonzero < target_records:
+            return _steer_smaller
+        if n_nonzero > target_records:
+            return _steer_larger
+        return _steer_stop
+
+    def settled() -> bool:
+        return (
+            best is not None
+            and best_key is not None
+            and best_key[0] == 0
+            and abs(best[3] - target_records) <= tol
+        )
 
     # Warm start: evaluate the user's lambda (or the bracket mid-point) first.
     if initial_lambda is not None and initial_lambda > 0:
@@ -1253,28 +1422,71 @@ def consider(lam: float) -> int:
     else:
         first_u = (lo_u + hi_u) / 2.0
     iters_left = budget_iters
-    n_nonzero = consider(10.0**first_u)
+    n_nonzero, verdict = consider(10.0**first_u)
     iters_left -= 1
     # Seed the bracket so the side the warm start landed on is tightened. An
     # over-pruned (infeasible) probe groups with "too few survivors".
-    if n_nonzero > target_records:
+    if steer(n_nonzero, verdict) == _steer_larger:
         lo_u = first_u  # too many survivors -> need a larger penalty
     else:
         hi_u = first_u  # too few survivors / over-pruned -> need a smaller penalty
 
-    # Keep searching while no feasible run is known yet, or the best is outside
-    # tolerance, until the iteration budget is spent.
-    while iters_left > 0 and (best is None or abs(best[3] - target_records) > tol):
+    # Keep searching while no acceptable run is known yet, or the best is
+    # outside tolerance, until the iteration budget is spent.
+    while iters_left > 0 and not settled():
         mid_u = (lo_u + hi_u) / 2.0
-        n_nonzero = consider(10.0**mid_u)
+        n_nonzero, verdict = consider(10.0**mid_u)
         iters_left -= 1
-        if n_nonzero == _over_pruned or n_nonzero < target_records:
-            hi_u = mid_u  # over-pruned / too few survivors -> smaller penalty
-        elif n_nonzero > target_records:
-            lo_u = mid_u  # too many survivors -> larger penalty
+        direction = steer(n_nonzero, verdict)
+        if direction == _steer_smaller:
+            hi_u = mid_u  # over-pruned / too few / short mass -> smaller penalty
+        elif direction == _steer_larger:
+            lo_u = mid_u  # too many survivors or certainties -> larger penalty
         else:
             break
 
+    if progress_callback is not None:
+        progress_callback(
+            {
+                "kind": "budget_search_done",
+                "evaluations": int(evaluation),
+                "budget_iters": int(budget_iters),
+                "target_records": int(target_records),
+                "stopped_on": (
+                    "acceptable_within_tolerance" if settled() else "budget_exhausted"
+                ),
+                "selected_l0_lambda": None if best is None else float(best[2]),
+                "selected_measure": None if best is None else int(best[3]),
+                "selected_feasible": (
+                    None
+                    if best_key is None or feasible_draw_pi_hi is None
+                    else best_key[0] == 0
+                ),
+            }
+        )
+    if search_receipt is not None:
+        search_receipt.update(
+            {
+                "budget_basis": budget_basis,
+                "target_records": int(target_records),
+                "tolerance": int(tol),
+                "budget_iters": int(budget_iters),
+                "feasible_draw_pi_hi": feasible_draw_pi_hi,
+                "evaluations": int(evaluation),
+                "probes": probes,
+                "selected_l0_lambda": None if best is None else float(best[2]),
+                "selected_measure": None if best is None else int(best[3]),
+                "selected_feasible": (
+                    None
+                    if best_key is None or feasible_draw_pi_hi is None
+                    else best_key[0] == 0
+                ),
+                "stopped_on": (
+                    "acceptable_within_tolerance" if settled() else "budget_exhausted"
+                ),
+            }
+        )
+
     if best is None:
         # Every penalty tried over-pruned past the cap-feasible floor: the budget
         # cannot be met under this conservation + cap. Name the three causes.
@@ -1377,6 +1589,7 @@ def calibrate(
     frame: Frame,
     targets: TargetSet,
     *,
+    gate_initialization: GateInitialization | None = None,
     weight_entity: str = "household",
     method: str = "adam",
     epochs: int = 256,
@@ -1393,6 +1606,8 @@ def calibrate(
     init_mean: float = 0.999,
     temperature: float = 0.25,
     budget_iters: int = _DEFAULT_BUDGET_ITERS,
+    budget_basis: str = BUDGET_BASIS_NONZERO_COUNT,
+    feasible_draw_pi_hi: float | None = None,
     seed: int = 0,
     target_loss_weights: np.ndarray | None = None,
     target_loss_scales: np.ndarray | None = None,
@@ -1444,7 +1659,12 @@ def calibrate(
             :attr:`CalibrationResult.l0_lambda`. A supplied ``l0_lambda`` is the
             search's warm start. The achieved count tracks the budget within a
             tolerance (the count is a noisy discrete function of the penalty), not
-            exactly.
+            exactly. ``budget_basis`` names the measure the search tracks (the
+            surviving non-zero count, or the gates' open-probability mass);
+            ``feasible_draw_pi_hi`` (mass basis only) makes the search stop only
+            on a probe whose gate probabilities admit an exact-count draw of
+            ``target_records`` at that certainty threshold, recording every probe
+            under ``options["budget_search"]``.
         l0_lambda: L0 penalty strength. Used directly when ``target_records`` is
             ``None``: ``> 0`` enables hard-concrete gates that prune the pool,
             ``0.0`` (default) keeps every record. When ``target_records`` is set,
@@ -1478,6 +1698,9 @@ def calibrate(
             cannot express, e.g. the pre-selection *design* weights during a
             post-L0 refit. When supplied, ``l2_anchor`` becomes a free-form
             provenance label recorded in options (e.g. ``"design"``).
+        gate_initialization: Optional informed L0 prior and protected-record
+            mask, aligned to the weight entity. Requires an Adam L0 solve;
+            protected gates remain open throughout training and selection.
         init_mean: Initial expected open-probability of the L0 gates (only used
             when pruning).
         temperature: Hard-concrete temperature (only used when pruning).
@@ -1565,6 +1788,9 @@ def calibrate(
             "total cannot be conserved (sum of caps < input total). Use "
             "max_weight_ratio >= 1, or mass='free'."
         )
+    if gate_initialization is not None:
+        if method != "adam" or (target_records is None and l0_lambda <= 0):
+            raise ValueError("gate_initialization requires an Adam L0 solve.")
     if target_records is not None and (
         not isinstance(target_records, int) or target_records <= 0
     ):
@@ -1618,6 +1844,29 @@ def calibrate(
         )
     if budget_iters <= 0:
         raise ValueError(f"budget_iters must be positive, got {budget_iters!r}.")
+    if budget_basis not in BUDGET_BASES:
+        raise ValueError(
+            f"budget_basis must be one of {sorted(BUDGET_BASES)}, got {budget_basis!r}."
+        )
+    if budget_basis != BUDGET_BASIS_NONZERO_COUNT and target_records is None:
+        raise ValueError("budget_basis applies to a target_records budget search.")
+    if feasible_draw_pi_hi is not None:
+        if target_records is None or budget_basis != BUDGET_BASIS_OPEN_PROBABILITY_MASS:
+            raise ValueError(
+                "feasible_draw_pi_hi requires a target_records budget search on the "
+                "open-probability-mass basis."
+            )
+        if (
+            isinstance(feasible_draw_pi_hi, bool)
+            or not isinstance(feasible_draw_pi_hi, int | float)
+            or not math.isfinite(feasible_draw_pi_hi)
+            or not (0.0 < float(feasible_draw_pi_hi) <= 1.0)
+        ):
+            raise ValueError(
+                "feasible_draw_pi_hi must be a finite value in (0, 1], got "
+                f"{feasible_draw_pi_hi!r}."
+            )
+        feasible_draw_pi_hi = float(feasible_draw_pi_hi)
     target_loss_cap = _validate_target_loss_cap(target_loss_cap)
 
     target_loss_weights_input = _validate_target_loss_weights(
@@ -1687,6 +1936,7 @@ def calibrate(
     target_loss_scales_t = torch.tensor(target_loss_scales_np, dtype=torch.float32)
 
     iterate_selection_receipt: dict[str, object] = {}
+    budget_search: dict[str, object] | None = None
     if method == "prox":
         # L1 path: proximal gradient (ISTA) on raw weights. The soft-threshold
         # drives unneeded records to exact zero, so L1 selects a sparse weighted
@@ -1726,6 +1976,7 @@ def calibrate(
         # Budget control (Finding 3): search l0_lambda so the achieved non-zero
         # count tracks target_records. The supplied l0_lambda (if any) is the
         # warm start; the search reports the penalty it settled on.
+        budget_search = {}
         (
             final_weights,
             trajectory,
@@ -1754,7 +2005,15 @@ def calibrate(
             initial_lambda=(l0_lambda if l0_lambda > 0.0 else None),
             progress_callback=progress_callback,
             budget_iters=budget_iters,
+            budget_basis=budget_basis,
+            feasible_draw_pi_hi=feasible_draw_pi_hi,
+            search_receipt=budget_search,
             return_gate_open_probabilities=True,
+            **(
+                {}
+                if gate_initialization is None
+                else {"gate_initialization": gate_initialization}
+            ),
         )
     else:
         effective_l0 = l0_lambda
@@ -1780,6 +2039,11 @@ def calibrate(
             progress_callback=progress_callback,
             return_gate_open_probabilities=True,
             selection_receipt=iterate_selection_receipt,
+            **(
+                {}
+                if gate_initialization is None
+                else {"gate_initialization": gate_initialization}
+            ),
         )
         n_nonzero = int((final_weights > prune_atol).sum())
         if effective_l0 > 0.0 and n_nonzero == 0:
@@ -1840,6 +2104,10 @@ def calibrate(
         target_loss_scales=target_loss_scales_np.copy(),
         target_loss_cap=target_loss_cap,
         options={
+            "gate_initialization_supplied": gate_initialization is not None,
+            "budget_basis": budget_basis,
+            "feasible_draw_pi_hi": feasible_draw_pi_hi,
+            "budget_search": budget_search,
             "method": method,
             "epochs": epochs,
             "learning_rate": learning_rate,
@@ -1888,6 +2156,117 @@ def calibrate(
     )
 
 
+def rebuild_calibration_result(
+    frame: Frame,
+    targets: TargetSet,
+    *,
+    weight_entity: str = "household",
+    weights: np.ndarray,
+    loss_trajectory: np.ndarray,
+    l0_lambda: float,
+    n_nonzero: int,
+    target_loss_weights: np.ndarray,
+    target_loss_scales: np.ndarray,
+    target_loss_cap: float,
+    options: Mapping[str, object],
+    gate_open_probabilities: np.ndarray | None = None,
+    closing_loss: float | None = None,
+) -> CalibrationResult:
+    """Re-assemble a :class:`CalibrationResult` from a solve's persisted outputs.
+
+    Compiles ``targets`` against ``frame`` exactly as :func:`calibrate` does,
+    places ``weights`` on the frame under the recorded mass policy
+    (``options["mass"]`` / ``options["mass_reason"]``), and rebuilds the
+    per-target diagnostics and the closing loss from the compiled system.
+    Nothing is optimised: this is the checkpoint/resume seam for builds whose
+    solve is expensive and whose later stages (an exact-count draw, a refit)
+    need only the solve's outputs. ``closing_loss``, when supplied, must agree
+    with the recomputed loss to a relative 1e-9; a mismatch means the frame,
+    the targets or the weights are not the ones the outputs were cut from.
+    """
+    problem = build_constraint_matrix(frame, targets, weight_entity)
+    if problem.skipped:
+        names = ", ".join(skipped.target.name for skipped in problem.skipped[:5])
+        raise ValueError(
+            f"cannot rebuild a result with {len(problem.skipped)} uncompilable "
+            f"target(s): {names}."
+        )
+    initial = problem.initial_weights
+    w0 = np.asarray(initial.values, dtype=np.float64)
+    final_weights = np.asarray(weights, dtype=np.float64)
+    if final_weights.shape != w0.shape:
+        raise ValueError(
+            f"weights shape {final_weights.shape} must match the {w0.shape} "
+            f"{weight_entity!r} weight vector."
+        )
+    if not np.isfinite(final_weights).all() or (final_weights < 0.0).any():
+        raise ValueError("weights must be finite and non-negative.")
+    trajectory = np.asarray(loss_trajectory, dtype=np.float64)
+    if trajectory.ndim != 1 or trajectory.size == 0:
+        raise ValueError("loss_trajectory must be a non-empty vector.")
+    loss_weights = _validate_target_loss_weights(
+        np.asarray(target_loss_weights, dtype=np.float64), problem.target_vector.shape
+    )
+    loss_scales = _validate_target_loss_scales(
+        np.asarray(target_loss_scales, dtype=np.float64),
+        problem.target_vector.shape,
+        targets=problem.target_vector,
+    )
+    loss_cap = _validate_target_loss_cap(target_loss_cap)
+    if gate_open_probabilities is not None:
+        gate_open_probabilities = np.asarray(gate_open_probabilities, dtype=np.float64)
+        if gate_open_probabilities.shape != w0.shape:
+            raise ValueError("gate_open_probabilities must align with the weights.")
+    mass = str(options.get("mass", FREE_MASS))
+    if mass not in (CONSERVE_MASS, FREE_MASS):
+        raise ValueError(f"options['mass'] must be conserve or free, got {mass!r}.")
+    mass_reason = options.get("mass_reason")
+    calibrated = initial.with_values(final_weights, kind=WeightKind.CALIBRATED)
+    new_frame = _apply_weights(
+        frame,
+        weight_entity,
+        initial,
+        calibrated,
+        mass,
+        targets,
+        mass_reason=None if mass_reason is None else str(mass_reason),
+    )
+    diagnostics = _build_diagnostics(problem, frame, w0, final_weights)
+    recomputed = relative_error_loss(
+        problem.estimates(final_weights),
+        problem.target_vector,
+        target_loss_weights=loss_weights,
+        target_loss_scales=loss_scales,
+        target_loss_cap=loss_cap,
+    )
+    if closing_loss is not None and not math.isclose(
+        float(closing_loss), float(recomputed), rel_tol=1e-9, abs_tol=1e-12
+    ):
+        raise ValueError(
+            f"closing loss {closing_loss!r} disagrees with the loss recomputed on "
+            f"the compiled system ({recomputed!r}); the frame, targets or weights "
+            "are not the ones these outputs were cut from."
+        )
+    return CalibrationResult(
+        frame=new_frame,
+        weight_entity=weight_entity,
+        weights=final_weights,
+        initial_weights=w0.copy(),
+        diagnostics=diagnostics,
+        loss_trajectory=trajectory,
+        skipped=problem.skipped,
+        problem=problem,
+        l0_lambda=float(l0_lambda),
+        n_nonzero=int(n_nonzero),
+        closing_loss=float(recomputed),
+        target_loss_weights=loss_weights,
+        target_loss_scales=loss_scales,
+        target_loss_cap=loss_cap,
+        options=dict(options),
+        gate_open_probabilities=gate_open_probabilities,
+    )
+
+
 def _apply_weights(
     frame: Frame,
     weight_entity: str,
@@ -2012,6 +2391,7 @@ def refit_l0_selection(
     epochs: int = 256,
     learning_rate: float = 0.02,
     mass: str = FREE_MASS,
+    mass_reason: str | None = None,
     max_weight_ratio: float | None = None,
     l2_lambda: float = 0.0,
     l2_anchor: str = "initial",
@@ -2035,6 +2415,8 @@ def refit_l0_selection(
     gates and L0 penalty are removed and :func:`calibrate` runs again with
     ``l0_lambda=0`` on only the selected records.
 
+    ``mass_reason`` carries a caller's calibration provenance into the refit.
+
     The explicit exact-k path subsets the original ``frame`` rather than
     ``selection.frame``. A record may have positive open probability while its
     deterministic L0 gate is closed; starting from the original frame keeps
@@ -2184,6 +2566,7 @@ def refit_l0_selection(
         epochs=epochs,
         learning_rate=learning_rate,
         mass=mass,
+        mass_reason=mass_reason,
         max_weight_ratio=max_weight_ratio,
         target_records=None,
         l0_lambda=0.0,
diff --git a/packages/microcosm-calibrate/tests/fixtures/pre_best_iterate/controls.json b/packages/microcosm-calibrate/tests/fixtures/pre_best_iterate/controls.json
index d3e83fdb2..7a4c3bbb6 100644
--- a/packages/microcosm-calibrate/tests/fixtures/pre_best_iterate/controls.json
+++ b/packages/microcosm-calibrate/tests/fixtures/pre_best_iterate/controls.json
@@ -117,7 +117,7 @@
   },
   "same_runtime_oracle": {
     "module": "optimizer_1f7d676f.py",
-    "module_sha256": "712d31887697047791b4973502e3c52332bb027244688cc8772f118384c4b34e",
+    "module_sha256": "d09944322f3185736b21db61a666351fb3a77edde6690c9d7782263ac0d36939",
     "function": "_optimize",
     "function_source_sha256": "7c6bba4f2d6ad00a137d031b8cc40e3b97f4678026a9c3900b8c281123cee234",
     "source_commit": "1f7d676f2449894bfd794973eaa507aa79bfbfdb",
@@ -131,8 +131,10 @@
       "_validate_target_loss_cap": "7d7a663cc1de3f3667ea713329387a7913063335a47bc693299fd5c2479f8553"
     },
     "gates_source_path": "packages/microcosm-calibrate/src/microcosm/calibrate/gates.py",
-    "gates_module_sha256": "379e4adbb3ed7cdd13f7c7c548da45163f2a50330c874ee51095d38243d392e6",
     "prune_rel_atol": 1e-06,
-    "note": "Compare this frozen function and the current solver in the same runtime with separate seed resets. Recorded Mac bytes remain an additional check only on the authoring runtime and dependency versions."
+    "note": "Compare this frozen function and the current solver in the same runtime with separate seed resets. Recorded Mac bytes remain an additional check only on the authoring runtime and dependency versions.",
+    "frozen_gates_module": "gates_14608a5e.py",
+    "frozen_gates_sha256": "14608a5ee02132f06eaad4a59de3b051c8b8e1d07bd1768f4eb57f237173cef7",
+    "frozen_gates_source_sha256": "14608a5ee02132f06eaad4a59de3b051c8b8e1d07bd1768f4eb57f237173cef7"
   }
 }
diff --git a/packages/microcosm-calibrate/tests/fixtures/pre_best_iterate/gates_14608a5e.py b/packages/microcosm-calibrate/tests/fixtures/pre_best_iterate/gates_14608a5e.py
new file mode 100644
index 000000000..5874d3803
--- /dev/null
+++ b/packages/microcosm-calibrate/tests/fixtures/pre_best_iterate/gates_14608a5e.py
@@ -0,0 +1,157 @@
+"""Hard-concrete L0 gates: the generate-big-then-prune mechanism.
+
+A :class:`HardConcrete` module carries one stochastic gate per record, each a
+relaxed Bernoulli (the hard-concrete distribution of Louizos et al., 2018) whose
+expected L0 "norm" — the expected number of open gates — is differentiable. The
+solver multiplies the record weights by these gates and adds
+``l0_lambda * penalty`` to the loss; raising ``l0_lambda`` drives gates shut,
+pruning the pool toward fewer non-zero weights. This is the core calibration
+path: generate big, then prune to ``target_records``.
+
+The math is the reference one verbatim: a sigmoid-of-logistic-noise stretched to
+``[gamma, zeta]`` and clamped to ``[0, 1]`` in training (so gates can hit hard 0
+/ 1), the sigmoid of the logits stretched the same way in eval, and the L0
+penalty ``sum(sigmoid(logits - temperature*log(-gamma/zeta)))`` — the closed-form
+probability a gate is open.
+"""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+import torch
+from torch import nn
+
+__all__ = ["HardConcrete", "hard_concrete_open_probability_threshold"]
+
+#: Stretch bounds for the hard-concrete distribution (Louizos et al., 2018).
+#: ``gamma < 0 < 1 < zeta`` lets the stretched-then-clamped variable reach exact
+#: 0 and 1, which is what makes the gate able to prune hard.
+_GAMMA = -0.1
+_ZETA = 1.1
+
+
+def hard_concrete_open_probability_threshold(temperature: float) -> float:
+    """Return the open-probability cutoff for a positive deterministic gate.
+
+    The evaluation-time hard-concrete gate is positive exactly when its logit
+    exceeds ``log(-gamma / zeta)``. Expressed on the per-record open
+    probability returned by :meth:`HardConcrete.get_active_prob`, that same
+    boundary is
+
+    ``sigmoid((1 - temperature) * log(-gamma / zeta))``.
+
+    This helper describes the gate threshold itself. A calibration result's
+    legacy support additionally applies its weight-scale pruning tolerance, so
+    callers should not assume equivalence for arbitrarily tiny latent weights.
+    """
+    if not math.isfinite(temperature) or temperature <= 0.0:
+        raise ValueError(
+            f"temperature must be positive and finite, got {temperature!r}."
+        )
+    value = (1.0 - float(temperature)) * math.log(-_GAMMA / _ZETA)
+    if value >= 0.0:
+        return 1.0 / (1.0 + math.exp(-value))
+    exp_value = math.exp(value)
+    return exp_value / (1.0 + exp_value)
+
+
+class HardConcrete(nn.Module):
+    """One hard-concrete L0 gate per record, with a differentiable L0 penalty.
+
+    Args:
+        n: Number of gates (one per record of the calibrated entity).
+        init_mean: Initial expected open-probability of every gate (e.g.
+            ``0.999`` to start with essentially all records active and let the
+            penalty close them). Must lie in ``(0, 1)``.
+        temperature: Concrete-distribution temperature; lower is closer to a
+            hard Bernoulli.
+        initial_probabilities: Optional per-record actual open probabilities
+            in (0, 1); overrides the historical scalar initialization.
+        protected_mask: Optional boolean vector. These records have gates
+            fixed at one during training and evaluation.
+
+    Raises:
+        ValueError: If ``init_mean`` is not strictly between 0 and 1, or
+            ``temperature`` is not positive.
+    """
+
+    def __init__(
+        self,
+        n: int,
+        *,
+        init_mean: float = 0.999,
+        temperature: float = 0.25,
+        initial_probabilities: np.ndarray | None = None,
+        protected_mask: np.ndarray | None = None,
+    ) -> None:
+        super().__init__()
+        if not (0.0 < init_mean < 1.0):
+            raise ValueError(
+                f"HardConcrete.init_mean must lie in (0, 1), got {init_mean!r}."
+            )
+        if temperature <= 0:
+            raise ValueError(
+                f"HardConcrete.temperature must be positive, got {temperature!r}."
+            )
+        if initial_probabilities is not None:
+            probabilities = np.asarray(initial_probabilities, dtype=np.float64)
+            if (
+                probabilities.shape != (n,)
+                or not np.isfinite(probabilities).all()
+                or ((probabilities <= 0) | (probabilities >= 1)).any()
+            ):
+                raise ValueError(
+                    "initial_probabilities must align with gates and lie in (0, 1)."
+                )
+        if protected_mask is None:
+            protected_mask = np.zeros(n, dtype=bool)
+        protected_mask = np.asarray(protected_mask)
+        if protected_mask.shape != (n,) or protected_mask.dtype != np.bool_:
+            raise ValueError("protected_mask must be an aligned boolean vector.")
+        self.register_buffer("protected_mask", torch.tensor(protected_mask))
+        self.temperature = float(temperature)
+        self.gamma = _GAMMA
+        self.zeta = _ZETA
+        self.qz_logits = nn.Parameter(torch.zeros(n))
+        init_val = math.log(init_mean / (1.0 - init_mean))
+        with torch.no_grad():
+            self.qz_logits.fill_(init_val)
+            if initial_probabilities is not None:
+                # The new vector is an actual open probability, unlike the
+                # historical scalar init_mean's sigmoid-logit convention.
+                shift = self.temperature * math.log(-self.gamma / self.zeta)
+                logits = np.log(probabilities / (1 - probabilities)) + shift
+                self.qz_logits.copy_(torch.tensor(logits, dtype=self.qz_logits.dtype))
+
+    def forward(self) -> torch.Tensor:
+        """Return the current gates: sampled in training, deterministic in eval."""
+        if self.training:
+            u = torch.zeros_like(self.qz_logits).uniform_(1e-8, 1.0 - 1e-8)
+            s = torch.log(u) - torch.log(1.0 - u) + self.qz_logits
+            s = torch.sigmoid(s / self.temperature)
+        else:
+            s = torch.sigmoid(self.qz_logits)
+        stretched = s * (self.zeta - self.gamma) + self.gamma
+        return torch.where(self.protected_mask, 1.0, torch.clamp(stretched, 0.0, 1.0))
+
+    def get_penalty(self) -> torch.Tensor:
+        """Expected number of open gates — the differentiable L0 surrogate.
+
+        Returns:
+            ``sum(sigmoid(logits - temperature*log(-gamma/zeta)))``: the
+            closed-form expected count of open gates, which the solver scales by
+            ``l0_lambda`` and adds to the loss.
+        """
+        shift = self.temperature * math.log(-self.gamma / self.zeta)
+        return torch.where(
+            self.protected_mask, 1.0, torch.sigmoid(self.qz_logits - shift)
+        ).sum()
+
+    def get_active_prob(self) -> torch.Tensor:
+        """Per-gate open-probability (the per-record version of the penalty)."""
+        shift = self.temperature * math.log(-self.gamma / self.zeta)
+        return torch.where(
+            self.protected_mask, 1.0, torch.sigmoid(self.qz_logits - shift)
+        )
diff --git a/packages/microcosm-calibrate/tests/fixtures/pre_best_iterate/optimizer_1f7d676f.py b/packages/microcosm-calibrate/tests/fixtures/pre_best_iterate/optimizer_1f7d676f.py
index 382647af7..2137b9b9f 100644
--- a/packages/microcosm-calibrate/tests/fixtures/pre_best_iterate/optimizer_1f7d676f.py
+++ b/packages/microcosm-calibrate/tests/fixtures/pre_best_iterate/optimizer_1f7d676f.py
@@ -12,7 +12,11 @@
 import numpy as np
 import torch
 
-from microcosm.calibrate.gates import HardConcrete
+# Frozen control: the gate module this oracle runs with is the sibling copy the
+# test loads under this name, never the live microcosm.calibrate.gates, so a
+# gate-behaviour change shows as a numeric mismatch rather than being absorbed.
+from pre_best_iterate_gates import HardConcrete
+
 from microcosm.calibrate.solve import (
     _PRUNE_REL_ATOL,
     _apply_constraint,
diff --git a/packages/microcosm-calibrate/tests/test_exact_k.py b/packages/microcosm-calibrate/tests/test_exact_k.py
index 4bf6535c0..d1db4b19a 100644
--- a/packages/microcosm-calibrate/tests/test_exact_k.py
+++ b/packages/microcosm-calibrate/tests/test_exact_k.py
@@ -601,3 +601,80 @@ def test_named_cardinality_gate_fails_closed() -> None:
 
     normalized = assert_exact_k_support([3, 1], 2, pool_size=4)
     np.testing.assert_array_equal(normalized, [1, 3])
+
+
+def test_design_feasibility_agrees_with_the_draw() -> None:
+    import numpy as np
+
+    from microcosm.calibrate import exact_k_design_feasibility, select_exact_k
+
+    rng = np.random.default_rng(355)
+    verdicts: set[str] = set()
+    for trial in range(120):
+        n = int(rng.integers(8, 40))
+        # Polarised vectors like an informed L0 at many epochs: a shoulder near
+        # one, a thin tail with exact zeros, a few exact ones.
+        tail = rng.uniform(0.0, 0.05, n)
+        tail[rng.random(n) < 0.4] = 0.0
+        pi = np.where(rng.random(n) < 0.5, rng.uniform(0.9, 1.0, n), tail)
+        pi[: int(rng.integers(0, 3))] = 1.0
+        k = int(rng.integers(1, n + 1))
+        pi_hi = float(rng.choice([1.0, 0.95, 0.7, 0.5]))
+        verdict = exact_k_design_feasibility(pi, k, pi_hi)
+        verdicts.add(str(verdict["reason"]))
+        assert verdict["k"] == k and verdict["pi_hi"] == pi_hi
+        assert verdict["certainty_count"] + verdict["boundary_pool_size"] == n
+        assert verdict["boundary_draw"] == k - verdict["certainty_count"]
+        try:
+            support, receipt, q = select_exact_k(pi, k=k, pi_hi=pi_hi, seed=trial)
+        except ValueError as error:
+            assert verdict["feasible"] is False, (verdict, str(error))
+            if verdict["reason"] == "certainties_exceed_k":
+                assert "certainty units" in str(error)
+            else:
+                assert "degenerate boundary mass" in str(error)
+        else:
+            assert verdict["feasible"] is True, verdict
+            assert len(support) == k
+            assert receipt["certainty_count"] == verdict["certainty_count"]
+    # The generator covered every verdict the draw can return.
+    assert verdicts == {
+        "feasible",
+        "certainties_exceed_k",
+        "boundary_short_of_draw",
+        "boundary_mass_short",
+    }
+
+
+def test_design_feasibility_reports_the_degenerate_mass_inequality() -> None:
+    import numpy as np
+
+    from microcosm.calibrate import exact_k_design_feasibility
+
+    # Two near-certain gates and a tail whose mass cannot cover the draw: at
+    # pi_hi 0.95 the draw needs 3 boundary units from a mass of 0.7 with a
+    # maximum of 0.6 -> 3 * 0.6 / 0.7 > 1.
+    pi = np.array([1.0, 0.99, 0.6, 0.05, 0.05, 0.0])
+    short = exact_k_design_feasibility(pi, 5, 0.95)
+    assert short["feasible"] is False and short["reason"] == "boundary_mass_short"
+    assert short["certainty_count"] == 2 and short["boundary_draw"] == 3
+    assert short["boundary_positive"] == 3
+    assert short["max_normalized_probability"] > 1.0
+    # Lowering the threshold promotes the 0.6 gate: 2 draws from mass 0.1,
+    # both tail units taken deterministically.
+    promoted = exact_k_design_feasibility(pi, 5, 0.5)
+    assert promoted["feasible"] is True and promoted["reason"] == "feasible"
+    # More certainties than k refuses; a boundary with fewer positive units
+    # than places refuses by that name.
+    assert exact_k_design_feasibility(pi, 1, 0.95)["reason"] == "certainties_exceed_k"
+    assert (
+        exact_k_design_feasibility(pi, 6, 0.95)["reason"] == "feasible"
+    )  # k == pool: the whole boundary is taken, zeros included
+    assert (
+        exact_k_design_feasibility(np.array([1.0, 0.0, 0.0]), 2, 1.0)["reason"]
+        == "boundary_short_of_draw"
+    )
+    with pytest.raises(ValueError, match="exceeds the pool size"):
+        exact_k_design_feasibility(pi, 7, 0.95)
+    with pytest.raises(ValueError, match="pi_hi"):
+        exact_k_design_feasibility(pi, 2, 1.5)
diff --git a/packages/microcosm-calibrate/tests/test_informed_gates.py b/packages/microcosm-calibrate/tests/test_informed_gates.py
new file mode 100644
index 000000000..eede278d6
--- /dev/null
+++ b/packages/microcosm-calibrate/tests/test_informed_gates.py
@@ -0,0 +1,289 @@
+"""Informed L0 must preserve rare carriers without replacing the search."""
+
+import numpy as np
+import pytest
+import torch
+from scipy import sparse
+
+from microcosm.calibrate.gates import HardConcrete
+from microcosm.calibrate.initialization import contribution_initialization
+
+
+def test_small_weight_large_measure_is_protected():
+    init = contribution_initialization(
+        sparse.csr_array([[1000.0, 0, 0], [0, 1, 1]]),
+        np.array([0.01, 100.0, 100.0]),
+        np.array([10.0, 200.0]),
+    )
+    assert init.protected[0]
+    assert init.probabilities[0] > init.probabilities[1]
+
+
+def test_protected_gates_stay_open_during_training_and_evaluation():
+    gates = HardConcrete(
+        3,
+        initial_probabilities=np.array([0.2, 0.4, 0.8]),
+        protected_mask=np.array([True, False, False]),
+    )
+    assert np.allclose(gates.get_active_prob().detach().numpy(), [1, 0.4, 0.8])
+    with torch.no_grad():
+        gates.qz_logits.fill_(-100)
+    for training in (True, False):
+        gates.train(training)
+        assert gates()[0].item() == 1
+    assert gates.get_active_prob()[0].item() == 1
+
+
+@pytest.mark.parametrize(
+    "probabilities", [[0, 0.5], [0.5, 1], [float("nan"), 0.5], [0.5]]
+)
+def test_invalid_initial_probabilities_refuse(probabilities):
+    with pytest.raises(ValueError):
+        HardConcrete(2, initial_probabilities=np.array(probabilities))
+
+
+def test_mass_basis_budget_search_tracks_open_probability_mass():
+    import numpy as np
+    import pandas as pd
+
+    from microcosm.calibrate import Target, TargetSet, calibrate
+    from microcosm.calibrate.solve import (
+        BUDGET_BASIS_NONZERO_COUNT,
+        BUDGET_BASIS_OPEN_PROBABILITY_MASS,
+    )
+    from microcosm.frame import EntitySchema, Frame, WeightKind, Weights
+
+    n = 60
+    rng = np.random.default_rng(3)
+    household = pd.DataFrame(
+        {"household_id": np.arange(1, n + 1), "x": rng.uniform(1, 5, n)}
+    )
+    person = pd.DataFrame(
+        {"person_id": np.arange(1, n + 1), "person_household_id": np.arange(1, n + 1)}
+    )
+    frame = Frame(
+        {"person": person, "household": household},
+        EntitySchema(group_entities=("household",)),
+        {"household": Weights(np.ones(n), WeightKind.DESIGN)},
+    )
+    targets = TargetSet(
+        [
+            Target("count", "household", lambda f: np.ones(f.n("household")), 30.0),
+            Target(
+                "x",
+                "household",
+                lambda f: f.table("household")["x"].to_numpy(),
+                30.0 * 3.0,
+            ),
+        ]
+    )
+    common = dict(epochs=200, learning_rate=0.05, seed=1, budget_iters=10)
+    by_mass = calibrate(
+        frame,
+        targets,
+        target_records=20,
+        budget_basis=BUDGET_BASIS_OPEN_PROBABILITY_MASS,
+        **common,
+    )
+    assert by_mass.options["budget_basis"] == BUDGET_BASIS_OPEN_PROBABILITY_MASS
+    assert by_mass.gate_open_probabilities is not None
+    mass = float(np.sum(by_mass.gate_open_probabilities))
+    # The search's own tolerance is 5% of the budget (at least one record).
+    assert abs(mass - 20) <= max(1, round(0.05 * 20)) + 1
+    # The count basis on the same problem lands below the budget in mass.
+    by_count = calibrate(
+        frame,
+        targets,
+        target_records=20,
+        budget_basis=BUDGET_BASIS_NONZERO_COUNT,
+        **common,
+    )
+    assert by_count.options["budget_basis"] == BUDGET_BASIS_NONZERO_COUNT
+    with pytest.raises(ValueError, match="budget_basis"):
+        calibrate(frame, targets, target_records=20, budget_basis="bogus", **common)
+    with pytest.raises(ValueError, match="target_records"):
+        calibrate(
+            frame, targets, budget_basis=BUDGET_BASIS_OPEN_PROBABILITY_MASS, **common
+        )
+
+
+def _stub_polarised_optimizer(thresholds, sharpness):
+    """A stand-in optimizer whose gates open below a per-record log10 penalty."""
+    import numpy as np
+
+    def fake_optimize(matrix, targets, tlw, tls, cap, initial_weights, **kwargs):
+        u = np.log10(float(kwargs["l0_lambda"]))
+        logit = np.clip(sharpness * (thresholds - u), -700.0, 700.0)
+        pi = 1.0 / (1.0 + np.exp(-logit))
+        weights = np.asarray(initial_weights, dtype=np.float64) * pi
+        trajectory = np.zeros(int(kwargs["epochs"]), dtype=np.float64)
+        if kwargs.get("return_gate_open_probabilities"):
+            return weights, trajectory, pi
+        return weights, trajectory
+
+    return fake_optimize
+
+
+def test_feasibility_aware_search_stops_only_on_a_drawable_design(monkeypatch):
+    """The S2 failure (microcosm#355, 2026-09-08) on a synthetic response.
+
+    The first probe lands inside the +/-5% band but *below* the budget with
+    near-binary gates, so an exact-count draw at 0.95 is infeasible. The plain
+    mass basis stops there; the feasibility-aware search keeps bisecting
+    toward a smaller penalty until a probe admits the draw.
+    """
+    import numpy as np
+    import pandas as pd
+
+    from microcosm.calibrate import (
+        Target,
+        TargetSet,
+        calibrate,
+        exact_k_design_feasibility,
+    )
+    from microcosm.calibrate import solve as solve_module
+    from microcosm.calibrate.solve import BUDGET_BASIS_OPEN_PROBABILITY_MASS
+    from microcosm.frame import EntitySchema, Frame, WeightKind, Weights
+
+    n, k = 1000, 500
+    # Open thresholds uniform on [-7.12, 0.88] in log10(lambda): the bracket
+    # mid-point probe (lambda 1e-3) opens ~485 gates, inside the band of 25.
+    thresholds = -7.12 + 8.0 * (np.arange(n) + 0.5) / n
+    monkeypatch.setattr(
+        solve_module, "_optimize", _stub_polarised_optimizer(thresholds, 10.0)
+    )
+    household = pd.DataFrame({"household_id": np.arange(1, n + 1)})
+    person = pd.DataFrame(
+        {"person_id": np.arange(1, n + 1), "person_household_id": np.arange(1, n + 1)}
+    )
+    frame = Frame(
+        {"person": person, "household": household},
+        EntitySchema(group_entities=("household",)),
+        {"household": Weights(np.ones(n), WeightKind.DESIGN)},
+    )
+    targets = TargetSet(
+        [Target("count", "household", lambda f: np.ones(f.n("household")), 500.0)]
+    )
+    common = dict(
+        epochs=3,
+        seed=1,
+        budget_iters=10,
+        target_records=k,
+        budget_basis=BUDGET_BASIS_OPEN_PROBABILITY_MASS,
+    )
+
+    plain = calibrate(frame, targets, **common)
+    plain_search = plain.options["budget_search"]
+    assert plain_search["evaluations"] == 1
+    assert plain_search["feasible_draw_pi_hi"] is None
+    assert plain_search["selected_feasible"] is None
+    assert abs(plain_search["selected_measure"] - k) <= plain_search["tolerance"]
+    assert plain_search["selected_measure"] < k
+    verdict = exact_k_design_feasibility(plain.gate_open_probabilities, k, 0.95)
+    assert verdict["feasible"] is False and verdict["reason"] == "boundary_mass_short"
+
+    events: list[dict] = []
+    aware = calibrate(
+        frame,
+        targets,
+        feasible_draw_pi_hi=0.95,
+        progress_callback=events.append,
+        **common,
+    )
+    search = aware.options["budget_search"]
+    # One budget_probe event per probe, matching the receipt, then the stop.
+    probe_events = [e for e in events if e.get("kind") == "budget_probe"]
+    assert [e["l0_lambda"] for e in probe_events] == [
+        p["l0_lambda"] for p in search["probes"]
+    ]
+    assert [e["verdict"] for e in probe_events] == [
+        p["verdict"] for p in search["probes"]
+    ]
+    assert probe_events[0]["budget_iteration"] == 1
+    assert probe_events[0]["budget_basis"] == BUDGET_BASIS_OPEN_PROBABILITY_MASS
+    done = [e for e in events if e.get("kind") == "budget_search_done"]
+    assert len(done) == 1 and done[0]["stopped_on"] == search["stopped_on"]
+    assert done[0]["selected_l0_lambda"] == search["selected_l0_lambda"]
+    # The stub optimizer emits no epoch events; only the search's own do.
+    assert {e.get("kind") for e in events} == {"budget_probe", "budget_search_done"}
+    assert aware.options["feasible_draw_pi_hi"] == 0.95
+    assert search["stopped_on"] == "acceptable_within_tolerance"
+    assert search["selected_feasible"] is True
+    assert 1 < search["evaluations"] <= 10
+    probes = search["probes"]
+    assert probes[0]["verdict"] == "boundary_mass_short"
+    assert probes[0]["l0_lambda"] == plain_search["selected_l0_lambda"]
+    assert any(p["verdict"] == "certainties_exceed_k" for p in probes)
+    assert probes[-1]["verdict"] == "feasible"
+    assert aware.l0_lambda == probes[-1]["l0_lambda"] < probes[0]["l0_lambda"]
+    assert abs(search["selected_measure"] - k) <= search["tolerance"]
+    final = exact_k_design_feasibility(aware.gate_open_probabilities, k, 0.95)
+    assert final["feasible"] is True
+
+    with pytest.raises(ValueError, match="feasible_draw_pi_hi"):
+        calibrate(frame, targets, epochs=3, target_records=k, feasible_draw_pi_hi=0.95)
+    with pytest.raises(ValueError, match="feasible_draw_pi_hi"):
+        calibrate(frame, targets, feasible_draw_pi_hi=1.5, **common)
+    with pytest.raises(ValueError, match="feasible_draw_pi_hi"):
+        calibrate(frame, targets, epochs=3, feasible_draw_pi_hi=0.95)
+
+
+def test_feasibility_aware_search_returns_the_closest_run_when_nothing_is_drawable(
+    monkeypatch,
+):
+    """No probe is both drawable and within tolerance: the search spends its
+    budget and returns the best run by (drawable first, then distance), so
+    the draw can refuse with a measurement instead of the search hiding it.
+    """
+    import numpy as np
+    import pandas as pd
+
+    from microcosm.calibrate import Target, TargetSet, calibrate
+    from microcosm.calibrate import solve as solve_module
+    from microcosm.calibrate.solve import BUDGET_BASIS_OPEN_PROBABILITY_MASS
+    from microcosm.frame import EntitySchema, Frame, WeightKind, Weights
+
+    n, k = 200, 100
+    # Steps so sharp that every probe the bisection visits opens either 90
+    # gates (drawable: the tail's equal, tiny probabilities scale to the 10
+    # places, but 90 is outside the band of 5) or 110 (more certainties than
+    # k, never drawable).
+    thresholds = np.concatenate(
+        [np.full(90, 0.5), np.full(20, -3.3), np.full(90, -6.5)]
+    )
+    monkeypatch.setattr(
+        solve_module, "_optimize", _stub_polarised_optimizer(thresholds, 400.0)
+    )
+    household = pd.DataFrame({"household_id": np.arange(1, n + 1)})
+    person = pd.DataFrame(
+        {"person_id": np.arange(1, n + 1), "person_household_id": np.arange(1, n + 1)}
+    )
+    frame = Frame(
+        {"person": person, "household": household},
+        EntitySchema(group_entities=("household",)),
+        {"household": Weights(np.ones(n), WeightKind.DESIGN)},
+    )
+    targets = TargetSet(
+        [Target("count", "household", lambda f: np.ones(f.n("household")), 100.0)]
+    )
+    result = calibrate(
+        frame,
+        targets,
+        epochs=3,
+        seed=1,
+        budget_iters=6,
+        target_records=k,
+        budget_basis=BUDGET_BASIS_OPEN_PROBABILITY_MASS,
+        feasible_draw_pi_hi=0.95,
+    )
+    search = result.options["budget_search"]
+    assert search["stopped_on"] == "budget_exhausted"
+    assert search["evaluations"] == 6
+    verdicts = {p["verdict"] for p in search["probes"]}
+    assert verdicts == {"feasible", "certainties_exceed_k"}
+    # A drawable probe outside the band beats an undrawable one at the same
+    # distance; the returned run is that drawable 90-gate probe.
+    assert search["selected_feasible"] is True
+    assert search["selected_measure"] == 90
+    assert abs(search["selected_measure"] - k) > search["tolerance"]
+    assert result.gate_open_probabilities is not None
diff --git a/packages/microcosm-calibrate/tests/test_solve.py b/packages/microcosm-calibrate/tests/test_solve.py
index 6ffa0bad5..7bd40f905 100644
--- a/packages/microcosm-calibrate/tests/test_solve.py
+++ b/packages/microcosm-calibrate/tests/test_solve.py
@@ -14,6 +14,7 @@
 import inspect
 import json
 import platform
+import sys
 import warnings
 from importlib.metadata import version
 from pathlib import Path
@@ -2125,15 +2126,31 @@ def _pre_best_iterate_oracle(fixture: dict):
     for name, expected in provenance["helper_source_sha256"].items():
         source = inspect.getsource(getattr(solve_module, name)).rstrip("\n")
         assert hashlib.sha256(source.encode()).hexdigest() == expected, name
-    # Pin the entire gate module, including the class's stretch constants.
+    # The oracle runs with a frozen copy of the gate module (stretch constants
+    # included), not the live one: a gate-behaviour change in
+    # microcosm.calibrate.gates then surfaces as a numeric mismatch on the
+    # gated path instead of being absorbed on both sides.
+    frozen_gates = (
+        Path(__file__).parent
+        / "fixtures/pre_best_iterate"
+        / (provenance["frozen_gates_module"])
+    )
     assert (
-        hashlib.sha256(Path(gates.__file__).read_bytes()).hexdigest()
-        == (provenance["gates_module_sha256"])
+        hashlib.sha256(frozen_gates.read_bytes()).hexdigest()
+        == provenance["frozen_gates_sha256"]
+    )
+    gates_spec = importlib.util.spec_from_file_location(
+        "pre_best_iterate_gates", frozen_gates
     )
+    frozen_gates_module = importlib.util.module_from_spec(gates_spec)
+    sys.modules["pre_best_iterate_gates"] = frozen_gates_module
+    gates_spec.loader.exec_module(frozen_gates_module)
+    assert frozen_gates_module.HardConcrete is not gates.HardConcrete
     assert solve_module._PRUNE_REL_ATOL == provenance["prune_rel_atol"]
     spec = importlib.util.spec_from_file_location("pre_best_iterate_oracle", path)
     oracle = importlib.util.module_from_spec(spec)
     spec.loader.exec_module(oracle)
+    assert oracle.HardConcrete is frozen_gates_module.HardConcrete
     source = inspect.getsource(oracle._optimize).rstrip("\n")
     assert (
         hashlib.sha256(source.encode()).hexdigest()
diff --git a/packages/microcosm-graph/tests/fixtures/parity/kernels/calibrate/pins.json b/packages/microcosm-graph/tests/fixtures/parity/kernels/calibrate/pins.json
index 4e83617d6..d985a22d8 100644
--- a/packages/microcosm-graph/tests/fixtures/parity/kernels/calibrate/pins.json
+++ b/packages/microcosm-graph/tests/fixtures/parity/kernels/calibrate/pins.json
@@ -1 +1 @@
-{"dependencies":{"numpy":"2.4.6","pandas":"3.0.3","scipy":"1.17.1","torch":"2.12.0"},"implementation_hash":"142dc3bf3eef39d37c36560c614e216d424ba61ae8d8f73915df66459373484b","kernel":"calibrate.adam@1","node":"calibrate","node_key":"31627146bf0703eb425f2a837f6747c3a687b9b9174b14ea4204c5aa473644e1","numeric":"bitwise","platform":"arm64/darwin/py3.13","platforms":{"arm64/darwin/py3.13":{"direct":"direct.csv","node_key":"31627146bf0703eb425f2a837f6747c3a687b9b9174b14ea4204c5aa473644e1"}},"seed":0}
+{"dependencies":{"numpy":"2.4.6","pandas":"3.0.3","scipy":"1.17.1","torch":"2.12.0"},"implementation_hash":"5f92148c5e438baaf7d89fb00cc9c5a690fe1b629bddf89c7afd439064ccfc40","kernel":"calibrate.adam@1","node":"calibrate","node_key":"d7191dc141b702b3a23049bf48ccf370d72cd2822864cb8551453f6dfcd5b055","numeric":"bitwise","platform":"arm64/darwin/py3.14","platforms":{"arm64/darwin/py3.14":{"direct":"direct.csv","node_key":"d7191dc141b702b3a23049bf48ccf370d72cd2822864cb8551453f6dfcd5b055"}},"seed":0}
diff --git a/tools/build_uk_rowwise_candidate.py b/tools/build_uk_rowwise_candidate.py
index 101ca0bb2..a66f2b709 100644
--- a/tools/build_uk_rowwise_candidate.py
+++ b/tools/build_uk_rowwise_candidate.py
@@ -91,6 +91,7 @@
     runtime_provenance,
     solve_uk_rowwise_weights_under_doctrine,
     spine_provenance_from_sidecar,
+    uk_fit_by_family,
     uk_household_weight_kind,
     uk_ladder_area_support_summary,
     uk_ladder_household_uprating,
@@ -99,6 +100,7 @@
     uk_local_target_surface,
     uk_support_limited_misses,
     uk_time_period,
+    uk_weight_summary,
     write_uk_calibration_diagnostics,
     write_uk_rowwise_dataset,
 )
@@ -135,6 +137,11 @@
 AREA_SUPPORT_FILENAME = "area_support_summary.csv"
 PAST_CAP_FILENAME = "past_cap_census.json"
 LOCAL_REGISTRY_FILENAME = "local_target_registry.json"
+DENSE_REFERENCE_DIAGNOSTICS_FILENAME = "dense_reference_diagnostics.csv"
+DATASET_SIZE_SELECTION_FILENAME = "dataset_size_selection.csv"
+
+#: Outputs a run writes only when ``--dataset-households`` is set.
+_SIZE_RUN_ONLY_OUTPUTS = frozenset({"dense_reference", "selection"})
 
 _CONSERVE_MASS = False
 _TARGET_RECORDS: int | None = None
@@ -472,6 +479,83 @@ def _pin_from_artifact(info: Mapping[str, Any]) -> dict[str, object]:
     }
 
 
+def _stderr_progress(line: str) -> None:
+    """Solver progress (epoch losses, budget probes, the search verdict)."""
+    print(line, file=sys.stderr, flush=True)
+
+
+def _refuse_stale_size_checkpoint(args: argparse.Namespace, out_dir: Path) -> None:
+    """Refuse an --out holding a checkpoint before the solve, not after it.
+
+    The checkpoint writer refuses to overwrite, but it runs after the dense
+    solve and the search; a stale checkpoint in --out must fail here, before
+    the hours are spent.
+    """
+    if args.dataset_households is None or args.no_size_checkpoint:
+        return
+    if args.resume_size_checkpoint is not None:
+        return
+    from microcosm.build.uk_runtime.size_checkpoint import (
+        SIZE_CHECKPOINT_ARRAYS_FILENAME,
+        SIZE_CHECKPOINT_MANIFEST_FILENAME,
+    )
+
+    existing = sorted(
+        str(out_dir / name)
+        for name in (SIZE_CHECKPOINT_ARRAYS_FILENAME, SIZE_CHECKPOINT_MANIFEST_FILENAME)
+        if (out_dir / name).exists()
+    )
+    if existing:
+        raise FileExistsError(
+            "refusing to run into an --out that already holds a size checkpoint: "
+            f"{existing}. Resume from it with --resume-size-checkpoint, or choose "
+            "another --out."
+        )
+
+
+def _size_checkpoint_identity(
+    args: argparse.Namespace,
+    *,
+    pins: Mapping[str, Mapping[str, object]],
+    source_year: int,
+) -> dict[str, object]:
+    """Everything a size checkpoint must share with the run that resumes it.
+
+    The pool (spine, ladder, clones, seed, sampling), the target surface
+    (ledger digests, year, rule, engine blocks) and the solve settings the
+    checkpointed dense solve and search were made with. The draw threshold is
+    deliberately absent: re-drawing at another threshold is the point.
+    """
+    return {
+        "dataset_pin": dict(pins["dataset"]),
+        "ladder_pin": dict(pins["ladder"]),
+        "ledger_facts_sha256": args.ledger_facts_sha256,
+        "ledger_manifest_sha256": args.ledger_manifest_sha256,
+        "seed": int(args.seed),
+        "selection_seed": int(
+            args.seed if args.selection_seed is None else args.selection_seed
+        ),
+        "n_clones": int(args.n_clones),
+        "dataset_households": args.dataset_households,
+        "epochs": int(args.epochs),
+        "learning_rate": float(args.learning_rate),
+        "sample_fraction": float(args.sample_fraction),
+        "sample_seed": int(args.sample_seed),
+        "source_year": int(source_year),
+        "source_lineage_modulus": args.source_lineage_modulus,
+        "calibration_year": getattr(args, "_calibration_year", None),
+        "target_weight_rule": args.target_weight_rule,
+        "engine_blocks": int(args.engine_blocks),
+        "measure_exclusions": (
+            None if args.measure_exclusions is None else str(args.measure_exclusions)
+        ),
+        # The solve doctrine the dense solve and the search run under: a
+        # resume after a doctrine change must refuse, not run under the old
+        # bound while the manifest declares the new one.
+        "doctrine": _doctrine_bounds(),
+    }
+
+
 def _candidate_identity_digest(
     *,
     pins: dict[str, dict[str, object]],
@@ -591,6 +675,11 @@ def _parse_args(argv: list[str] | None = None) -> argparse.Namespace:
         required=True,
         help="Output directory for the candidate H5 and evidence sidecars.",
     )
+    parser.add_argument(
+        "--dataset-households",
+        type=int,
+        help="Exact output household count after informed L0 and refit; pool clone K is unchanged. Candidate-only until size certification.",
+    )
     parser.add_argument("--n-clones", type=int, default=UK_LOCAL_CLONE_COUNT)
     parser.add_argument(
         "--candidate-clone-counts",
@@ -598,6 +687,50 @@ def _parse_args(argv: list[str] | None = None) -> argparse.Namespace:
         help="Dry-run only comma-separated candidate clone counts.",
     )
     parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument(
+        "--selection-seed",
+        type=int,
+        help=(
+            "Seed for the size selection only (informed L0 search, exact-count "
+            "draw, refit); defaults to --seed. The pool, ladder assignment and "
+            "dense reference stay on --seed, so two selections compare on one "
+            "pool. Requires --dataset-households."
+        ),
+    )
+    parser.add_argument(
+        "--selection-pi-hi",
+        type=float,
+        default=1.0,
+        help=(
+            "Certainty threshold of the exact-count draw: gates whose learned open "
+            "probability reaches it are taken with certainty. 1.0 (default) keeps "
+            "only the protected carriers certain; a lower value promotes learned "
+            "near-certain gates (the US exact-k ladder runs 0.95). Candidate-only; "
+            "recorded in the size receipt. Requires --dataset-households."
+        ),
+    )
+    parser.add_argument(
+        "--no-size-checkpoint",
+        action="store_true",
+        help=(
+            "Do not persist the dense solve and the informed L0 search before the "
+            "exact-count draw. By default a --dataset-households run writes "
+            "size_selection_checkpoint.{npz,json} into --out so a draw refusal "
+            "costs a re-draw, not the pool solve (microcosm#355)."
+        ),
+    )
+    parser.add_argument(
+        "--resume-size-checkpoint",
+        type=Path,
+        help=(
+            "Directory holding a size_selection_checkpoint written by an earlier "
+            "--dataset-households run on the same inputs: the pool and the target "
+            "surface are re-derived and verified, the dense solve and the search "
+            "are restored, and the run continues at the exact-count draw "
+            "(--selection-pi-hi may differ; both thresholds are recorded). "
+            "Requires --dataset-households and the same seeds, epochs and pins."
+        ),
+    )
     parser.add_argument(
         "--sample-fraction",
         type=float,
@@ -779,6 +912,7 @@ def _run_candidate(
             input_h5=input_h5,
             ladder_path=ladder_path,
         )
+        _refuse_stale_size_checkpoint(args, out_dir)
         ladder = load_uk_oa_ladder(ladder_path)
         target_provenance = ladder_target_provenance(ladder)
         joint_inputs = _load_joint_target_inputs(args)
@@ -841,6 +975,13 @@ def _run_candidate(
             source_lineage_modulus=args.source_lineage_modulus,
         )
         clone = assignment.result
+        if (
+            args.dataset_households is not None
+            and args.dataset_households > clone.frame.n("household")
+        ):
+            raise ValueError(
+                "--dataset-households exceeds the cloned pool; selection never clamps the request."
+            )
         if state is not None:
             append_phase(state, "cloned")
 
@@ -966,6 +1107,25 @@ def _run_candidate(
             file=sys.stderr,
             flush=True,
         )
+        checkpoint_identity = _size_checkpoint_identity(
+            args, pins=pins, source_year=source_year
+        )
+        resume_checkpoint = (
+            None
+            if args.resume_size_checkpoint is None
+            else args.resume_size_checkpoint.expanduser().resolve()
+        )
+        write_checkpoint = (
+            args.dataset_households is not None
+            and not args.no_size_checkpoint
+            and resume_checkpoint is None
+        )
+        if resume_checkpoint is not None:
+            print(
+                f"resuming the size selection from {resume_checkpoint}...",
+                file=sys.stderr,
+                flush=True,
+            )
         solve = solve_uk_rowwise_weights_under_doctrine(
             solve_frame,
             problem,
@@ -977,11 +1137,30 @@ def _run_candidate(
             learning_rate=args.learning_rate,
             conserve_mass=_CONSERVE_MASS,
             target_records=_TARGET_RECORDS,
+            dataset_households=args.dataset_households,
             l0_lambda=_L0_LAMBDA,
             budget_iters=_BUDGET_ITERS,
             seed=args.seed,
+            selection_seed=args.selection_seed,
+            selection_pi_hi=args.selection_pi_hi,
+            size_checkpoint_dir=out_dir if write_checkpoint else None,
+            resume_size_checkpoint=resume_checkpoint,
+            checkpoint_identity=checkpoint_identity,
+            checkpoint_provenance={"code_pin": code_pin, "build_id": state.build_id},
+            progress=_stderr_progress,
         )
         _validate_solve_result(solve, problem=problem)
+        if solve.size_receipt is not None and solve.size_receipt.get("checkpoint"):
+            checkpoint = solve.size_receipt["checkpoint"]
+            if "written" in checkpoint:
+                append_phase(state, "size_selection_checkpointed")
+                print(
+                    f"size selection checkpoint written to {out_dir}",
+                    file=sys.stderr,
+                    flush=True,
+                )
+            elif "resumed_from" in checkpoint:
+                append_phase(state, "size_selection_resumed")
         append_phase(state, "solved")
 
         # The kernel minted the calibration mass record inside calibrate() (the
@@ -1083,9 +1262,12 @@ def _run_candidate(
                 learning_rate=args.learning_rate,
                 conserve_mass=_CONSERVE_MASS,
                 target_records=_TARGET_RECORDS,
+                dataset_households=args.dataset_households,
                 l0_lambda=_L0_LAMBDA,
                 budget_iters=_BUDGET_ITERS,
                 solve_seed=args.seed,
+                selection_seed=args.selection_seed,
+                selection_pi_hi=args.selection_pi_hi,
             )
         args._rotated_holdout = rotated_holdout
 
@@ -1587,6 +1769,7 @@ def _joint_dry_run_plan(
         },
         "candidate_clone_counts": list(args.candidate_clone_counts or (args.n_clones,)),
         "candidate_clone_support": clone_support,
+        "parameters": _parameters(args, source_year=source_year),
         "releasable": False,
         "engine": "not_run",
         "ladder_target_provenance": dict(target_provenance),
@@ -1995,7 +2178,9 @@ def _dry_run_plan(
             "fraction": args.sample_fraction,
             "unreachable_check": "completed",
         },
-        "releasable": args.sample_fraction == 1.0 and args.engine_blocks == 1,
+        "releasable": args.sample_fraction == 1.0
+        and args.engine_blocks == 1
+        and args.dataset_households is None,
         "parameters": _parameters(args, source_year=source_year),
         "shapes": {
             "person": list(clone.frame.table("person").shape),
@@ -2047,6 +2232,13 @@ def _write_output_bundle(
         )
         write_uk_rowwise_dataset(candidate, staged["dataset"])
         solve.diagnostics.to_csv(staged["diagnostics"], index=False)
+        if solve.dense_reference is not None:
+            _dense_reference_diagnostics_frame(solve).to_csv(
+                staged["dense_reference"], index=False
+            )
+            _dataset_size_selection_frame(solve, problem=problem, clone=clone).to_csv(
+                staged["selection"], index=False
+            )
         support = support.copy()
         support["support_below_floor"] = (
             (support["assigned_households"] < 50)
@@ -2111,6 +2303,15 @@ def _write_output_bundle(
                 reported_path=output_paths["local_registry"],
             ),
         }
+        if solve.dense_reference is not None:
+            outputs["dense_reference_diagnostics"] = _artifact_info(
+                staged["dense_reference"],
+                reported_path=output_paths["dense_reference"],
+            )
+            outputs["dataset_size_selection"] = _artifact_info(
+                staged["selection"],
+                reported_path=output_paths["selection"],
+            )
         manifest = _manifest(
             args,
             candidate=candidate,
@@ -2289,11 +2490,25 @@ def _manifest(
             },
             "abs_delta": abs(new_total - old_total),
             "declared_stretch_bound": float(UK_LOCAL_MAX_WEIGHT_RATIO),
+            "stretch_reference": "pool_design"
+            if solve.size_receipt is None
+            else "normalized_horvitz_thompson_w_over_q",
+            # Against the frame the refit started from (the pool design on a
+            # dense run, the Horvitz-Thompson baseline on a size run)...
+            "realized_max_weight_ratio_vs_stretch_reference": float(
+                np.max(
+                    np.divide(
+                        np.asarray(solve.weights, dtype=np.float64),
+                        np.asarray(solve.initial_weights),
+                    )
+                )
+            ),
+            # ...and always against the pool design weights themselves.
             "realized_max_weight_ratio_vs_design": float(
                 np.max(
                     np.divide(
                         np.asarray(solve.weights, dtype=np.float64),
-                        np.asarray(clone.frame.weights_for("household").values),
+                        np.asarray(_design_weights_for(solve), dtype=np.float64),
                     )
                 )
             ),
@@ -2305,7 +2520,14 @@ def _manifest(
                 "ladder": ladder_rows,
                 "national": int(len(solve.national_diagnostics)),
             },
-            "n_households": int(problem.n_households),
+            "n_households": int(solve.frame.n("household")),
+            "pool_households": int(problem.n_households),
+            "dataset_size": None
+            if solve.size_receipt is None
+            else {
+                **dict(solve.size_receipt),
+                "dense_reference": _dense_reference_summary(solve),
+            },
             "initial_loss": float(solve.initial_loss),
             "final_loss": float(solve.final_loss),
             "max_abs_relative_error": float(abs_errors.max()),
@@ -2364,12 +2586,12 @@ def _manifest(
             },
         },
         "fit": {
-            "local_by_family": _fit_by_family(solve.diagnostics),
-            "national_by_family": _fit_by_family(solve.national_diagnostics),
+            "local_by_family": uk_fit_by_family(solve.diagnostics),
+            "national_by_family": uk_fit_by_family(solve.national_diagnostics),
             "weakest_families": sorted(
                 [
-                    *_fit_by_family(solve.diagnostics),
-                    *_fit_by_family(solve.national_diagnostics),
+                    *uk_fit_by_family(solve.diagnostics),
+                    *uk_fit_by_family(solve.national_diagnostics),
                 ],
                 key=lambda row: (
                     -float(row["worst_abs_relative_error"]),
@@ -2390,8 +2612,15 @@ def _manifest(
             for gate_id, payload in gate_rows.items()
             if not isinstance(payload, Mapping) or payload.get("status") != "passed"
         ),
-        "releasable": releasable,
-        "release_posture": release_posture,
+        "releasable": releasable and args.dataset_households is None,
+        "release_posture": {
+            **release_posture,
+            **(
+                {}
+                if args.dataset_households is None
+                else {"size_certification_present": False}
+            ),
+        },
         "ladder_household_uprating": dict(
             cross_grain.get("ladder_household_uprating")
             or {"applied": False, "reason": "no cross-grain receipt"}
@@ -2421,7 +2650,22 @@ def _manifest(
 def _parameters(args: argparse.Namespace, *, source_year: int) -> dict[str, Any]:
     return {
         "n_clones": int(args.n_clones),
+        "dataset_households": args.dataset_households,
         "seed": int(args.seed),
+        "selection_seed": None
+        if args.dataset_households is None
+        else int(args.seed if args.selection_seed is None else args.selection_seed),
+        "selection_pi_hi": None
+        if args.dataset_households is None
+        else float(args.selection_pi_hi),
+        "size_checkpoint": bool(
+            args.dataset_households is not None
+            and not args.no_size_checkpoint
+            and args.resume_size_checkpoint is None
+        ),
+        "resume_size_checkpoint": None
+        if args.resume_size_checkpoint is None
+        else str(args.resume_size_checkpoint.expanduser().resolve()),
         "source_year": source_year,
         "source_lineage_modulus": args.source_lineage_modulus,
         "sample_fraction": float(args.sample_fraction),
@@ -2443,27 +2687,98 @@ def _parameters(args: argparse.Namespace, *, source_year: int) -> dict[str, Any]
     }
 
 
-def _fit_by_family(diagnostics: pd.DataFrame) -> list[dict[str, object]]:
-    if diagnostics.empty:
-        return []
-    rows = []
-    for family, group in diagnostics.groupby("family", sort=True):
-        errors = group["abs_relative_error"].to_numpy(dtype=np.float64)
-        worst_index = int(np.argmax(errors))
-        worst = group.iloc[worst_index]
-        rows.append(
-            {
-                "family": str(family),
-                "n_targets": len(group),
-                "share_within_10pct": float((errors <= 0.10).mean()),
-                "share_within_25pct": float((errors <= 0.25).mean()),
-                "worst_abs_relative_error": float(errors[worst_index]),
-                "worst_cell": str(
-                    worst.get("target_name", worst.get("name", "unknown"))
-                ),
-            }
+def _design_weights_for(solve: UKRowwiseDoctrineSolve) -> np.ndarray:
+    """The pool design weights aligned to the solve's exported rows."""
+    if solve.selected_support is None or solve.dense_reference is None:
+        return np.asarray(solve.initial_weights, dtype=np.float64)
+    return np.asarray(solve.dense_reference.initial_weights, dtype=np.float64)[
+        np.asarray(solve.selected_support, dtype=np.int64)
+    ]
+
+
+def _dense_reference_summary(solve: UKRowwiseDoctrineSolve) -> dict[str, Any] | None:
+    """Manifest-sized evidence of the dense solve a size run was cut from."""
+
+    dense = solve.dense_reference
+    if dense is None:
+        return None
+    local_errors = dense.diagnostics["abs_relative_error"].to_numpy(dtype=np.float64)
+    national_errors = dense.national_diagnostics["abs_relative_error"].to_numpy(
+        dtype=np.float64
+    )
+    past_cap = dict(dense.past_cap_census or {})
+    return {
+        "initial_loss": float(dense.initial_loss),
+        "final_loss": float(dense.final_loss),
+        "n_nonzero": int(dense.n_nonzero),
+        "n_households": int(dense.weights.size),
+        "max_abs_relative_error": float(local_errors.max())
+        if local_errors.size
+        else None,
+        "median_abs_relative_error": float(np.median(local_errors))
+        if local_errors.size
+        else None,
+        "national_max_abs_relative_error": float(national_errors.max())
+        if national_errors.size
+        else None,
+        "past_cap": {key: int(past_cap[key]) for key in _PAST_CAP_COUNT_KEYS},
+        "weights": uk_weight_summary(dense.weights),
+        "local_by_family": uk_fit_by_family(dense.diagnostics),
+        "national_by_family": uk_fit_by_family(dense.national_diagnostics),
+        "diagnostics_file": DENSE_REFERENCE_DIAGNOSTICS_FILENAME,
+    }
+
+
+def _dense_reference_diagnostics_frame(solve: UKRowwiseDoctrineSolve) -> pd.DataFrame:
+    """Every target's dense-reference estimate, local rows then national rows."""
+
+    dense = solve.dense_reference
+    assert dense is not None
+    local = dense.diagnostics.copy()
+    local.insert(0, "grain", local["area_type"].astype(str))
+    national = dense.national_diagnostics.copy()
+    national.insert(0, "grain", "national")
+    return pd.concat([local, national], ignore_index=True, sort=False)
+
+
+def _dataset_size_selection_frame(
+    solve: UKRowwiseDoctrineSolve,
+    *,
+    problem: UKRowwiseLocalMatrix,
+    clone: UKLadderRowwiseDatasetResult,
+) -> pd.DataFrame:
+    """One row per selected pool household: identity, design, draw and refit."""
+
+    dense = solve.dense_reference
+    receipt = solve.size_receipt
+    assert dense is not None and receipt is not None
+    support = np.asarray(solve.selected_support, dtype=np.int64)
+    household = clone.frame.table("household")
+    clone_column = ladder_clone_index_column("household")
+    ids = household["household_id"].to_numpy()[support]
+    expected = np.asarray([problem.household_ids[i] for i in support])
+    if not np.array_equal(ids, expected):
+        raise RuntimeError(
+            "the cloned pool's household order does not match the solve's "
+            "matrix columns; the selection sidecar would misattribute rows."
         )
-    return rows
+    inclusion = np.asarray(receipt["inclusion_probabilities"], dtype=np.float64)
+    if inclusion.shape != support.shape:
+        raise RuntimeError("selection receipt inclusion probabilities are misaligned.")
+    return pd.DataFrame(
+        {
+            "pool_row_index": support,
+            "household_id": ids,
+            "clone_index": household[clone_column].to_numpy()[support]
+            if clone_column in household.columns
+            else np.zeros(support.size, dtype=np.int64),
+            "design_weight": dense.initial_weights[support],
+            "inclusion_probability": inclusion,
+            "certainty": inclusion >= 1.0,
+            "ht_baseline_weight": np.asarray(solve.initial_weights, dtype=np.float64),
+            "refit_weight": np.asarray(solve.weights, dtype=np.float64),
+        }
+    )
 
 
 def _local_output_registry(
@@ -2523,7 +2838,12 @@ def _validate_solve_result(
         raise RuntimeError(
             "doctrine solve returned no past-cap census; refusing candidate."
         )
-    if len(solve.weights) != problem.n_households:
+    expected_count = (
+        problem.n_households
+        if solve.selected_support is None
+        else len(solve.selected_support)
+    )
+    if len(solve.weights) != expected_count:
         raise RuntimeError(
             "doctrine solve returned a weight vector with the wrong length."
         )
@@ -2585,6 +2905,29 @@ def _validate_cli_args(args: argparse.Namespace) -> None:
         raise ValueError(
             "the joint registry path requires --input-sha256 and --ladder-sha256."
         )
+    if args.selection_seed is not None and args.dataset_households is None:
+        raise ValueError("--selection-seed requires --dataset-households.")
+    if not (0.0 < args.selection_pi_hi <= 1.0):
+        raise ValueError("--selection-pi-hi must be in (0, 1].")
+    if args.selection_pi_hi != 1.0 and args.dataset_households is None:
+        raise ValueError("--selection-pi-hi requires --dataset-households.")
+    if args.no_size_checkpoint and args.dataset_households is None:
+        raise ValueError("--no-size-checkpoint requires --dataset-households.")
+    if args.resume_size_checkpoint is not None:
+        if args.dataset_households is None:
+            raise ValueError("--resume-size-checkpoint requires --dataset-households.")
+        if args.no_size_checkpoint:
+            raise ValueError(
+                "--resume-size-checkpoint already implies no new checkpoint; "
+                "drop --no-size-checkpoint."
+            )
+    if args.dataset_households is not None:
+        if args.dataset_households <= 0:
+            raise ValueError("--dataset-households must be positive.")
+        if args.release_candidate:
+            raise ValueError(
+                "--dataset-households is candidate-only: size-specific matched comparison and promotion scorecard are required before release."
+            )
     if args.release_candidate:
         required_release = {
             "--input-sha256": args.input_sha256,
@@ -2665,6 +3008,8 @@ def _output_paths(
         "local_gates": out_dir
         / LOCAL_GATE_REPORT_FILENAME_TEMPLATE.format(calibration_year=calibration_year),
         "local_registry": out_dir / LOCAL_REGISTRY_FILENAME,
+        "dense_reference": out_dir / DENSE_REFERENCE_DIAGNOSTICS_FILENAME,
+        "selection": out_dir / DATASET_SIZE_SELECTION_FILENAME,
     }
 
 
@@ -2705,12 +3050,16 @@ def _publish_staged_files(
         "past_cap",
         "calibration_diagnostics",
         "local_registry",
+        "dense_reference",
+        "selection",
         "manifest",
     )
     published: list[Path] = []
     succeeded = False
     try:
         for key in publish_order:
+            if key in _SIZE_RUN_ONLY_OUTPUTS and not staged[key].exists():
+                continue
             destination = output_paths[key]
             if destination.exists():
                 raise FileExistsError(
diff --git a/tools/evaluate_uk_dataset_size.py b/tools/evaluate_uk_dataset_size.py
new file mode 100644
index 000000000..289300ef2
--- /dev/null
+++ b/tools/evaluate_uk_dataset_size.py
@@ -0,0 +1,1095 @@
+#!/usr/bin/env python3
+"""Evaluate one UK rowwise dataset-size candidate and write auditable receipts."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.metadata
+import json
+import re
+import shutil
+import subprocess
+import sys
+import time
+from collections.abc import Mapping, Sequence
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+from microcosm.build.uk_runtime.size_evaluation import (
+    RowwiseRun,
+    area_support_tables,
+    dense_reference_deltas,
+    fit_tables,
+    footprint,
+    frozen_vs_recomputed,
+    gate_table,
+    load_run,
+    paired_targets,
+    run_acceptance,
+    summarize,
+    weight_tables,
+)
+
+_REPO = Path(__file__).resolve().parents[1]
+_STEPS = (
+    "00-run-acceptance",
+    "10-dense-reference",
+    "20-vs-reference",
+    "30-incumbent-score",
+    "40-incumbent-surface",
+    "50-downstream",
+    "90-summary",
+)
+_CANDIDATE_NOTICE = (
+    "These are candidate evaluations and untargeted diagnostics. No gate "
+    "threshold is loosened or applied as a verdict; `--release-candidate` "
+    "remains refused for size runs."
+)
+
+
+def _parse_args(argv: Sequence[str] | None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--run", required=True, type=Path)
+    parser.add_argument("--label")
+    parser.add_argument("--reference", action="append", default=[])
+    parser.add_argument("--spine", action="append", default=[])
+    parser.add_argument("--incumbent-dir", type=Path)
+    parser.add_argument(
+        "--scoring-registry",
+        type=Path,
+        help=(
+            "Frozen compiled scoring register (TargetRegistry JSON) for step 30. "
+            "Defaults to <run>/scoring_registry_compiled.json when present, else the "
+            "first reference's; candidate runs do not write one."
+        ),
+    )
+    parser.add_argument("--ledger-facts", type=Path)
+    parser.add_argument("--ledger-facts-sha256")
+    parser.add_argument("--ledger-manifest-sha256")
+    parser.add_argument("--eval-home", type=Path)
+    parser.add_argument("--incumbent-h5", type=Path)
+    parser.add_argument("--reforms-config", type=Path)
+    parser.add_argument("--steps")
+    parser.add_argument("--skip")
+    parser.add_argument("--out", type=Path)
+    parser.add_argument("--skip-h5", action="store_true")
+    return parser.parse_args(argv)
+
+
+def _label_paths(values: Sequence[str], *, option: str) -> dict[str, Path]:
+    result: dict[str, Path] = {}
+    for value in values:
+        if "=" not in value:
+            raise ValueError(f"{option} must be LABEL=PATH: {value!r}")
+        label, raw_path = value.split("=", 1)
+        if not label or not raw_path or label in result:
+            raise ValueError(f"invalid or duplicate {option}: {value!r}")
+        result[label] = Path(raw_path).resolve()
+    return result
+
+
+def _selected_steps(args: argparse.Namespace) -> set[str]:
+    selected = set(_STEPS)
+    if args.steps:
+        selected = {value.strip() for value in args.steps.split(",") if value.strip()}
+    skipped: set[str] = set()
+    if args.skip:
+        skipped = {value.strip() for value in args.skip.split(",") if value.strip()}
+    unknown = sorted((selected | skipped) - set(_STEPS))
+    if unknown:
+        raise ValueError(f"unknown evaluation step(s): {unknown}")
+    return selected - skipped
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as file:
+        for block in iter(lambda: file.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _artifact(path: Path) -> dict[str, Any]:
+    return {
+        "path": str(path.resolve()),
+        "sha256": _sha256(path),
+        "bytes": path.stat().st_size,
+    }
+
+
+def _write_json(path: Path, payload: object) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+    )
+
+
+def _write_markdown(path: Path, title: str, payload: object) -> None:
+    path.write_text(
+        f"# {title}\n\n{_CANDIDATE_NOTICE}\n\n```json\n"
+        + json.dumps(payload, indent=2, sort_keys=True)
+        + "\n```\n",
+        encoding="utf-8",
+    )
+
+
+def _ensure_candidate_notice(path: Path) -> None:
+    if not path.is_file():
+        return
+    content = path.read_text(encoding="utf-8")
+    if _CANDIDATE_NOTICE not in content:
+        path.write_text(_CANDIDATE_NOTICE + "\n\n" + content, encoding="utf-8")
+
+
+def _now() -> str:
+    return datetime.now(UTC).isoformat()
+
+
+def _receipt(
+    folder: Path,
+    *,
+    step: str,
+    status: str,
+    reason: str | None,
+    argv: Sequence[str],
+    started_at: str,
+    started_clock: float,
+    inputs: Mapping[str, Path],
+    outputs: Mapping[str, Path],
+    exit_code: int | None = 0,
+    commands: Sequence[Mapping[str, Any]] | None = None,
+) -> dict[str, Any]:
+    receipt: dict[str, Any] = {
+        "step": step,
+        "status": status,
+        "reason": reason,
+        "argv": list(argv),
+        "cwd": str(_REPO),
+        "started_at": started_at,
+        "finished_at": _now(),
+        "wall_seconds": time.perf_counter() - started_clock,
+        "exit_code": exit_code,
+        "inputs": {
+            name: _artifact(path) for name, path in inputs.items() if path.is_file()
+        },
+        "outputs": {
+            name: _artifact(path) for name, path in outputs.items() if path.is_file()
+        },
+    }
+    if commands is not None:
+        receipt["commands"] = list(commands)
+    _write_json(folder / "receipt.json", receipt)
+    return receipt
+
+
+def _prepare(folder: Path) -> None:
+    if folder.name not in _STEPS or folder.parent == Path(folder.anchor):
+        raise ValueError(f"refusing to rewrite unsafe step folder: {folder}")
+    if folder.exists():
+        shutil.rmtree(folder)
+    folder.mkdir(parents=True)
+
+
+def _h5_path(run: RowwiseRun) -> Path | None:
+    outputs = run.manifest.get("outputs")
+    if isinstance(outputs, Mapping):
+        for record in outputs.values():
+            if isinstance(record, Mapping):
+                name = Path(str(record.get("path") or "")).name
+                candidate = run.path / name
+                if name.endswith(".h5") and candidate.is_file():
+                    return candidate
+    matches = sorted(run.path.glob("microcosm_uk_*_local.h5"))
+    return matches[0] if matches else None
+
+
+def _run_inputs(run: RowwiseRun, *, prefix: str) -> dict[str, Path]:
+    inputs = {
+        f"{prefix}_manifest": run.path / "rowwise_candidate_manifest.json",
+        f"{prefix}_solve_diagnostics": run.path / "solve_diagnostics.csv",
+        f"{prefix}_calibration_diagnostics": run.path / "calibration_diagnostics.json",
+        f"{prefix}_area_support": run.path / "area_support_summary.csv",
+    }
+    gates = sorted(run.path.glob("*.local_gates.json"))
+    if gates:
+        inputs[f"{prefix}_gates"] = gates[0]
+    h5 = _h5_path(run)
+    if h5 is not None:
+        inputs[f"{prefix}_h5"] = h5
+    for name in ("dense_reference_diagnostics.csv", "dataset_size_selection.csv"):
+        path = run.path / name
+        if path.is_file():
+            inputs[f"{prefix}_{path.stem}"] = path
+    return inputs
+
+
+def _spine(path: Path | None) -> pd.DataFrame | None:
+    if path is None:
+        return None
+    return pd.read_hdf(path, "household", columns=["household_id", "household_weight"])
+
+
+def _comparison(
+    run: RowwiseRun,
+    reference: RowwiseRun,
+    *,
+    run_spine: pd.DataFrame | None,
+    reference_spine: pd.DataFrame | None,
+) -> dict[str, Any]:
+    return {
+        "run": {
+            "fit": fit_tables(run),
+            "weights": weight_tables(run, spine_weights=run_spine),
+            "areas": area_support_tables(run),
+            "gates": gate_table(run),
+            "footprint": footprint(run),
+        },
+        "reference": {
+            "fit": fit_tables(reference),
+            "weights": weight_tables(reference, spine_weights=reference_spine),
+            "areas": area_support_tables(reference),
+            "gates": gate_table(reference),
+            "footprint": footprint(reference),
+        },
+        "paired_targets": paired_targets(run, reference),
+    }
+
+
+_RUSAGE_SHIM = (
+    "import atexit, resource, runpy, sys\n"
+    "script = sys.argv[1]\n"
+    "sys.argv = [script, *sys.argv[2:]]\n"
+    "def _report():\n"
+    "    peak = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss\n"
+    "    if sys.platform != 'darwin':\n"
+    "        peak *= 1024\n"
+    "    sys.stderr.write(f'__MICROCOSM_MAXRSS_BYTES__={int(peak)}\\n')\n"
+    "    sys.stderr.flush()\n"
+    "atexit.register(_report)\n"
+    "runpy.run_path(script, run_name='__main__')\n"
+)
+_MAXRSS_RE = re.compile(r"^__MICROCOSM_MAXRSS_BYTES__=([0-9]+)\s*$")
+
+
+def _run_command(command: list[str], *, timed: bool = False) -> dict[str, Any]:
+    """Run one external step; when timed, measure it portably.
+
+    The timed form runs a Python script in a child interpreter through a
+    small shim that executes the script in-process and reports the child's
+    own peak resident set (bytes on every platform) on stderr at exit; wall
+    time is measured here. No platform-specific ``time`` binary is involved,
+    so the receipt is the same on macOS and on the linux CI runners, and the
+    child's exit code is the script's own.
+    """
+
+    if timed:
+        if len(command) < 2 or command[0] != sys.executable:
+            raise ValueError("timed commands must be `<interpreter> <script> [args]`")
+        argv = [sys.executable, "-c", _RUSAGE_SHIM, *command[1:]]
+    else:
+        argv = command
+    started = time.perf_counter()
+    completed = subprocess.run(
+        argv,
+        cwd=_REPO,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    wall = time.perf_counter() - started
+    peak_rss: int | None = None
+    stderr = completed.stderr
+    if timed:
+        kept: list[str] = []
+        for line in stderr.splitlines():
+            match = _MAXRSS_RE.match(line)
+            if match:
+                peak_rss = int(match.group(1))
+            else:
+                kept.append(line)
+        stderr = "\n".join(kept)
+    exit_code = completed.returncode
+    return {
+        "argv": command,
+        "status": "ran" if exit_code == 0 else "failed",
+        "exit_code": exit_code,
+        "wall_seconds": wall,
+        "peak_rss_bytes": peak_rss,
+        "stdout_tail": completed.stdout[-4000:],
+        "stderr_tail": stderr[-4000:],
+    }
+
+
+def _safe_label(label: str) -> str:
+    return re.sub(r"[^A-Za-z0-9_.-]+", "-", label).strip("-") or "dataset"
+
+
+def _git_commit() -> str | None:
+    result = subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        cwd=_REPO,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    return result.stdout.strip() if result.returncode == 0 else None
+
+
+def _engine_version() -> str | None:
+    try:
+        return importlib.metadata.version("policyengine-uk")
+    except importlib.metadata.PackageNotFoundError:
+        return None
+
+
+def _load_optional_json(path: Path) -> dict[str, Any] | None:
+    if not path.is_file():
+        return None
+    with path.open(encoding="utf-8") as file:
+        payload = json.load(file)
+    return payload if isinstance(payload, dict) else None
+
+
+def _summary_markdown(summary: Mapping[str, Any], index: Mapping[str, Any]) -> str:
+    lines = [
+        "# UK dataset-size evaluation",
+        "",
+        _CANDIDATE_NOTICE,
+        "",
+        "## Identity",
+        "",
+    ]
+    identity = summary["identity"]
+    lines.extend(
+        [
+            f"- Label: `{identity['label']}`",
+            f"- Run: `{identity['path']}`",
+            f"- Git commit: `{identity.get('git_commit')}`",
+            "",
+            "## Pre-registered outcomes",
+            "",
+        ]
+    )
+    scorecard = summary["scorecard"]
+    scorecard_columns = list(scorecard["columns"])
+    lines.append(
+        "| Metric | "
+        + " | ".join(scorecard_columns)
+        + " | Flag | Expectation | Red flag |"
+    )
+    lines.append("|---|" + "---:|" * len(scorecard_columns) + "---|---|---|")
+    outcomes = {row["id"]: row for row in summary["pre_registered_outcomes"]}
+    for scorecard_row in scorecard["rows"]:
+        outcome = outcomes[scorecard_row["id"]]
+        values = scorecard_row["values"]
+        lines.append(
+            f"| {scorecard_row['label']} | "
+            + " | ".join(str(values[column]) for column in scorecard_columns)
+            + f" | {outcome['flag']} | {outcome['expectation']} | "
+            f"{outcome['red_flag']} |"
+        )
+    lines.extend(
+        [
+            "",
+            "## Gates",
+            "",
+            "| Gate | Status | Criticality |",
+            "|---|---|---|",
+        ]
+    )
+    for row in summary["gates"]:
+        lines.append(f"| {row['id']} | {row['status']} | {row['criticality']} |")
+    lines.extend(
+        [
+            "",
+            "## Per-grain fit",
+            "",
+            "| Grain | Rows | Within 10% | Within 25% | Median abs. error | Max abs. error |",
+            "|---|---:|---:|---:|---:|---:|",
+        ]
+    )
+    for grain, row in summary["fit"]["by_grain"].items():
+        lines.append(
+            f"| {grain} | {row['n']} | {row['within_10pct']} | "
+            f"{row['within_25pct']} | {row['median_abs']} | {row['max_abs']} |"
+        )
+    lines.extend(["", "## Paired deltas", ""])
+    references = summary["references"]
+    if references:
+        lines.extend(
+            [
+                "| Reference | Common | Wins | Ties | Losses |",
+                "|---|---:|---:|---:|---:|",
+            ]
+        )
+        for label, row in references.items():
+            lines.append(
+                f"| {label} | {row['n_common']} | {row['wins']} | "
+                f"{row['ties']} | {row['losses']} |"
+            )
+    else:
+        lines.append("No external reference was evaluated.")
+    lines.extend(
+        [
+            "",
+            "## Area support breaches",
+            "",
+            "| Grain | Areas | Any breach | Codes |",
+            "|---|---:|---:|---|",
+        ]
+    )
+    for grain, row in summary["area_support"]["by_geography_level"].items():
+        breaches = row["breaches"]
+        lines.append(
+            f"| {grain} | {row['n_areas']} | {breaches['any']} | "
+            f"{', '.join(breaches['codes'])} |"
+        )
+    lines.extend(
+        [
+            "",
+            "## Footprint",
+            "",
+            "```json",
+            json.dumps(summary["footprint"], indent=2, sort_keys=True),
+            "```",
+            "",
+            "## File index",
+            "",
+        ]
+    )
+    for name, record in sorted(index.items()):
+        lines.append(f"- `{name}` — `{record['sha256']}` ({record['bytes']} bytes)")
+    return "\n".join(lines) + "\n"
+
+
+def main(argv: list[str] | None = None) -> int:
+    raw_argv = list(sys.argv[1:] if argv is None else argv)
+    args = _parse_args(raw_argv)
+    run_path = args.run.resolve()
+    label = args.label or run_path.name
+    reference_paths = _label_paths(args.reference, option="--reference")
+    spine_paths = _label_paths(args.spine, option="--spine")
+    selected = _selected_steps(args)
+    out = (args.out or run_path / "evaluation").resolve()
+    out.mkdir(parents=True, exist_ok=True)
+
+    run = load_run(run_path, label=label, skip_h5=args.skip_h5)
+    references = {
+        reference_label: load_run(
+            reference_path,
+            label=reference_label,
+            skip_h5=args.skip_h5,
+        )
+        for reference_label, reference_path in reference_paths.items()
+    }
+    spines = {spine_label: _spine(path) for spine_label, path in spine_paths.items()}
+    previous_manifest = _load_optional_json(out / "evaluation_manifest.json") or {}
+    step_state = dict(previous_manifest.get("steps") or {})
+
+    def record(step: str, receipt: Mapping[str, Any]) -> None:
+        step_state[step] = {
+            "status": receipt["status"],
+            "reason": receipt["reason"],
+            "receipt": str((out / step / "receipt.json").resolve()),
+        }
+
+    if "00-run-acceptance" in selected:
+        step = "00-run-acceptance"
+        folder = out / step
+        _prepare(folder)
+        started_at, started_clock = _now(), time.perf_counter()
+        solve = run.manifest.get("solve") or {}
+        size = solve.get("dataset_size") if isinstance(solve, Mapping) else None
+        size = size if isinstance(size, Mapping) else {}
+        result = run_acceptance(
+            run,
+            expected_households=size.get("requested_households"),
+            expected_pool=size.get("pool_households"),
+            expected_epochs=(run.manifest.get("parameters") or {}).get("epochs"),
+        )
+        output = folder / "run_acceptance.json"
+        _write_json(output, result)
+        receipt = _receipt(
+            folder,
+            step=step,
+            status="ran",
+            reason=None,
+            argv=raw_argv,
+            started_at=started_at,
+            started_clock=started_clock,
+            inputs=_run_inputs(run, prefix="run"),
+            outputs={"run_acceptance": output},
+        )
+        record(step, receipt)
+
+    dense_result = dense_reference_deltas(run)
+    if "10-dense-reference" in selected:
+        step = "10-dense-reference"
+        folder = out / step
+        _prepare(folder)
+        started_at, started_clock = _now(), time.perf_counter()
+        outputs: dict[str, Path] = {}
+        if dense_result is None:
+            status, reason = "skipped", "run has no dense reference"
+        else:
+            status, reason = "ran", None
+            json_path = folder / "size_only_deltas.json"
+            md_path = folder / "size_only_deltas.md"
+            _write_json(json_path, dense_result)
+            _write_markdown(md_path, "Dense-reference deltas", dense_result)
+            outputs = {"json": json_path, "markdown": md_path}
+        receipt = _receipt(
+            folder,
+            step=step,
+            status=status,
+            reason=reason,
+            argv=raw_argv,
+            started_at=started_at,
+            started_clock=started_clock,
+            inputs={"dense_reference": run.path / "dense_reference_diagnostics.csv"},
+            outputs=outputs,
+        )
+        record(step, receipt)
+
+    if "20-vs-reference" in selected:
+        step = "20-vs-reference"
+        folder = out / step
+        _prepare(folder)
+        started_at, started_clock = _now(), time.perf_counter()
+        outputs = {}
+        if not references:
+            status, reason = "skipped", "no --reference was supplied"
+        else:
+            status, reason = "ran", None
+            for reference_label, reference in references.items():
+                comparison = _comparison(
+                    run,
+                    reference,
+                    run_spine=spines.get(label),
+                    reference_spine=spines.get(reference_label),
+                )
+                reference_folder = folder / _safe_label(reference_label)
+                reference_folder.mkdir()
+                json_path = reference_folder / "comparison.json"
+                md_path = reference_folder / "comparison.md"
+                _write_json(json_path, comparison)
+                _write_markdown(
+                    md_path, f"Comparison with {reference_label}", comparison
+                )
+                outputs[f"{reference_label}_json"] = json_path
+                outputs[f"{reference_label}_markdown"] = md_path
+        receipt = _receipt(
+            folder,
+            step=step,
+            status=status,
+            reason=reason,
+            argv=raw_argv,
+            started_at=started_at,
+            started_clock=started_clock,
+            inputs={
+                **_run_inputs(run, prefix="run"),
+                **{
+                    name: path
+                    for key, value in references.items()
+                    for name, path in _run_inputs(
+                        value, prefix=f"reference_{key}"
+                    ).items()
+                },
+                **{f"spine_{key}": value for key, value in spine_paths.items()},
+            },
+            outputs=outputs,
+        )
+        record(step, receipt)
+
+    incumbent_score: dict[str, Any] | None = None
+    if "30-incumbent-score" in selected:
+        step = "30-incumbent-score"
+        folder = out / step
+        _prepare(folder)
+        started_at, started_clock = _now(), time.perf_counter()
+        registry_candidates = [
+            *([args.scoring_registry] if args.scoring_registry is not None else []),
+            run.path / "scoring_registry_compiled.json",
+            *(
+                reference.path / "scoring_registry_compiled.json"
+                for reference in references.values()
+            ),
+        ]
+        registry = next(
+            (path for path in registry_candidates if path.is_file()),
+            registry_candidates[-1]
+            if registry_candidates
+            else run.path / "scoring_registry_compiled.json",
+        )
+        outputs = {}
+        command_rows: list[dict[str, Any]] = []
+        score_inputs = {
+            "candidate_diagnostics": run.path / "calibration_diagnostics.json",
+            "registry": registry,
+        }
+        if args.incumbent_dir is None:
+            status, reason, exit_code = (
+                "skipped",
+                "--incumbent-dir was not supplied",
+                None,
+            )
+        elif not registry.is_file():
+            status, reason, exit_code = (
+                "skipped",
+                "no frozen scoring register: pass --scoring-registry (candidate runs "
+                "do not write scoring_registry_compiled.json)",
+                None,
+            )
+        else:
+            diagnostics = run.path / "calibration_diagnostics.json"
+            incumbent_weights = args.incumbent_dir / "incumbent_local_weights.csv"
+            incumbent_metrics = args.incumbent_dir / "incumbent_household_metrics.csv"
+            score_inputs.update(
+                {
+                    "incumbent_weights": incumbent_weights,
+                    "incumbent_metrics": incumbent_metrics,
+                }
+            )
+            missing = [
+                path.name
+                for path in (incumbent_weights, incumbent_metrics)
+                if not path.is_file()
+            ]
+            if missing:
+                status, reason, exit_code = (
+                    "failed",
+                    f"missing incumbent input(s): {missing}",
+                    1,
+                )
+            else:
+                output = folder / "score_vs_incumbent.json"
+                command = [
+                    sys.executable,
+                    str(_REPO / "tools/score_uk_local_candidate.py"),
+                    "--candidate-diagnostics-json",
+                    str(diagnostics),
+                    "--candidate-diagnostics-sha256",
+                    _sha256(diagnostics),
+                    "--incumbent-weights-csv",
+                    str(incumbent_weights),
+                    "--incumbent-weights-sha256",
+                    _sha256(incumbent_weights),
+                    "--incumbent-household-metrics-csv",
+                    str(incumbent_metrics),
+                    "--incumbent-household-metrics-sha256",
+                    _sha256(incumbent_metrics),
+                    "--registry-json",
+                    str(registry),
+                    "--registry-sha256",
+                    _sha256(registry),
+                    "--output-json",
+                    str(output),
+                ]
+                command_result = _run_command(command)
+                command_rows.append(command_result)
+                status = command_result["status"]
+                exit_code = command_result["exit_code"]
+                reason = (
+                    command_result["stderr_tail"] or None
+                    if status == "failed"
+                    else None
+                )
+                if output.is_file():
+                    outputs["score"] = output
+                    incumbent_score = _load_optional_json(output)
+        receipt = _receipt(
+            folder,
+            step=step,
+            status=status,
+            reason=reason,
+            argv=raw_argv,
+            started_at=started_at,
+            started_clock=started_clock,
+            inputs=score_inputs,
+            outputs=outputs,
+            exit_code=exit_code,
+            commands=command_rows,
+        )
+        record(step, receipt)
+    else:
+        incumbent_score = _load_optional_json(
+            out / "30-incumbent-score/score_vs_incumbent.json"
+        )
+
+    surface_result: dict[str, Any] | None = None
+    if "40-incumbent-surface" in selected:
+        step = "40-incumbent-surface"
+        folder = out / step
+        _prepare(folder)
+        started_at, started_clock = _now(), time.perf_counter()
+        outputs = {}
+        command_rows = []
+        candidate_h5 = _h5_path(run)
+        surface_inputs = {
+            "candidate_manifest": run.path / "rowwise_candidate_manifest.json"
+        }
+        if candidate_h5 is not None:
+            surface_inputs["candidate_h5"] = candidate_h5
+        if args.ledger_facts is not None:
+            surface_inputs["ledger_facts"] = args.ledger_facts
+        if args.incumbent_dir is not None:
+            surface_inputs.update(
+                {
+                    "incumbent_manifest": args.incumbent_dir
+                    / "incumbent_local_surface_manifest.json",
+                    "incumbent_metrics": args.incumbent_dir
+                    / "incumbent_household_metrics.csv",
+                    "incumbent_weights": args.incumbent_dir
+                    / "incumbent_local_weights.csv",
+                }
+            )
+        if args.ledger_facts is None:
+            status, reason, exit_code = (
+                "skipped",
+                "--ledger-facts was not supplied",
+                None,
+            )
+        elif candidate_h5 is None:
+            status, reason, exit_code = "failed", "run H5 is absent", 1
+        elif not args.ledger_facts_sha256 or not args.ledger_manifest_sha256:
+            status, reason, exit_code = (
+                "failed",
+                "ledger SHA-256 arguments are required",
+                1,
+            )
+        else:
+            output = folder / "incumbent_surface_evaluation.json"
+            markdown = folder / "incumbent_surface_evaluation.md"
+            command = [
+                sys.executable,
+                str(_REPO / "tools/evaluate_uk_incumbent_surface.py"),
+                "--candidate-h5",
+                str(candidate_h5),
+                "--candidate-manifest",
+                str(run.path / "rowwise_candidate_manifest.json"),
+                "--ledger-facts",
+                str(args.ledger_facts),
+                "--ledger-facts-sha256",
+                args.ledger_facts_sha256,
+                "--ledger-manifest-sha256",
+                args.ledger_manifest_sha256,
+                "--engine-blocks",
+                "1",
+                "--out-json",
+                str(output),
+                "--out-md",
+                str(markdown),
+            ]
+            if args.incumbent_dir is not None:
+                command.extend(
+                    [
+                        "--incumbent-manifest",
+                        str(
+                            args.incumbent_dir / "incumbent_local_surface_manifest.json"
+                        ),
+                        "--incumbent-metrics-csv",
+                        str(args.incumbent_dir / "incumbent_household_metrics.csv"),
+                        "--incumbent-weights-csv",
+                        str(args.incumbent_dir / "incumbent_local_weights.csv"),
+                    ]
+                )
+            command_result = _run_command(command)
+            command_rows.append(command_result)
+            status = command_result["status"]
+            exit_code = command_result["exit_code"]
+            reason = (
+                command_result["stderr_tail"] or None if status == "failed" else None
+            )
+            if status == "ran" and output.is_file():
+                surface_result = frozen_vs_recomputed(run, output)
+                frozen_path = folder / "frozen_vs_recomputed.json"
+                _write_json(frozen_path, surface_result)
+                _ensure_candidate_notice(markdown)
+                outputs.update(
+                    {"json": output, "markdown": markdown, "frozen": frozen_path}
+                )
+        receipt = _receipt(
+            folder,
+            step=step,
+            status=status,
+            reason=reason,
+            argv=raw_argv,
+            started_at=started_at,
+            started_clock=started_clock,
+            inputs=surface_inputs,
+            outputs=outputs,
+            exit_code=exit_code,
+            commands=command_rows,
+        )
+        record(step, receipt)
+    else:
+        surface_result = _load_optional_json(
+            out / "40-incumbent-surface/frozen_vs_recomputed.json"
+        )
+
+    downstream_result: dict[str, Any] | None = None
+    if "50-downstream" in selected:
+        step = "50-downstream"
+        folder = out / step
+        _prepare(folder)
+        started_at, started_clock = _now(), time.perf_counter()
+        outputs = {}
+        command_rows = []
+        downstream_inputs: dict[str, Path] = {}
+        if args.eval_home is None:
+            status, reason, exit_code = "skipped", "--eval-home was not supplied", None
+        elif not references:
+            status, reason, exit_code = (
+                "skipped",
+                "downstream comparison requires a --reference",
+                None,
+            )
+        else:
+            first_reference = next(iter(references.values()))
+            candidate_h5 = _h5_path(run)
+            reference_h5 = _h5_path(first_reference)
+            if candidate_h5 is None or reference_h5 is None:
+                status, reason, exit_code = (
+                    "failed",
+                    "candidate or reference H5 is absent",
+                    1,
+                )
+            else:
+                status, reason, exit_code = "ran", None, 0
+                scripts = args.eval_home / "scripts"
+                configs = args.eval_home / "config"
+                downstream_inputs.update(
+                    {
+                        "candidate_h5": candidate_h5,
+                        "reference_h5": reference_h5,
+                        "compare_script": scripts / "compare_uk_datasets.py",
+                        "admin_script": scripts / "t4_admin_benchmarks.py",
+                        "scorecard_script": scripts / "scorecard_731.py",
+                        "expected_divergences": configs / "expected_divergences.json",
+                        "anchors": configs / "anchors_2025.json",
+                    }
+                )
+                jobs: list[tuple[str, list[str], list[Path]]] = [
+                    (
+                        "compare_uk_datasets",
+                        [
+                            sys.executable,
+                            str(scripts / "compare_uk_datasets.py"),
+                            "--candidate-h5",
+                            str(candidate_h5),
+                            "--incumbent-h5",
+                            str(reference_h5),
+                            "--year",
+                            "2025",
+                            "--expected-divergences",
+                            str(configs / "expected_divergences.json"),
+                            "--out-json",
+                            str(folder / "t3_distribution.json"),
+                            "--out-md",
+                            str(folder / "t3_distribution.md"),
+                        ],
+                        [
+                            folder / "t3_distribution.json",
+                            folder / "t3_distribution.md",
+                        ],
+                    ),
+                    (
+                        "t4_admin_benchmarks",
+                        [
+                            sys.executable,
+                            str(scripts / "t4_admin_benchmarks.py"),
+                            "--candidate-h5",
+                            str(candidate_h5),
+                            "--incumbent-h5",
+                            str(reference_h5),
+                            "--year",
+                            "2025",
+                            "--anchors",
+                            str(configs / "anchors_2025.json"),
+                            "--out",
+                            str(folder / "t4_admin.json"),
+                        ],
+                        [folder / "t4_admin.json"],
+                    ),
+                ]
+                if args.reforms_config is not None:
+                    downstream_inputs.update(
+                        {
+                            "reforms_script": scripts / "t5_reforms.py",
+                            "reforms_config": args.reforms_config,
+                        }
+                    )
+                    jobs.append(
+                        (
+                            "t5_reforms",
+                            [
+                                sys.executable,
+                                str(scripts / "t5_reforms.py"),
+                                "--candidate-h5",
+                                str(candidate_h5),
+                                "--incumbent-h5",
+                                str(reference_h5),
+                                "--config",
+                                str(args.reforms_config),
+                                "--out",
+                                str(folder / "t5_reforms.json"),
+                            ],
+                            [folder / "t5_reforms.json"],
+                        )
+                    )
+                else:
+                    command_rows.append(
+                        {
+                            "name": "t5_reforms",
+                            "status": "skipped",
+                            "reason": "--reforms-config was not supplied",
+                            "wall_seconds": None,
+                            "peak_rss_bytes": None,
+                        }
+                    )
+                datasets: list[tuple[str, Path]] = [(label, candidate_h5)]
+                datasets.extend(
+                    (key, value)
+                    for key, reference in references.items()
+                    if (value := _h5_path(reference)) is not None
+                )
+                if args.incumbent_h5 is not None:
+                    datasets.append(("incumbent", args.incumbent_h5.resolve()))
+                    downstream_inputs["incumbent_h5"] = args.incumbent_h5.resolve()
+                for dataset_label, h5 in datasets:
+                    output = folder / f"scorecard_731_{_safe_label(dataset_label)}.json"
+                    jobs.append(
+                        (
+                            f"scorecard_731:{dataset_label}",
+                            [
+                                sys.executable,
+                                str(scripts / "scorecard_731.py"),
+                                "--h5",
+                                str(h5),
+                                "--label",
+                                dataset_label,
+                                "--year",
+                                "2026",
+                                "--out",
+                                str(output),
+                            ],
+                            [output],
+                        )
+                    )
+                for job_name, command, job_outputs in jobs:
+                    command_result = {
+                        "name": job_name,
+                        **_run_command(command, timed=True),
+                    }
+                    command_rows.append(command_result)
+                    if command_result["status"] == "failed":
+                        status, exit_code = "failed", int(command_result["exit_code"])
+                        reason = f"{job_name} failed: {command_result['stderr_tail']}"
+                    for path in job_outputs:
+                        if path.is_file():
+                            if path.suffix == ".md":
+                                _ensure_candidate_notice(path)
+                            outputs[path.name] = path
+                downstream_result = {row["name"]: row for row in command_rows}
+                footprint_path = folder / "footprint.json"
+                _write_json(footprint_path, downstream_result)
+                outputs["footprint"] = footprint_path
+        receipt = _receipt(
+            folder,
+            step=step,
+            status=status,
+            reason=reason,
+            argv=raw_argv,
+            started_at=started_at,
+            started_clock=started_clock,
+            inputs=downstream_inputs,
+            outputs=outputs,
+            exit_code=exit_code,
+            commands=command_rows,
+        )
+        record(step, receipt)
+    else:
+        downstream_result = _load_optional_json(out / "50-downstream/footprint.json")
+
+    if "90-summary" in selected:
+        step = "90-summary"
+        folder = out / step
+        _prepare(folder)
+        started_at, started_clock = _now(), time.perf_counter()
+        summary = summarize(
+            run,
+            references=references,
+            dense_deltas=dense_result,
+            incumbent_score=incumbent_score,
+            surface=surface_result,
+            downstream=downstream_result,
+        )
+        markdown_path = folder / "EVALUATION.md"
+        existing_index = {
+            str(path.relative_to(out)): _artifact(path)
+            for path in out.rglob("*")
+            if path.is_file() and path != folder / "evaluation_summary.json"
+        }
+        markdown_path.write_text(
+            _summary_markdown(summary, existing_index), encoding="utf-8"
+        )
+        file_index = {
+            str(path.relative_to(out)): _artifact(path)
+            for path in out.rglob("*")
+            if path.is_file() and path != folder / "evaluation_summary.json"
+        }
+        summary["files"] = file_index
+        summary_path = folder / "evaluation_summary.json"
+        _write_json(summary_path, summary)
+        summary_inputs = {
+            **_run_inputs(run, prefix="run"),
+            **{
+                name: path
+                for key, value in references.items()
+                for name, path in _run_inputs(value, prefix=f"reference_{key}").items()
+            },
+            **{
+                f"evaluation_{str(path.relative_to(out)).replace('/', '_')}": path
+                for path in out.rglob("*")
+                if path.is_file() and folder not in path.parents
+            },
+        }
+        receipt = _receipt(
+            folder,
+            step=step,
+            status="ran",
+            reason=None,
+            argv=raw_argv,
+            started_at=started_at,
+            started_clock=started_clock,
+            inputs=summary_inputs,
+            outputs={"summary": summary_path, "markdown": markdown_path},
+        )
+        record(step, receipt)
+
+    for step in _STEPS:
+        step_state.setdefault(
+            step,
+            {"status": "skipped", "reason": "not selected", "receipt": None},
+        )
+    evaluation_manifest = {
+        "schema_version": 1,
+        "run": {"label": label, "path": str(run.path)},
+        "references": [
+            {"label": key, "path": str(value.path)} for key, value in references.items()
+        ],
+        "code_git_commit": _git_commit(),
+        "engine_version": _engine_version(),
+        "steps": {step: step_state[step] for step in _STEPS},
+        "created_at": _now(),
+    }
+    _write_json(out / "evaluation_manifest.json", evaluation_manifest)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tools/spec_engine_coverage.py b/tools/spec_engine_coverage.py
index 3f5ae7e76..e8cd35660 100644
--- a/tools/spec_engine_coverage.py
+++ b/tools/spec_engine_coverage.py
@@ -41,7 +41,7 @@
 
 REPORT_SCHEMA_VERSION = 3
 EXPECTED_POINTER_INVENTORY_SHA256 = (
-    "3fc6b9480ea81b9635bd0db56e180c2daf32a5cd2006a70d350586c570f96754"
+    "2c0423a08dc16bf5f142134804a1a6545f887e32ca5c991c856a2f8bcfaea0f0"
 )
 DEFAULT_REPORT_PATH = (
     Path(__file__).resolve().parents[1]
@@ -202,9 +202,10 @@ def valid_sha256(value: object) -> bool:
     if not isinstance(compiler_abi, Mapping):
         failures.append("compiler_ir_abi is missing")
     else:
-        if set(compiler_abi) != {"version", "sha256"} or compiler_abi.get(
-            "version"
-        ) != COMPILER_IR_ABI_VERSION:
+        if (
+            set(compiler_abi) != {"version", "sha256"}
+            or compiler_abi.get("version") != COMPILER_IR_ABI_VERSION
+        ):
             failures.append("compiler_ir_abi contract differs")
         if not valid_sha256(compiler_abi.get("sha256")):
             failures.append("compiler_ir_abi/sha256 is invalid")
@@ -249,9 +250,9 @@ def valid_sha256(value: object) -> bool:
         if not isinstance(claims, list):
             failures.append("field_usage claim receipts are incomplete")
             claims = []
-        if field_usage.get("claim_count") != len(definitions) or len(
-            claims
-        ) != len(definitions):
+        if field_usage.get("claim_count") != len(definitions) or len(claims) != len(
+            definitions
+        ):
             failures.append(
                 "field_usage claim count differs from the closed claim registry"
             )