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..b37736685
--- /dev/null
+++ b/changelog.d/uk-dataset-sizes-355.added.md
@@ -0,0 +1,2 @@
+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.
diff --git a/docs/evidence/spec-engine/us-f0-coverage.json b/docs/evidence/spec-engine/us-f0-coverage.json
index 3adf1102e..4ce20b8c6 100644
--- a/docs/evidence/spec-engine/us-f0-coverage.json
+++ b/docs/evidence/spec-engine/us-f0-coverage.json
@@ -1656,13 +1656,13 @@
           "compiler_ir.node_slices"
         ],
         "expected": {
-          "map_sha256": "6b4902d9a640dd459942e588ae2cc7fb937f1c42ad814365c7c1616c98ce1b68",
-          "protocol_sha256": "e63bbfa0f05302a672acd9914e3652c151cc7ee690182d8823dfb85329b1e911"
+          "map_sha256": "ade72ab19dcb267412114ec92d3b259632818984103317f5a6843fdff8577540",
+          "protocol_sha256": "38c526abb5252806308cc9115f266a2860d107a7199651786fc9c2d442172928"
         },
         "failures": [],
         "observed": {
-          "map_sha256": "6b4902d9a640dd459942e588ae2cc7fb937f1c42ad814365c7c1616c98ce1b68",
-          "protocol_sha256": "e63bbfa0f05302a672acd9914e3652c151cc7ee690182d8823dfb85329b1e911"
+          "map_sha256": "ade72ab19dcb267412114ec92d3b259632818984103317f5a6843fdff8577540",
+          "protocol_sha256": "38c526abb5252806308cc9115f266a2860d107a7199651786fc9c2d442172928"
         },
         "status": "covered"
       },
@@ -1677,7 +1677,7 @@
           "compiler_ir.seed_stream_map"
         ],
         "expected": {
-          "implementation_sha256": "e63bbfa0f05302a672acd9914e3652c151cc7ee690182d8823dfb85329b1e911",
+          "implementation_sha256": "38c526abb5252806308cc9115f266a2860d107a7199651786fc9c2d442172928",
           "protocol": "legacy-v1",
           "streams": [
             "build_model",
@@ -1698,7 +1698,7 @@
         },
         "failures": [],
         "observed": {
-          "implementation_sha256": "e63bbfa0f05302a672acd9914e3652c151cc7ee690182d8823dfb85329b1e911",
+          "implementation_sha256": "38c526abb5252806308cc9115f266a2860d107a7199651786fc9c2d442172928",
           "protocol": "legacy-v1",
           "streams": [
             "build_model",
@@ -2599,7 +2599,7 @@
       "country": "us",
       "schema_id": "country_spec",
       "schema_version": 1,
-      "spec_sha256": "9db29b4d33424fbb21a83c63927c7de55ba9a333d631f6323935f67a496eee46"
+      "spec_sha256": "9db2d6db2967b60f441551e1e668533214f422ea4dac735d8326b577263f1438"
     }
   },
   "report_schema_version": 3,
@@ -2609,7 +2609,7 @@
     "country": "us",
     "schema_id": "country_spec",
     "schema_version": 1,
-    "spec_sha256": "9db29b4d33424fbb21a83c63927c7de55ba9a333d631f6323935f67a496eee46"
+    "spec_sha256": "9db2d6db2967b60f441551e1e668533214f422ea4dac735d8326b577263f1438"
   },
   "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..1a43aca29
--- /dev/null
+++ b/docs/uk-dataset-size-plan-355.md
@@ -0,0 +1,116 @@
+# 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.
+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.
+
+## 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..247ea054c
--- /dev/null
+++ b/experiments/355-uk-dataset-size-receipts.md
@@ -0,0 +1,168 @@
+# #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.
+
+## 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.
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 a158ccfb5..bcb21ab62 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": "6b4902d9a640dd459942e588ae2cc7fb937f1c42ad814365c7c1616c98ce1b68",
-    "seed_protocol": "e63bbfa0f05302a672acd9914e3652c151cc7ee690182d8823dfb85329b1e911",
+    "seed_map": "ade72ab19dcb267412114ec92d3b259632818984103317f5a6843fdff8577540",
+    "seed_protocol": "38c526abb5252806308cc9115f266a2860d107a7199651786fc9c2d442172928",
     "source_manifest": "cd5ba8924d64da5425ee14cca82a774e3f4b2bb5aabe06df291cc3cc457287a9",
     "take_up": "fa186daea0f8dd641cc470e41d1a2953f887d45282ec990201298f47bedf8d4d",
     "tail": "ac92829c88a1a4fb6460d61190918d5d99c6c377fc8dd8f62f02b332d09bf59c",
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 65862e805..165f78fd5 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,
@@ -443,6 +444,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,
@@ -527,6 +543,8 @@
 )
 
 __all__ = [
+    "PRE_REGISTERED_OUTCOMES_V1",
+    "RowwiseRun",
     "UK_AGE_TAIL_BANDS",
     "UK_AGE_TAIL_BAND_POPULATIONS_RESOURCE",
     "UK_AGE_TAIL_DECLARED_SEEDS",
@@ -753,6 +771,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",
@@ -763,6 +782,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",
@@ -800,7 +820,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",
@@ -815,6 +838,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",
@@ -830,6 +854,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",
@@ -856,6 +881,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",
@@ -863,14 +889,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",
@@ -917,6 +946,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..678000d7a
--- /dev/null
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/dataset_size.py
@@ -0,0 +1,382 @@
+"""Exact household-count UK candidates on a fixed, materialized target surface."""
+
+import json
+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,
+    refit_l0_selection,
+    select_exact_k,
+)
+from microcosm.calibrate.initialization import contribution_initialization
+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]
+
+
+def refit_uk_dataset_size(
+    frame: Frame,
+    dense: CalibrationResult,
+    *,
+    households: int,
+    epochs: int,
+    learning_rate: float,
+    seed: int,
+    pi_hi: float = 1.0,
+) -> 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.
+    """
+    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."
+        )
+    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
+    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."
+        )
+    common = 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,
+    )
+    selection = calibrate(
+        frame,
+        TargetSet(problem.targets),
+        target_records=households,
+        gate_initialization=init,
+        mass_reason=dense.options["mass_reason"],
+        **common,
+    )
+    probabilities = selection.gate_open_probabilities
+    if probabilities is None:
+        raise RuntimeError("informed L0 returned no selection probabilities.")
+    if not isinstance(pi_hi, float | int) or isinstance(pi_hi, bool):
+        raise ValueError("pi_hi must be a number in (0, 1].")
+    pi_hi = float(pi_hi)
+    if not (0.0 < pi_hi <= 1.0):
+        raise ValueError("pi_hi must be a number in (0, 1].")
+    # Exact-one certainties are protected by the gates themselves. At the
+    # default pi_hi=1.0 no learned boundary score is promoted; a lower
+    # threshold promotes near-certain gates and is recorded in the receipt.
+    feasibility = selection_feasibility(
+        probabilities,
+        households,
+        protected=init.protected,
+        n_nonzero=int(selection.n_nonzero),
+        l0_lambda=float(selection.l0_lambda),
+        requested_pi_hi=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,
+        selection,
+        support=support,
+        k=households,
+        support_inclusion_probabilities=q,
+        mass_reason=dense.options["mass_reason"],
+        **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()),
+            "selection_receipt": sampling,
+            "selection_pi_hi": pi_hi,
+            "selection_feasibility": feasibility,
+            "selection_l0_lambda": selection.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,
+) -> 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.
+    """
+
+    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
+    feasible = m <= 0 or (
+        positive.size >= m and boundary_max * m <= boundary_mass * (1.0 + 1e-12)
+    )
+    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:
+        certain_t = pi >= threshold
+        c_t = int(certain_t.sum())
+        m_t = int(households) - c_t
+        boundary_t = pi[~certain_t]
+        positive_t = boundary_t[boundary_t > 0.0]
+        mass_t = float(positive_t.sum()) if positive_t.size else 0.0
+        max_t = float(positive_t.max()) if positive_t.size else 0.0
+        ok = m_t >= 0 and (
+            m_t == 0
+            or (positive_t.size >= m_t and max_t * m_t <= mass_t * (1.0 + 1e-12))
+        )
+        scan[f"{threshold:g}"] = {
+            "certainties": c_t,
+            "boundary_draw": m_t,
+            "boundary_mass": mass_t,
+            "boundary_max": max_t,
+            "feasible": bool(ok),
+        }
+        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 = _feasible_at(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),
+        "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),
+        "selection_l0_lambda": float(l0_lambda),
+    }
+
+
+def _feasible_at(pi: np.ndarray, households: int, threshold: float) -> bool:
+    certain = pi >= threshold
+    draw = households - int(certain.sum())
+    if draw < 0:
+        return False
+    if draw == 0:
+        return True
+    boundary = pi[~certain]
+    positive = boundary[boundary > 0.0]
+    if positive.size < draw:
+        return False
+    return bool(float(positive.max()) * draw <= float(positive.sum()) * (1.0 + 1e-12))
+
+
+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/local_rowwise.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/local_rowwise.py
index a38650ef8..9396018d7 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
@@ -151,6 +151,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 +1046,19 @@ 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,
 ) -> 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.
+
     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
@@ -1142,6 +1187,186 @@ def solve_uk_rowwise_weights_under_doctrine(
         target_loss_weights=target_loss_weights,
         target_loss_cap=doctrine.target_loss_cap,
     )
+    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
+
+        sized = refit_uk_dataset_size(
+            frame,
+            result,
+            households=dataset_households,
+            epochs=epochs,
+            learning_rate=learning_rate,
+            seed=seed if selection_seed is None else selection_seed,
+            pi_hi=selection_pi_hi,
+        )
+        dense_result = result
+        result = sized.result
+        selected_support = sized.support
+        size_receipt = sized.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,
+        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 +1496,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 +1539,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 +1586,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/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/tests/test_spec_engine_country_bundles.py b/packages/microcosm-build/tests/test_spec_engine_country_bundles.py
index c10b6fff9..9350ecdd8 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 = "b128d14f8e6351d745a16ef4537d5c1b8d71d11b9d96cb8a65f1a4fb953f13ed"
+AM_SPEC_SHA256 = "12fb58433f1e03eb20069e59a0da6fe7ed43bcff7dfc3c207cb70531e66a61fa"
 
 
 @pytest.mark.parametrize(
@@ -45,7 +45,7 @@
         ),
         (
             "be",
-            "8c6018eaf518b239a5625f8df8bf783ce4723a03704d100f3dbf4c2bb7765772",
+            "50ffc5f8455188a6421fe8ec38aa61b61cbdb3249dcfd6f4b201e11b5d7893ee",
             {
                 "household.household_id",
                 "person.person_id",
@@ -55,7 +55,7 @@
         ),
         (
             "uk",
-            "e0dd9175920f6d1368a74957367182dc4d6357ffbdb1f728457ead91dd16dd9b",
+            "d57d248fe947c3215850020bb16c6def308e373c92afa433395c81e8eda91fce",
             {
                 "benunit.benunit_id",
                 "household.household_id",
diff --git a/packages/microcosm-build/tests/test_spec_engine_loader.py b/packages/microcosm-build/tests/test_spec_engine_loader.py
index a7effd506..7834d3ade 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 == (
-        "7a0fbb0a2a16aff28a9ac6e205e6679b013c580171db87b39597a0b14a97e423"
+        "1c716f69c2d64990b0a02dfb2f220cf7eba4001982c69806c5bc0b46ef450184"
     )
 
     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_local_rowwise.py b/packages/microcosm-build/tests/test_uk_local_rowwise.py
index faecd4975..84a892236 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,389 @@ 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.9"]["feasible"] is True
+    assert report["smallest_feasible_pi_hi_on_grid"] == 0.9
+    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_feasibility"]["requested_pi_hi"] == 0.5
+    assert receipt["selection_feasibility"]["feasible_at_requested_pi_hi"] is True
+    # 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
+        )
diff --git a/packages/microcosm-build/tests/test_uk_rowwise_candidate.py b/packages/microcosm-build/tests/test_uk_rowwise_candidate.py
index 8bd053f90..34c7ce38c 100644
--- a/packages/microcosm-build/tests/test_uk_rowwise_candidate.py
+++ b/packages/microcosm-build/tests/test_uk_rowwise_candidate.py
@@ -1822,3 +1822,193 @@ 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)
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_us_multispine_pool_tool.py b/packages/microcosm-build/tests/test_us_multispine_pool_tool.py
index 07e81d2fb..6547bd6dd 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": "9db29b4d33424fbb21a83c63927c7de55ba9a333d631f6323935f67a496eee46",
+            "spec_sha256": "9db2d6db2967b60f441551e1e668533214f422ea4dac735d8326b577263f1438",
         },
     }
 
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 746ed9e6a..066be5c9e 100644
--- a/packages/microcosm-calibrate/src/microcosm/calibrate/solve.py
+++ b/packages/microcosm-calibrate/src/microcosm/calibrate/solve.py
@@ -77,6 +77,7 @@
 
 from microcosm.calibrate.exact_k import assert_exact_k_support
 from microcosm.calibrate.gates import HardConcrete
+from microcosm.calibrate.initialization import GateInitialization
 from microcosm.calibrate.matrix import (
     CalibrationProblem,
     SkippedTarget,
@@ -754,6 +755,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,
@@ -799,7 +801,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)
@@ -1053,6 +1067,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,
@@ -1144,6 +1159,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,
@@ -1332,6 +1349,7 @@ def calibrate(
     frame: Frame,
     targets: TargetSet,
     *,
+    gate_initialization: GateInitialization | None = None,
     weight_entity: str = "household",
     method: str = "adam",
     epochs: int = 256,
@@ -1432,6 +1450,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).
@@ -1519,6 +1540,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
     ):
@@ -1708,6 +1732,11 @@ def calibrate(
             progress_callback=progress_callback,
             budget_iters=budget_iters,
             return_gate_open_probabilities=True,
+            **(
+                {}
+                if gate_initialization is None
+                else {"gate_initialization": gate_initialization}
+            ),
         )
     else:
         effective_l0 = l0_lambda
@@ -1732,6 +1761,11 @@ def calibrate(
             temperature=temperature,
             progress_callback=progress_callback,
             return_gate_open_probabilities=True,
+            **(
+                {}
+                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:
@@ -1792,6 +1826,7 @@ 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,
             "method": method,
             "epochs": epochs,
             "learning_rate": learning_rate,
@@ -1954,6 +1989,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",
@@ -1977,6 +2013,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
@@ -2126,6 +2164,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/test_informed_gates.py b/packages/microcosm-calibrate/tests/test_informed_gates.py
new file mode 100644
index 000000000..b4a779f0c
--- /dev/null
+++ b/packages/microcosm-calibrate/tests/test_informed_gates.py
@@ -0,0 +1,42 @@
+"""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))
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 8485a3916..f6dd716f1 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":"a7a0330fb7b7a4c80b62e2a44dcc9075aa6da9b27a20a4282ca6969f4570ef18","kernel":"calibrate.adam@1","node":"calibrate","node_key":"0168f69547e21ef71c67442a52622de83efd32fd23adc8faf93cc347f6c80b4c","numeric":"bitwise","platform":"arm64/darwin/py3.14","platforms":{"arm64/darwin/py3.14":{"direct":"direct.csv","node_key":"0168f69547e21ef71c67442a52622de83efd32fd23adc8faf93cc347f6c80b4c"}},"seed":0}
+{"dependencies":{"numpy":"2.4.6","pandas":"3.0.3","scipy":"1.17.1","torch":"2.12.0"},"implementation_hash":"d24fc41dd747ee454d519493330c43f367e45717862bf43c18e3202b49dcafae","kernel":"calibrate.adam@1","node":"calibrate","node_key":"6afacecea1762afe3d6b6dbfdde38c0f1fe7aaaeef6bb3f5b578226deffdb6e3","numeric":"bitwise","platform":"arm64/darwin/py3.14","platforms":{"arm64/darwin/py3.14":{"direct":"direct.csv","node_key":"6afacecea1762afe3d6b6dbfdde38c0f1fe7aaaeef6bb3f5b578226deffdb6e3"}},"seed":0}
diff --git a/tools/build_uk_rowwise_candidate.py b/tools/build_uk_rowwise_candidate.py
index 101ca0bb2..7aa502c2a 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
@@ -591,6 +598,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 +610,28 @@ 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(
         "--sample-fraction",
         type=float,
@@ -841,6 +875,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")
 
@@ -977,9 +1018,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,
             seed=args.seed,
+            selection_seed=args.selection_seed,
+            selection_pi_hi=args.selection_pi_hi,
         )
         _validate_solve_result(solve, problem=problem)
         append_phase(state, "solved")
@@ -1083,9 +1127,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 +1634,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 +2043,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 +2097,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 +2168,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 +2355,14 @@ 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",
             "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(solve.initial_weights),
                     )
                 )
             ),
@@ -2305,7 +2374,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 +2440,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 +2466,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 +2504,14 @@ 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),
         "source_year": source_year,
         "source_lineage_modulus": args.source_lineage_modulus,
         "sample_fraction": float(args.sample_fraction),
@@ -2443,27 +2533,89 @@ 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 _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 +2675,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 +2742,19 @@ 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.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 +2835,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 +2877,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..df30d9d25
--- /dev/null
+++ b/tools/evaluate_uk_dataset_size.py
@@ -0,0 +1,1072 @@
+#!/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("--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 = 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",
+                "run has no 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())