diff --git a/changelog.d/1095-certify-against-current-build.changed.md b/changelog.d/1095-certify-against-current-build.changed.md
new file mode 100644
index 0000000000..243c357f72
--- /dev/null
+++ b/changelog.d/1095-certify-against-current-build.changed.md
@@ -0,0 +1 @@
+UK cuts check and certify their candidate against the current build of their own line, as the Hub's `releases.json` names it, instead of the enhanced FRS (microcosm#1095, now that the migration in microcosm#665 is complete): national against national, dense against dense. A cut resolves its reference once, refusing a build that is withdrawn or not certified, and keeps its record, the dataset and the evidence the gates read from it with the run (`tools/run_uk_cut.py`'s new `reference` step, or `tools/resolve_uk_reference.py` outside it). The comparison of the candidate's target fit with the reference's is a report with no verdict (`score_vs_reference.json`), built by one country-neutral head-to-head module that the US comparison tool now shares. The input-mass gate compares each column's total with the reference's at the reference's own solved weights, within the largest relative drift measured between the last two national builds, and no column may lose more than 90% of the reference's total (the largest drop between those builds, rounded up for headroom), since a symmetric tolerance above one fails no drop short of zero; it withholds the figures of the columns fewer than three source households carry. The export-surface gate compares with the reference's exported columns, so the declared extras shrink from 250 to the 32 the current national build does not export (the dense line's geography and clone columns, and six that microcosm#1550 adds), and an entry the reference now carries is reported as redundant rather than failed. The input-coverage gate requires every loader input the reference carries, measured by the gate's own rule, less the coverage manifest's reviewed exclusions. The gross receipts that microcosm#1550 stops writing, which the current builds still carry, are excluded against those builds in all three gates until a promotion moves the reference past them. The trading allowance full-relief carrier that five SPI rows filter on since microcosm#1439, which the current national build does not carry, is signed as unresolvable on that build for the comparison, as microcosm#1572 signed it on the enhanced FRS. A cut can pin a listed build as its reference (`--reference-build`) for a line with no current build, recorded as pinned, and each national certification records the change since a fixed baseline, chained from its reference's record without loading the baseline, listing every column that has left the chain and recording a chain that restarts. The certification and the release contract move to schema 2 with a `reference` block, the dense build takes `--input-mass-reference` and `--reference-surface` from its own line's current build, and the frozen enhanced-FRS facts stay only as a historical record.
diff --git a/docs/gate-battery-contract.md b/docs/gate-battery-contract.md
index 10662fa269..b8ffb08f7d 100644
--- a/docs/gate-battery-contract.md
+++ b/docs/gate-battery-contract.md
@@ -126,7 +126,8 @@ Canonical artifact keys:
 | `coverage_engine`, `coverage_manifest` (optional override) | the UK national build | `release_input_coverage`, both phases |
 | `build_stage_names` | the UK national build preflight | `source_coverage` |
 | `parity_evidence` | the UK national build | `export_surface`, `target_surface`, `target_fit` |
-| `input_mass_reference` | the UK national build, when the licensed sidecar is supplied | `input_mass_parity` (UK override) |
+| `reference_surface` | the UK release cut (`--reference-surface`), and the dense build when given one | `export_surface` (the reference's exported columns), `release_input_coverage` (the inputs it carries), microcosm#1095 |
+| `input_mass_reference` | the UK release cut and the dense build: the current build's totals and carriers, from the cut's reference step | `input_mass_parity` (UK override) |
 | `reviewed_input_mass_exclusions` (optional override) | the UK national build | `input_mass_parity` (UK override) |
 | `uk_area_support_summary`, `exclusions_evaluated_on` | the UK local rowwise build | `area_support` (UK binding; reviewed exclusions state the area's figures beside the floors it misses, and stale entries fail; they are gate-only and defer none of the area's cells, microcosm#1301) |
 | `local_target_diagnostics`, `exclusions_evaluated_on` | the UK local rowwise build | `per_family_fit` (the diagnostics only); `target_fit` on `surface: local_candidate` (UK binding; the local cells stand on `local_target_fit_reviewed_exclusions.json`, keyed `family/area_code/metric`, which lifts the fence only and is evaluated on the build's review date, microcosm#1301) |
@@ -229,7 +230,7 @@ stretches on declaration alone:
 | --- | --- | --- |
 | phases | `terminal` | `preflight`, `assembled`, `transferred`, `terminal` |
 | entries | 9 | 73 (64 national-build entries, 7 local-candidate entries and 2 local diagnostics) |
-| incumbent posture | none — incumbent-comparison gates deliberately not selected; external oracles replace self-parity | full — export/target parity against the pinned enhanced-FRS incumbent |
+| incumbent posture | none — incumbent-comparison gates deliberately not selected; external oracles replace self-parity | full — export surface, input coverage and input mass against the current build of the cut's own line (microcosm#1095; until then the pinned enhanced-FRS incumbent) |
 | criticality mix | 8 blocking + 1 diagnostic | 71 blocking + 2 local diagnostics |
 
 The differences are entirely in the two country inputs — the spec file
@@ -257,15 +258,21 @@ inputs — never implicit module state.** A country picks its reference on
 purpose and cannot silently inherit a mis-referenced comparison.
 
 The UK input-mass entry is the worked case. Its `parameters` declare the
-active `reference`, the closed `reference_registry` of named identities plus
-`totals_sha256` pins, the numeric thresholds, and the
-`reviewed_exclusions_resource` for the schema-3 per-reference register. The
-UK binding holds the runtime-supplied reference sidecar to the active named
-descriptor, failing closed on identity or totals-digest drift; an exclusion
-suppresses only for the active reference block. The export-surface entry declares its
-reviewed comparison registers the same way (the allowed-extra column list
-and the reviewed reference-side exclusions), with the hard-required,
-never-waivable columns remaining a code-level guard noted in the entry.
+active `reference` kind, `current_build` (microcosm#1095): the current build
+of the cut's own line, which the cut's reference step resolves from the
+Hub's `releases.json` and records, so the spec commits to the rule and the
+cut's record to the build. They also declare the numeric thresholds and the
+`reviewed_exclusions_resource` for the schema-3 per-reference register, whose
+blocks are keyed by the reference's `<release>@<build>` label; an exclusion
+suppresses only for the reference it names. The export-surface entry declares
+its reviewed comparison registers the same way (the allowed-extra column
+list, now only what the current national build does not export, and the
+reviewed reference-side exclusions), with the hard-required, never-waivable
+columns remaining a code-level guard noted in the entry. The input-coverage
+entry requires what the reference carries, less the coverage manifest's
+reviewed exclusions. Until microcosm#1095 all three compared with the pinned
+enhanced FRS, through a closed registry of named identities with
+`totals_sha256` pins.
 
 ## The onboarding checklist: every input a country supplies
 
diff --git a/docs/uk-cut-anyone.md b/docs/uk-cut-anyone.md
index 728b7f4e9f..39938862ed 100644
--- a/docs/uk-cut-anyone.md
+++ b/docs/uk-cut-anyone.md
@@ -48,14 +48,18 @@ with `agent-secret get microcosm/uk-gate-signing-key-team maxghenis`, and
 
 1. `fetch`
 2. `preflight`
-3. spine
-4. national dry run, then the national calibration
-5. re-score, only when the in-build evaluation did not pass
-6. certify
-7. stage-1 comparison (with `--previous-h5`)
-8. assemble
-9. publish preflight
-10. publish (with `--publish`)
+3. `reference`: the current national build the cut compares with
+   ([The reference build](#the-reference-build))
+4. spine
+5. national dry run, then the national calibration
+6. re-score, only when the build's comparison with the reference is missing
+   or names another candidate or reference
+7. certify
+8. stage-1 comparison, against the reference (`--previous-h5` names another
+   file)
+9. assemble
+10. publish preflight
+11. publish (with `--publish`)
 
 Every step first checks whether its outputs already exist and verify, and
 skips itself if they do. So when a run stops, fix the cause and run the same
@@ -85,6 +89,7 @@ derive from licensed data:
 | Path | Contents |
 |---|---|
 | `inputs/` | shared verified inputs |
+| `cuts/<label>-<sha9>/reference/` | the build the cut compares with: its dataset, its record (`reference.json`) and the evidence the gates read from it |
 | `cuts/<label>-<sha9>/spine/` | the spine |
 | `cuts/<label>-<sha9>/national/` | the calibration run |
 | `cuts/<label>-<sha9>/release/` | the assembled release |
@@ -150,11 +155,10 @@ MICROCOSM_UK_CUT_MODAL_RUN=1 modal run --detach tools/modal_uk_cut.py --commit <
 `tools/uk_cut_inputs.json` says where each input lives. Every expected digest
 is read at run time from the pins the build already checks:
 `uk/source_stages.json`, `uk/frs_release.json`, `uk/chronicle_feed.json` and
-`uk/gates.json`. The one exception is the input-mass reference: the build
-binds it by a canonical digest of its contents, so the manifest also carries
-the hosted file's byte sha256. A file is installed only if it
-is byte-identical to what the build will accept, and nothing unverified is
-ever left at an input's path.
+`uk/gates.json`. A file is installed only if it is byte-identical to what the
+build will accept, and nothing unverified is ever left at an input's path.
+The build the cut compares with is not a fixed input: the `reference` step
+resolves it ([The reference build](#the-reference-build)).
 
 **Who can read them.** `policyengine/microcosm-uk-build-inputs`,
 `policyengine/populace-uk-private` and `policyengine/populace-uk-staging` are
@@ -168,8 +172,6 @@ is what admits a builder to the licensed inputs.
 | FRS 2024-25 (14 tabs) | `policyengine/policyengine-uk-data-private` `frs_2024_25.zip` @ `a2039519` (gated) | fetched, every member matches its pin |
 | SPI 2022-23, WAS round 8, ETB 1977-2024 | the same repo's `spi_2022_23.zip`, `was_2006_22.zip`, `etb_1977_24.zip` | fetched, matches |
 | HMRC personal incomes ODS | gov.uk URL pinned in `source_stages.json` | fetched, matches |
-| Incumbent enhanced FRS | `policyengine-uk-data-private` `enhanced_frs_2024_25.h5` @ `a9e52499` | fetched, matches |
-| Input-mass reference | `policyengine/microcosm-uk-build-inputs` (private) `input-mass-reference/fd41cb5f…/` | fetched, matches |
 | Chronicle UK consumer artifact (about 8 GB) | `policyengine/microcosm-uk-build-inputs` `chronicle-uk/<the feed's source commit>/`, read at main | fetched, both files match the feed pin. The path follows `chronicle_feed.json`, so each re-pin needs its artifact hosted (below). 64753803's (main's pin since PolicyEngine/chronicle#411) was uploaded on 2026-11-06 from a local build that matches both digests; 272c987's on 2026-10-26 from the build #1359 pinned; abf0921's was rebuilt on Modal and reproduced the pin byte for byte |
 | NTS 2002-2024 (6 tabs) | `policyengine-uk-data-private` `nts_2002_24.zip` @ `559b69e9` | fetched, every member matches its pin |
 | LCFS 2024-25 (2 tabs) | `policyengine-uk-data-private` `lcfs_2024_25.zip` @ `11051052` (a repack of the extracted files) | fetched, every member matches its pin |
@@ -232,22 +234,79 @@ the private repositories, is attached only with
 ephemeral secret for that run; no named workspace secret keeps it. A rebuild
 without `--upload` sends no credential at all.
 
-### Regenerating the input-mass reference
+### The reference build
 
-The certifier binds the reference by a canonical digest of its identity and
-totals. The emitted column set follows the installed policyengine-uk.
-Today's engine adds `bus_fare_spending` and `sic_industry_division`. That
-changes the digest, though all 131 shared totals are identical. Reproduce the
-pinned file (`fd41cb5f…`) at the commit that pinned it:
+A cut checks and certifies its candidate against the current build of the
+national line, as `releases.json` in `policyengine/populace-uk-private` names
+it (microcosm#1095). Until then every cut compared with the enhanced FRS.
+
+The `reference` step resolves that build once per cut. It refuses a build
+that is withdrawn or whose `release_certification.json` is not shippable,
+names another file or was signed by an unregistered key. It downloads the
+dataset, checks its sha256 and writes four files to
+`cuts/<label>-<sha9>/reference/`:
+
+- the dataset;
+- `reference.json`, the record every later step reads, so a promotion while
+  the cut runs does not change what it is compared with;
+- `input_mass_reference.json`, the build's input-mass totals and carriers at
+  its own solved weights, for the input-mass gate;
+- `reference_surface.json`, the columns it exports and the loader inputs it
+  carries, names and flags only, for the export-surface and input-coverage
+  gates.
+
+The totals are licensed-data aggregates and stay in the work directory like
+the dataset. The candidate's score against the reference is a report with no
+verdict (`score_vs_reference.json`); the certification records the reference
+it was checked against.
+
+To see what a cut would compare with now, without downloading anything:
 
 ```bash
-git worktree add --detach ../mc-0eac9bbbd 0eac9bbbd && cd ../mc-0eac9bbbd
-uv sync --all-packages --locked --extra uk        # policyengine-uk 2.89.0
-uv run --no-sync python tools/build_uk_efrs_parity_reference.py \
-  --input-h5 <enhanced_frs_2024_25.h5 @ a9e52499> --emit-weighted-totals <outside the repo>.json
+uv run --no-sync python tools/resolve_uk_reference.py --release microcosm-uk-2024-25-national --check
 ```
 
-The hosted copy's receipt records this recipe.
+`--re-resolve-reference` sets a cut's reference aside (as
+`reference.superseded-<time>`) and resolves the current build again; the
+score and the certification then run again against it.
+
+It refuses to move to the cut's own candidate, which becomes the current build
+once the cut is promoted. A build withdrawn after the fetch stops the certify
+and publish steps, even once the cut is certified, and `status` says so; the
+cut keeps its record until `--re-resolve-reference` moves it, which certifies
+the cut again.
+
+A line with no current build (a new line, or one whose only current build
+was withdrawn, `current: null`) refuses at the reference step. Pin one of its
+listed builds instead, with `--reference-build <build>` here or `--build` on
+`tools/resolve_uk_reference.py`. A pinned build passes the same certification
+checks as the current one and is refused if withdrawn. The record and the
+certification mark it `pinned`. A cut that already compares with another
+build keeps it unless `--re-resolve-reference` is given too. The release ids
+and the registry year are code constants, so the next FRS year needs a code
+change.
+
+Every check compares a cut with the build before it, so the certification
+also records the change since a fixed baseline:
+- each input column's total as a ratio of the baseline's;
+- each column that has left that chain, with why and its last ratio;
+- the inputs the baseline carried;
+- which of those this build no longer carries.
+
+The chain starts at the build each line compared with first (for the national
+line, eeb6093e). Each cut continues its reference's record, multiplying in
+the ratios its own input-mass gate measures, so no baseline dataset is ever
+loaded. It continues from the reference's certification kept beside it, which
+a resumed cut keeps again if the copy is missing.
+
+A column leaves the chain when it is absent on a side, when the reference's
+total is zero, or when one or two source households carry it on a side (its
+figures are withheld). It stays listed in every later certification, with the
+reason and the last ratio the chain recorded for it. A national chain that
+starts at any build but eeb6093e (a pinned build certified before the record
+began, say) has restarted, and the certification records `restarted_from`.
+The record carries no verdict. The dense line's published evidence carries
+none of these gates, so its chain restarts at each reference.
 
 ## Signing keys
 
diff --git a/docs/uk-dense-release-assembly-runbook-762.md b/docs/uk-dense-release-assembly-runbook-762.md
index 5ef6bb8fea..9d436dbd81 100644
--- a/docs/uk-dense-release-assembly-runbook-762.md
+++ b/docs/uk-dense-release-assembly-runbook-762.md
@@ -47,12 +47,26 @@ the gates stood on. See [Optional diagnostics](#optional-diagnostics-microcosm13
 - Optionally, the incumbent extraction
   (`tools/extract_uk_local_incumbent_surface.py`), only for the opt-in
   incumbent comparison.
-- The licensed input-mass reference the national line keeps with its runs
-  (`--input-mass-reference`). `uk_input_mass_parity` is release-blocking on
-  this line too and records `evidence_absent` without it. The sidecar's totals
-  digest must match the registry's `totals_sha256`; the totals depend on the
-  installed policyengine-uk, so re-emitting them under a newer engine does not
-  reproduce the pinned file.
+- The reference: the current build of the dense line, as `releases.json` in
+  `policyengine/populace-uk-private` names it (microcosm#1095). Resolve it
+  once, into a directory the run keeps:
+
+  ```bash
+  uv run --no-sync python tools/resolve_uk_reference.py \
+    --release microcosm-uk-2024-25-dense --output-dir <reference-dir>
+  ```
+
+  This refuses a build that is withdrawn or has a failed gate in its
+  `gate_summary.json`, and writes the dataset, its record (`reference.json`),
+  `input_mass_reference.json` (its input-mass totals and carriers at its own
+  solved weights, licensed-data aggregates that stay with the run) and
+  `reference_surface.json` (the columns it exports and the inputs it carries,
+  names and flags only). The build takes the last two
+  (`--input-mass-reference`, `--reference-surface`): `uk_input_mass_parity`,
+  `uk_export_surface` and `uk_release_input_coverage` are release-blocking on
+  this line too and record `evidence_absent` without them, and the build
+  refuses the two files if they name different builds. Until microcosm#1095
+  the dense line was held to the enhanced FRS's input totals and inputs.
 
 ## 1. Pre-flight the environment
 
@@ -73,7 +87,8 @@ uv run --no-sync python tools/build_uk_full.py --release-role dense \
   --ladder build/uk/uk_oa_ladder_2021.npz --ladder-sha256 <ladder> \
   --ledger-facts <chronicle-uk-artifact-dir> --ledger-facts-sha256 <facts> \
   --ledger-manifest-sha256 <manifest> --seed 42 \
-  --input-mass-reference <licensed-input-mass-reference> \
+  --input-mass-reference <reference-dir>/input_mass_reference.json \
+  --reference-surface <reference-dir>/reference_surface.json \
   --review-date <YYYY-MM-DD> --graph-store <graph-store-dir> \
   --logbook-prev-row-digest <previous row> --out <candidate-dir>
 ```
@@ -458,7 +473,7 @@ records a `rotated_holdout` limitation with `claim: report_only` and the
 coverage's `holdout` block (`run: true`); without it, `no_out_of_sample_claim`
 and `holdout: {run: false, claim: none}`.
 
-**Incumbent comparison.** Score the candidate, then measure the pinned
+**Incumbent comparison.** This local score still compares with the uk-data incumbent's area weights: it is a different comparison from the gates' reference build (microcosm#1095), and that change leaves it as it was. Score the candidate, then measure the pinned
 incumbent surface:
 
 ```bash
diff --git a/docs/uk-full-build-graph.md b/docs/uk-full-build-graph.md
index 9011ce1476..f8d0ff0ebe 100644
--- a/docs/uk-full-build-graph.md
+++ b/docs/uk-full-build-graph.md
@@ -20,7 +20,7 @@ uv run --no-sync python tools/build_uk_full.py --release-role dense \
   --out /data/uk/full-build
 ```
 
-`--release-role` is required. The dense role supplies every unset solve default from the local doctrine (epochs, learning rate, seed, K, weight rule, constituency vintage, selection) and refuses the national role's flags (`--target-loss-cap`, `--allow-unpinned-feed`, `--incumbent-h5` and `--incumbent-sha256`). `--ladder` with `--ladder-sha256` is required by the dense role, `--input-sha256` by every `--input-h5` build, and the three Ledger arguments (`--ledger-facts`, `--ledger-facts-sha256`, `--ledger-manifest-sha256`) by every build. The supplied hashes must agree with the committed Chronicle pins: a target-scope filter does not authorise a different source, and the dense role has no unpinned-feed override.
+`--release-role` is required. The dense role supplies every unset solve default from the local doctrine (epochs, learning rate, seed, K, weight rule, constituency vintage, selection) and refuses the national role's flags (`--target-loss-cap`, `--allow-unpinned-feed`, `--reference-h5` and `--reference-record`). `--ladder` with `--ladder-sha256` is required by the dense role, `--input-sha256` by every `--input-h5` build, and the three Ledger arguments (`--ledger-facts`, `--ledger-facts-sha256`, `--ledger-manifest-sha256`) by every build. The supplied hashes must agree with the committed Chronicle pins: a target-scope filter does not authorise a different source, and the dense role has no unpinned-feed override.
 
 The three atomic-area supports are the artifacts pinned in `uk/uk_atomic_area_supports.provenance.json` and `uk/spec/sources.yaml` (built by `tools/build_uk_atomic_area_supports.py` from the published ONS, NRS and NISRA lookups; publisher registration PolicyEngine/chronicle#269). `--geography-assignment atomic` is the default and requires all three; `--atomic-support-sha256-{ew,scotland,ni}` pin them like `--ladder-sha256`, and a release candidate requires all four pins. `--geography-assignment legacy` keeps the previous sequential ladder draw for measurement builds, takes no supports, and is refused by `--release-candidate`.
 
@@ -65,7 +65,7 @@ For smaller outputs, add `--dataset-households 150000` to use the common informe
 
 ## The national role
 
-`--release-role national` builds the certified national line on the same graph. The driver parses and validates it with the same posture-aware validator (the national role refuses the dense role's arguments, `--release-candidate` among them, and requires a bound `--input-h5` with `--input-sha256`; a `--spine-request` is refused because the national line solves a pinned checkpoint as bound) and composes the national graph (`uk_runtime.graph_national`): `uk.full.spine_checkpoint` admits the bound checkpoint, `uk.full.national_targets` compiles the national register from the pinned Chronicle artifact (measure exclusions, band edges, the frozen-register check, the feed pin with `--allow-unpinned-feed`; no ladder, no local surface), `uk.full.national_problem` refuses non-finite inputs, resolves the engine measures on the bound frame, materialises the register and encodes one ordered problem with the national doctrine's `family_equal` loss weights, mass reason and bounds in its bindings, `uk.full.dense` and `uk.full.calibrated` are the shared calibration nodes under the doctrine's epochs, learning rate and seed (the dense node's admission is the bound spine's provenance artifact rather than a preflight battery, because the national line runs no pre-solve battery: its source and reference gates are the release-cut certifier's), and `uk.full.gates.calibrated` evaluates the seven `UK_CALIBRATION_GATE_SCOPE` gates on the calibrated population. The driver then materialises the seam-shaped evidence from the stored artifacts: the diagnostics through the seam writer with the build block (the digest measured from the file), the target-support sidecars, the calibration-seam battery replayed from the stored phase report and signed (`GateBatteryRun.record_phase`), `microcosm_uk_2024_25.h5`, a graph readback of the written H5 (`uk.full.national.readback`), the schema-1 `build_record.json` that `tools/certify_uk_release_cut.py` certifies, the frozen `national_target_registry.json` and `national_contract_registry.json`, and the schema-4 `rowwise_candidate_manifest.json` (`uk_runtime.national_role`). The Logbook row is on the seam's `uk-frs-calibration` pipeline with the seam's attempt id; staging telemetry, the staged bundle and the end-of-build incumbent evaluation follow the dense role's switches. A blocked battery leaves the report on disk (`blocked_at_phase: "terminal"`), writes no H5 and records a failed row. The [national calibration runbook](uk-national-calibration-runbook-623.md) and the [national release assembly runbook](uk-national-release-assembly-runbook-806.md) describe the outputs. The in-process calibration seam (`run_uk_calibration`, `UKNationalCalibrationStage`) is retired; its contracts (gate scopes, sidecar authentication, provenance blocks, scoped signing) stay in `uk_runtime.calibration_run`. Parity with the seam is a solved question of construction (the same register, the same matrix row for row, the same solver under the same doctrine and seed, the same mass record) checked on the licensed spine.
+`--release-role national` builds the certified national line on the same graph. The driver parses and validates it with the same posture-aware validator (the national role refuses the dense role's arguments, `--release-candidate` among them, and requires a bound `--input-h5` with `--input-sha256`; a `--spine-request` is refused because the national line solves a pinned checkpoint as bound) and composes the national graph (`uk_runtime.graph_national`): `uk.full.spine_checkpoint` admits the bound checkpoint, `uk.full.national_targets` compiles the national register from the pinned Chronicle artifact (measure exclusions, band edges, the frozen-register check, the feed pin with `--allow-unpinned-feed`; no ladder, no local surface), `uk.full.national_problem` refuses non-finite inputs, resolves the engine measures on the bound frame, materialises the register and encodes one ordered problem with the national doctrine's `family_equal` loss weights, mass reason and bounds in its bindings, `uk.full.dense` and `uk.full.calibrated` are the shared calibration nodes under the doctrine's epochs, learning rate and seed (the dense node's admission is the bound spine's provenance artifact rather than a preflight battery, because the national line runs no pre-solve battery: its source and reference gates are the release-cut certifier's), and `uk.full.gates.calibrated` evaluates the seven `UK_CALIBRATION_GATE_SCOPE` gates on the calibrated population. The driver then materialises the seam-shaped evidence from the stored artifacts: the diagnostics through the seam writer with the build block (the digest measured from the file), the target-support sidecars, the calibration-seam battery replayed from the stored phase report and signed (`GateBatteryRun.record_phase`), `microcosm_uk_2024_25.h5`, a graph readback of the written H5 (`uk.full.national.readback`), the schema-1 `build_record.json` that `tools/certify_uk_release_cut.py` certifies, the frozen `national_target_registry.json` and `national_contract_registry.json`, and the schema-4 `rowwise_candidate_manifest.json` (`uk_runtime.national_role`). The Logbook row is on the seam's `uk-frs-calibration` pipeline with the seam's attempt id; staging telemetry, the staged bundle and the end-of-build comparison with the reference (the current national build, microcosm#1095) follow the dense role's switches. A blocked battery leaves the report on disk (`blocked_at_phase: "terminal"`), writes no H5 and records a failed row. The [national calibration runbook](uk-national-calibration-runbook-623.md) and the [national release assembly runbook](uk-national-release-assembly-runbook-806.md) describe the outputs. The in-process calibration seam (`run_uk_calibration`, `UKNationalCalibrationStage`) is retired; its contracts (gate scopes, sidecar authentication, provenance blocks, scoped signing) stay in `uk_runtime.calibration_run`. Parity with the seam is a solved question of construction (the same register, the same matrix row for row, the same solver under the same doctrine and seed, the same mass record) checked on the licensed spine.
 
 ## Graph owners and shared contracts
 
diff --git a/docs/uk-national-calibration-runbook-623.md b/docs/uk-national-calibration-runbook-623.md
index d11d01f85f..1d49053349 100644
--- a/docs/uk-national-calibration-runbook-623.md
+++ b/docs/uk-national-calibration-runbook-623.md
@@ -11,7 +11,7 @@ Run only after one of these is true:
 - Maria explicitly names a different base spine for this run.
 
 The input posture is a non-certified staging candidate at pre-clone grain,
-matching the incumbent published national surface. The seam records that
+matching the published national surface. The seam records that
 posture itself and marks its artifact `shippable: false`: release certification
 is the release-cut producer's job, not calibration's.
 
@@ -91,40 +91,56 @@ Signing the terminal gate report needs
 
 ## Scoring
 
-Rule 1 is decided by a separate tool run against the staged artifact, so run
-identity never depends on the incumbent's bytes:
+The candidate is compared with the current build of the national line, the
+cut's reference (microcosm#1095; `tools/resolve_uk_reference.py` resolves it
+and writes its record). The comparison is a separate tool run against the
+staged artifact, so run identity never depends on the reference's bytes:
 
 ```bash
 uv run --no-sync python tools/score_uk_national_candidate.py \
   --candidate-h5 data/ukds/acceptance/623-first-calibrated-candidate/microcosm_uk_2024_25.h5 \
   --candidate-sha256 <sha256-from-the-build-record> \
-  --incumbent-h5 <enhanced-frs-2024-25-h5> \
-  --incumbent-sha256 <sha256> \
+  --reference-h5 <reference-dir>/microcosm_uk_2024_25.h5 \
+  --reference-record <reference-dir>/reference.json \
   --registry-json data/ukds/acceptance/623-first-calibrated-candidate/national_target_registry.json \
-  --output-json data/ukds/acceptance/623-first-calibrated-candidate/score_vs_enhanced_frs.json
+  --output-json data/ukds/acceptance/623-first-calibrated-candidate/score_vs_reference.json
 ```
 
-Both artifacts are verified against the supplied digests before they are read,
-and both sides are scored on the same frozen register.
+Both artifacts are verified against their digests before they are read, and
+both sides are scored on the same frozen register.
 
-A target whose measure the incumbent cannot materialize (the admin-basis UC
-family measures, the CGT asset type, the ONS household type: inputs the
-enhanced FRS never carried) is pruned from **both** arms and reported, never
+A target whose measure the reference cannot materialize (an input a newer
+build added, for example) is pruned from **both** arms and reported, never
 refused: the scorer warns on stderr naming every absent measure and the rows
 it removed, and the receipt carries them under
-`incumbent_unresolvable_pruned` (`n_pruned`, `n_scored`, `n_surface`,
-`pruned_targets` with each one's family and measure, `measures`, `families`). The score stands on the common surface
-with band edges from the full register (#803). A measure the *candidate*
-cannot materialize still refuses: that is a defect.
-`--no-prune-incumbent-unresolvable` restores the refusal on the incumbent A measure may be pruned only under a signed, in-force entry of the reviewed incumbent-unresolvable register (`packages/microcosm-build/src/microcosm/build/uk/incumbent_unresolvable_measures.json`, keyed `entity.variable`, reviewed-exclusion schema); an unlisted measure refuses the evaluation, the receipt records the register digest and the entries used, and the certifier re-checks every pruned measure against the committed register, including each entry's window at the certification's own evaluation date. The candidate is validated on the full surface before any pruning, so an export missing a listed measure refuses rather than scoring on a reduced surface.
-side too. The receipt's `evaluation` block decides rule 1 (#578) on that
-surface: `verdict` is `passed` when the candidate's full loss is below the
-incumbent's, `failed` otherwise, and the release-cut certifier refuses any
-receipt whose verdict is not `passed` or whose surface does not close, so
-publication never runs on an unpassed evaluation. The build driver's
-national role runs this evaluation at the end of every build it is given an
-incumbent for (microcosm#965) and writes the same receipt as
-`score_vs_incumbent.json`.
+`reference_unresolvable_pruned` (`n_pruned`, `n_scored`, `n_surface`,
+`pruned_targets` with each one's family and measure, `measures`, `families`).
+The comparison stands on the common surface with band edges from the full
+register (#803). A measure the *candidate* cannot materialize still refuses:
+that is a defect. `--no-prune-reference-unresolvable` restores the refusal on
+the reference side too.
+
+A measure may be pruned only under a signed, in-force entry for this
+reference in the reviewed register
+(`packages/microcosm-build/src/microcosm/build/uk/reference_unresolvable_measures.json`,
+keyed by the reference's `<release>@<build>` label, then `entity.variable`,
+reviewed-exclusion schema). An unlisted measure refuses the comparison; the
+receipt records the register digest and the entries used, and the certifier
+re-checks every pruned measure against the committed register, including
+each entry's window at the certification's own evaluation date. The
+candidate is validated on the full surface before any pruning, so an export
+missing a listed measure refuses rather than scoring on a reduced surface.
+
+The receipt is a report with no verdict: its `evaluation` block records each
+side's loss and how many targets each fits more closely, with
+`no_threshold_applied`. The release-cut certifier requires it to name the
+candidate and the cut's reference and its surface to close; whether the
+comparison is good enough is the owner's call. The build driver's national
+role runs this comparison at the end of every build it is given a
+`--reference-h5` and `--reference-record` for, and writes the same receipt
+as `score_vs_reference.json`. Until microcosm#1095 the comparison was with
+the enhanced FRS and decided rule 1 (#578): the candidate's full loss had to
+be below the incumbent's.
 
 ## Evidence directory
 
@@ -137,13 +153,13 @@ incumbent for (microcosm#965) and writes the same receipt as
 - `national_target_registry.json`
 - `national_contract_registry.json`
 - `rowwise_candidate_manifest.json`
-- `score_vs_incumbent.json` (the build's own when run with `--incumbent-h5`;
-  the manifest's `evaluation` block records its verdict)
+- `score_vs_reference.json` (the build's own when run with `--reference-h5`;
+  the manifest's `evaluation` block summarizes it)
 - `logbook-spool/` (one row for the attempt, whatever its disposition)
 
-Acceptance follows #578: the candidate must not regress incumbent battery
-observables, and the score block decides rule 1. A rule-1 loss is evidence for
-#686/#736, not a threshold-edit instruction.
+The comparison with the reference informs acceptance and decides nothing
+by itself (microcosm#1095). A candidate that fits worse than the reference is
+evidence for #686/#736, not a threshold-edit instruction.
 
 The calibration battery is scoped to the calibration-relevant gates; the
 spine-construction and imputation gates are out of scope here and are listed in
diff --git a/docs/uk-national-release-assembly-runbook-806.md b/docs/uk-national-release-assembly-runbook-806.md
index c126956929..32786cc2a4 100644
--- a/docs/uk-national-release-assembly-runbook-806.md
+++ b/docs/uk-national-release-assembly-runbook-806.md
@@ -33,8 +33,26 @@ dashboard announces new and current builds, comparing `releases.json` before
 and after each change.
 
 Keep the spine H5, its sibling `.build.json` and `.spine_gates.json`, the
-Ledger consumer artifact and manifest digest, and the licensed input-mass
-reference together through the run.
+Ledger consumer artifact and manifest digest, and the cut's reference
+directory together through the run.
+
+## 0. Resolve the reference
+
+The cut compares with the current build of the national line, as
+`releases.json` in `policyengine/populace-uk-private` names it
+(microcosm#1095). Resolve it once, into a directory the run keeps:
+
+```bash
+uv run --no-sync python tools/resolve_uk_reference.py \
+  --release microcosm-uk-2024-25-national --output-dir <reference-dir>
+```
+
+This refuses a build that is withdrawn or not certified shippable, and
+writes the dataset, `reference.json` (its record), `input_mass_reference.json`
+(its input-mass totals and carriers, licensed-data aggregates that stay with
+the run) and `reference_surface.json` (the columns it exports and the inputs
+it carries, names and flags only). `tools/run_uk_cut.py` does this itself as
+its `reference` step.
 
 ## 1. Calibrate the national candidate
 
@@ -50,22 +68,26 @@ uv run --no-sync python tools/build_uk_full.py --release-role national \
   --ledger-facts <ledger-consumer-facts> \
   --ledger-facts-sha256 <ledger-facts-sha256> \
   --ledger-manifest-sha256 <ledger-manifest-sha256> \
-  --incumbent-h5 <incumbent-h5> \
-  --incumbent-sha256 <incumbent-h5-sha256> \
+  --reference-h5 <reference-dir>/microcosm_uk_2024_25.h5 \
+  --reference-record <reference-dir>/reference.json \
   --out <candidate-dir>
 ```
 
-`--incumbent-h5` (with its digest; `--incumbent-label` names it, default
-`enhanced_frs_2024_25`) makes the build evaluate the finished candidate
-against the incumbent after the bundle is staged: `score_vs_incumbent.json`
-lands beside the outputs with the rule-1 verdict, rows the incumbent cannot
-materialize are pruned from both arms and named on stderr, the receipt rides
-the staging telemetry as `artifacts/score_vs_incumbent.json`, and the manifest
-records `evaluation` (`status`, `verdict`, `rule_1`, `scored_surface`,
-`pruned_measures`). The evaluation never blocks the build: an error is
+`--reference-h5` with `--reference-record` makes the build compare the
+finished candidate with the reference after the bundle is staged:
+`score_vs_reference.json` lands beside the outputs. It is a report with no
+verdict: each side's loss on the targets both can materialize and how many
+targets each fits more closely, with `no_threshold_applied`. Rows the
+reference cannot materialize are pruned from both arms and named on stderr;
+a pruned measure needs an entry for this reference in
+`uk/reference_unresolvable_measures.json`. The receipt rides the staging
+telemetry as `artifacts/score_vs_reference.json`, and the manifest records
+`evaluation` (`status`, `reference`, `losses`, `targets`, `scored_surface`,
+`pruned_measures`). The comparison never blocks the build: an error is
 recorded as `status: error` and warned. Without the flags the manifest says
 `not_requested`, and the certifier has no receipt to read until the candidate
-is scored by hand.
+is scored with `tools/score_uk_national_candidate.py`, given `--reference-h5`
+and `--reference-record`.
 
 The role's doctrine is the campaign posture (1,500 epochs, `family_equal`,
 learning rate 0.02, seed 0): a certified cut passes no solve flags and records
@@ -81,14 +103,15 @@ name in both release manifests and in its folder on the Hub.
 
 ## 2. Score and certify the cut
 
-The rule-1 score receipt is the build's own when the national role was given
-`--incumbent-h5` (`score_vs_incumbent.json` beside the candidate); otherwise
-create it against the pinned incumbent following the scoring section of
-`docs/uk-national-calibration-runbook-623.md`. Its `evaluation.verdict` must
-be `passed`: the certifier refuses a receipt whose verdict is anything else,
-whose scored surface does not close over its pruned rows, or which carries no
-evaluation block. Then run the release-cut battery and compose the signed
-certification:
+The score receipt is the build's own when the national role was given
+`--reference-h5` (`score_vs_reference.json` beside the candidate); otherwise
+create it with `tools/score_uk_national_candidate.py`, given `--reference-h5
+<reference-dir>/microcosm_uk_2024_25.h5` and `--reference-record
+<reference-dir>/reference.json`. The certifier reads no verdict from it: it
+refuses a receipt that names another candidate or another reference than the
+cut's, whose scored surface does not close over its pruned rows, or which
+carries no evaluation block. Then run the release-cut battery and compose the
+signed certification:
 
 ```bash
 uv run --no-sync python tools/certify_uk_release_cut.py \
@@ -103,11 +126,25 @@ uv run --no-sync python tools/certify_uk_release_cut.py \
   --ledger-facts <ledger-consumer-facts> \
   --ledger-facts-sha256 <ledger-facts-sha256> \
   --ledger-manifest-sha256 <ledger-manifest-sha256> \
-  --input-mass-reference <licensed-input-mass-reference> \
-  --score-receipt <candidate-dir>/score_vs_incumbent.json \
+  --input-mass-reference <reference-dir>/input_mass_reference.json \
+  --reference-surface <reference-dir>/reference_surface.json \
+  --score-receipt <candidate-dir>/score_vs_reference.json \
+  --reference-record <reference-dir>/reference.json \
   --release-id microcosm-uk-2024-25-national
 ```
 
+The input-mass, export-surface and input-coverage gates compare the candidate
+with the reference: its totals within the relative tolerance gates.json
+declares, no column losing more than its declared share of the reference's
+total (`maximum_relative_drop`), and each line's reviewed exclusions keyed
+`<release>@<build>`; its exported columns (a column only the candidate
+exports must be a declared extra, an entry the reference now carries is
+reported as redundant), and the inputs it carries (each must reach the
+candidate's export with signal, less the coverage manifest's reviewed
+exclusions). The certifier refuses an input-mass reference or a surface that
+names another build than `--reference-record`, and the certification records
+the reference in its `reference` block.
+
 The spine is stage evidence for the family build-state gates, so `--spine-sha256` must be the parent the calibration recorded (`build_record.input_posture.sha256`, `source_pins.input_h5.sha256`, the signed diagnostics' `build.input_posture`); a spine that pins correctly but is not that parent is refused before any gate runs, and the certification records it as `parent_spine`.
 
 With the default paths, this writes
@@ -118,12 +155,13 @@ only when the certification says `shippable: true`.
 **Interim check until microcosm#1276 lands.** microcosm#1281 removed the QRF
 tail-concentration gate, and nothing release-blocking yet checks the SPI
 stage-1 columns (`hmrc_spi_*` and the other stage-1 outputs). Before assembly,
-measure the candidate and the currently promoted cut together:
+measure the candidate and the reference (the currently promoted cut)
+together:
 
 ```bash
 uv run --no-sync python tools/measure_uk_weighted_integrity_baselines.py \
   --h5 candidate=<candidate-dir>/microcosm_uk_2024_25.h5 \
-  --h5 previous=<promoted-cut-h5> \
+  --h5 previous=<reference-dir>/microcosm_uk_2024_25.h5 \
   --output <candidate-dir>/stage1_comparison.json
 ```
 
@@ -150,7 +188,7 @@ uv run --no-sync python tools/assemble_uk_release_dir.py \
   --diagnostics-json <candidate-dir>/calibration_diagnostics.json \
   --seam-gate-report <candidate-dir>/microcosm_uk_2024_25.terminal_gates.json \
   --release-cut-gate-json <candidate-dir>/microcosm_uk_2024_25.release_cut_gates.json \
-  --score-receipt <candidate-dir>/score_vs_incumbent.json \
+  --score-receipt <candidate-dir>/score_vs_reference.json \
   --out-dir releases
 ```
 
diff --git a/docs/uk-staging-operations.md b/docs/uk-staging-operations.md
index 0296a94707..0e3db7f6da 100644
--- a/docs/uk-staging-operations.md
+++ b/docs/uk-staging-operations.md
@@ -302,13 +302,14 @@ manifest the command prints. The telemetry run declares two reviewed
 artifacts, `artifacts/staged_dataset.json` (the same block) and
 `artifacts/fit_summary.json` (loss, fit by family, gate verdicts, the size
 receipt without its per-row arrays), so a run in the dashboard points at its
-bundle. A national run given `--incumbent-h5` adds a third,
-`artifacts/score_vs_incumbent.json`: the rule-1 score receipt against the
-incumbent on the surface both can materialize, produced after the bundle is
-staged and before the telemetry completes, with the rows the incumbent cannot
-materialize pruned from both arms and listed; the manifest's `evaluation`
-block records its verdict, and the release-cut certifier requires that
-verdict to be `passed`.
+bundle. A national run given `--reference-h5` and `--reference-record` adds a
+third, `artifacts/score_vs_reference.json`: its comparison with the current
+national build (microcosm#1095) on the surface both can materialize, produced
+after the bundle is staged and before the telemetry completes, with the rows
+the reference cannot materialize pruned from both arms and listed. It is a
+report with no verdict; the manifest's `evaluation` block summarizes it, and
+the release-cut certifier requires the receipt to name the candidate and the
+cut's reference.
 
 Re-stage a finished directory, including runs built before this lane existed,
 runs that kept their bundle local, and runs whose upload failed or was still
diff --git a/packages/microcosm-build/README.md b/packages/microcosm-build/README.md
index dcc65be05d..ce42357a75 100644
--- a/packages/microcosm-build/README.md
+++ b/packages/microcosm-build/README.md
@@ -5,8 +5,9 @@ The build end of the microcosm stack: typed stage plans over
 names its donor survey and fails loudly — no silent fallbacks), and the
 **dataset acceptance gates** every release must pass before publishing:
 
-- **parity** — every variable layer the incumbent populates, the candidate
-  populates (no all-zero gaps on engine-known inputs);
+- **parity** — every variable layer the reference populates, the candidate
+  populates (no all-zero gaps on engine-known inputs; for UK, the reference
+  is the current build of the cut's own line, microcosm#1095);
 - **support** — every imputed value lies inside its donor's realized range;
 - **aggregate-vs-admin** — weighted aggregates land within declared tolerance
   of administrative anchors from the
@@ -15,8 +16,8 @@ names its donor survey and fails loudly — no silent fallbacks), and the
   short-term capital gains to −$3.9T);
 - **export surface** — every replacement artifact can prove that its
   exported variables match a reference surface, with only documented
-  structural extras or reviewed exclusions (for UK, this is the eFRS
-  compatibility check);
+  structural extras or reviewed exclusions (for UK, the surface of the
+  current build of the cut's own line, microcosm#1095);
 - **target surface** — the calibration target set covers the reference
   target surface and may only be wider, not narrower (for UK, Microcosm must
   calibrate to at least the eFRS target surface);
diff --git a/packages/microcosm-build/src/microcosm/build/head_to_head.py b/packages/microcosm-build/src/microcosm/build/head_to_head.py
new file mode 100644
index 0000000000..eaf954aad9
--- /dev/null
+++ b/packages/microcosm-build/src/microcosm/build/head_to_head.py
@@ -0,0 +1,253 @@
+"""Compare a candidate with a reference artifact on one scored target surface.
+
+Every country scores each artifact on one compiled target surface with
+``microcosm.calibrate``'s canonical loss (``score_targets`` /
+``relative_error_loss``). This module compares the two scored results, and
+nothing else: for each target, whose absolute relative error is lower; how
+many targets each side has lower; the loss gap; and the same counts within
+each target family. Loading and scoring stay with each country (the US
+tool's pools, household slices and by-origin battery; the UK's frame, weight
+year and engine measures).
+
+The comparison decides nothing. It is evidence for the owner's decision to
+promote a build, with no threshold applied: the US head-to-head's rule from
+its start, and the UK cut's since microcosm#1095 retired its strict rule-1
+verdict against the enhanced FRS. The US tool keeps its own payload's names
+("incumbent") for its existing scorecards; the UK receipt uses this module's
+("reference").
+"""
+
+from __future__ import annotations
+
+from collections.abc import Hashable, Mapping, Sequence
+from dataclasses import dataclass
+from typing import Any
+
+__all__ = [
+    "HEAD_TO_HEAD_SCHEMA_VERSION",
+    "LOWER_CANDIDATE",
+    "LOWER_EQUAL",
+    "LOWER_REFERENCE",
+    "HeadToHead",
+    "ScoredTarget",
+    "TargetComparison",
+    "compare_scored_targets",
+    "lower_side",
+    "scored_targets_from_mapping",
+]
+
+HEAD_TO_HEAD_SCHEMA_VERSION = 1
+LOWER_CANDIDATE = "candidate"
+LOWER_REFERENCE = "reference"
+LOWER_EQUAL = "equal"
+
+
+@dataclass(frozen=True)
+class ScoredTarget:
+    """One target's signed relative error under one artifact."""
+
+    name: str
+    relative_error: float
+    period: Hashable | None = None
+    family: str | None = None
+
+
+@dataclass(frozen=True)
+class TargetComparison:
+    """One target, scored under both artifacts."""
+
+    name: str
+    period: Hashable | None
+    family: str | None
+    candidate_relative_error: float
+    reference_relative_error: float
+    lower: str
+
+    @property
+    def candidate_absolute_relative_error(self) -> float:
+        return abs(self.candidate_relative_error)
+
+    @property
+    def reference_absolute_relative_error(self) -> float:
+        return abs(self.reference_relative_error)
+
+    def to_payload(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "period": self.period,
+            "family": self.family,
+            "candidate_relative_error": self.candidate_relative_error,
+            "reference_relative_error": self.reference_relative_error,
+            "candidate_absolute_relative_error": (
+                self.candidate_absolute_relative_error
+            ),
+            "reference_absolute_relative_error": (
+                self.reference_absolute_relative_error
+            ),
+            "candidate_minus_reference_absolute_relative_error": (
+                self.candidate_absolute_relative_error
+                - self.reference_absolute_relative_error
+            ),
+            "lower_absolute_relative_error": self.lower,
+        }
+
+
+def lower_side(candidate_error: float, reference_error: float) -> str:
+    """Which side's absolute relative error is lower; ``equal`` on a tie.
+
+    Signed errors are compared on magnitude. A comparison involving NaN is
+    neither lower, so it counts as equal, as both countries' scorers did.
+    """
+
+    candidate = abs(float(candidate_error))
+    reference = abs(float(reference_error))
+    if candidate < reference:
+        return LOWER_CANDIDATE
+    if candidate > reference:
+        return LOWER_REFERENCE
+    return LOWER_EQUAL
+
+
+def _counts(comparisons: Sequence[TargetComparison]) -> dict[str, int]:
+    counts = {LOWER_CANDIDATE: 0, LOWER_REFERENCE: 0, LOWER_EQUAL: 0}
+    for comparison in comparisons:
+        counts[comparison.lower] += 1
+    return {
+        "candidate_lower_count": counts[LOWER_CANDIDATE],
+        "reference_lower_count": counts[LOWER_REFERENCE],
+        "equal_count": counts[LOWER_EQUAL],
+    }
+
+
+@dataclass(frozen=True)
+class HeadToHead:
+    """Two artifacts compared target by target, with their losses."""
+
+    candidate_loss: float
+    reference_loss: float
+    comparisons: tuple[TargetComparison, ...]
+
+    @property
+    def counts(self) -> dict[str, int]:
+        return _counts(self.comparisons)
+
+    def counts_by_family(self) -> dict[str, dict[str, int]]:
+        """The counts within each family, families sorted; ``None`` is kept."""
+
+        grouped: dict[str | None, list[TargetComparison]] = {}
+        for comparison in self.comparisons:
+            grouped.setdefault(comparison.family, []).append(comparison)
+        return {
+            family: _counts(rows)
+            for family, rows in sorted(
+                grouped.items(), key=lambda item: (item[0] is None, item[0] or "")
+            )
+        }
+
+    def to_payload(self) -> dict[str, Any]:
+        """The versioned, country-neutral comparison block, with no verdict."""
+
+        return {
+            "schema_version": HEAD_TO_HEAD_SCHEMA_VERSION,
+            "decision": "owner_decides",
+            "no_threshold_applied": True,
+            "loss": {
+                "candidate": self.candidate_loss,
+                "reference": self.reference_loss,
+                "candidate_minus_reference": self.candidate_loss - self.reference_loss,
+            },
+            "targets": {
+                **self.counts,
+                "compared": [
+                    comparison.to_payload() for comparison in self.comparisons
+                ],
+            },
+            "by_family": self.counts_by_family(),
+        }
+
+
+def compare_scored_targets(
+    candidate: Sequence[ScoredTarget],
+    reference: Sequence[ScoredTarget],
+    *,
+    candidate_loss: float,
+    reference_loss: float,
+) -> HeadToHead:
+    """Compare two scorings of the same target surface, in candidate order.
+
+    Both sequences must name the same targets in the same order (name and
+    period). A target's family comes from the candidate's scoring, and must
+    not disagree with the reference's where both give one.
+
+    Raises:
+        ValueError: If the two scorings cover different targets.
+    """
+
+    if len(candidate) != len(reference):
+        raise ValueError(
+            "The candidate and reference scorings cover different numbers of "
+            f"targets ({len(candidate)} and {len(reference)})."
+        )
+    comparisons = []
+    for candidate_row, reference_row in zip(candidate, reference, strict=True):
+        key = (candidate_row.name, candidate_row.period)
+        reference_key = (reference_row.name, reference_row.period)
+        if key != reference_key:
+            raise ValueError(
+                f"Target comparison contracts differ: {reference_key!r} vs {key!r}."
+            )
+        if (
+            candidate_row.family is not None
+            and reference_row.family is not None
+            and candidate_row.family != reference_row.family
+        ):
+            raise ValueError(
+                f"Target {key!r} belongs to family {candidate_row.family!r} in the "
+                f"candidate's scoring but {reference_row.family!r} in the "
+                "reference's."
+            )
+        comparisons.append(
+            TargetComparison(
+                name=candidate_row.name,
+                period=candidate_row.period,
+                family=(
+                    candidate_row.family
+                    if candidate_row.family is not None
+                    else reference_row.family
+                ),
+                candidate_relative_error=float(candidate_row.relative_error),
+                reference_relative_error=float(reference_row.relative_error),
+                lower=lower_side(
+                    candidate_row.relative_error, reference_row.relative_error
+                ),
+            )
+        )
+    return HeadToHead(
+        candidate_loss=float(candidate_loss),
+        reference_loss=float(reference_loss),
+        comparisons=tuple(comparisons),
+    )
+
+
+def scored_targets_from_mapping(
+    errors: Mapping[str, float],
+    *,
+    families: Mapping[str, str] | None = None,
+    order: Sequence[str] | None = None,
+) -> list[ScoredTarget]:
+    """Scored targets from ``{name: signed relative error}``, in ``order``.
+
+    ``order`` defaults to the names sorted; every name in it must be scored.
+    """
+
+    names = sorted(errors) if order is None else list(order)
+    missing = [name for name in names if name not in errors]
+    if missing:
+        raise ValueError(f"No score for targets {missing[:10]}.")
+    families = {} if families is None else families
+    return [
+        ScoredTarget(
+            name=name, relative_error=float(errors[name]), family=families.get(name)
+        )
+        for name in names
+    ]
diff --git a/packages/microcosm-build/src/microcosm/build/uk/country_package.json b/packages/microcosm-build/src/microcosm/build/uk/country_package.json
index 14ac473a8e..7bc487061b 100644
--- a/packages/microcosm-build/src/microcosm/build/uk/country_package.json
+++ b/packages/microcosm-build/src/microcosm/build/uk/country_package.json
@@ -348,7 +348,7 @@
       "schema_id": "legacy_json"
     },
     {
-      "path": "incumbent_unresolvable_measures.json",
+      "path": "reference_unresolvable_measures.json",
       "kind": "legacy_json",
       "schema_id": "legacy_json"
     },
diff --git a/packages/microcosm-build/src/microcosm/build/uk/gates.json b/packages/microcosm-build/src/microcosm/build/uk/gates.json
index fb6f9c2436..fc6846349b 100644
--- a/packages/microcosm-build/src/microcosm/build/uk/gates.json
+++ b/packages/microcosm-build/src/microcosm/build/uk/gates.json
@@ -17,7 +17,7 @@
       "parameters": {
         "check": "manifest_current"
       },
-      "notes": "Frameless preflight mirror of the US cheap preflight: the committed coverage manifest must match the engine's current variable surface, aborting before source stages on graph or reference drift."
+      "notes": "Frameless preflight mirror of the US cheap preflight: the committed coverage manifest must agree with its sources (the effective-mass policy, the candidate and family tiers, the stage-family contracts and their source hashes, the restored inputs) and its declared columns must be live PolicyEngine-UK loader inputs, aborting before source stages. The required inputs come from the cut's reference build at gate time (microcosm#1095), so it no longer holds the manifest to the frozen enhanced-FRS surface."
     },
     {
       "id": "uk_release_family_build_stages",
@@ -1125,7 +1125,7 @@
       "phase": "terminal",
       "criticality": "release_blocking",
       "parameters": {},
-      "notes": "The release input-coverage contract over the built frame: required columns present and populated per the committed manifest resource in this package."
+      "notes": "Every loader input the current build of the cut's line carries must be present on the release export and carry non-default signal on the reviewed share of effective population mass, less the manifest's reviewed exclusions; the reference carries an input by this gate's own rule, as the cut's reference step records in its reference surface (microcosm#1095). The stage families' build state is checked on the spine."
     },
     {
       "id": "uk_degenerate_release_surface",
@@ -1299,268 +1299,48 @@
       "criticality": "release_blocking",
       "parameters": {
         "allowed_extra_columns": [
-          "benunit.child_benefit_opts_out",
-          "benunit.frs_benunit_capital",
-          "benunit.has_mixed_age_couple_pension_credit_saving",
-          "benunit.liable_for_share_of_household_rent",
-          "benunit.pension_credit_reported_capital",
-          "benunit.uc_deduction_combination",
-          "benunit.uc_deduction_random_draw",
-          "benunit.uc_deduction_type_random_draw",
-          "benunit.uc_latent_deduction_rate",
-          "benunit.uc_reported_capital",
-          "benunit.would_claim_uc_at_legacy_closure",
-          "benunit.would_claim_uc_childcare",
-          "household.additional_residential_property_purchased",
           "household.atomic_area_basis",
           "household.atomic_area_code",
           "household.atomic_area_system",
-          "household.bus_fare_spending",
-          "household.bus_subsidy_spending",
           "household.cash_isa",
-          "household.cgt_support_copies",
-          "household.cgt_support_copy_index",
-          "household.high_value_support_copies",
-          "household.high_value_support_copy_index",
-          "household.household_is_high_value_support_copy",
-          "household.household_is_cgt_residential_clone",
-          "household.cgt_residential_clone_index",
           "household.household_clone_index",
           "household.constituency_code_oa",
-          "household.consumer_debt",
           "household.data_zone_code",
           "household.district_electoral_area_code",
-          "household.electricity_consumption",
-          "household.electricity_kwh",
-          "household.gas_consumption",
-          "household.gas_kwh",
           "household.geography_household_key",
-          "household.has_fuel_consumption",
-          "household.uses_energy_prepayment_meter",
-          "household.beer_litres",
-          "household.cider_litres",
-          "household.wine_litres",
-          "household.spirits_litres",
-          "household.other_fermented_litres",
-          "household.beer_draught_share",
-          "household.cider_draught_share",
-          "household.cigarettes_per_week",
-          "household.hand_rolling_tobacco_grams_per_week",
-          "household.cigars_grams_per_week",
-          "household.other_tobacco_grams_per_week",
-          "household.remote_gaming_net_losses",
-          "household.pool_betting_net_receipts",
-          "household.bingo_net_receipts",
-          "household.national_lottery_ticket_spending",
-          "household.land_based_casino_net_losses",
-          "household.machine_games_lower_rate_net_takings",
-          "household.machine_games_standard_rate_net_takings",
-          "household.machine_games_higher_rate_net_takings",
-          "household.land_based_fixed_odds_betting_net_losses",
-          "household.remote_uk_horseracing_betting_net_losses",
-          "household.remote_other_betting_net_losses",
-          "household.betting_exchange_commission",
-          "household.horse_and_dog_pool_betting_net_losses",
-          "household.household_is_capital_gains_clone",
-          "household.household_is_cgt_support_copy",
-          "household.household_is_spi_income_band_donor",
-          "household.household_is_spi_synthetic",
-          "household.household_lifetime_isa_balance",
-          "household.household_local_bus_trips",
           "household.in_rural_fuel_duty_relief_area",
-          "household.spi_income_band_donor_lower_bound",
           "household.intermediate_zone_code",
           "household.la_code_oa",
           "household.local_authority",
           "household.lsoa_code",
-          "household.mortgage_debt",
           "household.msoa_code",
-          "household.non_residential_property_purchased",
-          "household.num_vehicles",
           "household.oa_code",
-          "household.ons_household_type",
           "household.output_area_code",
-          "household.private_pension_wealth",
-          "household.property_purchased",
-          "household.rail_usage",
           "household.region_code_oa",
           "household.stocks_and_shares_isa",
           "household.super_data_zone_code",
-          "person.a_and_e_visits",
-          "person.aa_category",
-          "person.admitted_patient_visits",
-          "person.age_left_full_time_education",
-          "person.age_started_or_accepted_current_education_or_training",
-          "person.attends_private_school",
-          "person.attends_private_school_random_draw",
-          "person.capital_gains_asset_type",
-          "person.capital_gains_badr",
-          "person.capital_gains_residential_property",
-          "person.cgt_residential_probability",
-          "person.bus_in_london_trips",
-          "person.bus_pass_eligible",
-          "person.care_hours",
-          "person.charitable_investment_gifts",
-          "person.dla_m_category",
-          "person.dla_sc_category",
-          "person.employment_sector",
-          "person.contributory_benefits_annual_share",
-          "person.employment_income_annual_share",
-          "person.employment_income_other_spells",
-          "person.private_pension_income_annual_share",
-          "person.self_employment_income_annual_share",
-          "person.self_employment_income_other_spells",
-          "person.trading_allowance_claim_status",
-          "person.trading_allowance_full_relief",
-          "person.annuity_and_trust_income",
-          "person.esa_health_condition_proxy",
-          "person.esa_includes_support_component",
-          "person.esa_support_group_proxy",
-          "person.gift_aid",
-          "person.has_lifetime_isa",
-          "person.highest_education",
-          "person.is_before_universal_credit_qualifying_young_person_terminal_date",
-          "person.is_blind",
-          "person.is_claimant_or_partner",
-          "person.is_engaged_in_owned_company_trade",
-          "person.is_hbai_dependent_child",
-          "person.is_in_full_time_education",
-          "person.is_in_non_advanced_education",
-          "person.is_parent",
-          "person.is_uc_claimant",
-          "person.legacy_jobseeker_proxy",
-          "person.lifetime_isa_balance",
-          "person.lifetime_isa_payments",
-          "person.cash_isa_balance",
-          "person.stocks_and_shares_isa_balance",
-          "person.cash_isa_subscriptions",
-          "person.stocks_and_shares_isa_subscriptions",
-          "person.company_car_list_price",
-          "person.company_car_co2_emissions",
-          "person.company_car_fuel_type",
-          "person.company_car_electric_range",
-          "person.company_car_capital_contributions",
-          "person.company_car_private_fuel_provided",
-          "person.car_fuel_type",
-          "person.car_co2_emissions",
-          "person.car_engine_size",
-          "person.car_first_registration_date",
-          "person.car_is_ved_exempt",
-          "person.individual_savings_account_interest_income",
-          "person.local_bus_single_fare_share",
-          "person.local_bus_trips",
-          "person.local_bus_use_band",
-          "person.loss_relief",
-          "person.ni_class_4_losses_brought_forward",
-          "person.ons_family_index",
-          "person.ons_family_role",
-          "person.other_local_bus_trips",
-          "person.outpatient_visits",
-          "person.owned_company_carries_on_property_business",
-          "person.owned_company_carries_on_trade",
-          "person.owned_company_income_share",
-          "person.owned_company_is_main_employment",
-          "person.pension_contributions_via_salary_sacrifice",
-          "person.pip_dl_points",
-          "person.pip_m_points",
-          "person.property_finance_costs",
-          "person.property_rental_income",
-          "person.receives_benefits_in_own_right",
-          "person.rent_paid_as_boarder",
-          "person.rent_paid_as_lodger",
-          "person.relationship_to_head",
-          "person.reports_outstanding_student_loan",
-          "person.salary_sacrifice_asked",
-          "person.salary_sacrifice_reported",
-          "person.sic_industry_division",
-          "person.soc2020_major_group",
-          "person.soc2020_sub_major_group",
-          "person.stands_as_sole_owner_or_partner_of_company",
-          "person.statutory_paternity_pay",
-          "person.student_loan_balance",
-          "person.student_loan_plan",
-          "person.tax_free_childcare_spend_routed_share",
-          "person.is_apprentice",
-          "person.trading_loss",
-          "person.uc_is_in_startup_period",
-          "person.uc_is_in_gainful_self_employment",
-          "person.uc_limited_capability_for_WRA",
-          "person.uc_limited_capability_for_work",
-          "person.is_looked_after_by_local_authority",
-          "person.child_limit_non_parental_caring_exception",
-          "person.would_claim_carers_allowance",
-          "person.would_claim_marriage_allowance",
-          "person.would_claim_scp",
-          "person.max_free_entitlement_hours_used",
-          "person.person_is_spi_income_band_carrier",
-          "person.person_is_spi_income_recipient",
-          "benunit.benunit_source_id",
-          "benunit.benunit_support_channel",
-          "benunit.benunit_support_clone_index",
-          "benunit.dependent_children",
-          "household.council_tax_rebate",
-          "household.council_tax_reported",
-          "household.council_tax_single_adult_raw",
-          "household.household_source_id",
-          "household.household_support_channel",
-          "household.household_support_clone_index",
-          "household.num_bedrooms",
-          "household.source_household_id",
-          "household.source_household_key",
-          "household.source_year",
-          "household.subrent",
-          "person.disabled_students_allowance_eligible_expenses",
-          "person.free_school_breakfasts",
-          "person.hmrc_spi_assessable_income",
-          "person.hmrc_spi_employed_income",
-          "person.hmrc_spi_employment_benefits",
-          "person.hmrc_spi_employment_expenses",
-          "person.hmrc_spi_incapacity_benefit_income",
-          "person.hmrc_spi_miscellaneous_employment_income",
-          "person.hmrc_spi_other_income",
-          "person.hmrc_spi_other_social_security_income",
-          "person.hmrc_spi_pay",
-          "person.hmrc_spi_state_pension_income",
-          "person.hmrc_spi_taxable_termination_pay",
-          "person.hmrc_spi_total_earned_income",
-          "person.hmrc_spi_total_investment_income",
-          "person.hmrc_spi_unemployment_benefit_income",
-          "person.is_in_approved_training",
-          "person.ossben_identifiable_subset",
-          "person.other_investment_income",
-          "person.person_source_id",
-          "person.person_support_channel",
-          "person.person_support_clone_index",
-          "person.srp_regular_code5",
           "benunit.benunit_clone_index",
           "person.person_clone_index",
-          "benunit.benunit_build_id",
-          "household.household_build_id",
-          "person.person_build_id",
-          "person.months_since_last_birthday",
           "household.itl1_code",
           "household.itl2_code",
           "household.itl3_code",
           "household.ward_code",
-          "person.war_widows_pension_reported",
-          "person.widowed_parents_allowance_reported",
-          "person.spousal_maintenance_income",
-          "person.pension_contributions_via_bonus_sacrifice",
-          "household.liquid_fuel_consumption",
-          "household.solid_fuel_consumption",
-          "household.directly_held_shares",
-          "household.unit_and_investment_trusts",
-          "household.other_residential_property_secured_debt",
-          "household.non_residential_property_secured_debt"
+          "person.pip_dl_points",
+          "person.pip_m_points",
+          "person.trading_allowance_claim_status",
+          "person.trading_allowance_full_relief",
+          "person.uc_limited_capability_for_WRA",
+          "person.uc_limited_capability_for_work"
         ],
         "reviewed_exclusions": {
           "household.property_wealth": "policyengine-uk derives property_wealth from main_residence_value, other_residential_property_value and non_residential_property_value; a persisted copy overrides that sum and has no uprating index, so the candidate must drop it (microcosm#1106, the uk-data#543 defect).",
           "person.pip_dl_category": "policyengine-uk derives pip_dl_category from pip_dl_points (8 points for the standard rate, 12 for the enhanced) where no category is supplied for the year; a persisted category would override the points in every projected year, so the candidate carries the points the pip_points stage draws within the stored award and drops the category (microcosm#1095, P1; María's signature of 2026-11-09).",
           "person.pip_m_category": "policyengine-uk derives pip_m_category from pip_m_points (8 points for the standard rate, 12 for the enhanced) where no category is supplied for the year; a persisted category would override the points in every projected year, so the candidate carries the points the pip_points stage draws within the stored award and drops the category (microcosm#1095, P1; María's signature of 2026-11-09).",
+          "person.self_employment_gross_receipts": "microcosm#1550 (microcosm#1439) stops writing self_employment_gross_receipts: the trading allowance stage stores each trader's trading_allowance_claim_status and leaves gross receipts at the engine's zero, since neither the FRS nor the SPI records them. The current builds (national eeb6093e, dense 38605444) still export the receipts encoding microcosm#1428 wrote, so the candidate drops the column against them; the entry leaves once a promotion moves the reference past it (microcosm#1095; María's signature of 2026-11-10).",
           "person.tax_free_savings_income": "policyengine-uk derives tax_free_savings_income as the sum of the ISA interest it adds (individual_savings_account_interest_income); a persisted copy overrides that sum and is never uprated, so the candidate stores ISA interest apart from non-ISA interest under the additive ISA income contract and drops it (microcosm#1360)."
         }
       },
-      "notes": "Reviewed candidate-only fields from the June UK prototype (source provenance or genuine additional model inputs, not incumbent-surface losses), with household.uses_energy_prepayment_meter added for microcosm#1110 (the LCFS prepayment-meter flag policyengine-uk reads from 2.123.3 for the Energy Price Guarantee prepayment discount; an older engine ignores it, and the incumbent does not carry it until uk-data#539), the LCFS excise step's 24 household inputs added for microcosm#1359 (alcohol litres and the beer and cider draught shares, tobacco a week and the gambling duty bases; policyengine-uk reads the alcohol and tobacco ones from 2.145.0 and the gambling ones from 2.151.0, an older engine ignores them, and the incumbent carries none) plus the reviewed reference-side exclusions of the formula-owned property_wealth total (microcosm#1106) and the formula-owned tax_free_savings_income total, whose ISA interest the candidate stores apart under the additive ISA income contract (microcosm#1360). The all-zero incapacity benefit layer left the exclusions (microcosm#1095, from #796): the pinned reference lists it among its zero-share inputs, not on its export surface, so its exclusion never matched; the release boundary still drops the column, and this gate would refuse it as an unlisted extra. The two hard-required columns that may never be waived stay a code-level guard, per the microcosm#327 rule that a parity comparison's registers are declared inputs. During the migration window the runtime merges the exclusion register with the legacy constant and the spec-pin tests hold the two equal; the register becomes solely load-bearing when the constant retires."
+      "notes": "The candidate's export surface against the current build of the cut's own line (microcosm#1095), whose exported columns the cut's reference step records: a column the reference exports must be exported or be a reviewed drop, and a column only the candidate exports must be declared here. The list holds only what the current national build does not export: the dense line's geography and clone columns, which its own reference carries, and columns new since the reference, each naming its PR. An entry the reference now carries is reported as redundant, never failed. The reviewed exclusions are columns a candidate must never export, since a persisted copy overrides the engine's formula. Until microcosm#1095 the reference was the enhanced FRS's 145 inputs, beside 250 declared extras."
     },
     {
       "id": "uk_take_up_signal",
@@ -1824,24 +1604,19 @@
       "phase": "terminal",
       "criticality": "release_blocking",
       "parameters": {
-        "reference": "efrs-post-calibration",
+        "reference": "current_build",
         "reference_registry": {
-          "efrs-post-calibration": {
-            "identity": {
-              "filename": "enhanced_frs_2024_25.h5",
-              "revision": "a9e52499b6a6cca100a5ce4f36ca27b2e8a213df",
-              "sha256": "e433e532b17bd8ce76030156285816e33d44e93edabd2204adbef71d19a68712",
-              "vintage": "2024_25"
-            },
-            "totals_sha256": "fd41cb5f6cf6c4ef812320f21d1942173d49ce6f8725b21fbc9d9ca5423d298c",
-            "scope_note": "Channel-blind post-calibration enhanced-FRS production incumbent, pinned to the 2024-25 line; its artifact carries the SPI-synthetic rows structurally but no admin-restored mass in the SPI-channel-exclusive columns, so those columns are comparable only through per-reference reviewed exclusions."
+          "current_build": {
+            "kind": "current_build",
+            "scope_note": "The current build of the cut's own release line, as releases.json named it when the cut fetched its inputs (microcosm#1095): totals at each build's own solved weights, on the export surface."
           }
         },
-        "relative_tolerance": 4.521811483823806,
+        "relative_tolerance": 5.9984285545209834,
         "minimum_reference_total": 0.0,
+        "maximum_relative_drop": 0.9,
         "reviewed_exclusions_resource": "input_mass_reviewed_exclusions.json"
       },
-      "notes": "Weighted input-mass parity against the active named reference in the registry, with reviewed exclusions scoped per reference so a channel-blind reference exclusion does not suppress comparison against a future channel-aware reference. The tolerance is the worst surviving measured drift at the reviewed floor, exact, with no headroom; the reviewed per-reference exclusions (charitable_investment_gifts, signed at +15,168.8% on the post-#710 surface; owned_land, signed for seed variance) were retired on 2026-09-22 when the first release-cut certification measured both inside the fence (-99.0% and -73.5% against the enhanced FRS reference, microcosm#967); the register is empty and the gate's current failures are the two genuine breaches it names. The 0.0 floor excludes only arithmetically meaningless zero-mass denominators. Totals stay uncommitted under the UKDS licence, supplied per-run and pinned by totals_sha256; missing sidecar evidence records evidence_absent. Totals keys are flat frame column names since the #611 A4 dedup; that digest re-freeze was keys-only against the #610 values (identity unchanged, values byte-identical). Sensitivity floor, recorded rather than silent (microcosm#706 review): the tolerance is the worst surviving measured drift, and that edge is currently set by a column whose deviation is explained (vintage plus SPI composition, microcosm#703's head-to-head receipt), so at this value the gate is a gross mass-loss/explosion fence rather than a regression detector — the compared population sits at median 0.24 and p90 0.63. Tightening runs through this register: each explained top drift that earns a receipt lets the tolerance re-mint at the worst unexplained survivor, with the full distribution and the exclusions-versus-tolerance tradeoff in experiments/630-uk-gate-adjudication-receipts.md."
+      "notes": "Weighted input-mass parity against the current build of the cut's own line (microcosm#1095, replacing the enhanced-FRS reference): the national line against the national current build, the dense line against the dense one. The spec names the reference kind, not a file; each report records the build it compared with, its identity and the totals digest. A zeroed or missing column fails at any tolerance, the #278 signature. The tolerance is the exact maximum drift between the consecutive promoted national cuts a6299504 and eeb6093e over the 259 columns carried by at least three distinct source households, with no headroom (median 0.020, p90 0.22, p99 1.06; none zeroed or dropped), signed by María on 2026-11-10; it ratchets down as each newly certified pair is measured, the release-arm method of weighted_integrity.py. The tolerance is symmetric, so above one it fails no drop short of zero: maximum_relative_drop bounds the share of its reference total a column may lose, 0.9, the same pair's largest drop (0.8831 of its reference total) rounded up for headroom (María, 2026-11-10). Reviewed exclusions are signed for one reference build and go dormant once a promotion moves the reference past it. A column one or two source households carry on either side is checked but its figures are withheld from the report. The totals are licensed-data aggregates written beside the cut's reference, never committed; missing evidence records evidence_absent. The 0.0 floor excludes only arithmetically meaningless zero-mass denominators."
     },
     {
       "id": "uk_local_geography_ladder_post_calibration",
diff --git a/packages/microcosm-build/src/microcosm/build/uk/incumbent_unresolvable_measures.json b/packages/microcosm-build/src/microcosm/build/uk/incumbent_unresolvable_measures.json
deleted file mode 100644
index 24d86ee4e8..0000000000
--- a/packages/microcosm-build/src/microcosm/build/uk/incumbent_unresolvable_measures.json
+++ /dev/null
@@ -1,69 +0,0 @@
-{
-  "schema_version": 2,
-  "description": "Measures the incumbent comparison artifact (the enhanced FRS) is known not to carry, keyed entity.variable. A target bound through a listed measure may be pruned from BOTH arms of the rule-1 evaluation (microcosm#578 rule 1 on the common surface, microcosm#823); an unlisted unresolvable measure refuses the evaluation rather than pruning. Every entry is a complete approval receipt in the reviewed-exclusion schema, in force from approved_on through expires_on.",
-  "exclusions": {
-    "benunit.uc_calibration_administrative_family_type": {
-      "reason": "Administrative-basis UC family type (microcosm#832/#835/#937): derived from the relationship-to-head reconstruction (microcosm#791) the enhanced FRS never carried; 93 dwp_universal_credit rows bind through it.",
-      "approved_by": "juaristi22",
-      "adjudication": "microcosm#823 (rule-1 evaluation on the common surface; microcosm#578)",
-      "approved_on": "2026-09-22",
-      "expires_on": "2026-12-22"
-    },
-    "benunit.uc_calibration_child_count": {
-      "reason": "Administrative-basis UC dependent-child count (microcosm#832/#835/#937): the same relationship-to-head derivation (microcosm#791) the enhanced FRS never carried.",
-      "approved_by": "juaristi22",
-      "adjudication": "microcosm#823 (rule-1 evaluation on the common surface; microcosm#578)",
-      "approved_on": "2026-09-22",
-      "expires_on": "2026-12-22"
-    },
-    "benunit.uc_calibration_has_child_under_one": {
-      "reason": "Administrative-basis UC child-under-one flag (microcosm#832/#835/#937): the same relationship-to-head derivation (microcosm#791) the enhanced FRS never carried.",
-      "approved_by": "juaristi22",
-      "adjudication": "microcosm#823 (rule-1 evaluation on the common surface; microcosm#578)",
-      "approved_on": "2026-09-22",
-      "expires_on": "2026-12-22"
-    },
-    "benunit.uc_tcl_affected_benunit_proxy": {
-      "reason": "Two-child-limit affected-benunit proxy (microcosm#840): a counterfactual the enhanced FRS carries no inputs for; 15 dwp_two_child_limit rows bind through it.",
-      "approved_by": "juaristi22",
-      "adjudication": "microcosm#823 (rule-1 evaluation on the common surface; microcosm#578)",
-      "approved_on": "2026-09-22",
-      "expires_on": "2026-12-22"
-    },
-    "household.bus_in_london_boardings": {
-      "reason": "NTS bus-travel stage (microcosm#930): the enhanced FRS carries no bus travel, so it cannot materialize household boardings on London buses; the dft.bus_journeys London row (microcosm#1207, bound since microcosm#1286) binds through it.",
-      "approved_by": "juaristi22",
-      "adjudication": "microcosm#823 (rule-1 evaluation on the common surface; microcosm#578); the bus journeys family was bound after the incumbent pin (microcosm#1286).",
-      "approved_on": "2026-10-19",
-      "expires_on": "2027-01-19"
-    },
-    "household.ons_household_type": {
-      "reason": "ONS census household type (microcosm#887): the enhanced FRS carries no household-type classification; 10 ons_household_composition rows bind through it.",
-      "approved_by": "juaristi22",
-      "adjudication": "microcosm#823 (rule-1 evaluation on the common surface; microcosm#578)",
-      "approved_on": "2026-09-22",
-      "expires_on": "2026-12-22"
-    },
-    "household.other_local_bus_boardings": {
-      "reason": "NTS bus-travel stage (microcosm#930): the enhanced FRS carries no bus travel, so it cannot materialize household boardings on local buses outside London; the 8 dft.bus_journeys rows for the English regions outside London (microcosm#1207, bound since microcosm#1286) bind through it.",
-      "approved_by": "juaristi22",
-      "adjudication": "microcosm#823 (rule-1 evaluation on the common surface; microcosm#578); the bus journeys family was bound after the incumbent pin (microcosm#1286).",
-      "approved_on": "2026-10-19",
-      "expires_on": "2027-01-19"
-    },
-    "person.capital_gains_asset_type": {
-      "reason": "CGT asset type (microcosm#939, the E8 spine stage): the enhanced FRS carries gains amounts only; 2 hmrc_cgt rows bind through it.",
-      "approved_by": "juaristi22",
-      "adjudication": "microcosm#823 (rule-1 evaluation on the common surface; microcosm#578)",
-      "approved_on": "2026-09-22",
-      "expires_on": "2026-12-22"
-    },
-    "person.trading_allowance_full_relief": {
-      "reason": "Trading allowance claim status (microcosm#1439, the trading_allowance_receipts spine stage): the enhanced FRS leaves the claim status at the engine's UNKNOWN and carries no full-relief group; 5 hmrc_spi rows bind through it: self-employment income amounts and counts by total income band and by self-employment income band, and employment income counts by self-employment income band.",
-      "approved_by": "juaristi22",
-      "adjudication": "microcosm#823 (rule-1 evaluation on the common surface; microcosm#578); the SPI rows read the carrier since microcosm#1439, after the incumbent pin.",
-      "approved_on": "2026-11-10",
-      "expires_on": "2027-02-10"
-    }
-  }
-}
diff --git a/packages/microcosm-build/src/microcosm/build/uk/input_mass_reviewed_exclusions.json b/packages/microcosm-build/src/microcosm/build/uk/input_mass_reviewed_exclusions.json
index b1511d68ed..939c422526 100644
--- a/packages/microcosm-build/src/microcosm/build/uk/input_mass_reviewed_exclusions.json
+++ b/packages/microcosm-build/src/microcosm/build/uk/input_mass_reviewed_exclusions.json
@@ -1,29 +1,30 @@
 {
- "schema_version": 3,
- "description": "Reviewed input-mass parity exclusions for the UK terminal battery, scoped per named comparison reference (microcosm#630): an exclusion suppresses only when its reference is the armed one, so a column excluded on a channel-blind reference is compared normally against a channel-aware one with no register change. Each entry is a complete approval receipt (schema-2 fields per #610). The gate reports dormant entries, FAILS stale ones, and FAILS expired ones until the adjudication is renewed, so this register cannot rot.",
- "references": {
-  "efrs-post-calibration": {
-   "dfe_education_spending": {
-    "reason": "The candidate carries DfE education spending through the build (GBP 98.8bn against the incumbent's GBP 52.8m, +187,061%): the enhanced-FRS reference carries almost none of this input, so the comparison measures the reference's omission, not the candidate's. The input stays on the release surface and in the coverage manifest.",
-    "approved_by": "juaristi22",
-    "adjudication": "microcosm#1063 c9 (certifier rehearsal R5 on the 2026-09-30 build, 2026-10-01; ruling 2026-10-02 in session)",
-    "approved_on": "2026-10-02",
-    "expires_on": "2027-04-02"
-   },
-   "property_wealth": {
-    "reason": "The candidate no longer ships household.property_wealth: policyengine-uk derives it as the sum of main_residence_value, other_residential_property_value and non_residential_property_value, and a persisted copy overrides that sum and has no uprating index (microcosm#1106, the uk-data#543 defect). The enhanced-FRS reference stores its own WAS total, so the column is present in the reference and absent from the candidate, which this gate otherwise fails whatever the tolerance. The gate compares the release surface (the export frame, reviewed exclusions dropped) on both paths, the national seam and the release cut; the three components stay compared.",
-    "approved_by": "juaristi22",
-    "adjudication": "microcosm#1106 (#1145): part B measured on the A9 candidate at 2025 and on the final-head arm c7 of 2026-10-11; ruling 2026-10-11 in session",
-    "approved_on": "2026-10-11",
-    "expires_on": "2027-04-11"
-   },
-   "tax_free_savings_income": {
-    "reason": "The candidate no longer ships person.tax_free_savings_income: policyengine-uk derives it as the sum of individual_savings_account_interest_income, which the candidate stores apart from non-ISA interest under the additive ISA income contract, and a persisted copy overrides that sum and is never uprated (microcosm#1360). The enhanced-FRS reference stores it in the legacy gross layout, so the column is present in the reference and absent from the candidate, which this gate otherwise fails whatever the tolerance. Non-ISA savings_interest_income stays compared; it falls below the reference's gross total by the ISA part.",
-    "approved_by": "juaristi22",
-    "adjudication": "microcosm#1360 folded into microcosm#1418's PR B (ruling 2026-10-28 in session)",
-    "approved_on": "2026-10-28",
-    "expires_on": "2027-04-28"
-   }
+  "schema_version": 3,
+  "description": "Reviewed input-mass parity exclusions for the UK battery, scoped per reference build (microcosm#1095): each key is the <release>@<build> a cut compared with, and an exclusion suppresses only while that build is the cut's reference, so a promotion leaves it dormant. Each entry is a complete approval receipt (schema-2 fields per #610). The gate reports dormant entries, FAILS stale ones, and FAILS expired ones until the adjudication is renewed. The enhanced-FRS reference's three entries retired with it.",
+  "references": {
+    "microcosm-uk-2024-25-dense@uk-local-candidate-f100-s42-20261107T173210Z-38605444": {
+      "self_employment_gross_receipts": {
+        "reason": "microcosm#1550 (microcosm#1439) stops writing self_employment_gross_receipts: the trading allowance stage stores each trader's claim status and leaves gross receipts at the engine's zero, since neither the FRS nor the SPI records them. This build still carries the receipts encoding microcosm#1428 wrote, so a candidate built after microcosm#1550 carries none of that mass by design.",
+        "approved_by": "juaristi22",
+        "adjudication": "microcosm#1095: María's ruling in session, 2026-11-10, on the PR that compares UK cuts with the current build of their line",
+        "approved_on": "2026-11-10",
+        "expires_on": "2027-05-10",
+        "release_lines": [
+          "local"
+        ]
+      }
+    },
+    "microcosm-uk-2024-25-national@uk-frs-calibration-attempt-20261107T020434Z-eeb6093e": {
+      "self_employment_gross_receipts": {
+        "reason": "microcosm#1550 (microcosm#1439) stops writing self_employment_gross_receipts: the trading allowance stage stores each trader's claim status and leaves gross receipts at the engine's zero, since neither the FRS nor the SPI records them. This build still carries the receipts encoding microcosm#1428 wrote, so a candidate built after microcosm#1550 carries none of that mass by design.",
+        "approved_by": "juaristi22",
+        "adjudication": "microcosm#1095: María's ruling in session, 2026-11-10, on the PR that compares UK cuts with the current build of their line",
+        "approved_on": "2026-11-10",
+        "expires_on": "2027-05-10",
+        "release_lines": [
+          "national"
+        ]
+      }
+    }
   }
- }
 }
diff --git a/packages/microcosm-build/src/microcosm/build/uk/reference_unresolvable_measures.json b/packages/microcosm-build/src/microcosm/build/uk/reference_unresolvable_measures.json
new file mode 100644
index 0000000000..9267fc365f
--- /dev/null
+++ b/packages/microcosm-build/src/microcosm/build/uk/reference_unresolvable_measures.json
@@ -0,0 +1,15 @@
+{
+  "schema_version": 3,
+  "description": "Measures a reference build is known not to carry, scoped per reference (microcosm#1095): each key is a reference's <release>@<build>, and each entry under it, keyed entity.variable, lets a target bound through that measure be pruned from BOTH arms of the head-to-head comparison on the common surface (microcosm#823). An unlisted unresolvable measure refuses the comparison rather than pruning. Entries under a build that is no longer the cut's reference are dormant. Every entry is a complete approval receipt in the reviewed-exclusion schema, in force from approved_on through expires_on.",
+  "references": {
+    "microcosm-uk-2024-25-national@uk-frs-calibration-attempt-20261107T020434Z-eeb6093e": {
+      "person.trading_allowance_full_relief": {
+        "reason": "Trading allowance full-relief carrier (microcosm#1439, the trading_allowance_receipts spine stage): this build exports neither trading_allowance_claim_status nor the full-relief carrier, both new since it (microcosm#1550), and policyengine-uk 2.177.7 does not define the carrier; 5 hmrc_spi rows filter on it: self-employment income amounts and counts by total income band and by self-employment income band, and employment income counts by self-employment income band.",
+        "approved_by": "juaristi22",
+        "adjudication": "microcosm#823 (rule-1 evaluation on the common surface; microcosm#578), carried to the current-build reference by microcosm#1095: María's ruling in session, 2026-11-11, on the PR that compares UK cuts with the current build of their line, after microcosm#1572 signed the same measure on the enhanced FRS.",
+        "approved_on": "2026-11-11",
+        "expires_on": "2027-02-11"
+      }
+    }
+  }
+}
diff --git a/packages/microcosm-build/src/microcosm/build/uk/release_input_coverage_manifest.json b/packages/microcosm-build/src/microcosm/build/uk/release_input_coverage_manifest.json
index a48c20e803..e787c342dd 100644
--- a/packages/microcosm-build/src/microcosm/build/uk/release_input_coverage_manifest.json
+++ b/packages/microcosm-build/src/microcosm/build/uk/release_input_coverage_manifest.json
@@ -8,309 +8,6 @@
   "tier": "frs"
  },
  "columns": {
-  "a_and_e_visits": {
-   "status": "required"
-  },
-  "aa_category": {
-   "status": "required"
-  },
-  "access_fund": {
-   "status": "required"
-  },
-  "accommodation_type": {
-   "status": "required"
-  },
-  "admitted_patient_visits": {
-   "status": "required"
-  },
-  "adult_ema": {
-   "status": "required"
-  },
-  "afcs_reported": {
-   "status": "required"
-  },
-  "age": {
-   "status": "required"
-  },
-  "age_started_or_accepted_current_education_or_training": {
-   "status": "required"
-  },
-  "alcohol_and_tobacco_consumption": {
-   "status": "required"
-  },
-  "attends_private_school_random_draw": {
-   "status": "required"
-  },
-  "brma": {
-   "status": "required"
-  },
-  "bsp_reported": {
-   "status": "required"
-  },
-  "bus_subsidy_spending": {
-   "status": "required"
-  },
-  "capital_gains": {
-   "status": "required"
-  },
-  "carers_allowance_reported": {
-   "status": "required"
-  },
-  "charitable_investment_gifts": {
-   "status": "required"
-  },
-  "child_benefit_opts_out": {
-   "status": "required"
-  },
-  "child_benefit_reported": {
-   "status": "required"
-  },
-  "child_ema": {
-   "status": "required"
-  },
-  "child_tax_credit_reported": {
-   "status": "required"
-  },
-  "childcare_expenses": {
-   "status": "required"
-  },
-  "clothing_and_footwear_consumption": {
-   "status": "required"
-  },
-  "communication_consumption": {
-   "status": "required"
-  },
-  "corporate_wealth": {
-   "status": "required"
-  },
-  "council_tax": {
-   "status": "required"
-  },
-  "council_tax_band": {
-   "status": "required"
-  },
-  "council_tax_benefit_reported": {
-   "status": "required"
-  },
-  "current_education": {
-   "status": "required"
-  },
-  "dfe_education_spending": {
-   "status": "required"
-  },
-  "diesel_spending": {
-   "status": "required"
-  },
-  "dividend_income": {
-   "status": "required"
-  },
-  "dla_m_category": {
-   "status": "required"
-  },
-  "dla_sc_category": {
-   "status": "required"
-  },
-  "domestic_energy_consumption": {
-   "status": "required"
-  },
-  "domestic_rates": {
-   "status": "required"
-  },
-  "education_consumption": {
-   "status": "required"
-  },
-  "education_grants": {
-   "status": "required"
-  },
-  "electricity_consumption": {
-   "status": "required"
-  },
-  "employee_pension_contributions": {
-   "status": "required"
-  },
-  "employer_pension_contributions": {
-   "status": "required"
-  },
-  "employment_income": {
-   "status": "required"
-  },
-  "employment_status": {
-   "status": "required"
-  },
-  "esa_contrib_reported": {
-   "status": "required"
-  },
-  "esa_income_reported": {
-   "status": "required"
-  },
-  "external_child_payments": {
-   "status": "required"
-  },
-  "food_and_non_alcoholic_beverages_consumption": {
-   "status": "required"
-  },
-  "free_school_fruit_veg": {
-   "status": "required"
-  },
-  "free_school_meals": {
-   "status": "required"
-  },
-  "full_rate_vat_expenditure_rate": {
-   "status": "required"
-  },
-  "gas_consumption": {
-   "status": "required"
-  },
-  "gender": {
-   "status": "required"
-  },
-  "gift_aid": {
-   "status": "required"
-  },
-  "gross_financial_wealth": {
-   "status": "required"
-  },
-  "health_consumption": {
-   "status": "required"
-  },
-  "healthy_start_vouchers": {
-   "status": "required"
-  },
-  "highest_education": {
-   "status": "required"
-  },
-  "hours_worked": {
-   "status": "required"
-  },
-  "household_furnishings_consumption": {
-   "status": "required"
-  },
-  "household_owns_tv": {
-   "status": "required"
-  },
-  "household_weight": {
-   "status": "required"
-  },
-  "housing_benefit_reported": {
-   "status": "required"
-  },
-  "housing_service_charges": {
-   "status": "required"
-  },
-  "housing_water_and_electricity_consumption": {
-   "status": "required"
-  },
-  "iidb_reported": {
-   "status": "required"
-  },
-  "income_support_reported": {
-   "status": "required"
-  },
-  "is_before_universal_credit_qualifying_young_person_terminal_date": {
-   "status": "required"
-  },
-  "is_benunit_head": {
-   "status": "required"
-  },
-  "is_disabled_for_benefits": {
-   "status": "required"
-  },
-  "is_enhanced_disabled_for_benefits": {
-   "status": "required"
-  },
-  "is_household_head": {
-   "status": "required"
-  },
-  "is_in_non_advanced_education": {
-   "status": "required"
-  },
-  "is_married": {
-   "status": "required"
-  },
-  "is_parent": {
-   "status": "required"
-  },
-  "is_severely_disabled_for_benefits": {
-   "status": "required"
-  },
-  "jsa_contrib_reported": {
-   "status": "required"
-  },
-  "jsa_income_reported": {
-   "status": "required"
-  },
-  "lump_sum_income": {
-   "status": "required"
-  },
-  "main_residence_value": {
-   "status": "required"
-  },
-  "main_residential_property_purchased_is_first_home": {
-   "status": "required"
-  },
-  "maintenance_expenses": {
-   "status": "required"
-  },
-  "maintenance_income": {
-   "status": "required"
-  },
-  "marital_status": {
-   "status": "required"
-  },
-  "maximum_extended_childcare_hours_usage": {
-   "status": "required"
-  },
-  "miscellaneous_consumption": {
-   "status": "required"
-  },
-  "miscellaneous_income": {
-   "status": "required"
-  },
-  "mortgage_capital_repayment": {
-   "status": "required"
-  },
-  "mortgage_interest_repayment": {
-   "status": "required"
-  },
-  "net_financial_wealth": {
-   "status": "required"
-  },
-  "nhs_a_and_e_spending": {
-   "status": "required"
-  },
-  "nhs_admitted_patient_spending": {
-   "status": "required"
-  },
-  "nhs_outpatient_spending": {
-   "status": "required"
-  },
-  "non_residential_property_value": {
-   "status": "required"
-  },
-  "num_vehicles": {
-   "status": "required"
-  },
-  "other_residential_property_value": {
-   "status": "required"
-  },
-  "outpatient_visits": {
-   "status": "required"
-  },
-  "owned_land": {
-   "status": "required"
-  },
-  "pension_contributions_via_salary_sacrifice": {
-   "status": "required"
-  },
-  "pension_credit_reported": {
-   "status": "required"
-  },
-  "personal_pension_contributions": {
-   "status": "required"
-  },
-  "petrol_spending": {
-   "status": "required"
-  },
   "pip_dl_category": {
    "reason": "formula-owned in policyengine-uk and derived from persisted components; a persisted copy overrides the formula and is not uprated",
    "status": "reviewed_exclusion",
@@ -321,144 +18,27 @@
    "status": "reviewed_exclusion",
    "tracking_note": "microcosm#1095 (P1 of the November event-data plan): policyengine-uk 2.177.7 derives pip_m_category from pip_m_points (8 points for the standard rate, 12 for the enhanced) where no category is supplied for the year; the pip_points stage stores the points within the stored award, and the release and calibration boundaries drop the category, which the spine keeps (María's signature of 2026-11-09)."
   },
-  "private_pension_income": {
-   "status": "required"
-  },
-  "private_transfer_income": {
-   "status": "required"
-  },
-  "property_income": {
-   "status": "required"
-  },
-  "property_purchased": {
-   "status": "required"
-  },
   "property_wealth": {
    "reason": "formula-owned in policyengine-uk and derived from persisted components; a persisted copy overrides the formula and is not uprated",
    "status": "reviewed_exclusion",
    "tracking_note": "microcosm#1106 (the uk-data#543 defect): the release and calibration boundaries drop the WAS total, and policyengine-uk sums main_residence_value, other_residential_property_value and non_residential_property_value, which stay required."
   },
-  "rail_subsidy_spending": {
-   "status": "required"
-  },
-  "rail_usage": {
-   "status": "required"
-  },
-  "receives_benefits_in_own_right": {
-   "status": "required"
-  },
-  "recreation_consumption": {
-   "status": "required"
-  },
-  "region": {
-   "status": "required"
-  },
-  "rent": {
-   "status": "required"
-  },
-  "restaurants_and_hotels_consumption": {
-   "status": "required"
-  },
-  "savings": {
-   "status": "required"
-  },
-  "savings_interest_income": {
-   "status": "required"
-  },
-  "sda_reported": {
-   "status": "required"
-  },
-  "self_employment_income": {
-   "status": "required"
-  },
-  "ssmg_reported": {
-   "status": "required"
-  },
-  "state_pension_reported": {
-   "status": "required"
-  },
-  "statutory_maternity_pay": {
-   "status": "required"
-  },
-  "statutory_sick_pay": {
-   "status": "required"
-  },
-  "structural_insurance_payments": {
-   "status": "required"
-  },
-  "student_loan_balance": {
-   "status": "required"
-  },
-  "student_loan_plan": {
-   "status": "required"
-  },
-  "student_loan_repayments": {
-   "status": "required"
-  },
-  "student_loans": {
-   "status": "required"
+  "self_employment_gross_receipts": {
+   "reason": "microcosm#1550 (microcosm#1439) stops writing it: the trading allowance stage stores each trader's trading_allowance_claim_status and leaves gross receipts at the engine's zero, since neither the FRS nor the SPI records them. The current builds (national eeb6093e, dense 38605444) still carry the receipts encoding microcosm#1428 wrote (María's signature of 2026-11-10).",
+   "status": "reviewed_exclusion",
+   "tracking_note": "microcosm#1095: remove once neither line's current build carries it."
   },
   "tax_free_savings_income": {
    "reason": "formula-owned in policyengine-uk and derived from persisted components; a persisted copy overrides the formula and is not uprated",
    "status": "reviewed_exclusion",
    "tracking_note": "microcosm#1360: under the additive ISA income contract the producer stores ISA interest in individual_savings_account_interest_income, which policyengine-uk adds into tax_free_savings_income; savings_interest_income, now interest outside ISAs, stays required."
-  },
-  "tenure_type": {
-   "status": "required"
-  },
-  "transport_consumption": {
-   "status": "required"
-  },
-  "universal_credit_reported": {
-   "status": "required"
-  },
-  "water_and_sewerage_charges": {
-   "status": "required"
-  },
-  "winter_fuel_allowance_reported": {
-   "status": "required"
-  },
-  "working_tax_credit_reported": {
-   "status": "required"
-  },
-  "would_claim_child_benefit": {
-   "status": "required"
-  },
-  "would_claim_extended_childcare": {
-   "status": "required"
-  },
-  "would_claim_marriage_allowance": {
-   "status": "required"
-  },
-  "would_claim_pc": {
-   "status": "required"
-  },
-  "would_claim_scp": {
-   "status": "required"
-  },
-  "would_claim_targeted_childcare": {
-   "status": "required"
-  },
-  "would_claim_tfc": {
-   "status": "required"
-  },
-  "would_claim_uc": {
-   "status": "required"
-  },
-  "would_claim_universal_childcare": {
-   "status": "required"
-  },
-  "would_evade_tv_licence_fee": {
-   "status": "required"
   }
  },
  "counts": {
-  "required": 141,
-  "reviewed_exclusion": 4,
-  "total": 145
+  "reviewed_exclusion": 5
  },
- "derivation": "Surface = efrs_parity_reference.json populated effective loader inputs. status='required' when the sha-pinned candidate evidence records non-default signal on at least the reviewed owning-entity effective-mass share OR the column is pinned in restored_required_columns after a source-family restoration; all remaining surface columns are reviewed_exclusion with reason 'not yet ported from enhanced FRS pipeline — pending review' and a UK_COVERAGE_PROGRESS.md tracking note, except the engine_derived_exclusions, which are reviewed_exclusion with their own reason because the engine computes them from persisted inputs. The final release gate applies the same effective-mass floor, and distributional restorations must pass it on their required source channel.",
- "description": "Declared full-coverage contract for a UK release: every populated effective loader input in the pinned enhanced FRS must be persisted with non-default signal, or carry a reviewed exclusion with the campaign reason and tracking note.",
+ "derivation": "Columns = the reviewed exclusions of efrs_parity_known_gaps.json: its known gaps, with reason 'not yet ported from enhanced FRS pipeline — pending review' and a UK_COVERAGE_PROGRESS.md tracking note, and its engine_derived_exclusions, with their own reason because the engine computes them from persisted inputs; and the inputs the current builds carry that a later build stops carrying on purpose, each a signed ruling until a promotion moves the reference past it. Every other input the cut's reference build carries is required. The gate applies one effective-mass floor to the reference and the candidate, and distributional restorations must pass it on their required source channel.",
+ "description": "Release input-coverage contract for a UK cut: every loader input the current build of the cut's line carries must be persisted with non-default signal on the reviewed share of effective population mass, unless it carries a reviewed exclusion here with its reason and tracking note (microcosm#1095).",
  "effective_mass_coverage": {
   "minimum_nondefault_mass_share": 1e-06,
   "rationale": "One part per million rejects zero-weight support and numerical dust while remaining about 100 times below the rarest populated record share in the pinned enhanced-FRS reference.",
@@ -1238,13 +818,8 @@
   }
  },
  "reference": {
-  "derived_from": "efrs_parity_reference.json",
-  "filename": "enhanced_frs_2024_25.h5",
-  "period": "2024",
-  "populated_input_columns": 145,
-  "revision": "a9e52499b6a6cca100a5ce4f36ca27b2e8a213df",
-  "sha256": "e433e532b17bd8ce76030156285816e33d44e93edabd2204adbef71d19a68712",
-  "vintage": "2024_25"
+  "kind": "current_build",
+  "required_inputs": "The loader inputs the current build of the cut's line carries, measured by the coverage gate's own rule; the cut's reference step records them in reference_surface.json. Until microcosm#1095 they were the populated inputs of the frozen enhanced-FRS reference."
  },
  "restoration_evidence": {
   "derived_from": "efrs_parity_known_gaps.json",
@@ -1253,5 +828,5 @@
    "gift_aid"
   ]
  },
- "schema_version": 3
+ "schema_version": 4
 }
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/battery_bindings.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/battery_bindings.py
index d8a28f2910..2f68553bf6 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/battery_bindings.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/battery_bindings.py
@@ -124,6 +124,7 @@
     coerce_reviewed_exclusions,
     load_uk_local_area_support_exclusion_register,
     uk_default_input_mass_reviewed_exclusions,
+    uk_input_mass_carriers,
     uk_input_mass_parity_gate,
     uk_input_mass_totals,
 )
@@ -257,9 +258,13 @@ def _evaluate_release_input_coverage(
         build_state = _uk_gate_surface(spine_frame)
     else:
         build_state = spine_frame
+    # The required inputs are the ones the cut's reference build carries
+    # (microcosm#1095); the artifact selector marks the gate evidence_absent
+    # when no reference surface arrived.
     return uk_release_input_coverage_gate(
         _uk_gate_surface(uk_release_export_frame(context.frame)),
         engine,
+        reference_surface=context.artifacts["reference_surface"],
         manifest=manifest,
         build_state_frame=build_state,
     )
@@ -276,7 +281,7 @@ def _coverage_required_artifacts(parameters: Mapping[str, Any]) -> frozenset[str
     # the calibrated frame.
     if parameters.get("check") == "manifest_current":
         return frozenset({"coverage_engine"})
-    return frozenset({"coverage_engine", "spine_frame"})
+    return frozenset({"coverage_engine", "spine_frame", "reference_surface"})
 
 
 def _evaluate_source_coverage(
@@ -1143,18 +1148,31 @@ def _validate_input_mass_exclusion_references(
     *,
     label: str,
 ) -> None:
-    unknown = sorted(set(register) - set(UK_INPUT_MASS_REFERENCE_REGISTRY))
-    if unknown:
+    from microcosm.build.uk_runtime.cut_reference import UK_CUT_REFERENCE_RELEASES
+
+    malformed = sorted(
+        name
+        for name in register
+        if name.count("@") != 1
+        or name.split("@", 1)[0] not in UK_CUT_REFERENCE_RELEASES
+        or not name.split("@", 1)[1]
+    )
+    if malformed:
         raise ValueError(
-            f"{label} names unknown input-mass reference(s) {unknown}; known "
-            f"references are {sorted(UK_INPUT_MASS_REFERENCE_REGISTRY)}."
+            f"{label} names {malformed}; an input-mass exclusion is signed for "
+            "one reference build, named <release>@<build> for a UK line "
+            "(microcosm#1095)."
         )
 
 
 def _resolve_input_mass_exclusions(
     context: EvidenceContext, *, reference: str
 ) -> tuple[Mapping[str, UKReviewedExclusion], str]:
-    """Active-reference input-mass exclusions and their content source."""
+    """The exclusions signed for this reference build, and their source.
+
+    ``reference`` is the build's ``<release>@<build>``; entries signed for
+    any other build are dormant (microcosm#1095).
+    """
 
     committed = uk_default_input_mass_reviewed_exclusions()
     _validate_input_mass_exclusion_references(
@@ -1475,10 +1493,14 @@ def _evaluate_weights_audit(
 def _evaluate_export_surface(
     context: EvidenceContext, parameters: Mapping[str, Any]
 ) -> GateResult:
+    # The reference side is the export surface of the cut's reference build,
+    # the current build of the line (microcosm#1095).
     parity = context.artifacts["parity_evidence"]
+    reference = context.artifacts["reference_surface"]
     return uk_export_surface_gate(
         parity.candidate_columns,
-        parity.reference_columns,
+        reference.export_columns,
+        reference_name=reference.label,
         **dict(parameters),
     )
 
@@ -1766,6 +1788,12 @@ def _evaluate_input_mass_parity(
     register = kwargs.pop("reviewed_exclusions_resource", None)
     relative_tolerance = kwargs.pop("relative_tolerance", None)
     minimum_reference_total = kwargs.pop("minimum_reference_total", None)
+    maximum_relative_drop = kwargs.pop("maximum_relative_drop", None)
+    if maximum_relative_drop is None:
+        raise ValueError(
+            "uk/gates.json input_mass_parity declares no maximum_relative_drop; "
+            "the drop limit is part of the reviewed policy (microcosm#1095)."
+        )
     coerced_registry = coerce_input_mass_reference_registry(
         declared_registry, label="uk/gates.json input_mass_parity"
     )
@@ -1780,18 +1808,21 @@ def _evaluate_input_mass_parity(
             f"uk/gates.json declares input-mass reference {reference_name!r} "
             f"but known references are {sorted(coerced_registry)}."
         )
+    reference = context.artifacts["input_mass_reference"]
+    descriptor = coerced_registry[reference_name].descriptor_for(reference)
     if register != UK_INPUT_MASS_EXCLUSION_REGISTER_RESOURCE:
         raise ValueError(
             f"uk/gates.json names exclusion register {register!r} but the "
             f"runtime loads {UK_INPUT_MASS_EXCLUSION_REGISTER_RESOURCE!r}."
         )
     exclusions, _source = _resolve_input_mass_exclusions(
-        context, reference=reference_name
+        context, reference=reference.label
     )
     exclusions, out_of_line = _in_line(exclusions, context)
     policy = UKInputMassParityPolicy(
         relative_tolerance=relative_tolerance,
         minimum_reference_total=minimum_reference_total,
+        maximum_relative_drop=maximum_relative_drop,
         reviewed_exclusions=exclusions,
     )
     # The reference is compared against the surface the release ships: the
@@ -1800,12 +1831,14 @@ def _evaluate_input_mass_parity(
     # carries the spine's WAS property_wealth, which the reference also
     # stores, so comparing it there would call the signed exclusion stale
     # (microcosm#1106).
+    export_frame = uk_release_export_frame(context.frame)
     result = uk_input_mass_parity_gate(
-        uk_input_mass_totals(uk_release_export_frame(context.frame)),
-        context.artifacts["input_mass_reference"],
-        descriptor=coerced_registry[reference_name],
+        uk_input_mass_totals(export_frame),
+        reference,
+        descriptor=descriptor,
         policy=policy,
         now=_exclusion_clock(context),
+        candidate_carriers=uk_input_mass_carriers(export_frame),
         **kwargs,
     )
     return _with_out_of_line(result, context, out_of_line)
@@ -1817,10 +1850,11 @@ def _input_mass_reference_evidence(
     reference_name = str(parameters["reference"])
     reference = context.artifacts["input_mass_reference"]
     exclusions, source = _resolve_input_mass_exclusions(
-        context, reference=reference_name
+        context, reference=reference.label
     )
     return {
         "reference": reference_name,
+        "reference_label": reference.label,
         "reference_evidence_sha256": _input_mass_reference_evidence_sha256(reference),
         "exclusions_policy": source,
         "reviewed_exclusions": _exclusion_payload(exclusions),
@@ -2367,7 +2401,7 @@ def _ledger_compile_parity_required_artifacts(
         name="export_surface",
         evaluator=_evaluate_export_surface,
         parameter_keys=frozenset({"allowed_extra_columns", "reviewed_exclusions"}),
-        artifact_keys=frozenset({"parity_evidence"}),
+        artifact_keys=frozenset({"parity_evidence", "reference_surface"}),
         needs_frame=False,
     ),
     "target_surface": UKGateBinding(
@@ -2405,6 +2439,7 @@ def _ledger_compile_parity_required_artifacts(
                 "reviewed_exclusions_resource",
                 "relative_tolerance",
                 "minimum_reference_total",
+                "maximum_relative_drop",
                 "candidate_name",
             }
         ),
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/candidate_score.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/candidate_score.py
index cbc3e34b14..29faf9351e 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/candidate_score.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/candidate_score.py
@@ -1,19 +1,25 @@
-"""Score a UK national candidate against the incumbent on one frozen register.
+"""Compare a UK national candidate with the current build on one frozen register.
 
-The #578 rule-1 score core, shared by the scorer command
-(``tools/score_uk_national_candidate.py``), the rowwise driver's national
-role (which evaluates every build at its end) and the release-cut certifier
-(which refuses a receipt whose verdict is not ``passed``).
+The head-to-head behind every UK national cut (microcosm#1095), shared by
+the scorer command (``tools/score_uk_national_candidate.py``), the rowwise
+driver's national role (which evaluates every build at its end) and the
+release-cut certifier (which requires a receipt for this candidate and this
+reference). The reference is the current build of the national line, as the
+cut recorded it when it fetched its inputs (:mod:`.cut_reference`).
 
 Both artifacts are materialized through the route the calibration seam
-uses. A target whose measure the *candidate* cannot materialize refuses:
-that is a defect. A target whose measure the *incumbent* cannot materialize
-is structural — the incumbent artifact never carried the input (the
-admin-basis UC family measures, the CGT asset type, the ONS household type
-on the enhanced FRS) — so :func:`evaluate_uk_candidate_against_incumbent`
-prunes it from both arms, scores the common surface with band edges from
-the full register (#803), and reports every pruned measure loudly in the
-receipt rather than quietly shrinking the surface or refusing the score.
+uses, and compared target by target through the country-neutral
+:mod:`microcosm.build.head_to_head`. The comparison decides nothing: it is
+evidence for the owner's decision to promote the candidate, with no
+threshold, as the US head-to-head is. Until microcosm#1095 the reference was
+the enhanced FRS and the receipt carried a strict rule-1 verdict.
+
+A target whose measure the *candidate* cannot materialize refuses: that is a
+defect. A target whose measure the *reference* cannot materialize (a build
+from before an input existed) is pruned from both arms under a signed entry
+of the reviewed reference-unresolvable register for that reference, scored
+on the common surface with band edges from the full register (#803), and
+reported in the receipt.
 """
 
 from __future__ import annotations
@@ -26,6 +32,10 @@
 from pathlib import Path
 from typing import Any
 
+from microcosm.build.head_to_head import (
+    compare_scored_targets,
+    scored_targets_from_mapping,
+)
 from microcosm.build.target_materialization import MeasureResolutionError
 from microcosm.build.uk_runtime.national_calibration import prepare_uk_target_frame
 from microcosm.build.uk_runtime.national_frame import (
@@ -39,7 +49,7 @@
 from microcosm.build.uk_runtime.weighted_integrity import (
     UKReviewedExclusion,
     exclusion_evaluation_date,
-    load_uk_reviewed_exclusion_register,
+    load_uk_reference_scoped_exclusion_register,
 )
 from microcosm.calibrate import TargetRegistry, score_targets
 
@@ -69,17 +79,17 @@ def _holdout_loss(basis: str) -> float | None:
 def score_uk_national_candidate(
     *,
     candidate_h5: str | Path,
-    incumbent_h5: str | Path,
+    reference_h5: str | Path,
     candidate_sha256: str,
-    incumbent_sha256: str,
+    reference_sha256: str,
     target_registry: TargetRegistry,
     calibration_year: int,
+    reference_label: str,
     measure_resolver_factory: Callable[[Path, Any], Any] | None = None,
     candidate_label: str | None = None,
-    incumbent_label: str = "enhanced_frs_2024_25",
     band_edge_registry: TargetRegistry | None = None,
 ) -> dict[str, Any]:
-    """Return the #578 rule-1 score block on a shared target registry.
+    """Return the head-to-head score block on a shared target registry.
 
     Both artifacts are verified against their declared digests before a byte
     is read, and both sides are materialized through the same route the
@@ -93,7 +103,7 @@ def score_uk_national_candidate(
     if candidate_label is None:
         candidate_label = candidate_path.stem
     candidate_pin = _verify_artifact("candidate", candidate_h5, candidate_sha256)
-    incumbent_pin = _verify_artifact("incumbent", incumbent_h5, incumbent_sha256)
+    reference_pin = _verify_artifact("reference", reference_h5, reference_sha256)
     candidate_frame, candidate_resolution = _scored_frame(
         candidate_h5,
         target_registry,
@@ -101,43 +111,49 @@ def score_uk_national_candidate(
         measure_resolver_factory,
         band_edge_registry=band_edge_registry,
     )
-    incumbent_frame, incumbent_resolution = _scored_frame(
-        incumbent_h5,
+    reference_frame, reference_resolution = _scored_frame(
+        reference_h5,
         target_registry,
         calibration_year,
         measure_resolver_factory,
         band_edge_registry=band_edge_registry,
-        incumbent=True,
+        reference=True,
     )
     candidate = score_targets(
         candidate_frame,
         target_registry.to_target_set(),
         target_loss_cap=UK_SCORE_LOSS_CAP,
     )
-    incumbent = score_targets(
-        incumbent_frame,
+    reference = score_targets(
+        reference_frame,
         target_registry.to_target_set(),
         target_loss_cap=UK_SCORE_LOSS_CAP,
     )
     candidate_errors = _relative_errors(candidate)
-    incumbent_errors = _relative_errors(incumbent)
+    reference_errors = _relative_errors(reference)
     names = sorted(candidate_errors)
-    missing = sorted(set(names) ^ set(incumbent_errors))
+    missing = sorted(set(names) ^ set(reference_errors))
     if missing:
         raise RuntimeError(
-            "candidate and incumbent scores produced different target rows: "
+            "candidate and reference scores produced different target rows: "
             f"{missing[:10]}."
         )
-    wins = _target_wins(candidate_errors, incumbent_errors)
+    families = {
+        spec.to_target().row_name: spec.family for spec in target_registry.specs
+    }
+    head_to_head = compare_scored_targets(
+        scored_targets_from_mapping(candidate_errors, families=families, order=names),
+        scored_targets_from_mapping(reference_errors, families=families, order=names),
+        candidate_loss=float(candidate.final_loss),
+        reference_loss=float(reference.final_loss),
+    )
     return {
         "candidate_train_loss": float(candidate.final_loss),
         "candidate_holdout_loss": _holdout_loss(UK_SCORE_HOLDOUT_BASIS),
         "candidate_full_loss": float(candidate.final_loss),
-        "incumbent_train_loss": float(incumbent.final_loss),
-        "incumbent_holdout_loss": _holdout_loss(UK_SCORE_HOLDOUT_BASIS),
-        "incumbent_full_loss": float(incumbent.final_loss),
-        "candidate_target_wins": wins["candidate"],
-        "incumbent_target_wins": wins["incumbent"],
+        "reference_train_loss": float(reference.final_loss),
+        "reference_holdout_loss": _holdout_loss(UK_SCORE_HOLDOUT_BASIS),
+        "reference_full_loss": float(reference.final_loss),
         "holdout_basis": UK_SCORE_HOLDOUT_BASIS,
         "loss": {
             "objective": "relative_error_loss",
@@ -151,11 +167,11 @@ def score_uk_national_candidate(
         },
         "artifacts": {
             "candidate": {"label": candidate_label, **candidate_pin},
-            "incumbent": {"label": incumbent_label, **incumbent_pin},
+            "reference": {"label": reference_label, **reference_pin},
         },
         "measure_resolution": {
             "candidate": candidate_resolution,
-            "incumbent": incumbent_resolution,
+            "reference": reference_resolution,
         },
         # Each file's own year and the factor the engine multiplies its
         # household weights by to reach the scored year. Scores taken before
@@ -163,33 +179,19 @@ def score_uk_national_candidate(
         "weight_year": {
             "scored_year": int(calibration_year),
             "candidate": _weight_year(candidate_frame, calibration_year),
-            "incumbent": _weight_year(incumbent_frame, calibration_year),
+            "reference": _weight_year(reference_frame, calibration_year),
         },
-        "target_drift": _target_drift(
-            target_registry, candidate_errors, incumbent_errors
-        ),
+        "head_to_head": head_to_head.to_payload(),
         "signed_asymmetries": [
             {
-                "id": "incumbent_own_registry",
+                "id": "reference_own_registry",
                 "description": (
-                    "The incumbent was calibrated to its own registry; both "
-                    "artifacts are rescored here on the supplied frozen register."
-                ),
-            },
-            {
-                "id": "national_direct_vs_collapsed_local",
-                "description": (
-                    "Candidate national weights are a direct national solve; "
-                    "incumbent national weights are the published national "
-                    "surface being compared on the same frozen register."
+                    "The reference was calibrated to the register of its own "
+                    "build; both artifacts are rescored here on the "
+                    "candidate's frozen register."
                 ),
             },
         ],
-        "target_wins_by_family": _target_wins_by_family(
-            target_registry,
-            candidate_errors,
-            incumbent_errors,
-        ),
     }
 
 
@@ -210,44 +212,6 @@ def _relative_errors(result) -> dict[str, float]:
     }
 
 
-def _target_wins(
-    candidate_errors: dict[str, float],
-    incumbent_errors: dict[str, float],
-) -> dict[str, int]:
-    candidate = 0
-    incumbent = 0
-    for name, candidate_error in candidate_errors.items():
-        incumbent_error = incumbent_errors[name]
-        if abs(candidate_error) < abs(incumbent_error):
-            candidate += 1
-        elif abs(incumbent_error) < abs(candidate_error):
-            incumbent += 1
-    return {"candidate": candidate, "incumbent": incumbent}
-
-
-def _target_wins_by_family(
-    registry: TargetRegistry,
-    candidate_errors: dict[str, float],
-    incumbent_errors: dict[str, float],
-) -> dict[str, dict[str, int]]:
-    by_row_name = {spec.to_target().row_name: spec.family for spec in registry.specs}
-    result: dict[str, dict[str, int]] = {}
-    for name, family in by_row_name.items():
-        bucket = result.setdefault(
-            family,
-            {"candidate_target_wins": 0, "incumbent_target_wins": 0, "ties": 0},
-        )
-        candidate_error = abs(candidate_errors[name])
-        incumbent_error = abs(incumbent_errors[name])
-        if candidate_error < incumbent_error:
-            bucket["candidate_target_wins"] += 1
-        elif incumbent_error < candidate_error:
-            bucket["incumbent_target_wins"] += 1
-        else:
-            bucket["ties"] += 1
-    return result
-
-
 def _load_registry(path: str | Path) -> TargetRegistry:
     """Load the frozen register through its own validating loader.
 
@@ -280,9 +244,16 @@ def _verify_artifact(role: str, path: str | Path, expected: str) -> dict[str, ob
     }
 
 
-#: Rule 1 scores each file's best estimate of the year's income against the
-#: same annual targets; an incumbent built before the annual income
-#: descriptors existed has none, so its annual measures are its current ones.
+#: The comparison scores each file's best estimate of the year's income
+#: against the same annual targets; a reference built before the annual
+#: income descriptors existed has none, so its annual measures are its
+#: current ones.
+UK_REFERENCE_ANNUAL_INCOME_FALLBACK = (
+    "reference without annual income descriptors: its annual measures are its "
+    "current values (a share of 1 and no other spells)"
+)
+#: The same fallback for the enhanced FRS, which the dense line's opt-in
+#: local diagnostic still reads (tools/extract_uk_local_incumbent_surface.py).
 UK_INCUMBENT_ANNUAL_INCOME_FALLBACK = (
     "incumbent without annual income descriptors: its annual measures are its "
     "current values (a share of 1 and no other spells)"
@@ -296,7 +267,7 @@ def _scored_frame(
     factory: Callable[[Path, Any], Any] | None,
     *,
     band_edge_registry: TargetRegistry | None = None,
-    incumbent: bool = False,
+    reference: bool = False,
 ) -> tuple[Any, Any]:
     frame, _provenance = load_uk_national_frame(h5_path)
     # policyengine-uk projects a file's household weights from the file's own
@@ -305,8 +276,8 @@ def _scored_frame(
     frame = uk_engine_year_frame(frame, simulation_year=calibration_year)
     resolver = None if factory is None else factory(Path(h5_path), frame)
     fallback = getattr(resolver, "use_current_income_for_annual_measures", None)
-    if incumbent and fallback is not None:
-        fallback(reason=UK_INCUMBENT_ANNUAL_INCOME_FALLBACK)
+    if reference and fallback is not None:
+        fallback(reason=UK_REFERENCE_ANNUAL_INCOME_FALLBACK)
     return prepare_uk_target_frame(
         frame,
         registry,
@@ -337,63 +308,33 @@ def build(h5_path: Path, frame: Any):
     return build
 
 
-def _target_drift(
-    registry: TargetRegistry,
-    candidate_errors: dict[str, float],
-    incumbent_errors: dict[str, float],
-) -> list[dict[str, object]]:
-    """Per-target relative errors, the auditable half of the score block."""
-
-    families = {spec.to_target().row_name: spec.family for spec in registry.specs}
-    rows = []
-    for name in sorted(candidate_errors):
-        candidate = candidate_errors[name]
-        incumbent = incumbent_errors[name]
-        # Relative errors are signed; the win is decided on magnitude, the
-        # same rule the aggregate counts use.
-        rows.append(
-            {
-                "target": name,
-                "family": families.get(name),
-                "candidate_relative_error": candidate,
-                "incumbent_relative_error": incumbent,
-                "winner": (
-                    "candidate"
-                    if abs(candidate) < abs(incumbent)
-                    else "incumbent"
-                    if abs(incumbent) < abs(candidate)
-                    else "tie"
-                ),
-            }
-        )
-    return rows
-
-
-#: The rule the verdict decides: microcosm#578 rule 1, on the surface both
-#: artifacts can materialize.
+#: What the comparison is (schema 2, microcosm#1095; schema 1 was the strict
+#: rule-1 verdict against the enhanced FRS).
 UK_EVALUATION_RULE = (
-    "microcosm#578 rule 1: the candidate beats the incumbent on the frozen "
-    "comparison register, both artifacts rescored on the surface both can "
-    "materialize; rows the incumbent cannot materialize are pruned from both "
-    "arms under the reviewed incumbent-unresolvable register and listed."
+    "microcosm#1095: the candidate and the current build of its release line "
+    "(the reference), both rescored on the candidate's frozen register on the "
+    "surface both can materialize, compared target by target with no "
+    "threshold; rows the reference cannot materialize are pruned from both "
+    "arms under the reviewed reference-unresolvable register and listed."
 )
-UK_EVALUATION_SCHEMA_VERSION = 1
-UK_EVALUATION_VERDICT_PASSED = "passed"
-UK_EVALUATION_VERDICT_FAILED = "failed"
-INCUMBENT_UNRESOLVABLE_NOTE = (
+UK_EVALUATION_SCHEMA_VERSION = 2
+REFERENCE_UNRESOLVABLE_NOTE = (
     "Rows pruned from BOTH arms because their measures cannot be computed on "
-    "the incumbent (inputs the incumbent artifact does not carry), each under "
-    "a signed entry of the reviewed incumbent-unresolvable register. The "
-    "candidate's fit on these rows is measured by the calibration diagnostics "
-    "and the terminal gates instead."
+    "the reference (inputs the reference build does not carry), each under a "
+    "signed entry of the reviewed reference-unresolvable register for this "
+    "reference. The candidate's fit on these rows is measured by the "
+    "calibration diagnostics and the terminal gates instead."
 )
 
-#: The reviewed register of measures the incumbent is known not to carry
-#: (``microcosm.build.uk`` resource, reviewed-exclusion schema 2, keyed
-#: ``entity.variable``). Pruning a target from both arms is a doctrine
-#: decision, not a scorer's inference: only a measure with a signed, in-force
-#: entry may be pruned, and an unlisted one refuses the evaluation.
-UK_INCUMBENT_UNRESOLVABLE_REGISTER = "incumbent_unresolvable_measures.json"
+#: The reviewed register of measures a reference build is known not to carry
+#: (``microcosm.build.uk`` resource, the per-reference schema 3, keyed by the
+#: reference's ``<release>@<build>`` and then ``entity.variable``). Pruning a
+#: target from both arms is a doctrine decision, not a scorer's inference:
+#: only a measure with a signed, in-force entry for the cut's own reference
+#: may be pruned, and an unlisted one refuses the evaluation. Entries for
+#: another build are dormant: they go unused once a promotion moves the
+#: reference past them.
+UK_REFERENCE_UNRESOLVABLE_REGISTER = "reference_unresolvable_measures.json"
 
 #: A materialization skip's reason names the missing column as
 #: ``'entity.variable'`` (or ``'variable'``); the prune loop matches that
@@ -401,17 +342,28 @@ def _target_drift(
 _SKIP_COLUMN = re.compile(r"^'(?:([a-z_0-9]+)\.)?([A-Za-z_0-9]+)'$")
 
 
-def load_uk_incumbent_unresolvable_measures(
+def load_uk_reference_unresolvable_register(
     source: str | Path | None = None,
-) -> dict[str, UKReviewedExclusion]:
-    """The reviewed incumbent-unresolvable register (packaged unless overridden)."""
+) -> dict[str, Mapping[str, UKReviewedExclusion]]:
+    """Every reference's reviewed unresolvable measures (packaged by default)."""
 
-    return load_uk_reviewed_exclusion_register(
-        source, resource=UK_INCUMBENT_UNRESOLVABLE_REGISTER
+    return load_uk_reference_scoped_exclusion_register(
+        source, resource=UK_REFERENCE_UNRESOLVABLE_REGISTER
     )
 
 
-def uk_incumbent_unresolvable_register_digest(
+def load_uk_reference_unresolvable_measures(
+    *,
+    reference_label: str,
+    source: str | Path | None = None,
+) -> dict[str, UKReviewedExclusion]:
+    """The reviewed unresolvable measures for one reference, empty if none."""
+
+    register = load_uk_reference_unresolvable_register(source)
+    return dict(register.get(reference_label, {}))
+
+
+def uk_reference_unresolvable_register_digest(
     source: str | Path | None = None,
 ) -> dict[str, str]:
     """Name and digest of the register a receipt was evaluated under."""
@@ -421,10 +373,10 @@ def uk_incumbent_unresolvable_register_digest(
 
         raw = (
             importlib_resources.files("microcosm.build.uk")
-            .joinpath(UK_INCUMBENT_UNRESOLVABLE_REGISTER)
+            .joinpath(UK_REFERENCE_UNRESOLVABLE_REGISTER)
             .read_bytes()
         )
-        name = UK_INCUMBENT_UNRESOLVABLE_REGISTER
+        name = UK_REFERENCE_UNRESOLVABLE_REGISTER
     else:
         raw = Path(source).read_bytes()
         name = str(source)
@@ -449,20 +401,22 @@ def _require_reviewed_unresolvable(
     variable: str,
     *,
     evaluated_on: date,
+    reference_label: str,
 ) -> UKReviewedExclusion:
     key = f"{entity}.{variable}"
     record = reviewed.get(key)
     if record is None:
         raise MeasureResolutionError(
-            f"{key} is unresolvable on the incumbent but is not on the reviewed "
-            f"incumbent-unresolvable register ({UK_INCUMBENT_UNRESOLVABLE_REGISTER}); "
-            "a target may be pruned from both arms only under a signed entry, "
-            "so the evaluation refuses rather than pruning.",
+            f"{key} is unresolvable on the reference {reference_label} but has no "
+            "entry for it on the reviewed reference-unresolvable register "
+            f"({UK_REFERENCE_UNRESOLVABLE_REGISTER}); a target may be pruned "
+            "from both arms only under a signed entry, so the evaluation "
+            "refuses rather than pruning.",
             receipt={},
         )
     if record.premature(evaluated_on):
         raise MeasureResolutionError(
-            f"the reviewed incumbent-unresolvable entry for {key} is not yet in "
+            f"the reviewed reference-unresolvable entry for {key} is not yet in "
             f"force (takes force {record.approved_on}, evaluated on "
             f"{evaluated_on.isoformat()}); correct the receipt's approved_on or "
             "wait for it.",
@@ -470,7 +424,7 @@ def _require_reviewed_unresolvable(
         )
     if record.expired(evaluated_on):
         raise MeasureResolutionError(
-            f"the reviewed incumbent-unresolvable entry for {key} expired "
+            f"the reviewed reference-unresolvable entry for {key} expired "
             f"{record.expires_on} (evaluated on {evaluated_on.isoformat()}); renew "
             "the adjudication or remove the entry.",
             receipt={},
@@ -488,7 +442,7 @@ def _require_reviewed_unresolvable(
 
 @dataclass(frozen=True)
 class PrunedTarget:
-    """One target dropped from both arms because the incumbent lacks its measure."""
+    """One target dropped from both arms because the reference lacks its measure."""
 
     name: str
     family: str
@@ -523,8 +477,8 @@ def _packaged_contract_targets() -> Mapping[str, Any]:
     return _uk_contract_targets()
 
 
-def prune_incumbent_unresolvable(
-    incumbent_h5: str | Path,
+def prune_reference_unresolvable(
+    reference_h5: str | Path,
     registry: TargetRegistry,
     calibration_year: int,
     measure_resolver_factory: Callable[[Path, Any], Any] | None,
@@ -534,14 +488,16 @@ def prune_incumbent_unresolvable(
     max_rounds: int | None = None,
     reviewed_measures: Mapping[str, UKReviewedExclusion] | None = None,
     evaluated_on: date | None = None,
+    reference_label: str,
 ) -> tuple[TargetRegistry, dict[str, PrunedTarget]]:
-    """Drop every target whose measure the incumbent cannot materialize.
+    """Drop every target whose measure the reference cannot materialize.
 
-    Probes the incumbent's resolution on the scoring surface; on each
+    Probes the reference's resolution on the scoring surface; on each
     :class:`MeasureResolutionError` naming a measure, requires a signed,
-    in-force entry for that measure on the reviewed incumbent-unresolvable
-    register (``reviewed_measures``, the packaged register by default,
-    evaluated on ``evaluated_on``, today by default), then drops the targets
+    in-force entry for that measure on the reviewed reference-unresolvable
+    register for ``reference_label`` (``reviewed_measures``, the packaged
+    register's entries for it by default, evaluated on ``evaluated_on``,
+    today by default), then drops the targets
     the resolution receipt's skip rows name for it, else every target whose
     contract binding gates or values through it, and records each drop with
     the failing measure and the entry's adjudication. An unlisted measure
@@ -557,7 +513,7 @@ def prune_incumbent_unresolvable(
     if measure_resolver_factory is None:
         return registry, {}
     reviewed = (
-        load_uk_incumbent_unresolvable_measures()
+        load_uk_reference_unresolvable_measures(reference_label=reference_label)
         if reviewed_measures is None
         else reviewed_measures
     )
@@ -567,18 +523,19 @@ def prune_incumbent_unresolvable(
     # The probes stand on the full register's band edges too (#803): a
     # pruned surface never redraws its own edges, not even to be probed.
     edges = registry if band_edge_registry is None else band_edge_registry
-    # On 11 November 2026 two of the nine signed measures took two probes
-    # each: eleven failing probes, past the fixed bound of ten this replaced.
+    # On 11 November 2026 two of the enhanced FRS's nine signed measures took
+    # two probes each: eleven failing probes, past the fixed bound of ten this
+    # replaced.
     rounds = 3 * len(reviewed) + 1 if max_rounds is None else max_rounds
     for _round in range(rounds):
         try:
             _scored_frame(
-                incumbent_h5,
+                reference_h5,
                 surface,
                 calibration_year,
                 measure_resolver_factory,
                 band_edge_registry=edges,
-                incumbent=True,
+                reference=True,
             )
         except MeasureResolutionError as error:
             failing = _failing_measure(error)
@@ -586,7 +543,11 @@ def prune_incumbent_unresolvable(
                 raise
             entity, variable = failing
             record = _require_reviewed_unresolvable(
-                reviewed, entity, variable, evaluated_on=now
+                reviewed,
+                entity,
+                variable,
+                evaluated_on=now,
+                reference_label=reference_label,
             )
             receipt = getattr(error, "receipt", None) or {}
             skips = receipt.get("skips", []) if isinstance(receipt, Mapping) else []
@@ -614,7 +575,7 @@ def prune_incumbent_unresolvable(
                 ]
             if not dropped:
                 raise MeasureResolutionError(
-                    f"{entity}.{variable} is unresolvable on the incumbent but "
+                    f"{entity}.{variable} is unresolvable on the reference but "
                     "neither the resolution receipt nor any contract binding "
                     "names a target for it; refusing to prune blindly.",
                     receipt=receipt if isinstance(receipt, Mapping) else {},
@@ -634,13 +595,13 @@ def prune_incumbent_unresolvable(
             )
             if not surface.specs:
                 raise RuntimeError(
-                    "every target is unresolvable on the incumbent; nothing "
+                    "every target is unresolvable on the reference; nothing "
                     "remains to score."
                 ) from error
             continue
         return surface, pruned
     raise RuntimeError(
-        f"the incumbent's measure resolution still fails after {rounds} pruning rounds."
+        f"the reference's measure resolution still fails after {rounds} pruning rounds."
     )
 
 
@@ -649,6 +610,7 @@ def pruned_block(
     *,
     n_scored: int,
     n_surface: int,
+    reference_label: str,
     reviewed_measures: Mapping[str, UKReviewedExclusion] | None = None,
     register: Mapping[str, str] | None = None,
 ) -> dict[str, Any]:
@@ -673,63 +635,61 @@ def pruned_block(
         "measures": measures,
         "families": dict(sorted(families.items())),
         # The candidate materialized every target of the full surface before
-        # the incumbent's gaps were pruned; only the incumbent is pruned for.
+        # the reference's gaps were pruned; only the reference is pruned for.
         "candidate_validated_on_full_surface": True,
         "reviewed_register": {
             **(
-                {"resource": UK_INCUMBENT_UNRESOLVABLE_REGISTER, "sha256": None}
+                {"resource": UK_REFERENCE_UNRESOLVABLE_REGISTER, "sha256": None}
                 if register is None
                 else dict(register)
             ),
+            "reference": reference_label,
             "entries_used": entries_used,
         },
-        "note": INCUMBENT_UNRESOLVABLE_NOTE,
+        "note": REFERENCE_UNRESOLVABLE_NOTE,
     }
 
 
 def evaluation_block(score: Mapping[str, Any]) -> dict[str, Any]:
-    """The machine-checkable verdict the certifier reads from a receipt."""
+    """The comparison's summary the certifier reads from a receipt: no verdict."""
 
-    candidate_loss = float(score["candidate_full_loss"])
-    incumbent_loss = float(score["incumbent_full_loss"])
-    pruned = score.get("incumbent_unresolvable_pruned") or {}
+    pruned = score.get("reference_unresolvable_pruned") or {}
     n_scored = int(pruned.get("n_scored", score["register"]["n_specs"]))
     n_pruned = int(pruned.get("n_pruned", 0))
     n_surface = int(pruned.get("n_surface", n_scored + n_pruned))
-    rule_1_passed = candidate_loss < incumbent_loss
+    targets = score["head_to_head"]["targets"]
     return {
         "schema_version": UK_EVALUATION_SCHEMA_VERSION,
         "rule": UK_EVALUATION_RULE,
+        "reference": score["artifacts"]["reference"]["label"],
         "scored_surface": {
             "n_scored": n_scored,
             "n_pruned": n_pruned,
             "n_surface": n_surface,
         },
-        "rule_1": {
-            "passed": rule_1_passed,
-            "candidate_full_loss": candidate_loss,
-            "incumbent_full_loss": incumbent_loss,
-            "candidate_target_wins": int(score["candidate_target_wins"]),
-            "incumbent_target_wins": int(score["incumbent_target_wins"]),
+        "losses": {
+            "candidate_full_loss": float(score["candidate_full_loss"]),
+            "reference_full_loss": float(score["reference_full_loss"]),
         },
-        "verdict": (
-            UK_EVALUATION_VERDICT_PASSED
-            if rule_1_passed
-            else UK_EVALUATION_VERDICT_FAILED
-        ),
+        "targets": {
+            "candidate_lower_count": int(targets["candidate_lower_count"]),
+            "reference_lower_count": int(targets["reference_lower_count"]),
+            "equal_count": int(targets["equal_count"]),
+        },
+        "no_threshold_applied": True,
     }
 
 
 def pruned_warning(score: Mapping[str, Any]) -> str | None:
     """The loud warning for a receipt that pruned rows, or None."""
 
-    pruned = score.get("incumbent_unresolvable_pruned") or {}
+    pruned = score.get("reference_unresolvable_pruned") or {}
     if not pruned.get("n_pruned"):
         return None
     lines = [
         f"warning: {pruned['n_pruned']} of {pruned['n_surface']} targets cannot be "
-        "materialized on the incumbent and were pruned from BOTH arms; the "
-        f"score stands on {pruned['n_scored']} common targets:"
+        "materialized on the reference and were pruned from BOTH arms; the "
+        f"comparison stands on {pruned['n_scored']} common targets:"
     ]
     targets = pruned.get("pruned_targets", {})
     for measure in pruned.get("measures", []):
@@ -743,55 +703,68 @@ def pruned_warning(score: Mapping[str, Any]) -> str | None:
         )
     lines.append(
         "  the candidate's fit on these rows is measured by the calibration "
-        "diagnostics and the terminal gates, not by this score."
+        "diagnostics and the terminal gates, not by this comparison."
     )
     return "\n".join(lines)
 
 
-def evaluate_uk_candidate_against_incumbent(
+def evaluate_uk_candidate_against_reference(
     *,
     candidate_h5: str | Path,
-    incumbent_h5: str | Path,
+    reference_h5: str | Path,
     candidate_sha256: str,
-    incumbent_sha256: str,
+    reference_sha256: str,
     target_registry: TargetRegistry,
     calibration_year: int,
+    reference_label: str,
     measure_resolver_factory: Callable[[Path, Any], Any] | None = None,
     candidate_label: str | None = None,
-    incumbent_label: str = "enhanced_frs_2024_25",
     band_edge_registry: TargetRegistry | None = None,
-    prune_incumbent_unresolvable_measures: bool = True,
+    prune_reference_unresolvable_measures: bool = True,
     contract_targets: Mapping[str, Any] | None = None,
     reviewed_measures: Mapping[str, UKReviewedExclusion] | None = None,
     evaluated_on: date | None = None,
+    reference_record: Mapping[str, Any] | None = None,
 ) -> dict[str, Any]:
-    """Score on the common resolvable surface and decide the rule-1 verdict.
+    """Compare on the common resolvable surface and summarize, with no verdict.
 
-    Returns the score block with ``incumbent_unresolvable_pruned`` (every
+    Returns the score block with ``reference_unresolvable_pruned`` (every
     row dropped, its family, the absent measure and the register entry it
-    was pruned under) and ``evaluation`` (rule, counts, rule-1 losses and
-    wins, ``verdict``). Pruning stands on the reviewed incumbent-unresolvable
-    register (the packaged one unless ``reviewed_measures`` is supplied);
-    with pruning off the strict scorer's refusal stands.
+    was pruned under) and ``evaluation`` (rule, reference, counts, losses).
+    Pruning stands on the reviewed reference-unresolvable register's entries
+    for ``reference_label`` (the packaged register unless ``reviewed_measures``
+    is supplied); with pruning off the strict scorer's refusal stands.
+    ``reference_record`` (the cut's :class:`~.cut_reference.UKCutReference`
+    record) is kept in the receipt as ``reference``; it must name the scored
+    file.
     """
 
+    if reference_record is not None and (
+        reference_record.get("sha256") != reference_sha256
+        or f"{reference_record.get('release')}@{reference_record.get('build')}"
+        != reference_label
+    ):
+        raise ValueError(
+            "The reference record names another build than the scored reference "
+            f"({reference_label}, {reference_sha256})."
+        )
     surface = target_registry
     pruned: dict[str, PrunedTarget] = {}
     register_digest = (
-        uk_incumbent_unresolvable_register_digest()
+        uk_reference_unresolvable_register_digest()
         if reviewed_measures is None
         else None
     )
     reviewed = (
-        load_uk_incumbent_unresolvable_measures()
+        load_uk_reference_unresolvable_measures(reference_label=reference_label)
         if reviewed_measures is None
         else reviewed_measures
     )
-    if prune_incumbent_unresolvable_measures:
+    if prune_reference_unresolvable_measures:
         # The candidate is validated on the FULL surface before any pruning:
         # a measure the candidate cannot materialize is a defect and refuses
-        # whether or not the incumbent shares the gap (review finding A1),
-        # so pruning only ever removes rows the incumbent cannot express.
+        # whether or not the reference shares the gap (review finding A1),
+        # so pruning only ever removes rows the reference cannot express.
         _scored_frame(
             candidate_h5,
             target_registry,
@@ -801,8 +774,8 @@ def evaluate_uk_candidate_against_incumbent(
                 target_registry if band_edge_registry is None else band_edge_registry
             ),
         )
-        surface, pruned = prune_incumbent_unresolvable(
-            incumbent_h5,
+        surface, pruned = prune_reference_unresolvable(
+            reference_h5,
             target_registry,
             calibration_year,
             measure_resolver_factory,
@@ -810,6 +783,7 @@ def evaluate_uk_candidate_against_incumbent(
             contract_targets=contract_targets,
             reviewed_measures=reviewed,
             evaluated_on=evaluated_on,
+            reference_label=reference_label,
         )
     # A pruned surface must never redraw its own band edges (#803): the
     # edges come from the full register when the caller supplied none.
@@ -818,22 +792,24 @@ def evaluate_uk_candidate_against_incumbent(
         edges = target_registry
     score = score_uk_national_candidate(
         candidate_h5=candidate_h5,
-        incumbent_h5=incumbent_h5,
+        reference_h5=reference_h5,
         candidate_sha256=candidate_sha256,
-        incumbent_sha256=incumbent_sha256,
+        reference_sha256=reference_sha256,
         target_registry=surface,
         calibration_year=calibration_year,
         measure_resolver_factory=measure_resolver_factory,
         candidate_label=candidate_label,
-        incumbent_label=incumbent_label,
+        reference_label=reference_label,
         band_edge_registry=edges,
     )
-    score["incumbent_unresolvable_pruned"] = pruned_block(
+    score["reference_unresolvable_pruned"] = pruned_block(
         pruned,
         n_scored=len(surface.specs),
         n_surface=len(target_registry.specs),
+        reference_label=reference_label,
         reviewed_measures=reviewed,
         register=register_digest,
     )
+    score["reference"] = None if reference_record is None else dict(reference_record)
     score["evaluation"] = evaluation_block(score)
     return score
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/cut_reference.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/cut_reference.py
new file mode 100644
index 0000000000..cebb75c215
--- /dev/null
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/cut_reference.py
@@ -0,0 +1,838 @@
+"""The current build a UK cut is checked against (microcosm#1095).
+
+A cut compares its candidate with the current build of its own release line,
+as the Hub's ``releases.json`` names it when the cut fetches its inputs: the
+national line with the national, the dense line with the dense. Comparing
+the dense file with the national would mix the lines' differences (clones,
+local targets, area columns) into checks meant to catch change between cuts.
+
+The reference is resolved once per cut. The fetch writes its record, and
+every later step reads that record and re-checks the file's SHA-256 against
+it; none re-resolves, so a promotion while a cut runs cannot split its
+reference. Each check that uses the reference names it in its own output.
+
+The fetch runs without the gate signing key, so it reads a build's
+certification by its fields, not its signature: a national build's
+``release_certification.json`` must be shippable, name this file's SHA-256
+and carry a registered key's fingerprint, and a dense build's
+``gate_summary.json`` must report every gate passed. The publication that
+made the build current verified the signatures. ``releases.json`` itself
+never names a withdrawn build as current.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import shutil
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from microcosm.build.uk_runtime.release_identity import (
+    UK_DENSE_RELEASE_ID,
+    UK_NATIONAL_RELEASE_ID,
+)
+
+__all__ = [
+    "UK_CUT_REFERENCE_KIND",
+    "UK_CUT_REFERENCE_RELEASES",
+    "UK_CUT_REFERENCE_SCHEMA_VERSION",
+    "UKCutReference",
+    "UK_CUT_REFERENCE_INPUT_MASS_NAME",
+    "UK_CUT_REFERENCE_RECORD_NAME",
+    "UK_CUT_REFERENCE_EVIDENCE_NAME",
+    "UK_CUT_REFERENCE_SURFACE_NAME",
+    "UK_NATIONAL_SINCE_BASELINE_ORIGIN",
+    "check_uk_cut_reference",
+    "fetch_uk_cut_reference",
+    "keep_uk_cut_reference_evidence",
+    "read_uk_cut_reference",
+    "resolve_uk_cut_reference",
+    "uk_cut_reference_chain",
+    "uk_cut_reference_evidence_done",
+    "uk_cut_reference_withdrawal",
+    "uk_input_mass_reference_payload",
+    "verify_uk_cut_reference_file",
+    "write_uk_cut_reference",
+    "write_uk_cut_reference_evidence",
+]
+
+UK_CUT_REFERENCE_KIND = "uk_cut_reference"
+UK_CUT_REFERENCE_SCHEMA_VERSION = 1
+#: The record's file name beside the reference's dataset in a cut.
+UK_CUT_REFERENCE_RECORD_NAME = "reference.json"
+#: The reference's input-mass totals and carriers, written beside it: the
+#: input-mass gate's reference (licensed-data aggregates, never committed).
+UK_CUT_REFERENCE_INPUT_MASS_NAME = "input_mass_reference.json"
+#: The reference's column surface (names and flags): the export-surface and
+#: input-coverage gates' reference (:mod:`.reference_surface`).
+UK_CUT_REFERENCE_SURFACE_NAME = "reference_surface.json"
+#: The reference's own certification evidence, kept beside it: a national
+#: build's certification carries its change since the baseline, which the
+#: cut continues (the review of microcosm#1574).
+UK_CUT_REFERENCE_EVIDENCE_NAME = "reference_evidence.json"
+#: Where the national line's record of change since the baseline starts: its
+#: current build when the record began, whose certification predates it. A
+#: chain that starts at any other build has restarted, which the
+#: certification records as ``restarted_from`` (round 2 of the review of
+#: microcosm#1574). A new FRS year moves it, as it moves the release ids.
+UK_NATIONAL_SINCE_BASELINE_ORIGIN = (
+    f"{UK_NATIONAL_RELEASE_ID}@uk-frs-calibration-attempt-20261107T020434Z-eeb6093e"
+)
+
+#: Each line's registry variant and the build evidence its fetch reads.
+UK_CUT_REFERENCE_RELEASES: Mapping[str, tuple[str, str]] = {
+    UK_NATIONAL_RELEASE_ID: ("compact", "release_certification"),
+    UK_DENSE_RELEASE_ID: ("dense", "gate_summary"),
+}
+_REGISTRY_YEAR = 2025
+
+_HubDownload = Callable[..., str]
+
+_RECORD_KEYS = frozenset(
+    {
+        "kind",
+        "schema_version",
+        "release",
+        "build",
+        "repo_id",
+        "path_in_repo",
+        "filename",
+        "sha256",
+        "size_bytes",
+        "built_with_model_package",
+        "built_with_core_package",
+        "evidence",
+        "resolved_at",
+        "selection",
+    }
+)
+#: How the cut chose its reference: the line's current build, or a listed
+#: build the operator pinned (``--reference-build``; the review of
+#: microcosm#1574, for a line with no current build).
+UK_CUT_REFERENCE_SELECTIONS = frozenset({"current", "pinned"})
+
+
+@dataclass(frozen=True)
+class UKCutReference:
+    """One build of a UK release line, resolved for a cut to compare with."""
+
+    release: str
+    build: str
+    repo_id: str
+    path_in_repo: str
+    filename: str
+    sha256: str
+    size_bytes: int
+    built_with_model_package: Mapping[str, str]
+    built_with_core_package: Mapping[str, str]
+    evidence: Mapping[str, str]
+    resolved_at: str
+    selection: str = "current"
+
+    @property
+    def label(self) -> str:
+        """``<release>@<build>``, the name every check that uses it records."""
+
+        return f"{self.release}@{self.build}"
+
+    def to_record(self) -> dict[str, Any]:
+        return {
+            "kind": UK_CUT_REFERENCE_KIND,
+            "schema_version": UK_CUT_REFERENCE_SCHEMA_VERSION,
+            "release": self.release,
+            "build": self.build,
+            "repo_id": self.repo_id,
+            "path_in_repo": self.path_in_repo,
+            "filename": self.filename,
+            "sha256": self.sha256,
+            "size_bytes": self.size_bytes,
+            "built_with_model_package": dict(self.built_with_model_package),
+            "built_with_core_package": dict(self.built_with_core_package),
+            "evidence": dict(self.evidence),
+            "resolved_at": self.resolved_at,
+            "selection": self.selection,
+        }
+
+    @classmethod
+    def from_record(cls, payload: object) -> UKCutReference:
+        if not isinstance(payload, Mapping) or set(payload) != _RECORD_KEYS:
+            raise ValueError(
+                "A UK cut reference record must have exactly the keys "
+                f"{sorted(_RECORD_KEYS)}."
+            )
+        if payload["kind"] != UK_CUT_REFERENCE_KIND:
+            raise ValueError(
+                f"A UK cut reference record has kind {UK_CUT_REFERENCE_KIND!r}, "
+                f"not {payload['kind']!r}."
+            )
+        if payload["schema_version"] != UK_CUT_REFERENCE_SCHEMA_VERSION:
+            raise ValueError(
+                "A UK cut reference record has schema_version "
+                f"{UK_CUT_REFERENCE_SCHEMA_VERSION}, not "
+                f"{payload['schema_version']!r}."
+            )
+        if payload["release"] not in UK_CUT_REFERENCE_RELEASES:
+            raise ValueError(
+                f"A UK cut reference names release {payload['release']!r}; a "
+                f"cut compares with one of {sorted(UK_CUT_REFERENCE_RELEASES)}."
+            )
+        for key in ("build", "repo_id", "path_in_repo", "filename", "resolved_at"):
+            if not isinstance(payload[key], str) or not payload[key]:
+                raise ValueError(f"A UK cut reference record has no {key}.")
+        sha256 = payload["sha256"]
+        if not _is_sha256(sha256):
+            raise ValueError("A UK cut reference record has no valid sha256.")
+        size = payload["size_bytes"]
+        if type(size) is not int or size <= 0:
+            raise ValueError("A UK cut reference record has no positive size_bytes.")
+        for key in ("built_with_model_package", "built_with_core_package"):
+            package = payload[key]
+            if (
+                not isinstance(package, Mapping)
+                or set(package) != {"name", "version"}
+                or not all(
+                    isinstance(value, str) and value for value in package.values()
+                )
+            ):
+                raise ValueError(
+                    f"A UK cut reference record's {key} must name a package and "
+                    "its version."
+                )
+        evidence = payload["evidence"]
+        if (
+            not isinstance(evidence, Mapping)
+            or set(evidence) != {"key", "filename", "sha256"}
+            or not _is_sha256(evidence["sha256"])
+        ):
+            raise ValueError(
+                "A UK cut reference record's evidence must name the build file "
+                "its fetch read, with its sha256."
+            )
+        if payload["selection"] not in UK_CUT_REFERENCE_SELECTIONS:
+            raise ValueError(
+                "A UK cut reference record's selection is one of "
+                f"{sorted(UK_CUT_REFERENCE_SELECTIONS)}, not {payload['selection']!r}."
+            )
+        return cls(
+            release=payload["release"],
+            build=payload["build"],
+            repo_id=payload["repo_id"],
+            path_in_repo=payload["path_in_repo"],
+            filename=payload["filename"],
+            sha256=sha256,
+            size_bytes=size,
+            built_with_model_package=dict(payload["built_with_model_package"]),
+            built_with_core_package=dict(payload["built_with_core_package"]),
+            evidence=dict(evidence),
+            resolved_at=payload["resolved_at"],
+            selection=payload["selection"],
+        )
+
+
+def _is_sha256(value: object) -> bool:
+    return (
+        isinstance(value, str)
+        and len(value) == 64
+        and all(character in "0123456789abcdef" for character in value)
+    )
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _line(release: str) -> tuple[str, str]:
+    try:
+        return UK_CUT_REFERENCE_RELEASES[release]
+    except KeyError:
+        raise ValueError(
+            f"A UK cut compares with the current build of {release!r} only if "
+            f"it is one of {sorted(UK_CUT_REFERENCE_RELEASES)}."
+        ) from None
+
+
+def _check_national_certification(
+    payload: object, *, release: str, build: str, dataset_sha256: str
+) -> None:
+    from microcosm.data.gate_signing_keys import registered_gate_signing_key
+
+    where = f"release_certification.json of {release}@{build}"
+    if not isinstance(payload, Mapping):
+        raise ValueError(f"The {where} is not a JSON object.")
+    if payload.get("kind") != "uk_release_certification":
+        raise ValueError(f"The {where} is not a UK release certification.")
+    if payload.get("release_id") != release:
+        raise ValueError(f"The {where} certifies another release.")
+    if payload.get("shippable") is not True:
+        raise ValueError(
+            f"The current build {release}@{build} is not certified shippable; a "
+            "cut compares only with a certified build."
+        )
+    candidate = payload.get("candidate")
+    if not isinstance(candidate, Mapping) or candidate.get("sha256") != dataset_sha256:
+        raise ValueError(
+            f"The {where} certifies another file than the build's dataset."
+        )
+    attestation = payload.get("attestation")
+    fingerprint = (
+        attestation.get("signing_key_sha256")
+        if isinstance(attestation, Mapping)
+        else None
+    )
+    if not isinstance(fingerprint, str) or (
+        registered_gate_signing_key("uk", fingerprint) is None
+    ):
+        raise ValueError(f"The {where} was not signed by a registered UK gate key.")
+
+
+def _check_dense_gate_summary(payload: object, *, release: str, build: str) -> None:
+    where = f"gate_summary.json of {release}@{build}"
+    if not isinstance(payload, Mapping):
+        raise ValueError(f"The {where} is not a JSON object.")
+    gates = payload.get("gates")
+    if not isinstance(gates, Mapping) or not gates:
+        raise ValueError(f"The {where} reports no gates.")
+    failing = sorted(
+        name
+        for name, gate in gates.items()
+        if not isinstance(gate, Mapping)
+        or gate.get("passed") is not True
+        or gate.get("status") != "passed"
+    )
+    if failing:
+        raise ValueError(
+            f"The current build {release}@{build} did not pass "
+            f"{', '.join(failing)}; a cut compares only with a certified build."
+        )
+
+
+def _checked_evidence(
+    certified: Any,
+    *,
+    release: str,
+    evidence_key: str,
+    hub_download: _HubDownload | None,
+) -> dict[str, str]:
+    from microcosm.data.loader import download_build_file
+
+    path = download_build_file(certified, evidence_key, hub_download=hub_download)
+    try:
+        payload = json.loads(path.read_text())
+    except (OSError, ValueError) as exc:
+        raise ValueError(
+            f"Could not read {path.name} of {release}@{certified.build}: {exc}."
+        ) from exc
+    if evidence_key == "release_certification":
+        _check_national_certification(
+            payload,
+            release=release,
+            build=certified.build,
+            dataset_sha256=certified.artifact_sha256,
+        )
+    else:
+        _check_dense_gate_summary(payload, release=release, build=certified.build)
+    return {"key": evidence_key, "filename": path.name, "sha256": _sha256(path)}
+
+
+def uk_cut_reference_withdrawal(
+    reference: UKCutReference, *, hub_download: _HubDownload | None = None
+) -> str | None:
+    """Why the cut's recorded reference no longer stands, read-only, or None.
+
+    A build is usually withdrawn because something is wrong with it, so a cut
+    that resolved it earlier must not certify against it afterwards (the
+    review of microcosm#1574). Reads the release record only and never moves
+    the cut to another build: that stays the operator's
+    ``--re-resolve-reference``.
+    """
+
+    reason = _withdrawal_reason(
+        reference.repo_id, reference.release, reference.build, hub_download
+    )
+    if reason is not None and reason.endswith("has been withdrawn"):
+        return f"{reason} since the cut resolved it"
+    return reason
+
+
+def _withdrawal_reason(
+    repo_id: str, release: str, build: str, hub_download: _HubDownload | None
+) -> str | None:
+    from microcosm.data.releases_record import (
+        RELEASES_RECORD_PATH,
+        parse_releases_record,
+    )
+
+    if hub_download is None:
+        from huggingface_hub import hf_hub_download as hub_download
+    path = hub_download(
+        repo_id=repo_id, filename=RELEASES_RECORD_PATH, repo_type="dataset"
+    )
+    record = parse_releases_record(Path(path).read_bytes())
+    entry = record.releases.get(release)
+    if entry is None:
+        return f"{RELEASES_RECORD_PATH} no longer lists {release}"
+    listed = entry.builds.get(build)
+    if listed is None:
+        return f"{RELEASES_RECORD_PATH} does not list {release}@{build}"
+    if listed.withdrawn:
+        return f"{release}@{build} has been withdrawn"
+    return None
+
+
+def check_uk_cut_reference(
+    release: str,
+    *,
+    build: str | None = None,
+    hub_download: _HubDownload | None = None,
+) -> dict[str, str]:
+    """Which build a cut of ``release`` would compare with now, read-only.
+
+    Reads the release record, the build's manifest and its certification
+    evidence, with every check the fetch makes, but downloads no dataset.
+    ``build`` pins a listed build, as :func:`resolve_uk_cut_reference` does.
+    """
+
+    import warnings
+
+    from microcosm.data.loader import resolve_certified
+
+    variant, evidence_key = _line(release)
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", UserWarning)
+        certified = resolve_certified(
+            "uk",
+            _REGISTRY_YEAR,
+            variant=variant,
+            build=build,
+            hub_download=hub_download,
+        )
+    _require_build_folder(certified, release=release)
+    evidence = _checked_evidence(
+        certified, release=release, evidence_key=evidence_key, hub_download=hub_download
+    )
+    if build is not None:
+        withdrawn = _withdrawal_reason(
+            certified.artifact_repo_id, release, certified.build, hub_download
+        )
+        if withdrawn:
+            raise ValueError(f"{withdrawn}; a cut never compares with a build that is.")
+    return {
+        "release": release,
+        "build": certified.build,
+        "selection": "current" if build is None else "pinned",
+        "path_in_repo": certified.artifact_path,
+        "sha256": certified.artifact_sha256,
+        "built_with_model_package": (
+            f"{certified.model.name} {certified.model.built_version}"
+        ),
+        "evidence": evidence["filename"],
+    }
+
+
+def _require_build_folder(certified: Any, *, release: str) -> None:
+    if certified.release_id != release or certified.build is None:
+        raise ValueError(
+            f"{release} is not recorded in the Hub's releases.json, so it has no "
+            "current build for a cut to compare with."
+        )
+
+
+def resolve_uk_cut_reference(
+    release: str,
+    *,
+    build: str | None = None,
+    hub_download: _HubDownload | None = None,
+    now: Callable[[], datetime] | None = None,
+) -> tuple[Path, UKCutReference]:
+    """Download and check the current build of ``release`` for a cut.
+
+    Returns the verified dataset's local path and the record a cut keeps.
+    Refuses a release the Hub does not record in ``releases.json`` and a
+    build whose certification evidence does not pass. ``build`` pins a
+    listed build instead of the current one, for a line with no current
+    build (the review of microcosm#1574); a pinned build is checked like the
+    current one, refused if withdrawn, and recorded as pinned.
+    """
+
+    import warnings
+
+    from microcosm.data.loader import download_certified
+
+    variant, evidence_key = _line(release)
+    with warnings.catch_warnings():
+        # The loader warns on a withdrawn pin; a cut refuses one below.
+        warnings.simplefilter("ignore", UserWarning)
+        path, certified = download_certified(
+            "uk",
+            _REGISTRY_YEAR,
+            variant=variant,
+            build=build,
+            hub_download=hub_download,
+        )
+    _require_build_folder(certified, release=release)
+    evidence = _checked_evidence(
+        certified, release=release, evidence_key=evidence_key, hub_download=hub_download
+    )
+    resolved_at = (now or (lambda: datetime.now(UTC)))().strftime("%Y-%m-%dT%H:%M:%SZ")
+    reference = UKCutReference(
+        release=release,
+        build=certified.build,
+        repo_id=certified.artifact_repo_id,
+        path_in_repo=certified.artifact_path,
+        filename=Path(certified.artifact_path).name,
+        sha256=certified.artifact_sha256,
+        size_bytes=path.stat().st_size,
+        built_with_model_package={
+            "name": certified.model.name,
+            "version": certified.model.built_version,
+        },
+        built_with_core_package={
+            "name": certified.core.name,
+            "version": certified.core.built_version,
+        },
+        evidence=evidence,
+        resolved_at=resolved_at,
+        selection="current" if build is None else "pinned",
+    )
+    if build is not None:
+        withdrawn = _withdrawal_reason(
+            reference.repo_id, release, reference.build, hub_download
+        )
+        if withdrawn:
+            raise ValueError(f"{withdrawn}; a cut never compares with a build that is.")
+    return path, reference
+
+
+def write_uk_cut_reference(path: str | Path, reference: UKCutReference) -> Path:
+    destination = Path(path)
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    destination.write_text(json.dumps(reference.to_record(), indent=2, sort_keys=True))
+    return destination
+
+
+def read_uk_cut_reference(path: str | Path) -> UKCutReference:
+    source = Path(path)
+    try:
+        payload = json.loads(source.read_text())
+    except (OSError, ValueError) as exc:
+        raise ValueError(
+            f"Could not read the cut's reference record {source}: {exc}."
+        ) from exc
+    return UKCutReference.from_record(payload)
+
+
+def verify_uk_cut_reference_file(reference: UKCutReference, path: str | Path) -> Path:
+    """Refuse ``path`` unless it is the file ``reference`` records."""
+
+    source = Path(path)
+    if not source.is_file():
+        raise ValueError(
+            f"The cut's reference {reference.label} is not at {source}; fetch it again."
+        )
+    size = source.stat().st_size
+    if size != reference.size_bytes:
+        raise ValueError(
+            f"{source} is {size} bytes, but the cut's reference {reference.label} "
+            f"is {reference.size_bytes}."
+        )
+    observed = _sha256(source)
+    if observed != reference.sha256:
+        raise ValueError(
+            f"{source} has sha256 {observed}, but the cut's reference "
+            f"{reference.label} has {reference.sha256}."
+        )
+    return source
+
+
+def fetch_uk_cut_reference(
+    release: str,
+    output_dir: str | Path,
+    *,
+    build: str | None = None,
+    hub_download: _HubDownload | None = None,
+    now: Callable[[], datetime] | None = None,
+) -> UKCutReference:
+    """Resolve the current build of ``release`` into ``output_dir``, once.
+
+    Copies the verified dataset there and writes its record beside it
+    (:data:`UK_CUT_REFERENCE_RECORD_NAME`). Refuses a directory that already
+    holds a record, so a run keeps the reference it started with.
+    """
+
+    directory = Path(output_dir)
+    record_path = directory / UK_CUT_REFERENCE_RECORD_NAME
+    if record_path.exists():
+        raise ValueError(
+            f"{directory} already holds a reference ({record_path}); a run keeps "
+            "the reference it started with. Use a new directory to resolve again."
+        )
+    source, reference = resolve_uk_cut_reference(
+        release, build=build, hub_download=hub_download, now=now
+    )
+    directory.mkdir(parents=True, exist_ok=True)
+    destination = directory / reference.filename
+    partial = destination.with_name(destination.name + ".partial")
+    shutil.copyfile(source, partial)
+    try:
+        verify_uk_cut_reference_file(reference, partial)
+    except ValueError:
+        partial.unlink(missing_ok=True)
+        raise
+    partial.replace(destination)
+    keep_uk_cut_reference_evidence(reference, directory, hub_download=hub_download)
+    write_uk_cut_reference(record_path, reference)
+    return reference
+
+
+def keep_uk_cut_reference_evidence(
+    reference: UKCutReference,
+    directory: str | Path,
+    *,
+    hub_download: _HubDownload | None = None,
+) -> Path:
+    """Copy the build's certification evidence beside it, checked.
+
+    The fetch keeps it, having read and checked it already; a resumed cut
+    whose copy is missing keeps it again before it writes the evidence the
+    gates read, since the chain since the baseline continues from it. The
+    copy is checked against the record's sha256 before it is kept.
+    """
+
+    from pathlib import PurePosixPath
+
+    directory = Path(directory)
+    if hub_download is None:
+        from huggingface_hub import hf_hub_download as hub_download
+    folder = PurePosixPath(reference.path_in_repo).parent
+    source = Path(
+        hub_download(
+            repo_id=reference.repo_id,
+            filename=str(folder / reference.evidence["filename"]),
+            repo_type="dataset",
+        )
+    )
+    if _sha256(source) != reference.evidence["sha256"]:
+        raise ValueError(
+            f"{reference.evidence['filename']} of {reference.label} no longer has "
+            "the sha256 the fetch checked."
+        )
+    destination = directory / UK_CUT_REFERENCE_EVIDENCE_NAME
+    shutil.copyfile(source, destination)
+    return destination
+
+
+def uk_input_mass_reference_payload(
+    h5_path: str | Path,
+    *,
+    label: str,
+    filename: str,
+    revision: str,
+    sha256: str,
+    vintage: str = "2024_25",
+) -> dict[str, object]:
+    """The schema-2 input-mass reference a cut writes from its reference build.
+
+    Totals and carriers come from the build's export frame at its own solved
+    weights (:func:`~.weight_year.uk_recorded_solve_year_frame`), so a build
+    an earlier policyengine-uk wrote compares on the weights it was solved
+    with, as the candidate does.
+    """
+
+    # Here, not in weighted_integrity: the target kernels reach that module,
+    # and the dataset readers below are no part of any target's value.
+    from microcosm.build.uk_runtime.national_frame import uk_published_release_frame
+    from microcosm.build.uk_runtime.rowwise_dataset import load_uk_rowwise_dataset
+    from microcosm.build.uk_runtime.weight_year import uk_recorded_solve_year_frame
+    from microcosm.build.uk_runtime.weighted_integrity import (
+        UK_INPUT_MASS_REFERENCE_KIND,
+        UK_INPUT_MASS_REFERENCE_SCHEMA_VERSION,
+        uk_input_mass_carriers,
+        uk_input_mass_totals,
+    )
+
+    # The row-wise reader opens both lines' files: the dense line's carries one
+    # ``clone_index`` name on every table, which the compact national loader
+    # refuses, and a national file carries none.
+    frame, _provenance = load_uk_rowwise_dataset(h5_path)
+    export = uk_published_release_frame(uk_recorded_solve_year_frame(frame))
+    return {
+        "schema_version": UK_INPUT_MASS_REFERENCE_SCHEMA_VERSION,
+        "kind": UK_INPUT_MASS_REFERENCE_KIND,
+        "label": label,
+        "identity": {
+            "filename": filename,
+            "revision": revision,
+            "sha256": sha256,
+            "vintage": vintage,
+        },
+        "totals": uk_input_mass_totals(export),
+        "carriers": uk_input_mass_carriers(export),
+    }
+
+
+def uk_cut_reference_chain(
+    reference: UKCutReference,
+    directory: str | Path,
+    *,
+    totals: Mapping[str, float],
+    carriers: Mapping[str, int],
+    carried_inputs: frozenset[str] | set[str],
+) -> dict[str, Any]:
+    """The reference's change since the baseline, for the cut to continue.
+
+    Every check compares a cut with the build before it, so drift can add up
+    across cuts (the review of microcosm#1574). A national build's
+    certification records its change since a fixed baseline: each column's
+    input-mass total as a ratio of the baseline's, the columns that have left
+    that chain with why and their last ratio, the inputs the baseline
+    carried, and which of them it no longer carries. The cut continues that
+    chain, multiplying the ratios its own input-mass gate measures, with no
+    baseline dataset loaded. A reference whose certification carries no chain
+    (one certified before it, or a dense build, whose published evidence
+    carries none of these gates) starts one: the reference is the baseline,
+    its ratios one, for the columns at least three source households carry.
+
+    The chain continues from the reference's evidence kept beside it
+    (:func:`keep_uk_cut_reference_evidence`), so a missing copy is refused:
+    read as a reference with no chain, it would restart the chain without a
+    trace (round 2 of the review).
+    """
+
+    from microcosm.build.uk_runtime.receipt_counts import UK_DISCLOSURE_FLOOR
+
+    evidence = Path(directory) / UK_CUT_REFERENCE_EVIDENCE_NAME
+    if not evidence.is_file():
+        raise ValueError(
+            f"{evidence} is missing: the change since the baseline continues from "
+            f"{reference.label}'s own evidence, so keep it again before writing "
+            "the cut's evidence (the reference step of tools/run_uk_cut.py does)."
+        )
+    payload = json.loads(evidence.read_text())
+    chain = payload.get("since_baseline") if isinstance(payload, Mapping) else None
+    if isinstance(chain, Mapping):
+        return {
+            "baseline": str(chain["baseline"]),
+            "input_mass_ratios": {
+                str(name): float(value)
+                for name, value in chain["input_mass_ratios"].items()
+            },
+            "input_mass_left": {
+                str(name): {
+                    "reason": str(entry["reason"]),
+                    "last_ratio": float(entry["last_ratio"]),
+                    "last_build": str(entry["last_build"]),
+                }
+                for name, entry in chain["input_mass_left"].items()
+            },
+            "baseline_inputs": sorted(str(name) for name in chain["baseline_inputs"]),
+        }
+    return {
+        "baseline": reference.label,
+        "input_mass_ratios": {
+            str(name): 1.0
+            for name, total in totals.items()
+            if float(total) != 0.0 and int(carriers.get(name, 0)) >= UK_DISCLOSURE_FLOOR
+        },
+        "input_mass_left": {},
+        "baseline_inputs": sorted(str(name) for name in carried_inputs),
+    }
+
+
+def write_uk_cut_reference_evidence(
+    reference: UKCutReference, h5_path: str | Path, output_dir: str | Path
+) -> dict[str, Path]:
+    """Write the evidence the gates read from the reference, beside it.
+
+    The input-mass totals and carriers of the build's export frame at its own
+    solved weights (:func:`uk_input_mass_reference_payload`),
+    which hold licensed-data aggregates and stay with the cut as the
+    reference's dataset does, and the build's column surface, names and
+    flags only (:func:`~.reference_surface.uk_reference_surface_payload`).
+    """
+
+    from microcosm.build.uk_runtime.reference_surface import (
+        uk_reference_surface_payload,
+    )
+
+    source = verify_uk_cut_reference_file(reference, h5_path)
+    directory = Path(output_dir)
+    directory.mkdir(parents=True, exist_ok=True)
+    payload = uk_input_mass_reference_payload(
+        source,
+        label=reference.label,
+        filename=reference.filename,
+        revision=reference.build,
+        sha256=reference.sha256,
+    )
+    surface = uk_reference_surface_payload(
+        source, label=reference.label, sha256=reference.sha256
+    )
+    chain = uk_cut_reference_chain(
+        reference,
+        directory,
+        totals=payload["totals"],
+        carriers=payload["carriers"],
+        carried_inputs={*surface["populated_inputs"], *surface["thin_inputs"]},
+    )
+    payload["since_baseline"] = {
+        "baseline": chain["baseline"],
+        "ratios": chain["input_mass_ratios"],
+        "left": chain["input_mass_left"],
+    }
+    surface["baseline"] = {
+        "label": chain["baseline"],
+        "inputs": chain["baseline_inputs"],
+    }
+    written: dict[str, Path] = {}
+    for key, name, content in (
+        ("input_mass_reference", UK_CUT_REFERENCE_INPUT_MASS_NAME, payload),
+        ("reference_surface", UK_CUT_REFERENCE_SURFACE_NAME, surface),
+    ):
+        destination = directory / name
+        partial = destination.with_name(destination.name + ".partial")
+        partial.write_text(json.dumps(content, sort_keys=True, allow_nan=False))
+        partial.replace(destination)
+        written[key] = destination
+    return written
+
+
+def uk_cut_reference_evidence_done(
+    reference: UKCutReference, output_dir: str | Path
+) -> tuple[bool, str]:
+    """Whether the reference's evidence is beside it and names this build."""
+
+    for name in (UK_CUT_REFERENCE_INPUT_MASS_NAME, UK_CUT_REFERENCE_SURFACE_NAME):
+        try:
+            payload = json.loads((Path(output_dir) / name).read_text())
+        except (OSError, ValueError):
+            return False, f"no {name} beside the reference"
+        if not isinstance(payload, Mapping):
+            return False, f"{name} is not a JSON object"
+        identity = payload.get("identity")
+        sha256 = (
+            identity.get("sha256")
+            if isinstance(identity, Mapping)
+            else payload.get("sha256")
+        )
+        if payload.get("label") != reference.label or sha256 != reference.sha256:
+            return False, f"{name} names another build"
+        block = (
+            "since_baseline" if name == UK_CUT_REFERENCE_INPUT_MASS_NAME else "baseline"
+        )
+        if not isinstance(payload.get(block), Mapping):
+            return False, f"{name} records no change since the baseline"
+        # Evidence written before the record listed the columns that leave
+        # the chain is written again (round 2 of the review).
+        if block == "since_baseline" and not isinstance(
+            payload[block].get("left"), Mapping
+        ):
+            return False, f"{name} lists no columns that left the chain"
+    return True, f"evidence for {reference.label}"
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/full_build_cli.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/full_build_cli.py
index 8c2c5ae682..672f8feef4 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/full_build_cli.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/full_build_cli.py
@@ -603,6 +603,16 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
     parser.add_argument("--measure-exclusions", type=Path)
     parser.add_argument("--register-json", type=Path)
     parser.add_argument("--input-mass-reference", type=Path)
+    parser.add_argument(
+        "--reference-surface",
+        type=Path,
+        help=(
+            "Dense role: the export surface and carried inputs of the dense "
+            "line's current build (reference_surface.json from "
+            "tools/resolve_uk_reference.py), which the export-surface and "
+            "input-coverage gates compare with (microcosm#1095)."
+        ),
+    )
     parser.add_argument(
         "--native-scorecard",
         type=Path,
@@ -825,18 +835,20 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
         help="National role only: allow a Ledger artifact whose feed commit is not the committed Chronicle pin.",
     )
     parser.add_argument(
-        "--incumbent-h5",
+        "--reference-h5",
         type=Path,
-        help="National role only: the incumbent dataset the finished candidate is evaluated against.",
-    )
-    parser.add_argument(
-        "--incumbent-sha256",
-        help="National role only: the incumbent's SHA-256, verified before it is read.",
+        help=(
+            "National role only: the current national build the finished "
+            "candidate is compared with (microcosm#1095)."
+        ),
     )
     parser.add_argument(
-        "--incumbent-label",
-        default="enhanced_frs_2024_25",
-        help="National role only: the incumbent's label in the score receipt.",
+        "--reference-record",
+        type=Path,
+        help=(
+            "National role only: the cut's record of that build "
+            "(tools/resolve_uk_reference.py), checked against the file."
+        ),
     )
     parser.add_argument(
         "--logbook-prev-row-digest",
@@ -1460,14 +1472,18 @@ def prepare_full_build(
         if path is not None:
             sources[name] = path
             optional.append(name)
-    if args.input_mass_reference is not None:
-        sources["uk_input_mass_reference"] = args.input_mass_reference
+    for name, path in (
+        ("uk_input_mass_reference", args.input_mass_reference),
+        # The reference build's surface (microcosm#1095): the export-surface
+        # and input-coverage gates read it, and are evidence_absent without.
+        ("uk_reference_surface", getattr(args, "reference_surface", None)),
+    ):
+        if path is None:
+            continue
+        sources[name] = path
         spine = replace(
             spine,
-            sources=(
-                *spine.sources,
-                SourceRef("uk_input_mass_reference", "raw-bytes-v1"),
-            ),
+            sources=(*spine.sources, SourceRef(name, "raw-bytes-v1")),
         )
     checkpoint_identity = (
         None
@@ -1807,6 +1823,7 @@ def _argument_sources(args: argparse.Namespace) -> dict[str, Path]:
             ("measure_exclusions", args.measure_exclusions),
             ("register_json", args.register_json),
             ("input_mass_reference", args.input_mass_reference),
+            ("reference_surface", getattr(args, "reference_surface", None)),
             ("native_scorecard", args.native_scorecard),
             ("matched_size_scorecard", args.matched_size_scorecard),
             ("resume_size_checkpoint", args.resume_size_checkpoint),
@@ -3194,7 +3211,7 @@ def _execute_national_build(
         "chronicle_provenance": dict(registry_document["chronicle_provenance"]),
     }
     record["inputs"] = inputs
-    record["incumbent"] = national_role.incumbent_arguments(args)
+    record["reference"] = national_role.reference_arguments(args)
     # 3. The solve and the seam battery, evaluated in the graph.
     stage(
         telemetry,
@@ -3275,7 +3292,6 @@ def _execute_national_build(
         "measure_resolution": evidence["calibration"].get("measure_resolution"),
         "register": evidence["register"],
         "spine_provenance": spine_provenance,
-        "score_vs_enhanced_frs": None,
     }
     stage(telemetry, "diagnostics", "started")
     diagnostics_outcome = write_uk_calibration_diagnostics(
@@ -3528,7 +3544,7 @@ def _close_national_attempt(
     """Stage the published bundle, evaluate, close the telemetry, spool the row.
 
     The seam's order: the manifest and the staged bundle's hand-over first,
-    then the incumbent evaluation, which waits for no upload and runs before
+    then the comparison with the reference, which waits for no upload and runs before
     the telemetry completes, then the build record and the manifest rewritten
     with the delivery summary and the sums refreshed. The build record is
     rewritten after the hand-over, so the bundle the emitter holds keeps the
@@ -3556,9 +3572,9 @@ def _close_national_attempt(
         )
         staged_dataset = staged.delivery
         append_phase(state, STAGED_DATASET_PHASES[staged_dataset["status"]])
-        evaluation = national_role.evaluate_against_incumbent(
+        evaluation = national_role.evaluate_against_reference(
             args,
-            incumbent=record.get("incumbent"),
+            reference=record.get("reference"),
             inputs=record["inputs"],
             output_paths=paths,
             telemetry=telemetry,
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/full_gates.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/full_gates.py
index f9c9d7b183..6d3d201960 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/full_gates.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/full_gates.py
@@ -25,7 +25,6 @@
 from microcosm.build.uk_runtime.cgt_projection import UK_CGT_PROJECTION_ARTIFACT_KEY
 from microcosm.build.uk_runtime.graph_evidence import uk_spine_gate_artifacts
 from microcosm.build.uk_runtime.national_frame import uk_release_export_frame
-from microcosm.build.uk_runtime.parity_reference import load_efrs_parity_reference
 from microcosm.build.uk_runtime.support_floor import uk_support_floor_names
 from microcosm.build.uk_runtime.terminal_gates import uk_export_candidate_columns
 from microcosm.calibrate import TargetRegistry
@@ -254,7 +253,6 @@ def build_full_gate_context(
         for spec in reference_registry.specs
         if (spec.name, spec.period) in selected
     }
-    reference = load_efrs_parity_reference()
     manifest = uk_full_gate_manifest(selection_receipt)
     admin_totals, admin_receipt = uk_aggregate_admin_totals(frame, manifest)
     artifacts = dict(supporting_evidence)
@@ -281,14 +279,14 @@ def build_full_gate_context(
                 "resolved_reference_count": len(problem.targets),
                 "matrix_target_count": len(problem.names),
             },
+            # The export-surface and input-coverage gates read the reference
+            # build's surface (``reference_surface``, the dense line's
+            # current build, from --reference-surface) beside this; without
+            # it they are evidence_absent (microcosm#1095).
             "parity_evidence": SimpleNamespace(
                 candidate_columns=uk_export_candidate_columns(
                     uk_release_export_frame(frame)
                 ),
-                reference_columns={
-                    f"{entity}.{name}"
-                    for name, entity in reference.input_entities.items()
-                },
                 candidate_targets=set(national_errors),
                 reference_targets=national_reference,
                 target_relative_errors=national_errors,
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/graph_national.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/graph_national.py
index 54bc522b9f..c8a574003f 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/graph_national.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/graph_national.py
@@ -475,7 +475,7 @@ def implementation_hash(self) -> str:
         import microcosm.calibrate.artifacts as calibrate_artifacts
         import microcosm.calibrate.matrix as calibrate_matrix
 
-        from . import weighted_integrity
+        from . import receipt_counts, weighted_integrity
         from .target_compile_modules import uk_target_compile_modules
 
         implementation = source_hash(
@@ -502,8 +502,11 @@ def implementation_hash(self) -> str:
             calibrate_matrix,
             calibrate_artifacts,
             # full_targets takes its exclusion clock from here; hashed
-            # directly, as the dense target kernels do.
+            # directly, as the dense target kernels do. Its input-mass gate
+            # counts source households with receipt_counts (microcosm#1095),
+            # hashed beside it so every import it makes is hashed.
             weighted_integrity,
+            receipt_counts,
             *uk_target_compile_modules(),
         )
         return hashlib.sha256(
@@ -1003,7 +1006,7 @@ class UKNationalGateKernel(_NationalKernel):
 
     def implementation_hash(self) -> str:
         from .. import gate_battery
-        from . import battery_bindings, diagnostics, weighted_integrity
+        from . import battery_bindings, diagnostics, receipt_counts, weighted_integrity
 
         return hashlib.sha256(
             canonical_json(
@@ -1015,6 +1018,8 @@ def implementation_hash(self) -> str:
                         battery_bindings,
                         calibration_run,
                         weighted_integrity,
+                        # The input-mass gate's source-household counts.
+                        receipt_counts,
                         diagnostics,
                         support_floor_rules,
                     ),
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/graph_targets.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/graph_targets.py
index 2dddec06d7..1fd6040765 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/graph_targets.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/graph_targets.py
@@ -226,6 +226,7 @@ def implementation_hash(self) -> str:
             full_targets,
             high_value_homes,
             measure_simulation,
+            receipt_counts,
             weighted_integrity,
         )
         from .target_compile_modules import uk_target_compile_modules
@@ -252,8 +253,11 @@ def implementation_hash(self) -> str:
             calibrate_artifacts,
             # full_targets takes its exclusion clock from here. Hashed
             # directly, not listed: the module also loads the registers only
-            # the validation checks read, which no listed module may.
+            # the validation checks read, which no listed module may. Its
+            # input-mass gate counts source households with receipt_counts
+            # (microcosm#1095), hashed beside it.
             weighted_integrity,
+            receipt_counts,
             *uk_target_compile_modules(),
         )
         # The solve fingerprint: every packaged resource but the gate-only
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/graph_terminal.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/graph_terminal.py
index 5e55da28b9..15f0f6e85b 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/graph_terminal.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/graph_terminal.py
@@ -651,6 +651,38 @@ def decode_full_gate_report(payload: bytes | Mapping):
     return report, enforcement
 
 
+def _require_one_reference(supporting: Mapping[str, Any]) -> None:
+    """Refuse references of two builds, or of another line than the dense one.
+
+    The dense line compares with one build, its current one (microcosm#1095):
+    both files come from ``tools/resolve_uk_reference.py`` for that build. A
+    national build's files agree with each other, so the line is checked too
+    (the review of microcosm#1574).
+    """
+
+    from .release_identity import UK_DENSE_RELEASE_ID
+
+    mass = supporting.get("input_mass_reference")
+    surface = supporting.get("reference_surface")
+    for name, evidence in (("input-mass reference", mass), ("surface", surface)):
+        if evidence is not None and not str(evidence.label).startswith(
+            f"{UK_DENSE_RELEASE_ID}@"
+        ):
+            raise ValueError(
+                f"The dense build's {name} names {evidence.label}, not a build of "
+                f"{UK_DENSE_RELEASE_ID}; resolve it with tools/resolve_uk_reference.py "
+                f"--release {UK_DENSE_RELEASE_ID}."
+            )
+    if mass is None or surface is None:
+        return
+    if (mass.label, mass.sha256) != (surface.label, surface.sha256):
+        raise ValueError(
+            f"The input-mass reference names {mass.label} ({mass.sha256}) but the "
+            f"reference surface names {surface.label} ({surface.sha256}); write "
+            "both from one reference with tools/resolve_uk_reference.py."
+        )
+
+
 def _spine_gate_evidence(context: KernelContext):
     from ..stage_evidence import decode_stage_evidence
 
@@ -846,6 +878,7 @@ def run(self, context: KernelContext) -> KernelResult:
         )
         from .geography_ladder import load_uk_oa_ladder
         from .local_rowwise import uk_ladder_area_support_summary
+        from .reference_surface import load_uk_reference_surface
         from .release_certification import rehydrate_uk_fit_weight_records
         from .weighted_integrity import load_uk_input_mass_reference
 
@@ -938,6 +971,11 @@ def run(self, context: KernelContext) -> KernelResult:
                 supporting["input_mass_reference"] = load_uk_input_mass_reference(
                     context.sources["uk_input_mass_reference"]
                 )
+            if "uk_reference_surface" in context.sources:
+                supporting["reference_surface"] = load_uk_reference_surface(
+                    context.sources["uk_reference_surface"]
+                )
+            _require_one_reference(supporting)
             household = frame.table("household").copy()
             household["household_weight"] = frame.weights_for("household").values
             summaries = uk_ladder_area_support_summary(
@@ -1209,10 +1247,10 @@ def append_uk_full_gate_nodes(
         else node
         for node in graph.nodes
     )
-    sources = ("uk_ladder",) + (
-        ("uk_input_mass_reference",)
-        if any(source.name == "uk_input_mass_reference" for source in graph.sources)
-        else ()
+    sources = ("uk_ladder",) + tuple(
+        name
+        for name in ("uk_input_mass_reference", "uk_reference_surface")
+        if any(source.name == name for source in graph.sources)
     )
     # The spine checkpoint's build state, when the bound checkpoint publishes
     # it: the input-coverage gate reads the stages' importance weights and
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/national_frame.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/national_frame.py
index 2b6282bb19..deaec533dc 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/national_frame.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/national_frame.py
@@ -74,6 +74,7 @@
     "uk_household_mass_conservation_receipt",
     "uk_time_period",
     "validate_uk_national_frame",
+    "uk_published_release_frame",
     "uk_release_export_frame",
     "write_uk_national_frame",
 ]
@@ -736,6 +737,11 @@ def _write_uk_single_year_tables(
         # (frs_spine.FRS_UC_LCW_STATUS_COLUMN) the uc_limited_capability stage
         # reads (microcosm#1095, Y1); it is no engine input.
         "frs_uc_lcw_status",
+        # The gross receipts microcosm#1550 (microcosm#1439) stops writing:
+        # the trading allowance stage stores the claim status instead. A frame
+        # from an older spine would carry the receipts encoding into the
+        # release, which the export gate refuses (microcosm#1095).
+        "self_employment_gross_receipts",
         # The company car carriers (frs_spine.FRS_COMPANY_CAR_CARRIER_COLUMNS)
         # the company_cars stage reads to set policyengine-uk's company car
         # inputs (PolicyEngine/uk-autumn-budget-dashboard-2026#316); they are
@@ -1052,6 +1058,50 @@ def uk_release_export_frame(frame: Frame) -> Frame:
     )
 
 
+def uk_published_release_frame(frame: Frame) -> Frame:
+    """A published release file read back, through today's export boundary.
+
+    A cut compares with the current build of its line (microcosm#1095), whose
+    file already left through the export boundary of its own build: a dense
+    file carries the consumers' area-code names (microcosm#1114), which
+    :func:`uk_release_export_frame` refuses on a frame it is to rename. Those
+    names go back to the ladder's first, so the boundary writes them again and
+    the reference leaves with today's drops and names, exactly as the
+    candidate does. A national file carries none and only takes the drops.
+    """
+
+    from .geography_ladder import UK_EXPORT_AREA_CODE_COLUMNS
+
+    household = frame.table("household")
+    published = {
+        export: ladder
+        for ladder, export in UK_EXPORT_AREA_CODE_COLUMNS.items()
+        if export in household.columns
+    }
+    shadowed = sorted(
+        ladder for ladder in published.values() if ladder in household.columns
+    )
+    if shadowed:
+        raise ValueError(
+            "A published release file carries both the ladder and the consumer "
+            f"names of the area code(s) {shadowed}; it did not leave through "
+            "the export boundary."
+        )
+    if published:
+        frame = uk_national_frame(
+            person=frame.table("person"),
+            benunit=frame.table("benunit"),
+            household=household.rename(columns=published),
+            time_period=uk_time_period(frame),
+            weight_kind=uk_household_weight_kind(frame),
+            household_weights=frame.weights_for("household").values,
+            mass_log=frame.mass_log,
+            isa_income_contract=uk_isa_income_contract(frame),
+            savings_income_projection=uk_savings_income_projection(frame),
+        )
+    return uk_release_export_frame(frame)
+
+
 def write_uk_national_frame(frame: Frame, path: str | Path) -> Path:
     """Atomically write a validated UK national Frame as a staging H5."""
 
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/national_role.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/national_role.py
index e52e1b2656..2386df83c2 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/national_role.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/national_role.py
@@ -5,8 +5,8 @@
 national path lives in :mod:`.full_build_cli`). This module holds what the
 role adds around the graph: the dry-run plan, the receipted doctrine
 overrides, the schema-4 national manifest over the seam-shaped evidence, the
-optional end-of-build evaluation against the incumbent (microcosm#578 rule 1
-on the common surface), the pinned-input and output-path checks and the
+optional end-of-build comparison with the reference (the current national
+build, microcosm#1095), the pinned-input and output-path checks and the
 local sums. These functions were moved from
 ``tools/build_uk_rowwise_candidate.py`` (microcosm#901 phase 4) and consume
 only the shared rowwise command surface (:mod:`.rowwise_cli`,
@@ -57,11 +57,11 @@
 from microcosm.calibrate import TargetRegistry
 
 __all__ = [
-    "evaluate_against_incumbent",
-    "incumbent_arguments",
+    "evaluate_against_reference",
     "national_doctrine_overrides",
     "national_dry_run",
     "national_manifest",
+    "reference_arguments",
     "require_bound_input",
     "require_signing_key",
 ]
@@ -146,6 +146,15 @@ def require_signing_key() -> None:
         ) from error
 
 
+def _dry_run_reference(args: argparse.Namespace) -> dict[str, Any] | None:
+    """The reference a dry run would compare with, without its full record."""
+
+    reference = reference_arguments(args)
+    if reference is None:
+        return None
+    return {key: value for key, value in reference.items() if key != "record"}
+
+
 def national_dry_run(
     args: argparse.Namespace,
     *,
@@ -203,7 +212,7 @@ def national_dry_run(
             ),
         ),
         "engine": "not_run",
-        "incumbent": incumbent_arguments(args),
+        "reference": _dry_run_reference(args),
         "releasable": False,
     }
     if operation_inventory is not None:
@@ -418,7 +427,7 @@ def verify_requested_pin(
 
 
 def _load_candidate_evaluator(importer=importlib.import_module):
-    """The common-surface scorer (microcosm#967), loaded when an incumbent is given.
+    """The head-to-head scorer, loaded when a reference is given.
 
     Lazy so the driver imports without it; a build asked to evaluate refuses
     up front, before any solve, when the scorer is not in the tree.
@@ -428,33 +437,45 @@ def _load_candidate_evaluator(importer=importlib.import_module):
         return importer("microcosm.build.uk_runtime.candidate_score")
     except ImportError as error:
         raise ValueError(
-            "--incumbent-h5 needs the common-surface scorer (microcosm#967): "
+            "--reference-h5 needs the head-to-head scorer: "
             "microcosm.build.uk_runtime.candidate_score is not in this tree."
         ) from error
 
 
-def incumbent_arguments(args: argparse.Namespace) -> dict[str, Any] | None:
-    """The national role's optional incumbent, pinned and verified up front."""
+def reference_arguments(args: argparse.Namespace) -> dict[str, Any] | None:
+    """The national role's optional reference, verified against its record.
+
+    The reference is the current build the cut recorded when it fetched it
+    (:mod:`.cut_reference`); the file must be the one the record names.
+    """
+
+    from microcosm.build.uk_runtime.cut_reference import (
+        read_uk_cut_reference,
+        verify_uk_cut_reference_file,
+    )
 
-    if args.incumbent_h5 is None and args.incumbent_sha256 is None:
+    if args.reference_h5 is None and args.reference_record is None:
         return None
-    if args.incumbent_h5 is None or args.incumbent_sha256 is None:
+    if args.reference_h5 is None or args.reference_record is None:
         raise ValueError(
-            "--incumbent-h5 and --incumbent-sha256 must be given together."
+            "--reference-h5 and --reference-record must be given together."
         )
     _load_candidate_evaluator()
-    incumbent_h5 = require_file(args.incumbent_h5, label="--incumbent-h5")
-    info = artifact_info(incumbent_h5)
-    verify_requested_pin("--incumbent-h5", info, requested=args.incumbent_sha256)
+    reference_h5 = require_file(args.reference_h5, label="--reference-h5")
+    record = read_uk_cut_reference(
+        require_file(args.reference_record, label="--reference-record")
+    )
+    verify_uk_cut_reference_file(record, reference_h5)
     return {
-        "path": str(incumbent_h5),
-        "sha256": info["sha256"],
-        "bytes": info["bytes"],
-        "label": str(args.incumbent_label),
+        "path": str(reference_h5),
+        "sha256": record.sha256,
+        "bytes": record.size_bytes,
+        "label": record.label,
+        "record": record.to_record(),
     }
 
 
-_incumbent_arguments = incumbent_arguments
+_reference_arguments = reference_arguments
 
 
 def list_sha256sums_entry(out_dir: Path, name: str) -> None:
@@ -476,127 +497,146 @@ def list_sha256sums_entry(out_dir: Path, name: str) -> None:
 
 
 #: Receipt blocks that are record arrays (lists of mappings): the reviewed
-#: telemetry artifact policy refuses them, and the verdict, the pruned block
-#: and the aggregates carry everything a reviewer reads. The full receipt stays
+#: telemetry artifact policy refuses them, and the summary, the pruned block
+#: and the counts carry everything a reviewer reads. The full receipt stays
 #: beside the outputs and in the staged bundle.
 _SCORE_RECEIPT_TELEMETRY_EXCLUDED = (
-    "target_drift",
     "signed_asymmetries",
     "measure_resolution",
 )
 
 
 def _score_receipt_telemetry_summary(score: Mapping[str, Any]) -> dict[str, Any]:
-    return {
+    summary = {
         key: value
         for key, value in score.items()
         if key not in _SCORE_RECEIPT_TELEMETRY_EXCLUDED
     }
+    head_to_head = summary.get("head_to_head")
+    if isinstance(head_to_head, Mapping):
+        targets = head_to_head.get("targets")
+        summary["head_to_head"] = {
+            **head_to_head,
+            "targets": {
+                key: value
+                for key, value in (targets or {}).items()
+                if key != "compared"
+            },
+        }
+    return summary
 
 
-def evaluate_against_incumbent(
+def evaluate_against_reference(
     args: argparse.Namespace,
     *,
-    incumbent: Mapping[str, Any] | None,
+    reference: Mapping[str, Any] | None,
     inputs: Mapping[str, Any],
     output_paths: Mapping[str, Path],
     telemetry: StagingRunBundleWriterV2 | None,
     calibration_year: int,
     out_dir: Path,
 ) -> dict[str, Any]:
-    """Score the finished candidate against the incumbent; never fail the build.
+    """Compare the finished candidate with the reference; never fail the build.
 
     Runs after the staged bundle is on the Hub and before the telemetry
     completes, so the receipt rides the run as a reviewed artifact. Rows the
-    incumbent cannot materialize are pruned from both arms and warned about
-    by name; the verdict (microcosm#578 rule 1 on the common surface) is
-    what the release-cut certifier requires to be ``passed``. An error is
-    recorded and warned, never raised: staging and the exit code stand.
+    reference cannot materialize are pruned from both arms and warned about
+    by name. The comparison decides nothing (microcosm#1095); the release-cut
+    certifier requires its receipt to name this candidate and this reference.
+    An error is recorded and warned, never raised: staging and the exit code
+    stand.
     """
 
-    if incumbent is None:
+    if reference is None:
         return {
             "status": "not_requested",
             "note": (
-                "no --incumbent-h5: the rule-1 score receipt the release-cut "
-                "certifier needs was not produced; score the candidate with "
+                "no --reference-h5: the score receipt the release-cut certifier "
+                "needs was not produced; score the candidate with "
                 "tools/score_uk_national_candidate.py before certification."
             ),
         }
     stage(
         telemetry,
-        "incumbent_evaluation",
+        "reference_evaluation",
         "started",
-        incumbent_sha256=incumbent["sha256"],
+        reference=reference["label"],
+        reference_sha256=reference["sha256"],
     )
     candidate = artifact_info(output_paths["dataset"])
     try:
         module = _load_candidate_evaluator()
-        score = module.evaluate_uk_candidate_against_incumbent(
+        score = module.evaluate_uk_candidate_against_reference(
             candidate_h5=output_paths["dataset"],
-            incumbent_h5=Path(incumbent["path"]),
+            reference_h5=Path(reference["path"]),
             candidate_sha256=candidate["sha256"],
-            incumbent_sha256=incumbent["sha256"],
+            reference_sha256=reference["sha256"],
             target_registry=inputs["national_registry"],
             calibration_year=calibration_year,
+            reference_label=reference["label"],
             measure_resolver_factory=module.uk_default_measure_resolver_factory(
                 out_dir, calibration_year
             ),
             candidate_label=output_paths["dataset"].stem,
-            incumbent_label=incumbent["label"],
             band_edge_registry=inputs["band_edge_registry"],
+            reference_record=reference["record"],
         )
         atomic_write_json(output_paths["score_receipt"], score)
     except Exception as error:  # noqa: BLE001 - the evaluation never fails a finished build
         message = f"{type(error).__name__}: {error}"[:600]
         print(
-            f"warning: the incumbent evaluation failed ({message}); the build's "
-            "evidence and staging are unaffected, and the candidate cannot be "
-            "certified until it is re-scored with "
+            f"warning: the comparison with the reference failed ({message}); the "
+            "build's evidence and staging are unaffected, and the candidate "
+            "cannot be certified until it is re-scored with "
             "tools/score_uk_national_candidate.py.",
             file=sys.stderr,
             flush=True,
         )
-        stage(telemetry, "incumbent_evaluation", "failed", error=message)
+        stage(telemetry, "reference_evaluation", "failed", error=message)
         return {
             "status": "error",
             "error": message,
-            "incumbent": dict(incumbent),
+            "reference": {
+                key: value for key, value in reference.items() if key != "record"
+            },
             "receipt": None,
         }
     warning = module.pruned_warning(score)
     if warning is not None:
         print(warning, file=sys.stderr, flush=True)
     evaluation = score["evaluation"]
-    pruned = score["incumbent_unresolvable_pruned"]
+    pruned = score["reference_unresolvable_pruned"]
     add_staging_artifact(
         telemetry,
-        "score_vs_incumbent",
+        "score_vs_reference",
         _score_receipt_telemetry_summary(score),
         artifact_kind="aggregate_diagnostics",
         classification="aggregate",
     )
     stage(
         telemetry,
-        "incumbent_evaluation",
+        "reference_evaluation",
         "completed",
-        verdict=evaluation["verdict"],
+        reference=evaluation["reference"],
         n_scored=int(evaluation["scored_surface"]["n_scored"]),
         n_pruned=int(evaluation["scored_surface"]["n_pruned"]),
     )
     return {
         "status": "completed",
-        "verdict": evaluation["verdict"],
-        "rule_1": dict(evaluation["rule_1"]),
+        "reference": evaluation["reference"],
+        "losses": dict(evaluation["losses"]),
+        "targets": dict(evaluation["targets"]),
         "scored_surface": dict(evaluation["scored_surface"]),
         "pruned_measures": list(pruned["measures"]),
         "pruned_families": dict(pruned["families"]),
         "receipt": artifact_info(output_paths["score_receipt"]),
-        "incumbent": dict(incumbent),
+        "reference_input": {
+            key: value for key, value in reference.items() if key != "record"
+        },
     }
 
 
-_evaluate_against_incumbent = evaluate_against_incumbent
+_evaluate_against_reference = evaluate_against_reference
 
 
 def validate_output_paths(
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/parity_reference.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/parity_reference.py
index a9114ff953..0006755aab 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/parity_reference.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/parity_reference.py
@@ -1,9 +1,12 @@
-"""Pinned enhanced-FRS input-surface reference for UK coverage parity.
+"""Pinned enhanced-FRS input-surface reference, kept as a historical record.
 
 The licensed H5 never ships in Microcosm.  ``efrs_parity_reference.json`` is the
 frozen, sha-addressed extraction of its populated PolicyEngine-UK input leaves.
-Release coverage manifests and gates consume this small checked-in fact instead
-of resolving a moving or licensed artifact at build time.
+Until microcosm#1095 the release coverage manifest and the export-surface and
+input-coverage gates compared every UK cut with it; a cut now compares with the
+current build of its own line (:mod:`.reference_surface`). The coverage
+manifest generator still checks its exclusions ledger,
+``efrs_parity_known_gaps.json``, against these frozen facts it was measured on.
 """
 
 from __future__ import annotations
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/reference_surface.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/reference_surface.py
new file mode 100644
index 0000000000..b6eb65be1c
--- /dev/null
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/reference_surface.py
@@ -0,0 +1,228 @@
+"""The column surface of a cut's reference build (microcosm#1095).
+
+The export-surface and release-input-coverage gates compared every UK cut
+with the frozen enhanced-FRS parity reference: the columns it exported and
+the inputs it populated. A cut now compares with the current build of its
+own line, so the reference step writes that build's surface beside it:
+
+- ``export_columns``: the ``entity.column`` names its release frame exports,
+  as :func:`~.terminal_gates.uk_export_candidate_columns` reads a candidate;
+- the loader inputs it carries, by the input-coverage gate's own rule
+  (:func:`~.release_input_coverage.uk_effective_input_signal`: non-default
+  signal against the live engine default on at least
+  ``minimum_nondefault_mass_share`` of effective population mass), split by
+  how many distinct source households carry them on rows of positive weight:
+  ``populated_inputs`` at least ``UK_DISCLOSURE_FLOOR``, ``thin_inputs`` one
+  or two (a count below the floor reads "<3").
+
+Names and flags only: the file holds no figure beyond the policy floor it was
+measured at. Its identity names the build (``label``, ``sha256``), and a gate
+refuses a surface of another build than the cut's reference.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+__all__ = [
+    "UK_REFERENCE_SURFACE_KIND",
+    "UK_REFERENCE_SURFACE_SCHEMA_VERSION",
+    "UKReferenceSurface",
+    "load_uk_reference_surface",
+    "uk_reference_surface_payload",
+]
+
+UK_REFERENCE_SURFACE_KIND = "uk_reference_surface"
+UK_REFERENCE_SURFACE_SCHEMA_VERSION = 1
+
+
+@dataclass(frozen=True)
+class UKReferenceSurface:
+    """What the reference build exports and populates, by name."""
+
+    label: str
+    sha256: str
+    export_columns: frozenset[str]
+    populated_inputs: frozenset[str]
+    thin_inputs: frozenset[str]
+    minimum_nondefault_mass_share: float
+    #: The fixed baseline the chain of cuts runs from, and the inputs it
+    #: carried (the review of microcosm#1574); none for an older file.
+    baseline_label: str | None = None
+    baseline_inputs: frozenset[str] = frozenset()
+
+    @property
+    def carried_inputs(self) -> frozenset[str]:
+        """Every input the reference carries with signal, thin ones included."""
+
+        return self.populated_inputs | self.thin_inputs
+
+
+def uk_reference_surface_payload(
+    h5_path: str | Path,
+    *,
+    label: str,
+    sha256: str,
+    engine: Any | None = None,
+) -> dict[str, Any]:
+    """The surface payload of the build at ``h5_path``, names and flags only.
+
+    ``engine`` is the coverage engine whose loader inputs and defaults the
+    gate will judge the candidate by (the live PolicyEngine-UK adapter when
+    omitted); the floor is the committed coverage manifest's.
+    """
+
+    from microcosm.build.uk_runtime.national_frame import (
+        _uk_gate_surface,
+        uk_published_release_frame,
+    )
+    from microcosm.build.uk_runtime.receipt_counts import (
+        UK_DISCLOSURE_FLOOR,
+        distinct_count,
+        source_household_ids,
+    )
+    from microcosm.build.uk_runtime.release_input_coverage import (
+        PolicyEngineUKCoverageEngine,
+        load_uk_release_input_coverage_manifest,
+        uk_effective_input_signal,
+    )
+    from microcosm.build.uk_runtime.rowwise_dataset import load_uk_rowwise_dataset
+    from microcosm.build.uk_runtime.terminal_gates import uk_export_candidate_columns
+    from microcosm.build.uk_runtime.weight_year import uk_recorded_solve_year_frame
+
+    if engine is None:
+        engine = PolicyEngineUKCoverageEngine()
+    floor = load_uk_release_input_coverage_manifest().effective_mass_coverage
+    floor = floor.minimum_nondefault_mass_share
+    # The row-wise reader opens both lines' files (the dense line's carries
+    # one ``clone_index`` name on every table, which the national loader
+    # refuses).
+    frame, _provenance = load_uk_rowwise_dataset(h5_path)
+    export = uk_published_release_frame(uk_recorded_solve_year_frame(frame))
+    surface = _uk_gate_surface(export)
+    schema = export.schema
+    household = surface.household
+    household_sources = pd.Series(
+        source_household_ids(household, stage="reference surface"),
+        index=household[schema.id_column("household")].to_numpy(),
+    )
+    person = surface.person
+    person_sources = household_sources.reindex(
+        person[schema.membership_column("household")].to_numpy()
+    ).to_numpy()
+    first_member = (
+        pd.DataFrame(
+            {
+                "benunit": person[schema.membership_column("benunit")].to_numpy(),
+                "source": person_sources,
+            }
+        )
+        .drop_duplicates("benunit")
+        .set_index("benunit")["source"]
+    )
+    sources_by_entity = {
+        "household": household_sources.to_numpy(),
+        "person": person_sources,
+        "benunit": first_member.reindex(
+            surface.benunit[schema.id_column("benunit")].to_numpy()
+        ).to_numpy(),
+    }
+    populated: set[str] = set()
+    thin: set[str] = set()
+    carried = uk_effective_input_signal(
+        surface, engine, minimum_nondefault_mass_share=floor
+    )
+    for name, (entity, signal) in carried.items():
+        # ``signal`` already excludes rows of zero weight.
+        carriers = distinct_count(sources_by_entity[entity], signal)
+        (populated if carriers >= UK_DISCLOSURE_FLOOR else thin).add(str(name))
+    return {
+        "schema_version": UK_REFERENCE_SURFACE_SCHEMA_VERSION,
+        "kind": UK_REFERENCE_SURFACE_KIND,
+        "label": label,
+        "sha256": sha256,
+        "minimum_nondefault_mass_share": floor,
+        "export_columns": sorted(uk_export_candidate_columns(export)),
+        "populated_inputs": sorted(populated),
+        "thin_inputs": sorted(thin),
+    }
+
+
+def load_uk_reference_surface(source: str | Path) -> UKReferenceSurface:
+    """Load a reference surface a cut wrote, refusing any other shape."""
+
+    path = Path(source)
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(payload, Mapping):
+        raise ValueError(f"{path}: a reference surface must be a JSON object.")
+    if (
+        payload.get("schema_version") != UK_REFERENCE_SURFACE_SCHEMA_VERSION
+        or payload.get("kind") != UK_REFERENCE_SURFACE_KIND
+    ):
+        raise ValueError(
+            f"{path}: not a schema-{UK_REFERENCE_SURFACE_SCHEMA_VERSION} "
+            f"{UK_REFERENCE_SURFACE_KIND}."
+        )
+    label = payload.get("label")
+    sha256 = payload.get("sha256")
+    if not isinstance(label, str) or label.count("@") != 1:
+        raise ValueError(f"{path}: a reference surface's label is <release>@<build>.")
+    if not isinstance(sha256, str) or len(sha256) != 64:
+        raise ValueError(f"{path}: a reference surface names its build's sha256.")
+    floor = payload.get("minimum_nondefault_mass_share")
+    if (
+        isinstance(floor, bool)
+        or not isinstance(floor, int | float)
+        or not math.isfinite(float(floor))
+        or not 0.0 < float(floor) <= 1.0
+    ):
+        raise ValueError(
+            f"{path}: a reference surface names the effective-mass floor it "
+            "was measured at, in (0, 1]."
+        )
+    lists = {}
+    for key in ("export_columns", "populated_inputs", "thin_inputs"):
+        value = payload.get(key)
+        if not isinstance(value, list) or not all(
+            isinstance(item, str) and item for item in value
+        ):
+            raise ValueError(f"{path}: {key} must be a list of column names.")
+        lists[key] = frozenset(value)
+    if lists["populated_inputs"] & lists["thin_inputs"]:
+        raise ValueError(f"{path}: a column cannot be both populated and thin.")
+    if not lists["export_columns"]:
+        raise ValueError(f"{path}: a reference surface exports no column.")
+    baseline = payload.get("baseline")
+    baseline_label = None
+    baseline_inputs: frozenset[str] = frozenset()
+    if baseline is not None:
+        inputs = baseline.get("inputs") if isinstance(baseline, Mapping) else None
+        baseline_label = (
+            baseline.get("label") if isinstance(baseline, Mapping) else None
+        )
+        if (
+            not isinstance(baseline_label, str)
+            or baseline_label.count("@") != 1
+            or not isinstance(inputs, list)
+            or not all(isinstance(item, str) and item for item in inputs)
+        ):
+            raise ValueError(
+                f"{path}: a reference surface's baseline names its build and the "
+                "inputs it carried."
+            )
+        baseline_inputs = frozenset(inputs)
+    return UKReferenceSurface(
+        label=label,
+        sha256=sha256,
+        minimum_nondefault_mass_share=float(floor),
+        baseline_label=baseline_label,
+        baseline_inputs=baseline_inputs,
+        **lists,
+    )
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/release_certification.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/release_certification.py
index 9915dbad2e..32035d7a99 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/release_certification.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/release_certification.py
@@ -79,7 +79,10 @@
     "uk_release_parity_evidence",
 ]
 
-UK_RELEASE_CERTIFICATION_SCHEMA_VERSION = 1
+#: Schema 2 (microcosm#1095) names the reference the cut was compared with,
+#: the current national build, and reads a head-to-head receipt with no
+#: verdict; schema 1 compared with the enhanced FRS under a strict rule.
+UK_RELEASE_CERTIFICATION_SCHEMA_VERSION = 2
 UK_RELEASE_CERTIFICATION_KIND = "uk_release_certification"
 UK_RELEASE_CUT_POSTURE = "release_cut"
 UK_CERTIFICATION_EXCLUDED_GATE_IDS = frozenset(UK_LOCAL_GATE_SCOPE) | frozenset(
@@ -229,12 +232,13 @@ def uk_release_parity_evidence(
     *,
     diagnostics_targets: Sequence[Mapping[str, Any]],
     reference_registry: Any,
-    parity_reference: Any,
 ) -> SimpleNamespace:
     """The parity-trio evidence over persisted inputs, sides never aliased.
 
-    Candidate columns come from the staged frame; reference columns from the
-    frozen parity instrument's declared input entities. Candidate targets
+    Candidate columns come from the staged frame; the export-surface gate
+    reads the reference's columns from the cut's reference surface itself
+    (the ``reference_surface`` artifact, microcosm#1095), where until then
+    they came from the frozen enhanced-FRS instrument. Candidate targets
     come from the solve's realized diagnostics rows; reference targets from
     the independently recompiled (and exclusion-pruned) register at
     ``name@period`` grain — the same two-source rule the retired June
@@ -262,10 +266,6 @@ def uk_release_parity_evidence(
         target_relative_errors[name] = float(row["relative_error"])
     return SimpleNamespace(
         candidate_columns=uk_export_candidate_columns(frame),
-        reference_columns={
-            f"{entity}.{name}"
-            for name, entity in parity_reference.input_entities.items()
-        },
         candidate_targets=set(target_relative_errors),
         reference_targets={
             f"{spec.name}@{spec.period}" for spec in reference_registry.specs
@@ -312,6 +312,7 @@ def run_uk_release_cut_battery(
     parity_evidence: Any,
     fit_weight_records: tuple[FitWeightRecord, ...] | None,
     input_mass_reference: Mapping[str, Any],
+    reference_surface: Any,
     exclusions_evaluated_on: date,
     gate_registry: Mapping[str, Any] | None = None,
     spine_frame: Any | None = None,
@@ -321,7 +322,9 @@ def run_uk_release_cut_battery(
     ``spine_frame`` is the frame the spine build produced, the evidence the
     input-coverage gate's family build-state half reads (typed importance
     weights and each stage's mass receipt); the calibrated candidate is the
-    evidence for everything else.
+    evidence for everything else. ``reference_surface`` is the cut's
+    reference build's surface, whose carried inputs the coverage gate
+    requires (microcosm#1095).
 
     Always release-candidate strict: this battery exists to certify a cut,
     so an ``evidence_absent`` gap blocks rather than being tolerated, and a
@@ -375,6 +378,7 @@ def run_uk_release_cut_battery(
         "parity_evidence": parity_evidence,
         "aggregate_admin": admin_totals,
         "input_mass_reference": input_mass_reference,
+        "reference_surface": reference_surface,
         "release_line": "national",
     }
     if fit_weight_records is not None:
@@ -401,6 +405,61 @@ def run_uk_release_cut_battery(
 # ---------------------------------------------------------------------------
 
 
+def _since_baseline(release_cut: Mapping[str, Any]) -> dict[str, Any]:
+    """The release cut's change since the baseline, from its two gates.
+
+    The input-mass gate continues each column's ratio to the baseline's
+    total and lists the columns that have left the chain; the coverage gate
+    names the baseline's inputs this build no longer carries. Both continue
+    the reference's own record, so the next cut reads it from this
+    certification without loading any baseline. A chain whose baseline is
+    not the national line's origin has restarted, and the certification
+    says so (``restarted_from``; round 2 of the review of microcosm#1574).
+    """
+
+    from microcosm.build.uk_runtime.cut_reference import (
+        UK_NATIONAL_SINCE_BASELINE_ORIGIN,
+    )
+    from microcosm.build.uk_runtime.release_identity import UK_NATIONAL_RELEASE_ID
+
+    gates = release_cut.get("gates") or {}
+
+    def block(gate_id: str) -> Mapping[str, Any] | None:
+        details = (gates.get(gate_id) or {}).get("details") or {}
+        value = details.get("since_baseline")
+        return value if isinstance(value, Mapping) else None
+
+    mass = block("uk_input_mass_parity")
+    coverage = block("uk_release_input_coverage")
+    if mass is None or coverage is None or not isinstance(mass.get("left"), Mapping):
+        raise UKReleaseCertificationError(
+            "The release-cut report records no change since the baseline: the "
+            "cut's reference evidence predates it, so write it again (the "
+            "reference step of tools/run_uk_cut.py)."
+        )
+    baseline = mass.get("baseline")
+    if baseline != coverage.get("baseline") or not str(baseline).startswith(
+        f"{UK_NATIONAL_RELEASE_ID}@"
+    ):
+        raise UKReleaseCertificationError(
+            "The release-cut report's input-mass and coverage gates must chain "
+            f"from one national baseline; they name {baseline!r} and "
+            f"{coverage.get('baseline')!r}."
+        )
+    return {
+        "baseline": str(baseline),
+        "restarted_from": (
+            None
+            if baseline == UK_NATIONAL_SINCE_BASELINE_ORIGIN
+            else UK_NATIONAL_SINCE_BASELINE_ORIGIN
+        ),
+        "input_mass_ratios": dict(sorted(mass["ratios"].items())),
+        "input_mass_left": dict(sorted(mass["left"].items())),
+        "baseline_inputs": sorted(coverage["inputs"]),
+        "inputs_dropped": sorted(coverage["dropped"]),
+    }
+
+
 def compose_uk_release_certification(
     *,
     release_id: str,
@@ -414,6 +473,7 @@ def compose_uk_release_certification(
     spine_sidecar: Mapping[str, Any],
     build_record: Mapping[str, Any],
     score_receipt_path: Path,
+    reference_record: Mapping[str, Any],
     exclusions_evaluated_on: date,
     certification_path: Path,
     reviewed_unresolvable_measures: Mapping[str, Any] | None = None,
@@ -425,9 +485,30 @@ def compose_uk_release_certification(
     ``UK_SHARED_GATE_IDS``, full phase coverage, verified signatures, the
     committed spec's scoped digests, green release-blocking verdicts, and a
     closed identity join from the spine report through the sidecar, the
-    build record, the diagnostics digest, and the candidate bytes.
+    build record, the diagnostics digest, and the candidate bytes, and a
+    head-to-head receipt that measured this candidate against the cut's own
+    reference (``reference_record``, the current national build the cut
+    recorded when it fetched it).
     """
 
+    from microcosm.build.uk_runtime.cut_reference import UKCutReference
+    from microcosm.build.uk_runtime.release_identity import UK_NATIONAL_RELEASE_ID
+
+    reference = UKCutReference.from_record(reference_record)
+    if reference.release != UK_NATIONAL_RELEASE_ID:
+        raise UKReleaseCertificationError(
+            f"A national certification compares with the national line; the "
+            f"reference record names {reference.label}."
+        )
+    # After a promotion, re-resolving would name the candidate itself, and a
+    # comparison with itself passes every gate (the review of microcosm#1574).
+    if reference.sha256 == candidate_sha256 or reference.build == build_record.get(
+        "build_id"
+    ):
+        raise UKReleaseCertificationError(
+            f"The cut's reference {reference.label} is the candidate itself; a "
+            "cut cannot be certified against its own build."
+        )
     parts_raw = {
         "spine": _load_part(spine_report_path),
         "calibration_seam": _load_part(seam_report_path),
@@ -491,6 +572,7 @@ def compose_uk_release_certification(
     _verify_score_receipt(
         score_receipt,
         candidate_sha256=candidate_sha256,
+        reference=reference,
         reviewed_unresolvable_measures=reviewed_unresolvable_measures,
         evaluated_on=exclusions_evaluated_on,
     )
@@ -511,6 +593,21 @@ def compose_uk_release_certification(
         # The spine whose stage receipts the release cut measured: bound to
         # the parent the calibration recorded, never an operator's choice.
         "parent_spine": {"sha256": spine_sha256},
+        # What the cut was compared with: the current national build when
+        # the cut fetched its inputs (microcosm#1095).
+        "reference": {
+            "release": reference.release,
+            "build": reference.build,
+            "filename": reference.filename,
+            "sha256": reference.sha256,
+            "built_with_model_package": dict(reference.built_with_model_package),
+            # The line's current build, or a listed build the operator pinned
+            # for a line with none (the review of microcosm#1574).
+            "selection": reference.selection,
+        },
+        # The change since a fixed baseline, chained across cuts so a slow
+        # drift shows: a record, with no verdict (the review of microcosm#1574).
+        "since_baseline": _since_baseline(parts_raw["release_cut"][0]),
         "parts": part_summaries,
         "spec": {
             "gates_manifest_sha256": full_digests["gates_manifest_sha256"],
@@ -867,14 +964,15 @@ def _verify_identity_join(
         )
 
 
-#: The verdict a certifiable score receipt must carry (candidate_score).
-UK_SCORE_RECEIPT_VERDICT_PASSED = "passed"
+#: The head-to-head receipt a certification reads (candidate_score schema 2).
+UK_SCORE_RECEIPT_SCHEMA_VERSION = 2
 
 
 def _verify_score_receipt(
     receipt: Mapping[str, Any],
     *,
     candidate_sha256: str,
+    reference: Any,
     reviewed_unresolvable_measures: Mapping[str, Any] | None = None,
     evaluated_on: date | None = None,
 ) -> None:
@@ -888,20 +986,42 @@ def _verify_score_receipt(
         raise UKReleaseCertificationError(
             "the score receipt's artifacts.candidate.sha256 is "
             f"{scored!r}, not the candidate under certification "
-            f"({candidate_sha256!r}); the rule-1 score must be measured on "
+            f"({candidate_sha256!r}); the comparison must be measured on "
             "this candidate's bytes."
         )
-    # Rule 1 (microcosm#578) is decided by the scorer on the surface both
-    # artifacts can materialize and signed into the receipt; the certifier
-    # refuses anything short of a passed verdict, so publication never runs
-    # on an unpassed evaluation. Pruned rows are reported, never a failure,
-    # but the surface must close over them.
+    # The comparison (microcosm#1095) decides nothing; the certifier requires
+    # that it was made, on this candidate, against the cut's own reference,
+    # and that its surface closes over the rows it pruned.
     evaluation = receipt.get("evaluation")
-    if not isinstance(evaluation, Mapping):
+    if (
+        not isinstance(evaluation, Mapping)
+        or evaluation.get("schema_version") != UK_SCORE_RECEIPT_SCHEMA_VERSION
+    ):
+        raise UKReleaseCertificationError(
+            "the score receipt carries no schema-2 evaluation block; re-score "
+            "the candidate against the cut's reference with "
+            "tools/score_uk_national_candidate.py."
+        )
+    scored_reference = (
+        artifacts.get("reference", {}).get("sha256")
+        if isinstance(artifacts, Mapping)
+        else None
+    )
+    recorded = receipt.get("reference")
+    named = (
+        (recorded.get("release"), recorded.get("build"), recorded.get("sha256"))
+        if isinstance(recorded, Mapping)
+        else None
+    )
+    if scored_reference != reference.sha256 or named != (
+        reference.release,
+        reference.build,
+        reference.sha256,
+    ):
         raise UKReleaseCertificationError(
-            "the score receipt carries no evaluation block; re-score the "
-            "candidate with tools/score_uk_national_candidate.py so the "
-            "rule-1 verdict is signed run evidence."
+            "the score receipt compared the candidate with another reference "
+            f"than the cut's ({reference.label}, {reference.sha256}); re-score "
+            "the candidate against the reference the cut recorded."
         )
     surface = evaluation.get("scored_surface")
     counts = (
@@ -919,26 +1039,20 @@ def _verify_score_receipt(
             "the score receipt's scored surface does not close: n_scored + "
             "n_pruned must equal n_surface with at least one scored target."
         )
-    verdict = evaluation.get("verdict")
-    if verdict != UK_SCORE_RECEIPT_VERDICT_PASSED:
-        raise UKReleaseCertificationError(
-            f"the score receipt's evaluation verdict is {verdict!r}, not "
-            f"{UK_SCORE_RECEIPT_VERDICT_PASSED!r}: rule 1 (microcosm#578) is "
-            "not met on the common surface, so the cut cannot be certified."
-        )
-    # Every pruned measure must stand on the committed reviewed register:
-    # the scorer's inference is re-checked here against the register of
-    # record, so a receipt scored under another register cannot certify.
-    pruned = receipt.get("incumbent_unresolvable_pruned")
+    # Every pruned measure must stand on the committed reviewed register,
+    # under the cut's own reference: the scorer's inference is re-checked
+    # here against the register of record, so a receipt scored under another
+    # register, or another reference's entries, cannot certify.
+    pruned = receipt.get("reference_unresolvable_pruned")
     measures = pruned.get("measures", []) if isinstance(pruned, Mapping) else []
     if measures:
         from microcosm.build.uk_runtime.candidate_score import (
-            load_uk_incumbent_unresolvable_measures,
-            uk_incumbent_unresolvable_register_digest,
+            load_uk_reference_unresolvable_measures,
+            uk_reference_unresolvable_register_digest,
         )
 
         reviewed = (
-            load_uk_incumbent_unresolvable_measures()
+            load_uk_reference_unresolvable_measures(reference_label=reference.label)
             if reviewed_unresolvable_measures is None
             else reviewed_unresolvable_measures
         )
@@ -946,24 +1060,21 @@ def _verify_score_receipt(
         if unlisted:
             raise UKReleaseCertificationError(
                 "the score receipt pruned targets through measure(s) not on the "
-                f"reviewed incumbent-unresolvable register: {unlisted}; pruning "
-                "from both arms stands only on a signed entry, so the cut "
-                "cannot be certified on this receipt."
+                "reviewed reference-unresolvable register for "
+                f"{reference.label}: {unlisted}; pruning from both arms stands "
+                "only on a signed entry, so the cut cannot be certified on this "
+                "receipt."
             )
-        # The receipt names the register it was scored under; against the
-        # committed register of record that digest must be the committed
-        # one, so a receipt scored under another register cannot certify.
         if reviewed_unresolvable_measures is None:
-            named = (
-                pruned.get("reviewed_register", {}).get("sha256")
-                if isinstance(pruned.get("reviewed_register"), Mapping)
-                else None
+            register = pruned.get("reviewed_register")
+            named_digest = (
+                register.get("sha256") if isinstance(register, Mapping) else None
             )
-            committed = uk_incumbent_unresolvable_register_digest()["sha256"]
-            if named != committed:
+            committed = uk_reference_unresolvable_register_digest()["sha256"]
+            if named_digest != committed:
                 raise UKReleaseCertificationError(
-                    "the score receipt was scored under incumbent-unresolvable "
-                    f"register {named!r}, not the committed register "
+                    "the score receipt was scored under reference-unresolvable "
+                    f"register {named_digest!r}, not the committed register "
                     f"({committed}); re-score the candidate on the register of "
                     "record."
                 )
@@ -984,7 +1095,7 @@ def _verify_score_receipt(
             if out_of_window:
                 raise UKReleaseCertificationError(
                     "the score receipt pruned targets through reviewed "
-                    "incumbent-unresolvable entries outside their window on "
+                    "reference-unresolvable entries outside their window on "
                     f"{evaluated_on.isoformat()}: {out_of_window}; renew the "
                     "adjudication or re-score the candidate."
                 )
@@ -993,21 +1104,13 @@ def _verify_score_receipt(
 def _score_receipt_summary(receipt: Mapping[str, Any]) -> dict[str, Any]:
     evaluation = receipt["evaluation"]
     surface = evaluation["scored_surface"]
-    rule_1 = evaluation.get("rule_1")
-    losses = (
-        {
-            "candidate_full_loss": rule_1.get("candidate_full_loss"),
-            "incumbent_full_loss": rule_1.get("incumbent_full_loss"),
-        }
-        if isinstance(rule_1, Mapping)
-        else {}
-    )
     return {
-        "verdict": evaluation["verdict"],
+        "reference": evaluation["reference"],
         "n_scored": surface["n_scored"],
         "n_pruned": surface["n_pruned"],
         "n_surface": surface["n_surface"],
-        **losses,
+        **dict(evaluation["losses"]),
+        **dict(evaluation["targets"]),
     }
 
 
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/release_input_coverage.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/release_input_coverage.py
index 36ef09053d..a1fcd4ad41 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/release_input_coverage.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/release_input_coverage.py
@@ -1,12 +1,16 @@
-"""UK release input-column coverage: the enhanced-FRS surface as a hard gate.
-
-Every populated effective loader input extracted from the immutable enhanced
-FRS reference is declared in ``release_input_coverage_manifest.json`` as either
-``required`` or ``reviewed_exclusion``. Required columns must be present on the
-final export tables and carry non-default signal on rows with enough effective
-population mass to clear the reviewed manifest floor. A reviewed exclusion
-that later carries effective signal is stale and fails, so the debt ledger can
-only shrink deliberately.
+"""UK release input-column coverage against the cut's reference build.
+
+Every loader input the current build of the cut's line carries must reach the
+release export with non-default signal on rows carrying at least the reviewed
+share of effective population mass, unless ``release_input_coverage_manifest.json``
+declares it a reviewed exclusion (microcosm#1095). The reference carries an
+input by the same rule the gate applies to the candidate
+(:func:`uk_effective_input_signal`), and the cut's reference step records
+which inputs those are (:mod:`.reference_surface`); until microcosm#1095 the
+required inputs were the populated inputs of the frozen enhanced-FRS
+reference. The manifest may also declare an input required whatever the
+reference carries. A reviewed exclusion that later carries effective signal
+is stale and fails, so the debt ledger can only shrink deliberately.
 
 The UK loader calls ``set_input`` for every engine-known persisted H5 column,
 including formula-owned variables. Those persisted overrides are therefore
@@ -29,11 +33,7 @@
 import pandas as pd
 
 from microcosm.build.gates import GateResult, input_column_coverage_gate
-from microcosm.build.uk_runtime.parity_reference import (
-    load_efrs_engine_derived_exclusions,
-    load_efrs_parity_known_gaps,
-    load_efrs_parity_reference,
-)
+from microcosm.build.uk_runtime.reference_surface import UKReferenceSurface
 from microcosm.build.uk_runtime.release_identity import (
     UK_RELEASE_TIER_FRS,
     validate_uk_release_tier,
@@ -41,6 +41,7 @@
 
 __all__ = [
     "RESTORED_REFERENCE_EFRS_REQUIRED_INPUTS",
+    "UK_RELEASE_INPUT_COVERAGE_SCHEMA_VERSION",
     "UKEffectiveMassCoveragePolicy",
     "UK_FAMILY_MASS_CHANGE_SEMANTICS",
     "UK_LOADER_INPUT_ALIASES",
@@ -51,12 +52,18 @@
     "assert_uk_release_input_coverage_build_stages",
     "assert_uk_release_input_coverage_manifest_current",
     "load_uk_release_input_coverage_manifest",
+    "uk_effective_input_signal",
     "uk_release_input_coverage_gate",
     "uk_release_input_coverage_required_columns",
     "uk_release_input_coverage_reviewed_exclusions",
 ]
 
 UK_RELEASE_INPUT_COVERAGE_RESOURCE = "release_input_coverage_manifest.json"
+#: Schema 4 (microcosm#1095): the required inputs come from the cut's
+#: reference build at gate time, so the manifest declares the reviewed
+#: exclusions, the effective-mass policy and the stage-family contracts.
+UK_RELEASE_INPUT_COVERAGE_SCHEMA_VERSION = 4
+_REFERENCE_KIND = "current_build"
 UK_LOADER_INPUT_ALIASES: Mapping[str, str] = {
     "capital_gains": "capital_gains_before_response",
     "employee_pension_contributions": ("employee_pension_contributions_reported"),
@@ -76,7 +83,6 @@
 #: mass record conserves the total and declares factor one.
 UK_FAMILY_MASS_CHANGE_SEMANTICS = "mass_conserving"
 _UK_PACKAGE = "microcosm.build.uk"
-_EFRS_PARITY_REFERENCE_RESOURCE = "efrs_parity_reference.json"
 
 DEFAULT_MINIMUM_NONDEFAULT_MASS_SHARE = 1e-6
 
@@ -433,10 +439,24 @@ def load_uk_release_input_coverage_manifest(
 ) -> UKReleaseInputCoverageManifest:
     """Load the non-vacuous UK manifest and validate exclusion metadata."""
     payload = _resource_payload(resource)
+    schema_version = payload.get("schema_version")
+    if schema_version != UK_RELEASE_INPUT_COVERAGE_SCHEMA_VERSION:
+        raise ValueError(
+            f"{resource}: schema_version must be "
+            f"{UK_RELEASE_INPUT_COVERAGE_SCHEMA_VERSION}, got {schema_version!r}; "
+            "the required inputs now come from the cut's reference build "
+            "(microcosm#1095)."
+        )
     raw_reference = payload.get("reference")
     raw_candidate = payload.get("candidate_evidence")
     if not isinstance(raw_reference, Mapping):
         raise ValueError(f"{resource}: 'reference' must be a JSON object.")
+    if raw_reference.get("kind") != _REFERENCE_KIND:
+        raise ValueError(
+            f"{resource}: reference.kind must be {_REFERENCE_KIND!r}; the "
+            "coverage contract compares a cut with the current build of its "
+            "own line."
+        )
     if not isinstance(raw_candidate, Mapping):
         raise ValueError(f"{resource}: 'candidate_evidence' must be a JSON object.")
     try:
@@ -461,11 +481,10 @@ def load_uk_release_input_coverage_manifest(
     )
 
     raw_columns = payload.get("columns")
-    if not isinstance(raw_columns, Mapping) or not raw_columns:
-        raise ValueError(
-            f"{resource}: 'columns' must be a non-empty JSON object; a silently "
-            "empty manifest would make the coverage gate vacuous."
-        )
+    if not isinstance(raw_columns, Mapping):
+        # Empty is allowed: the required inputs come from the reference, and
+        # the gate itself refuses a vacuous required set.
+        raise ValueError(f"{resource}: 'columns' must be a JSON object.")
     columns: list[UKReleaseInputColumn] = []
     for name, entry in sorted(raw_columns.items()):
         if not isinstance(entry, Mapping):
@@ -479,9 +498,6 @@ def load_uk_release_input_coverage_manifest(
                 note=str(entry.get("note", "")),
             )
         )
-    schema_version = payload.get("schema_version", 1)
-    if not isinstance(schema_version, int):
-        raise ValueError(f"{resource}: 'schema_version' must be an integer.")
     return UKReleaseInputCoverageManifest(
         reference={str(key): str(value) for key, value in raw_reference.items()},
         candidate_evidence={
@@ -499,6 +515,8 @@ def load_uk_release_input_coverage_manifest(
 
 
 def uk_release_input_coverage_required_columns() -> frozenset[str]:
+    """Inputs the committed manifest requires whatever the reference carries."""
+
     return load_uk_release_input_coverage_manifest().required_columns
 
 
@@ -872,6 +890,78 @@ def _effective_mass_diagnostics(
     return diagnostics
 
 
+def _source_households_by_entity(
+    tables: Mapping[str, pd.DataFrame],
+) -> dict[str, np.ndarray] | None:
+    """Each entity's rows' source household, or None without lineage.
+
+    A benefit unit takes its first member's household's source. Every built
+    frame carries ``household_source_id`` (the input-mass gate fails closed
+    without it); a hand-made fixture may not.
+    """
+
+    from microcosm.build.uk_runtime.receipt_counts import SOURCE_HOUSEHOLD_COLUMN
+
+    household = tables["household"]
+    if SOURCE_HOUSEHOLD_COLUMN not in household.columns:
+        return None
+    sources = household[SOURCE_HOUSEHOLD_COLUMN].to_numpy()
+    by_household = pd.Series(sources, index=household["household_id"].to_numpy())
+    person = tables["person"]
+    person_sources = by_household.reindex(
+        person["person_household_id"].to_numpy()
+    ).to_numpy()
+    first_member = (
+        pd.DataFrame(
+            {
+                "benunit": person["person_benunit_id"].to_numpy(),
+                "source": person_sources,
+            }
+        )
+        .drop_duplicates("benunit")
+        .set_index("benunit")["source"]
+    )
+    return {
+        "household": sources,
+        "person": person_sources,
+        "benunit": first_member.reindex(
+            tables["benunit"]["benunit_id"].to_numpy()
+        ).to_numpy(),
+    }
+
+
+def _columns_on_fewer_than_floor_sources(
+    column_values: Mapping[str, tuple[str, Any]],
+    *,
+    defaults: Mapping[str, object],
+    effective_weights: Mapping[str, np.ndarray],
+    sources: Mapping[str, np.ndarray] | None,
+) -> frozenset[str]:
+    """Columns whose effective signal one or two source households carry.
+
+    Their per-column figures would rest on fewer cases than the UKDS floor
+    of three, so the report withholds them (zero carriers is no cell).
+    """
+
+    if sources is None:
+        return frozenset()
+    from microcosm.build.uk_runtime.receipt_counts import (
+        UK_DISCLOSURE_FLOOR,
+        distinct_count,
+    )
+
+    thin: set[str] = set()
+    for name, (entity, values) in column_values.items():
+        if name not in defaults or entity not in sources:
+            continue
+        weights = np.asarray(effective_weights[entity], dtype=np.float64)
+        signal = _nondefault_signal_mask(values, defaults[name]) & (weights > 0.0)
+        carriers = distinct_count(sources[entity], signal)
+        if 0 < carriers < UK_DISCLOSURE_FLOOR:
+            thin.add(name)
+    return frozenset(thin)
+
+
 def _family_effective_mass_diagnostics(
     manifest: UKReleaseInputCoverageManifest,
     *,
@@ -1058,15 +1148,70 @@ def _valid_mass_record(record: object) -> bool:
     return bool(np.isclose(old, new, rtol=1e-9, atol=0.0) and factor == 1.0)
 
 
+def uk_effective_input_signal(
+    frame: Any,
+    engine: Any,
+    *,
+    minimum_nondefault_mass_share: float,
+) -> dict[str, tuple[str, np.ndarray]]:
+    """Each loader input ``frame`` carries, by the coverage gate's own rule.
+
+    An input is carried when its non-default signal (against the live engine
+    default) sits on at least ``minimum_nondefault_mass_share`` of its
+    entity's effective population mass: the floor the gate applies to a
+    candidate. The cut's reference step measures the reference build with
+    this, so a candidate is required to carry exactly what the reference
+    carries under the rule it is judged by (microcosm#1095). Returns each
+    carried input's entity and its row mask of signal on positive mass.
+    """
+
+    floor = float(minimum_nondefault_mass_share)
+    loadable = set(engine.variables())
+    table_items = _entity_tables(frame)
+    tables = {entity: table for entity, table in table_items}
+    effective_weights = _effective_weights_by_entity(frame, tables)
+    present: dict[str, tuple[str, Any]] = {}
+    for entity, table in table_items:
+        for column in table.columns:
+            if column not in loadable:
+                continue
+            if column in present:
+                raise ValueError(
+                    f"UK coverage column {column!r} occurs on both "
+                    f"{present[column][0]!r} and {entity!r} tables."
+                )
+            present[column] = (entity, table[column].to_numpy())
+    defaults = engine.default_values(sorted(present))
+    carried: dict[str, tuple[str, np.ndarray]] = {}
+    for name, (entity, values) in sorted(present.items()):
+        if name not in defaults:
+            continue
+        weights = np.asarray(effective_weights[entity], dtype=np.float64)
+        positive = weights > 0.0
+        signal = _nondefault_signal_mask(values, defaults[name]) & positive
+        total_mass = float(weights[positive].sum())
+        share = float(weights[signal].sum()) / total_mass if total_mass > 0 else 0.0
+        if share >= floor:
+            carried[name] = (entity, signal)
+    return carried
+
+
 def uk_release_input_coverage_gate(
     frame: Any,
     engine: Any,
     *,
+    reference_surface: UKReferenceSurface,
     manifest: UKReleaseInputCoverageManifest | None = None,
     build_state_frame: Any | None = None,
 ) -> GateResult:
     """Enforce required signal on rows carrying reviewed effective mass.
 
+    The required inputs are the ones the reference build carries
+    (``reference_surface``, measured by :func:`uk_effective_input_signal`)
+    among the live engine's loader inputs, plus any the manifest declares
+    required, less the manifest's reviewed exclusions (microcosm#1095). The
+    reference must have been measured at the manifest's effective-mass floor.
+
     The column-coverage and effective-mass halves read ``frame``, the
     release frame. The family build-state half (each stage family's typed
     ``importance`` weights and its mass receipt) is a spine-stage contract:
@@ -1077,8 +1222,24 @@ def uk_release_input_coverage_gate(
     half on it fails every family on the kind alone.
     """
     manifest = manifest or load_uk_release_input_coverage_manifest()
-    required = manifest.required_columns
     reviewed = manifest.reviewed_exclusions
+    floor = manifest.effective_mass_coverage.minimum_nondefault_mass_share
+    if reference_surface.minimum_nondefault_mass_share != floor:
+        raise ValueError(
+            f"The reference surface of {reference_surface.label} was measured at "
+            f"an effective-mass floor of "
+            f"{reference_surface.minimum_nondefault_mass_share!r}, not the "
+            f"manifest's {floor!r}; re-run the cut's reference step."
+        )
+    loadable = set(engine.variables())
+    from_reference = frozenset(reference_surface.carried_inputs & loadable)
+    required = (from_reference | manifest.required_columns) - set(reviewed)
+    if not required:
+        raise ValueError(
+            f"UK input coverage has no required input: the reference "
+            f"{reference_surface.label} carries no live loader input and the "
+            "manifest declares none, so the gate would be vacuous."
+        )
     relevant = required | set(reviewed)
     expected_entities = _engine_variable_entities(engine, relevant)
     table_items = _entity_tables(frame)
@@ -1120,37 +1281,48 @@ def uk_release_input_coverage_gate(
         for name, (_entity, values) in present_values.items()
         if not _nondefault_signal_mask(values, defaults[name]).any()
     }
-    floor = manifest.effective_mass_coverage.minimum_nondefault_mass_share
     insufficient_effective_mass = {
         name
         for name, details in diagnostics.items()
         if float(details["effective_signal_mass_share"]) < floor
     }
     degenerate = raw_degenerate | insufficient_effective_mass
+    # The UKDS floor: figures for a column one or two source households carry
+    # are withheld from the report; the verdict still stands on them.
+    withheld = _columns_on_fewer_than_floor_sources(
+        present_values,
+        defaults=defaults,
+        effective_weights=effective_weights,
+        sources=_source_households_by_entity(tables),
+    )
     base = input_column_coverage_gate(
         present_values.keys(),
         required_columns=required,
         degenerate_columns=degenerate,
         reviewed_exclusions=reviewed,
         name="uk_release_input_coverage",
-        reference_label="enhanced-FRS",
+        reference_label="reference",
     )
     failures = list(base.failures)
     for name, mismatch in wrong_entities.items():
         failures.append(
-            f"{name}: enhanced-FRS input column is stored on "
+            f"{name}: reference input column is stored on "
             f"{mismatch['actual']!r}, but PolicyEngine-UK owns it on "
             f"{mismatch['expected']!r}; a same-named column on the wrong table "
             "does not satisfy loader coverage."
         )
     for name in sorted((insufficient_effective_mass - raw_degenerate) & required):
-        prefix = f"{name}: required enhanced-FRS input column is present but every "
+        prefix = f"{name}: required reference input column is present but every "
         failures = [failure for failure in failures if not failure.startswith(prefix)]
         column_details = diagnostics[name]
+        share = (
+            "withheld (fewer than three source households carry it)"
+            if name in withheld
+            else f"{float(column_details['effective_signal_mass_share']):.12g}"
+        )
         failures.append(
-            f"{name}: required enhanced-FRS input column carries non-default "
-            f"signal on effective population mass share "
-            f"{float(column_details['effective_signal_mass_share']):.12g}, below "
+            f"{name}: required reference input column carries non-default "
+            f"signal on effective population mass share {share}, below "
             f"the reviewed floor {floor:.12g}; zero-weight support or numerical "
             "dust is not release coverage. Rebuild the source channel with a "
             "reviewed positive population-mass allocation."
@@ -1168,8 +1340,30 @@ def uk_release_input_coverage_gate(
         manifest,
     )
     failures.extend(family_build_failures)
+    since_baseline = None
+    if reference_surface.baseline_label is not None:
+        # Which of the inputs the fixed baseline carried this build no longer
+        # carries, by this gate's rule: names only, a record with no verdict
+        # (the review of microcosm#1574).
+        carried_now = uk_effective_input_signal(
+            frame, engine, minimum_nondefault_mass_share=floor
+        )
+        since_baseline = {
+            "baseline": reference_surface.baseline_label,
+            "inputs": sorted(reference_surface.baseline_inputs),
+            "dropped": sorted(
+                set(reference_surface.baseline_inputs) - set(carried_now)
+            ),
+        }
     details = {
         **dict(base.details),
+        **({"since_baseline": since_baseline} if since_baseline else {}),
+        # Names only: which build the required inputs came from, and which
+        # of them it carries on fewer than three source households ("<3").
+        "reference": reference_surface.label,
+        "required_from_reference": len(from_reference - set(reviewed)),
+        "required_by_manifest": sorted(manifest.required_columns),
+        "required_thin_in_reference": sorted(required & reference_surface.thin_inputs),
         "effective_mass_policy": {
             "weight_source": manifest.effective_mass_coverage.weight_source,
             "minimum_nondefault_mass_share": floor,
@@ -1177,7 +1371,18 @@ def uk_release_input_coverage_gate(
             "rationale": manifest.effective_mass_coverage.rationale,
         },
         "insufficient_effective_mass": sorted(insufficient_effective_mass),
-        "effective_mass_by_column": diagnostics,
+        "effective_mass_by_column": {
+            name: (
+                {
+                    "entity": column_details["entity"],
+                    "source_households": "<3",
+                    "figures": "withheld",
+                }
+                if name in withheld
+                else column_details
+            )
+            for name, column_details in diagnostics.items()
+        },
         "wrong_entity_columns": wrong_entities,
         "family_effective_mass": family_diagnostics,
         "family_build_state": family_build_state,
@@ -1200,31 +1405,21 @@ def _coverage_engine() -> PolicyEngineUKCoverageEngine | None:
     return engine
 
 
-def _efrs_reference_payload() -> Mapping[str, Any]:
-    return _resource_payload(_EFRS_PARITY_REFERENCE_RESOURCE)
-
-
-def _efrs_populated_layers() -> frozenset[str]:
-    shares = _efrs_reference_payload().get("nonzero_shares")
-    if not isinstance(shares, Mapping) or not shares:
-        raise ValueError(
-            f"{_EFRS_PARITY_REFERENCE_RESOURCE}: 'nonzero_shares' must be a "
-            "non-empty JSON object."
-        )
-    return frozenset(str(name) for name, share in shares.items() if float(share) > 0.0)
-
-
-def _efrs_input_entities() -> dict[str, str]:
-    reference = load_efrs_parity_reference()
-    return dict(reference.input_entities)
-
-
 def assert_uk_release_input_coverage_manifest_current(
     *,
     engine: Any | None = None,
     manifest: UKReleaseInputCoverageManifest | None = None,
 ) -> None:
-    """Fail before a build if the UK contract has narrowed or graph-rotted."""
+    """Fail before a build if the UK contract has drifted from its sources.
+
+    The required inputs come from the cut's reference build at gate time
+    (microcosm#1095), so this preflight checks only what does not depend on
+    the reference: the effective-mass policy, the candidate and family
+    tiers, the restored inputs, the stage-family contracts and their source
+    hashes, and that every declared column is a live PolicyEngine-UK loader
+    input with an owning entity. Until then it also held the manifest to the
+    frozen enhanced-FRS surface and its known-gaps ledger.
+    """
     manifest = manifest or load_uk_release_input_coverage_manifest()
     failures: list[str] = []
     if manifest.effective_mass_coverage != UKEffectiveMassCoveragePolicy():
@@ -1246,31 +1441,11 @@ def assert_uk_release_input_coverage_manifest_current(
             f"UKDS-licensed candidate, got {candidate_tier!r}."
         )
     declared = set(manifest.declared_columns)
-    surface = set(_efrs_populated_layers())
-    reference_entities = _efrs_input_entities()
-    missing = sorted(surface - declared)
-    extra = sorted(declared - surface)
-    if missing:
-        failures.append(
-            "manifest is missing enhanced-FRS populated loader input(s) "
-            f"{missing}; regenerate with "
-            "tools/build_uk_release_input_coverage_manifest.py."
-        )
-    if extra:
-        failures.append(
-            "manifest declares column(s) outside the enhanced-FRS populated "
-            f"loader-input surface: {extra}."
-        )
-
     for name in sorted(RESTORED_REFERENCE_EFRS_REQUIRED_INPUTS):
         if name in manifest.reviewed_exclusions:
             failures.append(
-                f"{name}: restored enhanced-FRS reference input cannot return "
-                "to a reviewed exclusion."
-            )
-        elif name not in manifest.required_columns:
-            failures.append(
-                f"{name}: restored enhanced-FRS reference input must remain required."
+                f"{name}: a restored reference input cannot return to a "
+                "reviewed exclusion."
             )
 
     for family_name, family in sorted(manifest.family_coverage.items()):
@@ -1321,11 +1496,11 @@ def assert_uk_release_input_coverage_manifest_current(
         for column, requirement in sorted(requirements.items()):
             if (
                 family_status == _REQUIRED_AT_BUILD_STATUS
-                and column not in manifest.required_columns
+                and column in manifest.reviewed_exclusions
             ):
                 failures.append(
-                    f"{family_name}: distributional requirement {column!r} must "
-                    "be a required release input while the family is "
+                    f"{family_name}: distributional requirement {column!r} "
+                    "cannot be a reviewed exclusion while the family is "
                     "required_at_build."
                 )
             if (
@@ -1346,63 +1521,6 @@ def assert_uk_release_input_coverage_manifest_current(
                     "with the reviewed UK release policy."
                 )
 
-    known_gaps = {gap.variable: gap for gap in load_efrs_parity_known_gaps()}
-    # Engine-derived exclusions (microcosm#1106) are a separate section of the
-    # same ledger: reference inputs the engine computes from persisted inputs,
-    # which the release must therefore not persist. They are never parity debt.
-    engine_derived = {
-        gap.variable: gap for gap in load_efrs_engine_derived_exclusions()
-    }
-    both = sorted(set(known_gaps) & set(engine_derived))
-    if both:
-        failures.append(
-            "efrs_parity_known_gaps.json names column(s) both as a parity known "
-            f"gap and as an engine-derived exclusion: {both}."
-        )
-    known_gaps = {**known_gaps, **engine_derived}
-    gaps_outside_surface = sorted(set(known_gaps) - surface)
-    if gaps_outside_surface:
-        failures.append(
-            "efrs_parity_known_gaps.json declares column(s) outside the "
-            f"enhanced-FRS populated surface: {gaps_outside_surface}."
-        )
-    for name in sorted(surface & declared):
-        column = manifest._by_name[name]
-        gap = known_gaps.get(name)
-        if gap is None:
-            if column.status != REQUIRED_STATUS:
-                failures.append(
-                    f"{name}: efrs_parity_known_gaps.json has no gap, so the "
-                    "manifest status must remain required."
-                )
-            continue
-        if column.status != REVIEWED_EXCLUSION_STATUS:
-            failures.append(
-                f"{name}: committed known gap must be a reviewed_exclusion in "
-                "the manifest."
-            )
-            continue
-        if column.reason != gap.reason:
-            failures.append(
-                f"{name}: manifest exclusion reason disagrees with "
-                "efrs_parity_known_gaps.json."
-            )
-        if column.tracking_note != gap.tracking_note:
-            failures.append(
-                f"{name}: manifest exclusion tracking note disagrees with "
-                "efrs_parity_known_gaps.json."
-            )
-
-    raw_engine = _efrs_reference_payload().get("engine")
-    raw_aliases = (
-        raw_engine.get("h5_input_aliases") if isinstance(raw_engine, Mapping) else None
-    )
-    if raw_aliases != dict(UK_LOADER_INPUT_ALIASES):
-        failures.append(
-            "efrs_parity_reference.json h5_input_aliases disagree with the "
-            "live UK coverage adapter; regenerate or update both together."
-        )
-
     if engine is None:
         engine = _coverage_engine()
     if engine is not None:
@@ -1418,23 +1536,9 @@ def assert_uk_release_input_coverage_manifest_current(
             )
         if not non_inputs:
             try:
-                live_entities = _engine_variable_entities(engine, declared)
+                _engine_variable_entities(engine, declared)
             except ValueError as exc:
                 failures.append(str(exc))
-            else:
-                entity_drift = {
-                    name: {
-                        "reference": reference_entities[name],
-                        "live": live_entities[name],
-                    }
-                    for name in sorted(surface & declared)
-                    if reference_entities[name] != live_entities[name]
-                }
-                if entity_drift:
-                    failures.append(
-                        "enhanced-FRS input owning entities disagree with the "
-                        f"live PolicyEngine-UK graph: {entity_drift}."
-                    )
 
     if failures:
         raise ValueError(
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/rowwise_cli.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/rowwise_cli.py
index 5676178464..8ec6c77892 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/rowwise_cli.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/rowwise_cli.py
@@ -125,7 +125,7 @@
 BUILD_RECORD_FILENAME = "build_record.json"
 NATIONAL_REGISTRY_FILENAME = "national_target_registry.json"
 NATIONAL_CONTRACT_REGISTRY_FILENAME = "national_contract_registry.json"
-SCORE_RECEIPT_FILENAME = "score_vs_incumbent.json"
+SCORE_RECEIPT_FILENAME = "score_vs_reference.json"
 DENSE_REFERENCE_DIAGNOSTICS_FILENAME = "dense_reference_diagnostics.csv"
 DATASET_SIZE_SELECTION_FILENAME = "dataset_size_selection.csv"
 
@@ -1200,6 +1200,10 @@ def refuse_dense_role_arguments(
         refused.append("--require-solve-reuse")
     if args.dataset_households is not None:
         refused.append("--dataset-households")
+    # The national cut's certify step reads its reference surface
+    # (microcosm#1095); the national build runs no export-surface gate.
+    if getattr(args, "reference_surface", None) is not None:
+        refused.append("--reference-surface")
     if args.selection_seed is not None:
         refused.append("--selection-seed")
     if getattr(args, "selection_initial_lambda", None) is not None:
@@ -1249,8 +1253,8 @@ def refuse_national_role_arguments(
         refused.append("--target-loss-cap")
     if args.allow_unpinned_feed:
         refused.append("--allow-unpinned-feed")
-    if args.incumbent_h5 is not None or args.incumbent_sha256 is not None:
-        refused.append("--incumbent-h5/--incumbent-sha256")
+    if args.reference_h5 is not None or args.reference_record is not None:
+        refused.append("--reference-h5/--reference-record")
     if args.target_weight_rule not in posture.allowed_target_weight_rules:
         refused.append(f"--target-weight-rule {args.target_weight_rule}")
     if refused:
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/terminal_gates.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/terminal_gates.py
index b26c2fe22d..cc68b01519 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/terminal_gates.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/terminal_gates.py
@@ -73,12 +73,10 @@
 ]
 
 UK_CANDIDATE_DATASET_NAME = "microcosm_uk_2024_25"
-# The label names the pinned reference artifact exactly: the 2024-25 line's
-# published enhanced_frs_2024_25.h5 (no separate "recalibrated" variant
-# exists at this vintage; the June report strings keep their own label).
-# After the swap, "reference" becomes the previous certified microcosm line
-# once a second certified cut exists; that later increment flips this value.
-UK_REFERENCE_DATASET_NAME = "enhanced_frs_2024_25"
+# The export-surface reference is the current build of the cut's own line
+# (microcosm#1095), as the cut's reference step recorded it; the reports name
+# the build. Until then it was the published enhanced_frs_2024_25.h5.
+UK_REFERENCE_DATASET_NAME = "current_build"
 UK_MAX_TARGET_ABS_RELATIVE_ERROR = 0.25
 
 
@@ -168,343 +166,55 @@ def __post_init__(self) -> None:
 )
 
 
-# Reviewed candidate-only fields from the June UK prototype.  They are source
-# provenance or genuine additional model inputs, not incumbent-surface losses.
+# Reviewed columns a candidate may export beyond the reference's surface.
+# Since microcosm#1095 the reference is the current build of the cut's own
+# line, so this lists only what the current national build does not export:
+# the dense line's geography and clone columns, which its own reference
+# carries, and any column new since the reference, each naming its PR. An
+# entry the reference now carries is reported as redundant, never failed;
+# the enhanced-FRS era's 224 entries the current build carries left with
+# it.
 UK_ALLOWED_EXTRA_EXPORT_COLUMNS: tuple[str, ...] = (
-    "benunit.child_benefit_opts_out",
-    "benunit.frs_benunit_capital",
-    "benunit.has_mixed_age_couple_pension_credit_saving",
-    "benunit.liable_for_share_of_household_rent",
-    "benunit.pension_credit_reported_capital",
-    "benunit.uc_deduction_combination",
-    "benunit.uc_deduction_random_draw",
-    "benunit.uc_deduction_type_random_draw",
-    "benunit.uc_latent_deduction_rate",
-    "benunit.uc_reported_capital",
-    "benunit.would_claim_uc_at_legacy_closure",
-    "benunit.would_claim_uc_childcare",
-    "household.additional_residential_property_purchased",
     "household.atomic_area_basis",
     "household.atomic_area_code",
     "household.atomic_area_system",
-    "household.bus_fare_spending",
-    "household.bus_subsidy_spending",
     "household.cash_isa",
-    # #1045: the CGT support split's family copy count.
-    "household.cgt_support_copies",
-    "household.cgt_support_copy_index",
-    # microcosm#1240: the high-value homes support split's family copy count,
-    # index and flag, the CGT split's precedent. The stage's coverage-manifest
-    # outputs; the first dense release build failed this gate on them
-    # (microcosm#1301).
-    "household.high_value_support_copies",
-    "household.high_value_support_copy_index",
-    "household.household_is_high_value_support_copy",
-    # #1063: the residential split's arm flag and index.
-    "household.household_is_cgt_residential_clone",
-    "household.cgt_residential_clone_index",
     "household.household_clone_index",
-    # microcosm#1114: the three area codes leave every artifact under the
-    # consumers' names (geography_ladder.UK_EXPORT_AREA_CODE_COLUMNS); the
-    # ladder names never reach an artifact and uk_export_candidate_columns
-    # translates them before this list is compared.
     "household.constituency_code_oa",
-    "household.consumer_debt",
-    # microcosm#932: the five nation-native aliases of the atomic assignment
-    # (output_area_code, data_zone_code, intermediate_zone_code,
-    # super_data_zone_code, district_electoral_area_code) never reach an
-    # artifact: graph_terminal._tables drops them at the single-year export
-    # boundary. They are listed because the full-build export-surface gate
-    # reads the graph frame's in-memory columns (full_gates.py,
-    # ``parity_evidence.candidate_columns``) before that boundary, and would
-    # otherwise flag them as unreviewed extras (the F8 gap on #932).
     "household.data_zone_code",
     "household.district_electoral_area_code",
-    "household.electricity_consumption",
-    "household.electricity_kwh",
-    "household.gas_consumption",
-    "household.gas_kwh",
     "household.geography_household_key",
-    "household.has_fuel_consumption",
-    # The LCFS prepayment-meter flag (microcosm#1110): policyengine-uk reads it
-    # from 2.123.3 for the Energy Price Guarantee prepayment discount, and an
-    # older engine ignores the column; the incumbent does not carry it yet
-    # (uk-data#539).
-    "household.uses_energy_prepayment_meter",
-    # microcosm#1359: the LCFS excise step's policyengine-uk inputs (the
-    # alcohol and tobacco ones from 2.145.0, the gambling duty bases from
-    # 2.151.0); an older engine ignores a column it does not know, and the
-    # incumbent carries none of them.
-    "household.beer_litres",
-    "household.cider_litres",
-    "household.wine_litres",
-    "household.spirits_litres",
-    "household.other_fermented_litres",
-    "household.beer_draught_share",
-    "household.cider_draught_share",
-    "household.cigarettes_per_week",
-    "household.hand_rolling_tobacco_grams_per_week",
-    "household.cigars_grams_per_week",
-    "household.other_tobacco_grams_per_week",
-    "household.remote_gaming_net_losses",
-    "household.pool_betting_net_receipts",
-    "household.bingo_net_receipts",
-    "household.national_lottery_ticket_spending",
-    "household.land_based_casino_net_losses",
-    "household.machine_games_lower_rate_net_takings",
-    "household.machine_games_standard_rate_net_takings",
-    "household.machine_games_higher_rate_net_takings",
-    "household.land_based_fixed_odds_betting_net_losses",
-    "household.remote_uk_horseracing_betting_net_losses",
-    "household.remote_other_betting_net_losses",
-    "household.betting_exchange_commission",
-    "household.horse_and_dog_pool_betting_net_losses",
-    "household.household_is_capital_gains_clone",
-    "household.household_is_cgt_support_copy",
-    "household.household_is_spi_income_band_donor",
-    "household.household_is_spi_synthetic",
-    # #1003: the WAS Lifetime ISA stage's household total and person cells.
-    "household.household_lifetime_isa_balance",
-    # #930: the NTS bus-travel stage's household journey cell.
-    "household.household_local_bus_trips",
-    # microcosm#1418: the dense build's Rural Fuel Duty Relief flag, set off
-    # each placed household's output area; the incumbent does not carry it.
     "household.in_rural_fuel_duty_relief_area",
-    "household.spi_income_band_donor_lower_bound",
     "household.intermediate_zone_code",
     "household.la_code_oa",
-    # #953: the engine's household local_authority enum input, written by the
-    # rowwise geography ladder from local_authority_code. The incumbent never
-    # carried it, so the coverage manifest cannot list it; this allow-list
-    # binds at the national release-cut export gate, and the rowwise lane's
-    # own guard is the ladder gate's code/member consistency check.
     "household.local_authority",
     "household.lsoa_code",
-    "household.mortgage_debt",
     "household.msoa_code",
-    "household.non_residential_property_purchased",
-    "household.num_vehicles",
     "household.oa_code",
-    "household.ons_household_type",
     "household.output_area_code",
-    "household.private_pension_wealth",
-    "household.property_purchased",
-    "household.rail_usage",
     "household.region_code_oa",
     "household.stocks_and_shares_isa",
     "household.super_data_zone_code",
-    "person.a_and_e_visits",
-    "person.aa_category",
-    "person.admitted_patient_visits",
-    "person.age_left_full_time_education",
-    "person.age_started_or_accepted_current_education_or_training",
-    "person.attends_private_school",
-    "person.attends_private_school_random_draw",
-    "person.capital_gains_asset_type",
-    "person.capital_gains_badr",
-    "person.capital_gains_residential_property",
-    "person.cgt_residential_probability",
-    "person.bus_in_london_trips",
-    "person.bus_pass_eligible",
-    "person.care_hours",
-    "person.charitable_investment_gifts",
-    "person.dla_m_category",
-    "person.dla_sc_category",
-    "person.employment_sector",
-    "person.contributory_benefits_annual_share",
-    "person.employment_income_annual_share",
-    "person.employment_income_other_spells",
-    "person.private_pension_income_annual_share",
-    "person.self_employment_income_annual_share",
-    "person.self_employment_income_other_spells",
-    # The self-employed's trading allowance claim status, which the enhanced
-    # FRS leaves at the engine's UNKNOWN, and the full-relief group's carrier,
-    # which the bound SPI self-employment rows read (microcosm#1439).
-    "person.trading_allowance_claim_status",
-    "person.trading_allowance_full_relief",
-    # The annuity and trust part of private_pension_income, a calibration-only
-    # descriptor no engine input reads (microcosm#1428).
-    "person.annuity_and_trust_income",
-    "person.esa_health_condition_proxy",
-    "person.esa_includes_support_component",
-    "person.esa_support_group_proxy",
-    "person.gift_aid",
-    "person.has_lifetime_isa",
-    "person.highest_education",
-    "person.is_before_universal_credit_qualifying_young_person_terminal_date",
-    "person.is_blind",
-    "person.is_claimant_or_partner",
-    "person.is_engaged_in_owned_company_trade",
-    "person.is_hbai_dependent_child",
-    "person.is_in_full_time_education",
-    "person.is_in_non_advanced_education",
-    "person.is_parent",
-    "person.is_uc_claimant",
-    "person.legacy_jobseeker_proxy",
-    "person.lifetime_isa_balance",
-    "person.lifetime_isa_payments",
-    "person.cash_isa_balance",
-    "person.stocks_and_shares_isa_balance",
-    "person.cash_isa_subscriptions",
-    "person.stocks_and_shares_isa_subscriptions",
-    # policyengine-uk 2.165.0's company car inputs, which the company_cars stage
-    # writes (PolicyEngine/uk-autumn-budget-dashboard-2026#316).
-    "person.company_car_list_price",
-    "person.company_car_co2_emissions",
-    "person.company_car_fuel_type",
-    "person.company_car_electric_range",
-    "person.company_car_capital_contributions",
-    "person.company_car_private_fuel_provided",
-    # policyengine-uk's vehicle excise duty inputs for households' own cars,
-    # which the lcfs_consumption stage's NTS car step writes (microcosm#1095 B3).
-    "person.car_fuel_type",
-    "person.car_co2_emissions",
-    "person.car_engine_size",
-    "person.car_first_registration_date",
-    "person.car_is_ved_exempt",
-    "person.individual_savings_account_interest_income",
-    "person.local_bus_single_fare_share",
-    "person.local_bus_trips",
-    "person.local_bus_use_band",
-    "person.loss_relief",
-    "person.ni_class_4_losses_brought_forward",
-    "person.ons_family_index",
-    "person.ons_family_role",
-    "person.other_local_bus_trips",
-    "person.outpatient_visits",
-    "person.owned_company_carries_on_property_business",
-    "person.owned_company_carries_on_trade",
-    "person.owned_company_income_share",
-    "person.owned_company_is_main_employment",
-    "person.pension_contributions_via_salary_sacrifice",
-    "person.pip_dl_points",
-    "person.pip_m_points",
-    "person.property_finance_costs",
-    "person.property_rental_income",
-    "person.receives_benefits_in_own_right",
-    "person.rent_paid_as_boarder",
-    "person.rent_paid_as_lodger",
-    "person.relationship_to_head",
-    "person.reports_outstanding_student_loan",
-    "person.salary_sacrifice_asked",
-    "person.salary_sacrifice_reported",
-    "person.sic_industry_division",
-    "person.soc2020_major_group",
-    "person.soc2020_sub_major_group",
-    "person.stands_as_sole_owner_or_partner_of_company",
-    "person.statutory_paternity_pay",
-    "person.student_loan_balance",
-    "person.student_loan_plan",
-    "person.tax_free_childcare_spend_routed_share",
-    "person.is_apprentice",
-    "person.trading_loss",
-    "person.uc_is_in_startup_period",
-    "person.uc_is_in_gainful_self_employment",
-    # microcosm#1095 (Y1): the limited capability flags the
-    # uc_limited_capability stage stores, DWP's status on linked claims and
-    # the engine's proxy elsewhere.
-    "person.uc_limited_capability_for_WRA",
-    "person.uc_limited_capability_for_work",
-    "person.is_looked_after_by_local_authority",
-    "person.child_limit_non_parental_caring_exception",
-    "person.would_claim_carers_allowance",
-    "person.would_claim_marriage_allowance",
-    "person.would_claim_scp",
-    "person.max_free_entitlement_hours_used",
-    "person.person_is_spi_income_band_carrier",
-    "person.person_is_spi_income_recipient",
-    # microcosm#1063 c9 (ruling 2026-10-02): every declared stage output the
-    # enhanced-FRS incumbent never carried is allow-listed rather than
-    # dropped, so the release candidate ships the spine's own surface. The
-    # certifier rehearsal R5 on the 2026-09-30 build named them: the source
-    # and support-channel lineage of the three entities, the council tax
-    # family (#934), the reported-benefit inputs the take-up stages read
-    # (the five internal disability carriers are not among them: they leave
-    # at the release boundary, UK_RELEASE_EXPORT_DROPPED_COLUMNS),
-    # the SPI channel's hmrc_spi_* leaves (#717), the FRS education and
-    # housing fields, the two raw FRS codes the spine fences
-    # (ossben_identifiable_subset, srp_regular_code5) and
-    # other_investment_income. Only incapacity_benefit_reported, an all-zero
-    # layer the pinned reference leaves off its surface, is dropped
-    # (national_frame.UK_RELEASE_EXPORT_DROPPED_COLUMNS).
-    "benunit.benunit_source_id",
-    "benunit.benunit_support_channel",
-    "benunit.benunit_support_clone_index",
-    "benunit.dependent_children",
-    "household.council_tax_rebate",
-    "household.council_tax_reported",
-    "household.council_tax_single_adult_raw",
-    "household.household_source_id",
-    "household.household_support_channel",
-    "household.household_support_clone_index",
-    "household.num_bedrooms",
-    "household.source_household_id",
-    "household.source_household_key",
-    "household.source_year",
-    "household.subrent",
-    "person.disabled_students_allowance_eligible_expenses",
-    "person.free_school_breakfasts",
-    "person.hmrc_spi_assessable_income",
-    "person.hmrc_spi_employed_income",
-    "person.hmrc_spi_employment_benefits",
-    "person.hmrc_spi_employment_expenses",
-    "person.hmrc_spi_incapacity_benefit_income",
-    "person.hmrc_spi_miscellaneous_employment_income",
-    "person.hmrc_spi_other_income",
-    "person.hmrc_spi_other_social_security_income",
-    "person.hmrc_spi_pay",
-    "person.hmrc_spi_state_pension_income",
-    "person.hmrc_spi_taxable_termination_pay",
-    "person.hmrc_spi_total_earned_income",
-    "person.hmrc_spi_total_investment_income",
-    "person.hmrc_spi_unemployment_benefit_income",
-    "person.is_in_approved_training",
-    "person.ossben_identifiable_subset",
-    "person.other_investment_income",
-    "person.person_source_id",
-    "person.person_support_channel",
-    "person.person_support_clone_index",
-    "person.srp_regular_code5",
     "benunit.benunit_clone_index",
     "person.person_clone_index",
-    # microcosm#1194: the build identifiers the release keeps beside the
-    # renumbered ones (national_frame.UK_BUILD_IDENTIFIER_COLUMNS). The
-    # lineage columns above describe them.
-    "benunit.benunit_build_id",
-    "household.household_build_id",
-    "person.person_build_id",
-    # The months since each person's last birthday, stored by the root stage
-    # so the engine reads one date of birth everywhere (microcosm#1095).
-    "person.months_since_last_birthday",
     "household.itl1_code",
     "household.itl2_code",
     "household.itl3_code",
     "household.ward_code",
-    # War Widow's or Widower's Pension, split out of bsp_reported (#1222,
-    # pe-uk#2382). The enhanced FRS still adds FRS benefit code 9 into
-    # bsp_reported, so its surface has no such input.
-    "person.war_widows_pension_reported",
-    # Widowed Parent's Allowance, split out of FRS code 6 by rate (#1222,
-    # pe-uk#2572). The enhanced FRS keeps the whole code in bsp_reported.
-    "person.widowed_parents_allowance_reported",
-    # Spousal maintenance (ALIAMT or ALUAMT, and APAMT; #1320, pe-uk#2572).
-    # The enhanced FRS reads no alimony and keeps APAMT a private transfer.
-    "person.spousal_maintenance_income",
-    # Bonus sacrifice (#1340, pe-uk#2572 section 1): the enhanced FRS carries
-    # salary sacrifice only.
-    "person.pension_contributions_via_bonus_sacrifice",
-    # Liquid and solid heating fuels (#1278, pe-uk#2572): the enhanced FRS
-    # draws no fuel beside electricity and gas.
-    "household.liquid_fuel_consumption",
-    "household.solid_fuel_consumption",
-    # The share split inside corporate_wealth (pe-uk#1974) and the debt
-    # secured on other property (UC Regs 2013 reg 49(1)(b)), from the WAS
-    # property draw (microcosm#1095): the enhanced FRS carries corporate_wealth
-    # alone and no secured debt.
-    "household.directly_held_shares",
-    "household.unit_and_investment_trusts",
-    "household.other_residential_property_secured_debt",
-    "household.non_residential_property_secured_debt",
+    # New since the current builds (national eeb6093e, dense 38605444); each
+    # leaves once a promotion moves the reference past it (microcosm#1095).
+    # microcosm#1550 (microcosm#1095, P1): the PIP points the pip_points stage
+    # draws within the stored award, from which the engine derives the
+    # categories.
+    "person.pip_dl_points",
+    "person.pip_m_points",
+    # microcosm#1550 (microcosm#1439): the trading allowance claim status and
+    # the full-relief group's carrier.
+    "person.trading_allowance_claim_status",
+    "person.trading_allowance_full_relief",
+    # microcosm#1550 (microcosm#1095, Y1): the UC limited capability flags.
+    "person.uc_limited_capability_for_WRA",
+    "person.uc_limited_capability_for_work",
 )
 
 UK_KNOWN_MISSING_REFERENCE_EXPORT_COLUMNS: tuple[str, ...] = (
@@ -535,6 +245,16 @@ def __post_init__(self) -> None:
         "the pip_points stage draws within the stored award and drops the "
         "category (microcosm#1095, P1; María's signature of 2026-11-09)."
     ),
+    "person.self_employment_gross_receipts": (
+        "microcosm#1550 (microcosm#1439) stops writing "
+        "self_employment_gross_receipts: the trading allowance stage stores "
+        "each trader's trading_allowance_claim_status and leaves gross receipts "
+        "at the engine's zero, since neither the FRS nor the SPI records them. "
+        "The current builds (national eeb6093e, dense 38605444) still export "
+        "the receipts encoding microcosm#1428 wrote, so the candidate drops the "
+        "column against them; the entry leaves once a promotion moves the "
+        "reference past it (microcosm#1095; María's signature of 2026-11-10)."
+    ),
     "person.tax_free_savings_income": (
         "policyengine-uk derives tax_free_savings_income as the sum of the ISA "
         "interest it adds (individual_savings_account_interest_income); a "
@@ -598,8 +318,8 @@ def uk_export_candidate_columns(frame: Any) -> set[str]:
     Structural id columns are not exported content (microcosm#1063 c9: the
     certifier rehearsal listed every id as an unreviewed extra), and the
     frame's household weights live beside the tables, so the surface carries
-    ``household.household_weight`` explicitly, as the enhanced-FRS reference
-    does.
+    ``household.household_weight`` explicitly, as the reference build's
+    surface does (the reference is measured with this function too).
     """
 
     from microcosm.build.uk_runtime.geography_ladder import (
@@ -1083,8 +803,13 @@ def uk_export_surface_gate(
     *,
     allowed_extra_columns: Iterable[str] = UK_ALLOWED_EXTRA_EXPORT_COLUMNS,
     reviewed_exclusions: Mapping[str, str] | None = None,
+    reference_name: str = UK_REFERENCE_DATASET_NAME,
 ) -> GateResult:
-    """Run the incumbent-compatible UK export-surface gate."""
+    """Compare the candidate's export surface with the reference build's.
+
+    ``reference_name`` labels the reference in the report: the binding
+    passes the build the cut's reference step recorded.
+    """
 
     candidate = {str(name) for name in candidate_columns}
     reference = {str(name) for name in reference_columns}
@@ -1093,7 +818,7 @@ def uk_export_surface_gate(
         candidate,
         reference,
         candidate_name=UK_CANDIDATE_DATASET_NAME,
-        reference_name=UK_REFERENCE_DATASET_NAME,
+        reference_name=reference_name,
         allowed_extra_columns=allowed_extra_columns,
         reviewed_exclusions=exclusions,
     )
@@ -1102,7 +827,7 @@ def uk_export_surface_gate(
     if not candidate:
         failures.append("UK candidate export-surface evidence is empty.")
     if not reference:
-        failures.append("Enhanced-FRS reference export-surface evidence is empty.")
+        failures.append("The reference build's export-surface evidence is empty.")
     if forbidden:
         failures.append(
             f"{UK_CANDIDATE_DATASET_NAME}: exports {len(forbidden)} reviewed "
@@ -1112,7 +837,15 @@ def uk_export_surface_gate(
         name=result.name,
         passed=not failures,
         failures=tuple(failures),
-        details={**dict(result.details), "forbidden_candidate_columns": forbidden},
+        details={
+            **dict(result.details),
+            "forbidden_candidate_columns": forbidden,
+            # Declared extras the reference now carries: reported, not failed,
+            # since a promotion moves the reference past them (microcosm#1095).
+            "redundant_allowed_extra_columns": sorted(
+                {str(name) for name in allowed_extra_columns} & reference
+            ),
+        },
     )
 
 
@@ -1120,7 +853,7 @@ def uk_target_surface_gate(
     candidate_targets: Iterable[str],
     reference_targets: Iterable[str],
 ) -> GateResult:
-    """Require the UK candidate target surface to cover enhanced FRS."""
+    """Require the UK candidate target surface to cover the reference register."""
 
     candidate = {str(name) for name in candidate_targets}
     reference = {str(name) for name in reference_targets}
@@ -1128,13 +861,13 @@ def uk_target_surface_gate(
         candidate,
         reference,
         candidate_name=UK_CANDIDATE_DATASET_NAME,
-        reference_name=UK_REFERENCE_DATASET_NAME,
+        reference_name="reference_register",
     )
     failures = [*result.failures]
     if not candidate:
         failures.append("UK candidate target-surface evidence is empty.")
     if not reference:
-        failures.append("Enhanced-FRS reference target-surface evidence is empty.")
+        failures.append("Reference register target-surface evidence is empty.")
     return GateResult(
         name=result.name,
         passed=not failures,
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/weight_year.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/weight_year.py
index 2a7e44a245..56bb5beaf9 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/weight_year.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/weight_year.py
@@ -57,6 +57,11 @@
     "Household weights as policyengine-uk projects them from the dataset year "
     "to the simulation year (microcosm#796 A19)."
 )
+UK_RECORDED_SOLVE_YEAR_MASS_REASON = (
+    "Household weights at the solve year by the release's own record: the "
+    "stored weights times the factor its build divided them by, whatever "
+    "policyengine-uk is installed (microcosm#1095)."
+)
 
 
 def uk_weight_projection_growth(year: int) -> float:
@@ -182,14 +187,46 @@ def uk_solve_year_frame(frame: Frame, *, solve_year: int) -> Frame:
     return uk_engine_year_frame(frame, simulation_year=solve_year)
 
 
+def uk_recorded_solve_year_frame(frame: Frame) -> Frame:
+    """A written frame at the weights its own build solved, by its record.
+
+    :func:`uk_solve_year_frame` gives a release back its solved weights
+    through the installed engine's projection, so it refuses a release an
+    earlier policyengine-uk wrote, whose projection differed. A cut's
+    reference is such a release: the current build may predate the installed
+    engine. Its mass log records the factor its build divided by, and that
+    factor alone returns its solve (microcosm#1095). A frame that was never
+    divided is returned as it is.
+    """
+
+    if not uk_weights_are_at_dataset_year(frame):
+        return frame
+    record = [r for r in frame.mass_log if r.entity == "household"][-1]
+    declared = record.declared_factor
+    if declared is None or not np.isfinite(float(declared)) or float(declared) <= 0.0:
+        raise ValueError(
+            "The frame's household weights were divided at the dataset year, but "
+            "its mass log records no positive factor to multiply them back by."
+        )
+    weights = frame.weights_for("household")
+    factor = 1.0 / float(declared)
+    return frame.with_weights(
+        "household",
+        Weights(np.asarray(weights.values, dtype=np.float64) * factor, weights.kind),
+        mass=MassChange(factor=factor, reason=UK_RECORDED_SOLVE_YEAR_MASS_REASON),
+    )
+
+
 __all__ = [
     "UK_ENGINE_YEAR_MASS_REASON",
+    "UK_RECORDED_SOLVE_YEAR_MASS_REASON",
     "UK_WEIGHT_PROJECTION_PARAMETER",
     "UK_WEIGHT_PROJECTION_PINS_BLOCK",
     "UK_WEIGHT_PROJECTION_VARIABLE",
     "UK_WEIGHT_YEAR_MASS_REASON",
     "uk_dataset_year_frame",
     "uk_engine_year_frame",
+    "uk_recorded_solve_year_frame",
     "uk_solve_year_frame",
     "uk_weight_projection_factor",
     "uk_weight_projection_growth",
diff --git a/packages/microcosm-build/src/microcosm/build/uk_runtime/weighted_integrity.py b/packages/microcosm-build/src/microcosm/build/uk_runtime/weighted_integrity.py
index fe7c1f697b..160a5858f3 100644
--- a/packages/microcosm-build/src/microcosm/build/uk_runtime/weighted_integrity.py
+++ b/packages/microcosm-build/src/microcosm/build/uk_runtime/weighted_integrity.py
@@ -6,8 +6,10 @@
 
 - **Input-mass parity** (#278): a rebuilt or selected artifact can zero an
   untargeted input column while every calibrated target still fits. The gate
-  compares weighted per-column totals against a frozen reference; total loss
-  fails at any tolerance.
+  compares weighted per-column totals against the current build of the cut's
+  own line (microcosm#1095; until then a frozen enhanced-FRS reference);
+  total loss fails at any tolerance, and so does a drop past the reviewed
+  share.
 - **QRF tail concentration** (#462): a weighted QRF can broadcast a
   donor-tail point mass so a handful of records carry most of a column's
   shipped weighted mass while the paired count target is hit exactly. The
@@ -122,6 +124,7 @@
 from importlib.resources import files
 from pathlib import Path
 from types import MappingProxyType
+from typing import Any
 
 import numpy as np
 import pandas as pd
@@ -130,23 +133,25 @@
     GateResult,
     input_mass_parity_gate,
 )
-from microcosm.build.input_mass import input_mass_totals
+from microcosm.build.input_mass import PERSON_REFERENCE_COLUMNS, input_mass_totals
 from microcosm.build.uk_runtime.national_frame import UK_EXPORTED_WEIGHT_COLUMNS
 from microcosm.frame import Frame
 
 __all__ = [
     "UK_DEGENERATE_EXCLUSION_REGISTER_RESOURCE",
     "UK_INPUT_MASS_EXCLUSION_REGISTER_RESOURCE",
+    "UK_CURRENT_BUILD_REFERENCE",
     "UK_INPUT_MASS_PARITY_GATE_NAME",
-    "UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256",
     "UK_LOCAL_TARGET_FIT_EXCLUSION_REGISTER_RESOURCE",
     "UK_TARGET_FIT_EXCLUSION_REGISTER_RESOURCE",
     "UKInputMassParityPolicy",
     "UKInputMassReference",
+    "UKCurrentBuildReference",
     "UKInputMassReferenceDescriptor",
     "UKReviewedExclusion",
     "UK_INPUT_MASS_REFERENCE_REGISTRY",
     "UK_RELEASE_LINES",
+    "UK_SINCE_BASELINE_LEFT_REASONS",
     "coerce_input_mass_reference_registry",
     "coerce_reviewed_exclusions",
     "exclusion_evaluation_date",
@@ -155,6 +160,7 @@
     "load_uk_reference_scoped_exclusion_register",
     "load_uk_reviewed_exclusion_register",
     "uk_default_input_mass_reviewed_exclusions",
+    "uk_input_mass_carriers",
     "uk_input_mass_parity_gate",
     "uk_input_mass_totals",
     "uk_qrf_tail_concentration_columns",
@@ -170,14 +176,17 @@
     "local_target_fit_reviewed_exclusions.json"
 )
 
-# Canonical sha256 of {"reference": {"identity": ..., "totals": ...}} for
-# the weighted input surface emitted from the pinned enhanced-FRS artifact by
-# build_uk_efrs_parity_reference.py. The totals remain uncommitted under the
-# UKDS EUL; this reviewed digest lets the gate and publication contract bind
-# them without disclosing them.
-UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256 = (
-    "fd41cb5f6cf6c4ef812320f21d1942173d49ce6f8725b21fbc9d9ca5423d298c"
-)
+#: The input-mass reference file a cut writes from its reference build
+#: (microcosm#1095): schema 2 names the build and carries each column's
+#: carriers. Schema 1 held the enhanced FRS's totals, which retired with it.
+UK_INPUT_MASS_REFERENCE_SCHEMA_VERSION = 2
+UK_INPUT_MASS_REFERENCE_KIND = "uk_input_mass_reference"
+#: Why a column leaves the record of change since the baseline, where it
+#: stays listed with its last ratio (round 2 of the review of
+#: microcosm#1574): absent from the candidate or the reference, a zero
+#: reference total (no ratio continues), or one or two source households on
+#: a side (its figures are withheld).
+UK_SINCE_BASELINE_LEFT_REASONS = ("absent", "zero_reference_total", "thin")
 
 
 _SHA256_HEX = frozenset("0123456789abcdef")
@@ -247,24 +256,69 @@ def spec_payload(self) -> dict[str, object]:
         }
 
 
-_UK_INPUT_MASS_REFERENCE_DESCRIPTOR = UKInputMassReferenceDescriptor(
-    name="efrs-post-calibration",
-    filename="enhanced_frs_2024_25.h5",
-    revision="a9e52499b6a6cca100a5ce4f36ca27b2e8a213df",
-    sha256="e433e532b17bd8ce76030156285816e33d44e93edabd2204adbef71d19a68712",
-    vintage="2024_25",
-    totals_sha256=UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256,
+@dataclass(frozen=True)
+class UKCurrentBuildReference:
+    """The input-mass reference kind: the current build of the cut's own line.
+
+    The spec names the kind, not a file (microcosm#1095): a cut compares its
+    candidate with the build its line's ``releases.json`` named when the cut
+    fetched its inputs, and every report records which build that was. The
+    concrete descriptor is made from the reference file the cut wrote
+    (:meth:`descriptor_for`), so the identity and totals digest the gate
+    checks are the reference's own.
+    """
+
+    name: str
+    scope_note: str
+
+    def __post_init__(self) -> None:
+        for field_name in ("name", "scope_note"):
+            value = getattr(self, field_name)
+            if (
+                not isinstance(value, str)
+                or not value.strip()
+                or value != value.strip()
+            ):
+                raise ValueError(
+                    f"UK input-mass reference {field_name} must be a non-empty "
+                    "trimmed string."
+                )
+
+    def spec_payload(self) -> dict[str, object]:
+        """The gates.json registry entry shape."""
+
+        return {"kind": "current_build", "scope_note": self.scope_note}
+
+    def descriptor_for(
+        self, reference: UKInputMassReference
+    ) -> UKInputMassReferenceDescriptor:
+        if reference.label is None:
+            raise ValueError(
+                "The input-mass reference names no build; a cut's reference file "
+                "records the build it was measured from."
+            )
+        return UKInputMassReferenceDescriptor(
+            name=self.name,
+            filename=reference.filename,
+            revision=reference.revision,
+            sha256=reference.sha256,
+            vintage=reference.vintage,
+            totals_sha256=_input_mass_reference_evidence_sha256(reference),
+            scope_note=self.scope_note,
+        )
+
+
+UK_CURRENT_BUILD_REFERENCE = UKCurrentBuildReference(
+    name="current_build",
     scope_note=(
-        "Channel-blind post-calibration enhanced-FRS production incumbent, "
-        "pinned to the 2024-25 line; its artifact carries the SPI-synthetic "
-        "rows structurally but no admin-restored mass in the "
-        "SPI-channel-exclusive columns, so those columns are comparable "
-        "only through per-reference reviewed exclusions."
+        "The current build of the cut's own release line, as releases.json "
+        "named it when the cut fetched its inputs (microcosm#1095): totals "
+        "at each build's own solved weights, on the export surface."
     ),
 )
 
 UK_INPUT_MASS_REFERENCE_REGISTRY = MappingProxyType(
-    {_UK_INPUT_MASS_REFERENCE_DESCRIPTOR.name: _UK_INPUT_MASS_REFERENCE_DESCRIPTOR}
+    {UK_CURRENT_BUILD_REFERENCE.name: UK_CURRENT_BUILD_REFERENCE}
 )
 
 _REVIEWED_EXCLUSION_FIELDS = frozenset(
@@ -466,57 +520,43 @@ def coerce_reviewed_exclusions(
 
 def coerce_input_mass_reference_registry(
     value: object, *, label: str
-) -> dict[str, UKInputMassReferenceDescriptor]:
-    """Validate the closed-world input-mass reference registry."""
+) -> dict[str, UKCurrentBuildReference]:
+    """Validate the closed-world input-mass reference registry.
+
+    Its one kind is the current build of the cut's own line
+    (``{"kind": "current_build", "scope_note": ...}``); a file pinned by
+    identity, as the enhanced-FRS entry was, is refused.
+    """
 
     if not isinstance(value, Mapping) or not value:
         raise TypeError(f"{label} reference_registry must be a non-empty mapping.")
-    records: dict[str, UKInputMassReferenceDescriptor] = {}
+    records: dict[str, UKCurrentBuildReference] = {}
     for name, entry in value.items():
         if not isinstance(name, str) or not name.strip() or name != name.strip():
             raise ValueError(
                 f"{label} reference_registry names must be non-empty trimmed "
                 f"strings; got {name!r}."
             )
-        if isinstance(entry, UKInputMassReferenceDescriptor):
-            descriptor = entry
-            if descriptor.name != name:
+        if isinstance(entry, UKCurrentBuildReference):
+            if entry.name != name:
                 raise ValueError(
                     f"{label} reference_registry entry {name!r} carries "
-                    f"descriptor name {descriptor.name!r}."
+                    f"reference name {entry.name!r}."
                 )
-            records[name] = descriptor
+            records[name] = entry
             continue
         if not isinstance(entry, Mapping):
             raise TypeError(
                 f"{label} reference_registry entry {name!r} must be an object."
             )
-        expected_entry_fields = {"identity", "totals_sha256", "scope_note"}
-        if set(entry) != expected_entry_fields:
-            raise ValueError(
-                f"{label} reference_registry entry {name!r} fields must be "
-                f"exactly {sorted(expected_entry_fields)}, got {sorted(entry)}."
-            )
-        identity = entry["identity"]
-        if not isinstance(identity, Mapping):
-            raise TypeError(
-                f"{label} reference_registry entry {name!r} identity must be an object."
-            )
-        expected_identity_fields = {"filename", "revision", "sha256", "vintage"}
-        if set(identity) != expected_identity_fields:
+        if set(entry) != {"kind", "scope_note"} or entry.get("kind") != "current_build":
             raise ValueError(
-                f"{label} reference_registry entry {name!r} identity fields "
-                f"must be exactly {sorted(expected_identity_fields)}, got "
-                f"{sorted(identity)}."
+                f"{label} reference_registry entry {name!r} must be exactly "
+                '{"kind": "current_build", "scope_note": ...}; a reference pinned '
+                "by file identity is no longer accepted (microcosm#1095)."
             )
-        records[name] = UKInputMassReferenceDescriptor(
-            name=name,
-            filename=identity["filename"],
-            revision=identity["revision"],
-            sha256=identity["sha256"],
-            vintage=identity["vintage"],
-            totals_sha256=entry["totals_sha256"],
-            scope_note=entry["scope_note"],
+        records[name] = UKCurrentBuildReference(
+            name=name, scope_note=entry["scope_note"]
         )
     return dict(sorted(records.items()))
 
@@ -793,50 +833,126 @@ def uk_default_input_mass_reviewed_exclusions() -> Mapping[
     )
 
 
-def load_uk_input_mass_reference(source: str | Path) -> UKInputMassReference:
-    """Load frozen reference totals emitted by the #609 measurement tooling.
+def _is_ratio(value: object) -> bool:
+    return (
+        isinstance(value, int | float)
+        and not isinstance(value, bool)
+        and math.isfinite(float(value))
+        and float(value) >= 0.0
+    )
+
+
+def _left_chain_ok(left: object, ratios: Mapping[str, Any]) -> bool:
+    """Each column that left the chain: why, its last ratio and build."""
+
+    return isinstance(left, Mapping) and all(
+        isinstance(entry, Mapping)
+        and set(entry) == {"reason", "last_ratio", "last_build"}
+        and entry["reason"] in UK_SINCE_BASELINE_LEFT_REASONS
+        and _is_ratio(entry["last_ratio"])
+        and isinstance(entry["last_build"], str)
+        and entry["last_build"].count("@") == 1
+        and column not in ratios
+        for column, entry in left.items()
+    )
+
 
-    Schema: ``{"schema_version": 1, "identity": {filename, revision, sha256,
-    vintage}, "totals": {column: weighted_total}}`` — totals keys are flat
-    frame column names, matching :func:`uk_input_mass_totals`. The identity
-    names the pinned artifact the totals were measured from and is recorded
-    verbatim in the gate details and the attestation evidence digest.
+def load_uk_input_mass_reference(source: str | Path) -> UKInputMassReference:
+    """Load the input-mass reference a cut wrote from its reference build.
+
+    Schema 2: ``{"schema_version": 2, "kind": "uk_input_mass_reference",
+    "label": "<release>@<build>", "identity": {filename, revision, sha256,
+    vintage}, "totals": {column: weighted_total}, "carriers": {column:
+    distinct source households}}``. The revision is the build, the totals
+    and carriers are :func:`uk_input_mass_totals` and
+    :func:`uk_input_mass_carriers` of the build's export frame at its own
+    solved weights (:func:`~.cut_reference.uk_input_mass_reference_payload`). The file stays
+    beside the cut's reference: its totals are licensed-data aggregates.
     """
 
     path = Path(source)
     payload = json.loads(path.read_text(encoding="utf-8"))
     if not isinstance(payload, Mapping):
         raise ValueError(f"{path}: input-mass reference must be a JSON object.")
-    if payload.get("schema_version") != 1:
+    if payload.get("schema_version") != UK_INPUT_MASS_REFERENCE_SCHEMA_VERSION:
         raise ValueError(
-            f"{path}: input-mass reference schema_version must be 1, got "
-            f"{payload.get('schema_version')!r}."
+            f"{path}: input-mass reference schema_version must be "
+            f"{UK_INPUT_MASS_REFERENCE_SCHEMA_VERSION}, got "
+            f"{payload.get('schema_version')!r}; the enhanced-FRS totals retired "
+            "with microcosm#1095, so write the reference from the line's current "
+            "build (tools/resolve_uk_reference.py)."
+        )
+    if payload.get("kind") != UK_INPUT_MASS_REFERENCE_KIND:
+        raise ValueError(
+            f"{path}: input-mass reference kind must be {UK_INPUT_MASS_REFERENCE_KIND!r}."
         )
     identity = payload.get("identity")
     if not isinstance(identity, Mapping):
         raise ValueError(f"{path}: input-mass reference needs an 'identity' object.")
     totals = payload.get("totals")
-    if not isinstance(totals, Mapping):
-        raise ValueError(f"{path}: input-mass reference needs a 'totals' object.")
-    reference = UKInputMassReference(
+    carriers = payload.get("carriers")
+    if not isinstance(totals, Mapping) or not isinstance(carriers, Mapping):
+        raise ValueError(
+            f"{path}: input-mass reference needs 'totals' and 'carriers' objects."
+        )
+    label = payload.get("label")
+    if not isinstance(label, str) or label.count("@") != 1:
+        raise ValueError(
+            f"{path}: input-mass reference label must be <release>@<build>."
+        )
+    if label.split("@", 1)[1] != identity.get("revision"):
+        raise ValueError(
+            f"{path}: input-mass reference label {label!r} does not name the "
+            f"build its identity records ({identity.get('revision')!r})."
+        )
+    since_baseline = payload.get("since_baseline")
+    if since_baseline is not None:
+        ratios = (
+            since_baseline.get("ratios")
+            if isinstance(since_baseline, Mapping)
+            else None
+        )
+        baseline = (
+            since_baseline.get("baseline")
+            if isinstance(since_baseline, Mapping)
+            else None
+        )
+        left = (
+            since_baseline.get("left") if isinstance(since_baseline, Mapping) else None
+        )
+        if (
+            not isinstance(baseline, str)
+            or baseline.count("@") != 1
+            or not isinstance(ratios, Mapping)
+            or not all(_is_ratio(value) for value in ratios.values())
+            or not _left_chain_ok(left, ratios)
+        ):
+            raise ValueError(
+                f"{path}: since_baseline names its baseline <release>@<build>, "
+                "a finite, non-negative ratio per column, and the columns that "
+                "left the chain, each with its reason, last ratio and last build."
+            )
+        since_baseline = {
+            "baseline": baseline,
+            "ratios": {str(name): float(value) for name, value in ratios.items()},
+            "left": {
+                str(name): {
+                    "reason": str(entry["reason"]),
+                    "last_ratio": float(entry["last_ratio"]),
+                    "last_build": str(entry["last_build"]),
+                }
+                for name, entry in left.items()
+            },
+        }
+    return UKInputMassReference(
         totals=dict(totals),
         filename=str(identity.get("filename", "")),
         revision=str(identity.get("revision", "")),
         sha256=str(identity.get("sha256", "")),
         vintage=str(identity.get("vintage", "")),
-    )
-    observed_digest = _input_mass_reference_evidence_sha256(reference)
-    for descriptor in UK_INPUT_MASS_REFERENCE_REGISTRY.values():
-        if (
-            reference.identity == descriptor.identity
-            and observed_digest == descriptor.totals_sha256
-        ):
-            return reference
-    known = sorted(UK_INPUT_MASS_REFERENCE_REGISTRY)
-    raise ValueError(
-        f"{path}: input-mass reference sidecar did not match any reviewed "
-        f"reference {known}; observed identity {reference.identity} with "
-        f"canonical evidence sha256 {observed_digest}."
+        label=label,
+        carriers=dict(carriers),
+        since_baseline=since_baseline,
     )
 
 
@@ -856,8 +972,27 @@ class UKInputMassReference:
     revision: str
     sha256: str
     vintage: str
+    label: str | None = None
+    carriers: Mapping[str, int] | None = None
+    #: The reference's own change since a fixed baseline, which the gate
+    #: continues: ``{"baseline": "<release>@<build>", "ratios": {column:
+    #: total / baseline total}, "left": {column: {"reason", "last_ratio",
+    #: "last_build"}}}`` (the review of microcosm#1574).
+    since_baseline: Mapping[str, Any] | None = None
 
     def __post_init__(self) -> None:
+        if self.carriers is not None:
+            carriers: dict[str, int] = {}
+            for name, count in self.carriers.items():
+                if type(count) is not int or count < 0:
+                    raise ValueError(
+                        "UK input-mass reference carriers must be non-negative "
+                        f"integers; got {name!r} -> {count!r}."
+                    )
+                carriers[str(name)] = count
+            object.__setattr__(
+                self, "carriers", MappingProxyType(dict(sorted(carriers.items())))
+            )
         if not isinstance(self.totals, Mapping) or not self.totals:
             raise ValueError(
                 "UK input-mass reference totals must be a non-empty mapping."
@@ -918,12 +1053,6 @@ def _input_mass_reference_evidence_sha256(
     return hashlib.sha256(canonical).hexdigest()
 
 
-def _validate_input_mass_reference(reference: UKInputMassReference) -> None:
-    _validate_input_mass_reference_for_descriptor(
-        reference, _UK_INPUT_MASS_REFERENCE_DESCRIPTOR
-    )
-
-
 def _validate_input_mass_reference_for_descriptor(
     reference: UKInputMassReference,
     descriptor: UKInputMassReferenceDescriptor,
@@ -935,8 +1064,7 @@ def _validate_input_mass_reference_for_descriptor(
         raise ValueError(
             "UK input-mass reference identity must match the reviewed "
             f"{descriptor.name}; expected {expected_identity}, got "
-            f"{reference.identity}. Known references: "
-            f"{sorted(UK_INPUT_MASS_REFERENCE_REGISTRY)}."
+            f"{reference.identity}."
         )
     observed_digest = _input_mass_reference_evidence_sha256(reference)
     if observed_digest != descriptor.totals_sha256:
@@ -953,18 +1081,29 @@ class UKInputMassParityPolicy:
 
     There are deliberately no defaults: the US tolerances (0.5 relative, a
     $1e9 USD floor over a 337k-record pool) are calibrated to US incidents
-    and dollar scales. UK values must come from the #609 measurement pass
-    over the certified compact, the pinned eFRS incumbent, and the staging
-    candidate, and be recorded with their derivation when committed.
+    and dollar scales. UK values are measured between consecutive certified
+    builds of a line, the current build being the reference (microcosm#1095),
+    and are recorded with their derivation when committed.
     """
 
     relative_tolerance: float
     minimum_reference_total: float
+    #: The largest share of its reference total a column's total may lose
+    #: (microcosm#1095): with a symmetric tolerance above one, the drift test
+    #: alone fails no drop short of zero.
+    maximum_relative_drop: float
     reviewed_exclusions: Mapping[str, UKReviewedExclusion] = field(default_factory=dict)
 
     def __post_init__(self) -> None:
         tolerance = float(self.relative_tolerance)
         floor = float(self.minimum_reference_total)
+        drop = float(self.maximum_relative_drop)
+        if not math.isfinite(drop) or not 0.0 <= drop <= 1.0:
+            raise ValueError(
+                "UK input-mass maximum_relative_drop must be a share in [0, 1], "
+                f"got {self.maximum_relative_drop!r}."
+            )
+        object.__setattr__(self, "maximum_relative_drop", drop)
         if not math.isfinite(tolerance) or tolerance < 0.0:
             raise ValueError(
                 "UK input-mass relative_tolerance must be finite and "
@@ -991,6 +1130,7 @@ def policy_payload(self) -> dict[str, object]:
         return {
             "relative_tolerance": self.relative_tolerance,
             "minimum_reference_total": self.minimum_reference_total,
+            "maximum_relative_drop": self.maximum_relative_drop,
             "reviewed_exclusions": {
                 name: record.policy_payload()
                 for name, record in sorted(self.reviewed_exclusions.items())
@@ -1020,6 +1160,203 @@ def uk_input_mass_totals(
     return totals
 
 
+def uk_input_mass_carriers(
+    frame: Frame,
+    *,
+    columns: Iterable[str] | None = None,
+) -> dict[str, int]:
+    """Distinct source households carrying each column :func:`uk_input_mass_totals` sums.
+
+    A column's carriers are the distinct ``household_source_id`` values among
+    rows of positive weight whose value is nonzero (a boolean: ``True``),
+    counted as the stage receipts count support
+    (:func:`~microcosm.build.uk_runtime.receipt_counts.distinct_count`):
+    support copies and clones repeat their source household, so they count
+    once. A person or benefit unit row counts its household's source. A
+    figure resting on fewer than ``UK_DISCLOSURE_FLOOR`` carriers is withheld
+    from what a report prints (microcosm#1095).
+    """
+
+    from microcosm.build.uk_runtime.receipt_counts import (
+        distinct_count,
+        source_household_ids,
+    )
+
+    schema = frame.schema
+    household = frame.table("household")
+    household_sources = pd.Series(
+        source_household_ids(household, stage="input-mass carriers"),
+        index=household[schema.id_column("household")].to_numpy(),
+    )
+    person = frame.table("person")
+    person_sources = household_sources.reindex(
+        person[schema.membership_column("household")].to_numpy()
+    ).to_numpy()
+    benunit_sources = None
+    if "benunit" in frame.entities:
+        first_member = (
+            pd.DataFrame(
+                {
+                    "benunit": person[schema.membership_column("benunit")].to_numpy(),
+                    "source": person_sources,
+                }
+            )
+            .drop_duplicates("benunit")
+            .set_index("benunit")["source"]
+        )
+        benunit_sources = first_member.reindex(
+            frame.table("benunit")[schema.id_column("benunit")].to_numpy()
+        ).to_numpy()
+    sources_by_entity = {
+        "household": household_sources.to_numpy(),
+        "person": person_sources,
+        "benunit": benunit_sources,
+    }
+    structural = {schema.person_id_column, *PERSON_REFERENCE_COLUMNS}
+    for group in schema.group_entities:
+        structural.add(schema.id_column(group))
+        structural.add(schema.membership_column(group))
+    requested = None if columns is None else {str(name) for name in columns}
+    carriers: dict[str, int] = {}
+    for entity in frame.entities:
+        sources = sources_by_entity.get(entity)
+        if sources is None:
+            continue
+        table = frame.table(entity)
+        weights = np.asarray(frame.resolve_weights(entity).values, dtype=np.float64)
+        for column in table.columns:
+            if column in structural or column in UK_EXPORTED_WEIGHT_COLUMNS:
+                continue
+            if requested is not None and column not in requested:
+                continue
+            values = table[column]
+            if pd.api.types.is_bool_dtype(values):
+                nonzero = values.fillna(False).to_numpy(dtype=bool)
+            elif pd.api.types.is_numeric_dtype(values):
+                numeric = pd.to_numeric(values, errors="coerce").fillna(0.0)
+                nonzero = numeric.to_numpy(dtype=np.float64) != 0.0
+            else:
+                continue
+            carriers[column] = distinct_count(sources, nonzero, weights)
+    return carriers
+
+
+def _thin_columns(
+    candidate_carriers: Mapping[str, int] | None,
+    reference_carriers: Mapping[str, int] | None,
+) -> frozenset[str]:
+    """Columns one or two source households carry on either side."""
+
+    from microcosm.build.uk_runtime.receipt_counts import UK_DISCLOSURE_FLOOR
+
+    if candidate_carriers is None or reference_carriers is None:
+        return frozenset()
+    return frozenset(
+        column
+        for column in set(candidate_carriers) | set(reference_carriers)
+        if any(
+            0 < count < UK_DISCLOSURE_FLOOR
+            for count in (
+                candidate_carriers.get(column),
+                reference_carriers.get(column),
+            )
+            if count is not None
+        )
+    )
+
+
+def _excess_drops(
+    candidate_totals: Mapping[str, float],
+    reference_totals: Mapping[str, float],
+    *,
+    maximum_relative_drop: float,
+    minimum_reference_total: float,
+) -> dict[str, float]:
+    """Columns whose total fell by more than the reviewed share of the reference's.
+
+    Drift is the shared gate's, signed: ``(candidate - reference) /
+    |reference|``. A column absent from the candidate or at exactly zero is
+    the shared gate's failure already, and a reference total at or below the
+    floor is skipped as the shared gate skips it.
+    """
+
+    drops: dict[str, float] = {}
+    for column, reference_total in reference_totals.items():
+        reference_total = float(reference_total)
+        if abs(reference_total) <= minimum_reference_total:
+            continue
+        if column not in candidate_totals:
+            continue
+        candidate_total = float(candidate_totals[column])
+        if candidate_total == 0.0:
+            continue
+        drift = (candidate_total - reference_total) / abs(reference_total)
+        if drift < -maximum_relative_drop:
+            drops[str(column)] = drift
+    return drops
+
+
+def _since_baseline(
+    candidate_totals: Mapping[str, float],
+    reference: UKInputMassReference,
+    thin: frozenset[str],
+) -> dict[str, Any] | None:
+    """Continue the reference's change since the baseline, or None without one.
+
+    A column leaves the chain where its ratio cannot be continued: absent on
+    a side, a zero reference total, or one or two source households on a
+    side (its figures are withheld). It stays listed, with the reason and
+    the last ratio the chain recorded for it, as of the reference, and the
+    reference's own list carries forward (round 2 of the review of
+    microcosm#1574): a column driven down and then dropped, or carried to
+    zero under a reviewed exclusion, does not vanish from the record. The
+    last ratio is one the reference's own certification already recorded,
+    so the list adds no figure.
+    """
+
+    chain = reference.since_baseline
+    if not chain:
+        return None
+    ratios: dict[str, float] = {}
+    left: dict[str, dict[str, Any]] = {
+        column: dict(entry) for column, entry in chain["left"].items()
+    }
+    for column, ratio in chain["ratios"].items():
+        reference_total = reference.totals.get(column)
+        candidate_total = candidate_totals.get(column)
+        if reference_total is None or candidate_total is None:
+            reason = "absent"
+        elif float(reference_total) == 0.0:
+            reason = "zero_reference_total"
+        elif column in thin:
+            reason = "thin"
+        else:
+            ratios[column] = (
+                float(ratio) * float(candidate_total) / float(reference_total)
+            )
+            continue
+        left[column] = {
+            "reason": reason,
+            "last_ratio": float(ratio),
+            "last_build": reference.label,
+        }
+    return {
+        "baseline": chain["baseline"],
+        "ratios": dict(sorted(ratios.items())),
+        "left": dict(sorted(left.items())),
+    }
+
+
+def _withheld_failure(message: str, thin: frozenset[str]) -> str:
+    column = message.split(":", 1)[0]
+    if column not in thin:
+        return message
+    return (
+        f"{column}: its mass check failed on a column one or two source "
+        "households carry on one side; the figures are withheld."
+    )
+
+
 def uk_input_mass_parity_gate(
     candidate_totals: Mapping[str, float],
     reference: UKInputMassReference,
@@ -1028,8 +1365,9 @@ def uk_input_mass_parity_gate(
     policy: UKInputMassParityPolicy,
     candidate_name: str = "uk_release_candidate",
     now: date | None = None,
+    candidate_carriers: Mapping[str, int] | None = None,
 ) -> GateResult:
-    """Require persisted UK input mass to survive against a frozen reference.
+    """Require persisted UK input mass to survive against the reference.
 
     Wraps :func:`microcosm.build.gates.input_mass_parity_gate` verbatim — a
     zero candidate total fails at any tolerance (the #278 signature),
@@ -1039,6 +1377,17 @@ def uk_input_mass_parity_gate(
     within tolerance is stale and **fails**; an exclusion outside the audited
     surface (absent from the reference, or below the reference floor) is
     dormant and reported.
+
+    Given both sides' carriers (``candidate_carriers`` and the reference's
+    own), a column one or two source households carry on either side is still
+    checked, but its figures never reach the report: its failure reads by
+    name, and it leaves ``worst_drifts`` for ``withheld_thin_columns``
+    (UKDS disclosure control, microcosm#1095).
+
+    The shared gate's tolerance is symmetric, so above one it fails no drop
+    short of zero; ``policy.maximum_relative_drop`` bounds how much of its
+    reference total a column may lose (microcosm#1095). A reviewed exclusion
+    covers both checks, and is stale only if the column passes both.
     """
 
     if not isinstance(reference, UKInputMassReference):
@@ -1062,6 +1411,15 @@ def uk_input_mass_parity_gate(
         minimum_reference_total=policy.minimum_reference_total,
         reviewed_exclusions=exclusions,
     )
+    all_drops = _excess_drops(
+        candidate_totals,
+        reference.totals,
+        maximum_relative_drop=policy.maximum_relative_drop,
+        minimum_reference_total=policy.minimum_reference_total,
+    )
+    drops = {
+        column: drift for column, drift in all_drops.items() if column not in exclusions
+    }
 
     stale: list[str] = []
     dormant: list[str] = []
@@ -1082,10 +1440,22 @@ def uk_input_mass_parity_gate(
             relative_tolerance=policy.relative_tolerance,
             minimum_reference_total=policy.minimum_reference_total,
         )
-        if probe.passed:
+        # Stale only if the column passes the drop limit too.
+        if probe.passed and column not in all_drops:
             stale.append(column)
 
-    failures = list(base.failures)
+    thin = _thin_columns(candidate_carriers, reference.carriers)
+    since_baseline = _since_baseline(candidate_totals, reference, thin)
+    failures = [_withheld_failure(message, thin) for message in base.failures]
+    for column, drift in sorted(drops.items()):
+        failures.append(
+            _withheld_failure(
+                f"{column}: {candidate_name} total fell by {-drift:.6g} of the "
+                f"reference's, beyond the reviewed maximum drop "
+                f"{policy.maximum_relative_drop:.6g}.",
+                thin,
+            )
+        )
     if stale:
         failures.append(
             "Stale reviewed input-mass exclusions — the column is within "
@@ -1105,6 +1475,20 @@ def uk_input_mass_parity_gate(
         failures=tuple(failures),
         details={
             **dict(base.details),
+            "worst_drifts": {
+                name: drift
+                for name, drift in dict(base.details["worst_drifts"]).items()
+                if name not in thin
+            },
+            "withheld_thin_columns": sorted(
+                thin & (set(reference.totals) | set(candidate_totals))
+            ),
+            "maximum_relative_drop": policy.maximum_relative_drop,
+            # Names only: a column's drift is in worst_drifts unless it is thin.
+            "excess_drops": sorted(drops),
+            # Each column's total as a ratio of the fixed baseline's, the
+            # reference's ratio times this comparison's: a record, no verdict.
+            **({"since_baseline": since_baseline} if since_baseline else {}),
             "stale_exclusions": stale,
             "dormant_exclusions": dormant,
             "expired_exclusions": expired,
@@ -1113,6 +1497,7 @@ def uk_input_mass_parity_gate(
             "reference": descriptor.name,
             "reference_scope_note": descriptor.scope_note,
             "reference_identity": reference.identity,
+            "reference_label": reference.label,
         },
     )
 
diff --git a/packages/microcosm-build/tests/engine/uk/test_uk_efrs_weighted_totals.py b/packages/microcosm-build/tests/engine/uk/test_uk_efrs_weighted_totals.py
index 6e5a2dc203..f7478b5cd4 100644
--- a/packages/microcosm-build/tests/engine/uk/test_uk_efrs_weighted_totals.py
+++ b/packages/microcosm-build/tests/engine/uk/test_uk_efrs_weighted_totals.py
@@ -1,7 +1,8 @@
 """Weighted-totals extraction from the pinned enhanced-FRS incumbent (#609).
 
-This is the reference side of the UK input_mass_parity gate: the frozen totals
-a candidate is measured against. The licensed artifact is never in CI, so the
+This was the reference side of the UK input_mass_parity gate until
+microcosm#1095 moved the gate to the current build of the cut's own line; the
+extraction stays as the measurement of the frozen enhanced-FRS reference. The licensed artifact is never in CI, so the
 sha pin is stubbed and the extraction runs against a synthetic H5 with the same
 shape — enough to prove the plumbing (table reading, engine-variable
 classification, weight broadcast, key format) before a licensed run pays for it.
@@ -139,59 +140,6 @@ def test_payload_pins_the_reference_identity_the_gate_records(
     }
 
 
-def test_payload_loads_as_a_gate_reference(
-    synthetic_efrs,
-    tmp_path,
-    monkeypatch,
-) -> None:
-    """The emitted file is exactly what the gate's loader accepts."""
-
-    from microcosm.build.uk_runtime import weighted_integrity
-    from microcosm.build.uk_runtime.weighted_integrity import (
-        UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256,
-        UK_INPUT_MASS_REFERENCE_REGISTRY,
-        UKInputMassParityPolicy,
-        load_uk_input_mass_reference,
-        uk_input_mass_parity_gate,
-    )
-
-    payload = TOOL.build_weighted_totals(synthetic_efrs)
-    path = tmp_path / "efrs_weighted_totals.json"
-    path.write_text(json.dumps(payload), encoding="utf-8")
-
-    # This synthetic source deliberately stubs the licensed artifact sha.
-    # The reviewed 131-column digest is covered by the runtime regressions.
-    monkeypatch.setattr(
-        weighted_integrity,
-        "_input_mass_reference_evidence_sha256",
-        lambda _reference: UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256,
-    )
-    descriptor = UK_INPUT_MASS_REFERENCE_REGISTRY["efrs-post-calibration"]
-    reference = load_uk_input_mass_reference(path)
-    identical = uk_input_mass_parity_gate(
-        dict(reference.totals),
-        reference,
-        descriptor=descriptor,
-        policy=UKInputMassParityPolicy(
-            relative_tolerance=0.0,
-            minimum_reference_total=0.0,
-        ),
-    )
-    zeroed = uk_input_mass_parity_gate(
-        {name: 0.0 for name in reference.totals},
-        reference,
-        descriptor=descriptor,
-        policy=UKInputMassParityPolicy(
-            relative_tolerance=0.0,
-            minimum_reference_total=0.0,
-        ),
-    )
-
-    assert reference.filename == TOOL.SOURCE_FILENAME
-    assert identical.passed
-    assert not zeroed.passed
-
-
 def test_emitting_totals_never_rewrites_the_committed_reference(
     synthetic_efrs,
     tmp_path,
diff --git a/packages/microcosm-build/tests/engine/uk/test_uk_release_input_coverage.py b/packages/microcosm-build/tests/engine/uk/test_uk_release_input_coverage.py
index da7693d0bc..d2f380bf0f 100644
--- a/packages/microcosm-build/tests/engine/uk/test_uk_release_input_coverage.py
+++ b/packages/microcosm-build/tests/engine/uk/test_uk_release_input_coverage.py
@@ -13,22 +13,28 @@ def test_full_required_set_with_signal_passes(self) -> None:
             }
         )
         result = uk_release_input_coverage_gate(
-            frame, _StubEngine(_DEFAULTS), manifest=_CONTRACT
+            frame,
+            _StubEngine(_DEFAULTS),
+            reference_surface=NO_REFERENCE_INPUTS,
+            manifest=_CONTRACT,
         )
         assert result.passed
         assert result.failures == ()
         assert result.details["dormant_exclusions"] == ["property_income"]
 
-    def test_missing_required_column_fails_and_names_efrs(self) -> None:
+    def test_missing_required_column_fails_and_names_the_reference(self) -> None:
         frame = _person_frame({"employment_income": np.asarray([0.0, 52_000.0])})
         result = uk_release_input_coverage_gate(
-            frame, _StubEngine(_DEFAULTS), manifest=_CONTRACT
+            frame,
+            _StubEngine(_DEFAULTS),
+            reference_surface=NO_REFERENCE_INPUTS,
+            manifest=_CONTRACT,
         )
         assert not result.passed
         assert result.details["missing"] == ["dividend_income"]
         assert any(
             "dividend_income" in failure
-            and "enhanced-FRS input column is absent" in failure
+            and "reference input column is absent" in failure
             for failure in result.failures
         )
 
@@ -41,16 +47,19 @@ def test_formula_owned_persisted_override_is_a_hard_requirement(self) -> None:
         absent = uk_release_input_coverage_gate(
             _person_frame({"age": np.asarray([40, 70])}),
             engine,
+            reference_surface=NO_REFERENCE_INPUTS,
             manifest=contract,
         )
         default_only = uk_release_input_coverage_gate(
             _person_frame({"state_pension_reported": np.asarray([0.0, 0.0])}),
             engine,
+            reference_surface=NO_REFERENCE_INPUTS,
             manifest=contract,
         )
         populated = uk_release_input_coverage_gate(
             _person_frame({"state_pension_reported": np.asarray([0.0, 12_000.0])}),
             engine,
+            reference_surface=NO_REFERENCE_INPUTS,
             manifest=contract,
         )
 
@@ -66,7 +75,10 @@ def test_default_only_required_column_fails(self) -> None:
             }
         )
         result = uk_release_input_coverage_gate(
-            frame, _StubEngine(_DEFAULTS), manifest=_CONTRACT
+            frame,
+            _StubEngine(_DEFAULTS),
+            reference_surface=NO_REFERENCE_INPUTS,
+            manifest=_CONTRACT,
         )
         assert not result.passed
         assert result.details["degenerate_required"] == ["dividend_income"]
@@ -79,6 +91,7 @@ def test_required_column_on_wrong_entity_fails(self) -> None:
         result = uk_release_input_coverage_gate(
             frame,
             _StubEngine(_DEFAULTS),
+            reference_surface=NO_REFERENCE_INPUTS,
             manifest=_CONTRACT,
         )
 
@@ -109,7 +122,10 @@ def test_required_column_without_valid_observations_fails(self, values) -> None:
             }
         )
         result = uk_release_input_coverage_gate(
-            frame, _StubEngine(_DEFAULTS), manifest=_CONTRACT
+            frame,
+            _StubEngine(_DEFAULTS),
+            reference_surface=NO_REFERENCE_INPUTS,
+            manifest=_CONTRACT,
         )
         assert not result.passed
         assert result.details["degenerate_required"] == ["dividend_income"]
@@ -123,7 +139,10 @@ def test_stale_reviewed_exclusion_fails(self) -> None:
             }
         )
         result = uk_release_input_coverage_gate(
-            frame, _StubEngine(_DEFAULTS), manifest=_CONTRACT
+            frame,
+            _StubEngine(_DEFAULTS),
+            reference_surface=NO_REFERENCE_INPUTS,
+            manifest=_CONTRACT,
         )
         assert not result.passed
         assert result.details["stale_exclusions"] == ["property_income"]
@@ -140,7 +159,10 @@ def test_absent_or_default_only_exclusion_passes(self) -> None:
             }
         )
         result = uk_release_input_coverage_gate(
-            frame, _StubEngine(_DEFAULTS), manifest=_CONTRACT
+            frame,
+            _StubEngine(_DEFAULTS),
+            reference_surface=NO_REFERENCE_INPUTS,
+            manifest=_CONTRACT,
         )
         assert result.passed
         assert result.details["reviewed_exclusions"] == {
@@ -159,6 +181,7 @@ def test_signal_only_on_zero_weight_rows_fails_effective_mass(self) -> None:
         result = uk_release_input_coverage_gate(
             frame,
             _StubEngine({"gift_aid": 0.0}),
+            reference_surface=NO_REFERENCE_INPUTS,
             manifest=contract,
         )
 
@@ -180,6 +203,7 @@ def test_positive_but_dust_mass_below_reviewed_floor_fails(self) -> None:
         result = uk_release_input_coverage_gate(
             frame,
             _StubEngine({"gift_aid": 0.0}),
+            reference_surface=NO_REFERENCE_INPUTS,
             manifest=contract,
         )
 
@@ -201,6 +225,7 @@ def test_signal_above_reviewed_effective_mass_floor_passes(self) -> None:
         result = uk_release_input_coverage_gate(
             frame,
             _StubEngine({"gift_aid": 0.0}),
+            reference_surface=NO_REFERENCE_INPUTS,
             manifest=contract,
         )
 
@@ -240,6 +265,7 @@ def test_explicit_person_weights_cannot_override_household_mass(self) -> None:
         result = uk_release_input_coverage_gate(
             frame,
             _StubEngine({"gift_aid": 0.0}),
+            reference_surface=NO_REFERENCE_INPUTS,
             manifest=_manifest((UKReleaseInputColumn("gift_aid", "required"),)),
         )
 
@@ -267,6 +293,7 @@ def test_base_signal_cannot_satisfy_spi_distributional_family(self) -> None:
         result = uk_release_input_coverage_gate(
             frame,
             _StubEngine({"gift_aid": 0.0}),
+            reference_surface=NO_REFERENCE_INPUTS,
             manifest=contract,
         )
 
@@ -289,6 +316,7 @@ def test_positive_spi_signal_satisfies_distributional_family(self) -> None:
         result = uk_release_input_coverage_gate(
             frame,
             _StubEngine({"gift_aid": 0.0}),
+            reference_surface=NO_REFERENCE_INPUTS,
             manifest=contract,
         )
 
@@ -320,6 +348,7 @@ def test_family_requires_reviewed_weight_kind_and_mass_record(self) -> None:
         result = uk_release_input_coverage_gate(
             frame,
             _StubEngine({"gift_aid": 0.0}),
+            reference_surface=NO_REFERENCE_INPUTS,
             manifest=contract,
         )
 
@@ -360,6 +389,7 @@ def test_family_accepts_reviewed_calibrated_mass_state(self) -> None:
         result = uk_release_input_coverage_gate(
             frame,
             _StubEngine({"gift_aid": 0.0}),
+            reference_surface=NO_REFERENCE_INPUTS,
             manifest=contract,
         )
 
@@ -381,6 +411,7 @@ def test_integer_encoded_enum_default_is_not_signal(self) -> None:
         result = uk_release_input_coverage_gate(
             frame,
             PolicyEngineUKCoverageEngine(),
+            reference_surface=NO_REFERENCE_INPUTS,
             manifest=contract,
         )
 
@@ -390,13 +421,17 @@ def test_integer_encoded_enum_default_is_not_signal(self) -> None:
     def test_zero_mass_signal_does_not_stale_a_reviewed_exclusion(self) -> None:
         contract = _manifest((_reviewed_gift_aid_exclusion(),))
         frame = _weighted_person_frame(
-            {"gift_aid": np.asarray([900.0, 0.0])},
+            {
+                "gift_aid": np.asarray([900.0, 0.0]),
+                "employment_income": np.asarray([0.0, 30_000.0]),
+            },
             np.asarray([0.0, 1_000.0]),
         )
 
         result = uk_release_input_coverage_gate(
             frame,
-            _StubEngine({"gift_aid": 0.0}),
+            _StubEngine({"gift_aid": 0.0, "employment_income": 0.0}),
+            reference_surface=reference_surface("employment_income"),
             manifest=contract,
         )
 
@@ -416,13 +451,17 @@ def test_deferred_family_does_not_enforce_future_distributional_gate(self) -> No
             family_coverage=family,
         )
         frame = _weighted_person_frame(
-            {"gift_aid": np.asarray([900.0, 0.0])},
+            {
+                "gift_aid": np.asarray([900.0, 0.0]),
+                "employment_income": np.asarray([0.0, 30_000.0]),
+            },
             np.asarray([0.0, 1_000.0]),
         )
 
         result = uk_release_input_coverage_gate(
             frame,
-            _StubEngine({"gift_aid": 0.0}),
+            _StubEngine({"gift_aid": 0.0, "employment_income": 0.0}),
+            reference_surface=reference_surface("employment_income"),
             manifest=contract,
         )
 
@@ -437,9 +476,10 @@ def test_shipped_manifest_is_current(self) -> None:
         assert_uk_release_input_coverage_manifest_current(
             engine=_StubEngine({}, set(manifest.declared_columns))
         )
-        # microcosm#1106: property_wealth is formula-owned in policyengine-uk,
-        # so the release leaves it to the engine; it is an engine-derived
-        # exclusion, not parity debt, and its components stay required. So is
+        # microcosm#1095: the required inputs come from the cut's reference
+        # build, so the manifest declares only the reviewed exclusions.
+        # property_wealth is formula-owned in policyengine-uk, so the release
+        # leaves it to the engine (microcosm#1106); so is
         # tax_free_savings_income under the additive ISA income contract
         # (microcosm#1360), and so are the PIP categories, which the engine
         # derives from the points the release stores (microcosm#1095, P1).
@@ -449,15 +489,18 @@ def test_shipped_manifest_is_current(self) -> None:
             "property_wealth",
             "tax_free_savings_income",
         ]
-        assert manifest.required_columns == (
-            frozenset(load_efrs_parity_reference().populated_layers)
-            - set(engine_derived)
-        )
-        assert set(manifest.reviewed_exclusions) == set(engine_derived)
+        assert manifest.required_columns == frozenset()
+        # And the gross receipts microcosm#1550 stops writing, which the
+        # current builds still carry (María's signature of 2026-11-10).
+        assert set(manifest.reviewed_exclusions) == set(engine_derived) | {
+            "self_employment_gross_receipts"
+        }
         assert load_efrs_parity_known_gaps() == ()
         assert [
             gap.variable for gap in load_efrs_engine_derived_exclusions()
         ] == engine_derived
+        assert manifest.reference["kind"] == "current_build"
+        assert manifest.schema_version == 4
         assert manifest.required_build_stages == frozenset(
             {
                 "frs_hmrc_spine_leaves",
@@ -496,24 +539,29 @@ def test_shipped_manifest_is_current(self) -> None:
             {"charitable_investment_gifts", "gift_aid"}
         )
 
-    def test_manifest_refuses_empty_columns(self, tmp_path) -> None:
-        bad = tmp_path / "empty.json"
-        bad.write_text(
-            json.dumps(
-                {
-                    "reference": {},
-                    "candidate_evidence": {"tier": "frs"},
-                    "effective_mass_coverage": {
-                        "weight_source": "household_weight",
-                        "minimum_nondefault_mass_share": 1e-6,
-                        "reviewed_on": "2026-07-11",
-                        "rationale": "reviewed test floor",
-                    },
-                    "columns": {},
-                }
-            )
-        )
-        with pytest.raises(ValueError, match="vacuous"):
+    def test_manifest_refuses_another_schema_or_reference(self, tmp_path) -> None:
+        payload = {
+            "schema_version": 4,
+            "reference": {"kind": "current_build"},
+            "candidate_evidence": {"tier": "frs"},
+            "effective_mass_coverage": {
+                "weight_source": "household_weight",
+                "minimum_nondefault_mass_share": 1e-6,
+                "reviewed_on": "2026-07-11",
+                "rationale": "reviewed test floor",
+            },
+            "columns": {},
+        }
+        bad = tmp_path / "manifest.json"
+        # No declared column is fine: the reference supplies the required
+        # inputs, and the gate refuses an empty required set itself.
+        bad.write_text(json.dumps(payload))
+        assert load_uk_release_input_coverage_manifest(str(bad)).columns == ()
+        bad.write_text(json.dumps({**payload, "schema_version": 3}))
+        with pytest.raises(ValueError, match="schema_version must be 4"):
+            load_uk_release_input_coverage_manifest(str(bad))
+        bad.write_text(json.dumps({**payload, "reference": {"filename": "x.h5"}}))
+        with pytest.raises(ValueError, match="reference.kind must be"):
             load_uk_release_input_coverage_manifest(str(bad))
 
     def test_distributional_family_requires_channel_denominator(self, tmp_path) -> None:
@@ -676,41 +724,41 @@ def test_reviewed_exclusion_requires_tracking_note(self) -> None:
 
     def test_engine_graph_drift_is_rejected(self) -> None:
         manifest = load_uk_release_input_coverage_manifest()
-        graph = set(manifest.declared_columns) - {"employment_income"}
-        with pytest.raises(ValueError, match="employment_income"):
+        graph = set(manifest.declared_columns) - {"property_wealth"}
+        with pytest.raises(ValueError, match="property_wealth"):
             assert_uk_release_input_coverage_manifest_current(
                 engine=_StubEngine({}, graph)
             )
 
-    def test_engine_entity_drift_is_rejected(self) -> None:
+    def test_unresolvable_owning_entity_is_rejected(self) -> None:
         manifest = load_uk_release_input_coverage_manifest()
-        graph = set(manifest.declared_columns)
-        with pytest.raises(ValueError, match="owning entities disagree"):
+
+        class _NoEntities(_StubEngine):
+            def variable_entities(self, names):
+                return {}
+
+        with pytest.raises(ValueError, match="property_wealth"):
             assert_uk_release_input_coverage_manifest_current(
-                engine=_StubEngine(
-                    {},
-                    graph,
-                    entities={"employment_income": "household"},
-                )
+                engine=_NoEntities({}, set(manifest.declared_columns))
             )
 
-    def test_manifest_cannot_demote_a_column_absent_from_known_gaps(self) -> None:
+    def test_manifest_cannot_exclude_a_restored_input(self) -> None:
         manifest = load_uk_release_input_coverage_manifest()
-        columns = tuple(
-            replace(
-                column,
-                status="reviewed_exclusion",
-                reason="not yet ported from enhanced FRS pipeline — pending review",
-                tracking_note="Tracked in UK_COVERAGE_PROGRESS.md.",
-            )
-            if column.name == "employment_income"
-            else column
-            for column in manifest.columns
+        demoted = replace(
+            manifest,
+            columns=(
+                *manifest.columns,
+                UKReleaseInputColumn(
+                    "charitable_investment_gifts",
+                    "reviewed_exclusion",
+                    reason="not yet ported from enhanced FRS pipeline — pending review",
+                    tracking_note="Tracked in UK_COVERAGE_PROGRESS.md.",
+                ),
+            ),
         )
-        demoted = replace(manifest, columns=columns)
-        with pytest.raises(ValueError, match="employment_income.*remain required"):
+        with pytest.raises(ValueError, match="charitable_investment_gifts.*restored"):
             assert_uk_release_input_coverage_manifest_current(
-                engine=_StubEngine({}, set(manifest.declared_columns)),
+                engine=_StubEngine({}, set(demoted.declared_columns)),
                 manifest=demoted,
             )
 
@@ -755,71 +803,62 @@ def test_deferred_family_columns_must_remain_reviewed_exclusions(self) -> None:
                 manifest=replace(manifest, family_coverage=families),
             )
 
-    def test_promoted_family_columns_must_be_required(self) -> None:
+    def test_promoted_family_columns_cannot_be_excluded(self) -> None:
         manifest = load_uk_release_input_coverage_manifest()
-        columns = tuple(
-            replace(
-                column,
-                status="reviewed_exclusion",
-                reason="not yet ported from enhanced FRS pipeline — pending review",
-                tracking_note="Tracked in UK_COVERAGE_PROGRESS.md.",
-            )
-            if column.name == "gift_aid"
-            else column
-            for column in manifest.columns
-        )
+        columns = (*manifest.columns, _reviewed_gift_aid_exclusion())
 
         with pytest.raises(ValueError, match="required_at_build"):
             assert_uk_release_input_coverage_manifest_current(
-                engine=_StubEngine({}, set(manifest.declared_columns)),
+                engine=_StubEngine({}, {*manifest.declared_columns, "gift_aid"}),
                 manifest=replace(manifest, columns=columns),
             )
 
-    def test_loader_aliases_are_hard_covered(self) -> None:
+    def test_loader_aliases_are_required_when_the_reference_carries_them(
+        self,
+    ) -> None:
+        # The required inputs come from the reference (microcosm#1095): an
+        # alias column the reference build carries is required of the
+        # candidate like any other input, and no alias is ever excluded.
         manifest = load_uk_release_input_coverage_manifest()
-        assert set(UK_LOADER_INPUT_ALIASES) <= set(manifest.required_columns)
+        assert set(UK_LOADER_INPUT_ALIASES).isdisjoint(manifest.reviewed_exclusions)
+        frame = _person_frame({"employment_income": np.asarray([0.0, 52_000.0])})
+        result = uk_release_input_coverage_gate(
+            frame,
+            _StubEngine({name: 0.0 for name in UK_LOADER_INPUT_ALIASES}),
+            reference_surface=reference_surface(*UK_LOADER_INPUT_ALIASES),
+            manifest=_manifest(()),
+        )
+        assert not result.passed
+        assert result.details["missing"] == sorted(
+            set(UK_LOADER_INPUT_ALIASES) - {"employment_income"}
+        )
+        assert result.details["required_from_reference"] == len(UK_LOADER_INPUT_ALIASES)
 
-    def test_formula_owned_persisted_overrides_are_hard_covered(self) -> None:
+    def test_engine_derived_exclusions_are_the_only_excluded_overrides(self) -> None:
         manifest = load_uk_release_input_coverage_manifest()
-        reference = json.loads(
-            (
-                _REPO_ROOT
-                / "packages"
-                / "microcosm-build"
-                / "src"
-                / "microcosm"
-                / "build"
-                / "uk"
-                / "efrs_parity_reference.json"
-            ).read_text(encoding="utf-8")
-        )
-        overrides = set(
-            reference["engine"]["formula_owned_persisted_overrides_included"]
-        )
-        assert len(overrides) == 13
         # The exceptions are declared: property_wealth, whose persisted copy
         # overrides the engine's component sum and is never uprated, so the
         # release leaves it to the formula (microcosm#1106), and
         # tax_free_savings_income, the engine's sum of the ISA interest the
         # additive contract stores apart (microcosm#1360). Every other
-        # formula-owned override stays required.
+        # formula-owned override the reference carries is required.
         #
-        # The PIP categories are engine-derived since the reference: its
-        # engine (2.89.0) read them as plain inputs, so they are not among its
-        # overrides, but the pinned engine derives them from the points the
-        # release stores (microcosm#1095, P1).
+        # The PIP categories are engine-derived since the enhanced FRS: its
+        # engine (2.89.0) read them as plain inputs, but the pinned engine
+        # derives them from the points the release stores (microcosm#1095, P1).
         since_reference = {"pip_dl_category", "pip_m_category"}
         engine_derived = {gap.variable for gap in load_efrs_engine_derived_exclusions()}
-        expected = {"property_wealth", "tax_free_savings_income"} | since_reference
-        assert engine_derived == expected
-        assert since_reference.isdisjoint(overrides)
-        assert engine_derived - since_reference <= overrides
+        assert engine_derived == (
+            {"property_wealth", "tax_free_savings_income"} | since_reference
+        )
         from policyengine_uk import CountryTaxBenefitSystem
 
         variables = CountryTaxBenefitSystem().variables
         assert not any(variables[name].is_input_variable() for name in since_reference)
-        assert overrides - engine_derived <= set(manifest.required_columns)
-        assert engine_derived.isdisjoint(manifest.required_columns)
+        # Beside them, the one input retired since the current builds.
+        assert set(manifest.reviewed_exclusions) == engine_derived | {
+            "self_employment_gross_receipts"
+        }
 
     def test_live_uk_adapter_recognises_loader_aliases(self) -> None:
         engine = PolicyEngineUKCoverageEngine()
diff --git a/packages/microcosm-build/tests/engine/uk/test_uk_weight_share_formula_inputs.py b/packages/microcosm-build/tests/engine/uk/test_uk_weight_share_formula_inputs.py
index fe9f627028..9466c0cf59 100644
--- a/packages/microcosm-build/tests/engine/uk/test_uk_weight_share_formula_inputs.py
+++ b/packages/microcosm-build/tests/engine/uk/test_uk_weight_share_formula_inputs.py
@@ -49,23 +49,38 @@ def test_constant_names_every_weight_share_formula_and_its_engine_inputs(system)
 
 
 def test_named_columns_are_release_surface_household_columns():
-    """The columns the check reads leave with the release: every one is an
-    enhanced-FRS household input (the parity reference) or a reviewed extra
-    household column of the export surface (the allow-list)."""
-    from microcosm.build.uk_runtime import load_efrs_parity_reference
-    from microcosm.build.uk_runtime.terminal_gates import (
-        UK_ALLOWED_EXTRA_EXPORT_COLUMNS,
+    """The columns the check reads leave with the release: every one is a
+    household column the spine declares and the release boundary keeps.
+
+    Until microcosm#1095 this read the enhanced-FRS reference and the export
+    allow-list; the export surface now compares with the current build, so
+    the spine's declared surface through the production export path stands
+    in for both.
+    """
+    import numpy as np
+    import pandas as pd
+
+    from microcosm.build.uk_runtime.graph import uk_spine_endpoint, uk_spine_graph
+    from microcosm.build.uk_runtime.national_frame import (
+        uk_national_frame,
+        uk_release_export_frame,
     )
 
-    reference = load_efrs_parity_reference().input_entities
-    household = {
-        column for column, entity in reference.items() if entity == "household"
+    columns = {
+        "person": ["person_id", "person_benunit_id", "person_household_id"],
+        "benunit": ["benunit_id"],
+        "household": ["household_id"],
     }
-    household |= {
-        name.split(".", 1)[1]
-        for name in UK_ALLOWED_EXTRA_EXPORT_COLUMNS
-        if name.startswith("household.")
+    for cells in uk_spine_endpoint(uk_spine_graph()).inputs:
+        columns[cells.entity] = list(
+            dict.fromkeys([*columns[cells.entity], *cells.columns])
+        )
+    tables = {
+        entity: pd.DataFrame({column: np.array([1]) for column in names})
+        for entity, names in columns.items()
     }
-    for formula, columns in UK_WEIGHT_SHARE_FORMULA_INPUTS.items():
-        missing = [c for c in columns if c not in household]
+    frame = uk_national_frame(**tables, time_period="2024", household_weights=[1.0])
+    household = set(uk_release_export_frame(frame).table("household").columns)
+    for formula, columns_read in UK_WEIGHT_SHARE_FORMULA_INPUTS.items():
+        missing = [c for c in columns_read if c not in household]
         assert not missing, f"{formula}: {missing} are not release household columns"
diff --git a/packages/microcosm-build/tests/engine_free/shared/test_country_spec.py b/packages/microcosm-build/tests/engine_free/shared/test_country_spec.py
index dccee82499..bd8f4369c8 100644
--- a/packages/microcosm-build/tests/engine_free/shared/test_country_spec.py
+++ b/packages/microcosm-build/tests/engine_free/shared/test_country_spec.py
@@ -1127,7 +1127,7 @@ def test_spi_spine_adds_no_country_package_resources(self) -> None:
             "take_up_contract.json",
             "target_reference_signed_exclusions.json",
             "input_mass_reviewed_exclusions.json",
-            "incumbent_unresolvable_measures.json",
+            "reference_unresolvable_measures.json",
             "spine_swap_signed_differences.json",
             "spine_candidate_acceptance.json",
             "ledger_compile_parity_incumbent_2025_signed_differences.json",
@@ -1305,7 +1305,7 @@ def test_uk_package_loads(self) -> None:
             "take_up_contract.json",
             "target_reference_signed_exclusions.json",
             "input_mass_reviewed_exclusions.json",
-            "incumbent_unresolvable_measures.json",
+            "reference_unresolvable_measures.json",
             "spine_swap_signed_differences.json",
             "spine_candidate_acceptance.json",
             "ledger_compile_parity_incumbent_2025_signed_differences.json",
@@ -1835,7 +1835,10 @@ def test_thresholds_match_the_schema4_manifest(self, manifest) -> None:
             params["uk_weight_ratio"]["maximum_max_to_median_ratio"]
             == 1_151.2542195939373
         )
-        assert params["uk_input_mass_parity"]["relative_tolerance"] == 4.521811483823806
+        # The a6299504 -> eeb6093e pair's exact maximum (microcosm#1095).
+        assert (
+            params["uk_input_mass_parity"]["relative_tolerance"] == 5.9984285545209834
+        )
         assert params["uk_input_mass_parity"]["minimum_reference_total"] == 0.0
         assert (
             params["uk_target_fit"]["max_abs_relative_error"]
diff --git a/packages/microcosm-build/tests/engine_free/shared/test_gate_battery_contract_pins.py b/packages/microcosm-build/tests/engine_free/shared/test_gate_battery_contract_pins.py
index 90e0711609..358bf8b0c4 100644
--- a/packages/microcosm-build/tests/engine_free/shared/test_gate_battery_contract_pins.py
+++ b/packages/microcosm-build/tests/engine_free/shared/test_gate_battery_contract_pins.py
@@ -31,9 +31,7 @@
 from microcosm.build.uk_runtime.battery_bindings import UK_GATE_REGISTRY
 from microcosm.build.uk_runtime.weighted_integrity import (
     UK_INPUT_MASS_EXCLUSION_REGISTER_RESOURCE,
-    UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256,
     UK_INPUT_MASS_REFERENCE_REGISTRY,
-    uk_default_input_mass_reviewed_exclusions,
 )
 from microcosm.data import contract as data_contract
 from test_support.paths import paths_for
@@ -165,26 +163,12 @@ def test_degenerate_evidence_pin_mirrors_the_committed_register(self) -> None:
             _canonical_sha256(payload)
         )
 
-    def test_input_mass_evidence_pin_mirrors_the_wrapped_reference(self) -> None:
-        from microcosm.build.gate_battery import _canonical_sha256
+    def test_the_input_mass_evidence_is_not_pinned(self) -> None:
+        """Its digest covers the reference build's own totals, which change
+        with every cut (microcosm#1095); the report names the build."""
 
-        reference = "efrs-post-calibration"
-        records = uk_default_input_mass_reviewed_exclusions()[reference]
-        assert data_contract._UK_GATE_BATTERY_INPUT_MASS_EVIDENCE_SHA256 == (
-            _canonical_sha256(
-                {
-                    "reference": reference,
-                    "reference_evidence_sha256": (
-                        UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256
-                    ),
-                    "exclusions_policy": "committed",
-                    "reviewed_exclusions": {
-                        name: record.policy_payload()
-                        for name, record in sorted(records.items())
-                    },
-                }
-            )
-        )
+        assert not hasattr(data_contract, "_UK_GATE_BATTERY_INPUT_MASS_EVIDENCE_SHA256")
+        assert not hasattr(data_contract, "_UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256")
 
     def test_numeric_threshold_mirrors_match_the_committed_spec(self) -> None:
         spec = load_country_spec("uk")
@@ -205,14 +189,7 @@ def test_numeric_threshold_mirrors_match_the_committed_spec(self) -> None:
             == (params["uk_target_fit"]["max_abs_relative_error"])
         )
         assert data_contract._UK_INPUT_MASS_ACTIVE_REFERENCE == reference
-        assert (
-            data_contract._UK_INPUT_MASS_REFERENCE_IDENTITY
-            == input_mass["reference_registry"][reference]["identity"]
-        )
-        assert (
-            data_contract._UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256
-            == (input_mass["reference_registry"][reference]["totals_sha256"])
-        )
+        assert input_mass["reference_registry"][reference]["kind"] == "current_build"
         assert input_mass["reviewed_exclusions_resource"] == (
             UK_INPUT_MASS_EXCLUSION_REGISTER_RESOURCE
         )
@@ -377,6 +354,24 @@ def test_national_release_id_mirrors_the_build_shard(self) -> None:
 
         assert data_contract._UK_NATIONAL_RELEASE_ID == UK_NATIONAL_RELEASE_ID
 
+    def test_since_baseline_record_mirrors_the_build_shard(self) -> None:
+        """Round 2 of the review of microcosm#1574: where the national chain
+        starts, and why a column leaves it."""
+
+        from microcosm.build.uk_runtime.cut_reference import (
+            UK_NATIONAL_SINCE_BASELINE_ORIGIN,
+        )
+        from microcosm.build.uk_runtime.weighted_integrity import (
+            UK_SINCE_BASELINE_LEFT_REASONS,
+        )
+
+        assert data_contract._UK_NATIONAL_SINCE_BASELINE_ORIGIN == (
+            UK_NATIONAL_SINCE_BASELINE_ORIGIN
+        )
+        assert data_contract._UK_SINCE_BASELINE_LEFT_REASONS == (
+            UK_SINCE_BASELINE_LEFT_REASONS
+        )
+
 
 class TestDenseLineMirrors:
     """The dense joint line's contract mirrors (microcosm#762 A18)."""
diff --git a/packages/microcosm-build/tests/engine_free/shared/test_head_to_head.py b/packages/microcosm-build/tests/engine_free/shared/test_head_to_head.py
new file mode 100644
index 0000000000..5dbf548c16
--- /dev/null
+++ b/packages/microcosm-build/tests/engine_free/shared/test_head_to_head.py
@@ -0,0 +1,142 @@
+"""The country-neutral head-to-head comparison of two scored artifacts."""
+
+from __future__ import annotations
+
+import math
+
+import pytest
+
+from microcosm.build.head_to_head import (
+    HEAD_TO_HEAD_SCHEMA_VERSION,
+    LOWER_CANDIDATE,
+    LOWER_EQUAL,
+    LOWER_REFERENCE,
+    ScoredTarget,
+    compare_scored_targets,
+    lower_side,
+    scored_targets_from_mapping,
+)
+
+
+@pytest.mark.parametrize(
+    ("candidate", "reference", "expected"),
+    [
+        (0.1, 0.2, LOWER_CANDIDATE),
+        (-0.1, 0.2, LOWER_CANDIDATE),
+        (0.3, -0.2, LOWER_REFERENCE),
+        (0.2, -0.2, LOWER_EQUAL),
+        (0.0, -0.0, LOWER_EQUAL),
+        (math.nan, 0.1, LOWER_EQUAL),
+        (0.1, math.nan, LOWER_EQUAL),
+    ],
+)
+def test_the_lower_side_is_decided_on_magnitude(candidate, reference, expected) -> None:
+    assert lower_side(candidate, reference) == expected
+
+
+def _scored(errors, families=None):
+    return [
+        ScoredTarget(
+            name=name,
+            relative_error=error,
+            period=2025,
+            family=None if families is None else families[name],
+        )
+        for name, error in errors.items()
+    ]
+
+
+def test_the_comparison_counts_targets_and_the_loss_gap() -> None:
+    families = {"a": "income", "b": "income", "c": "benefits", "d": "benefits"}
+    head_to_head = compare_scored_targets(
+        _scored({"a": 0.01, "b": -0.5, "c": 0.2, "d": 0.3}, families),
+        _scored({"a": -0.02, "b": 0.1, "c": -0.2, "d": 0.1}),
+        candidate_loss=0.25,
+        reference_loss=0.75,
+    )
+
+    assert head_to_head.counts == {
+        "candidate_lower_count": 1,
+        "reference_lower_count": 2,
+        "equal_count": 1,
+    }
+    assert head_to_head.counts_by_family() == {
+        "benefits": {
+            "candidate_lower_count": 0,
+            "reference_lower_count": 1,
+            "equal_count": 1,
+        },
+        "income": {
+            "candidate_lower_count": 1,
+            "reference_lower_count": 1,
+            "equal_count": 0,
+        },
+    }
+    payload = head_to_head.to_payload()
+    assert payload["schema_version"] == HEAD_TO_HEAD_SCHEMA_VERSION
+    assert payload["decision"] == "owner_decides"
+    assert payload["no_threshold_applied"] is True
+    assert payload["loss"] == {
+        "candidate": 0.25,
+        "reference": 0.75,
+        "candidate_minus_reference": -0.5,
+    }
+    first = payload["targets"]["compared"][0]
+    assert first == {
+        "name": "a",
+        "period": 2025,
+        "family": "income",
+        "candidate_relative_error": 0.01,
+        "reference_relative_error": -0.02,
+        "candidate_absolute_relative_error": 0.01,
+        "reference_absolute_relative_error": 0.02,
+        "candidate_minus_reference_absolute_relative_error": 0.01 - 0.02,
+        "lower_absolute_relative_error": LOWER_CANDIDATE,
+    }
+    assert "verdict" not in payload
+
+
+def test_targets_without_a_family_are_counted_last() -> None:
+    head_to_head = compare_scored_targets(
+        [ScoredTarget("a", 0.1, family="x"), ScoredTarget("b", 0.1)],
+        [ScoredTarget("a", 0.2), ScoredTarget("b", 0.2)],
+        candidate_loss=1.0,
+        reference_loss=1.0,
+    )
+
+    assert list(head_to_head.counts_by_family()) == ["x", None]
+
+
+def test_different_surfaces_are_refused() -> None:
+    with pytest.raises(ValueError, match="different numbers of targets"):
+        compare_scored_targets(
+            [ScoredTarget("a", 0.1)], [], candidate_loss=0.0, reference_loss=0.0
+        )
+    with pytest.raises(ValueError, match="contracts differ"):
+        compare_scored_targets(
+            [ScoredTarget("a", 0.1, period=2025)],
+            [ScoredTarget("a", 0.1, period=2024)],
+            candidate_loss=0.0,
+            reference_loss=0.0,
+        )
+    with pytest.raises(ValueError, match="belongs to family"):
+        compare_scored_targets(
+            [ScoredTarget("a", 0.1, family="x")],
+            [ScoredTarget("a", 0.1, family="y")],
+            candidate_loss=0.0,
+            reference_loss=0.0,
+        )
+
+
+def test_scored_targets_from_a_mapping_follow_the_given_order() -> None:
+    scored = scored_targets_from_mapping(
+        {"b": 0.2, "a": 0.1}, families={"a": "x"}, order=["b", "a"]
+    )
+
+    assert [(row.name, row.family) for row in scored] == [("b", None), ("a", "x")]
+    assert [row.name for row in scored_targets_from_mapping({"b": 0.2, "a": 0.1})] == [
+        "a",
+        "b",
+    ]
+    with pytest.raises(ValueError, match="No score for targets"):
+        scored_targets_from_mapping({"a": 0.1}, order=["a", "z"])
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_resolve_uk_reference.py b/packages/microcosm-build/tests/engine_free/uk/test_resolve_uk_reference.py
new file mode 100644
index 0000000000..617189a004
--- /dev/null
+++ b/packages/microcosm-build/tests/engine_free/uk/test_resolve_uk_reference.py
@@ -0,0 +1,118 @@
+"""tools/resolve_uk_reference.py: a line's current build, checked or fetched."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from microcosm.build.uk_runtime.cut_reference import read_uk_cut_reference
+from test_support.microcosm_build.uk_cut_reference import (
+    UK_DENSE_RELEASE,
+    UK_NATIONAL_RELEASE,
+    UKReferenceHub,
+    sha256_of,
+    stub_reference_evidence,
+)
+from tools import resolve_uk_reference as tool
+
+DENSE_BUILD = "uk-local-candidate-f100-s42-20261107T173210Z-38605444"
+NATIONAL_BUILD = "uk-frs-calibration-attempt-20261107T020434Z-eeb6093e"
+
+
+@pytest.fixture
+def hub(tmp_path: Path) -> UKReferenceHub:
+    hub = UKReferenceHub(tmp_path / "hub-root")
+    hub.publish(UK_NATIONAL_RELEASE, NATIONAL_BUILD, dataset=b"national")
+    hub.publish(UK_DENSE_RELEASE, DENSE_BUILD, dataset=b"dense")
+    return hub
+
+
+def test_check_prints_the_current_build_and_downloads_no_dataset(hub, capsys) -> None:
+    assert tool.main(["--release", UK_DENSE_RELEASE, "--check"], hub_download=hub) == 0
+
+    summary = json.loads(capsys.readouterr().out)
+    assert summary["build"] == DENSE_BUILD
+    assert not any(call.endswith(".h5") for call in hub.calls)
+
+
+def test_output_dir_keeps_the_dataset_and_its_record(hub, tmp_path: Path) -> None:
+    out = tmp_path / "reference"
+
+    assert (
+        tool.main(
+            ["--release", UK_DENSE_RELEASE, "--output-dir", str(out)],
+            hub_download=hub,
+            write_evidence=stub_reference_evidence,
+        )
+        == 0
+    )
+
+    reference = read_uk_cut_reference(out / "reference.json")
+    assert reference.build == DENSE_BUILD
+    assert (out / reference.filename).read_bytes() == b"dense"
+    assert reference.sha256 == sha256_of(b"dense")
+    assert (out / "input_mass_reference.json").exists()
+
+
+def test_a_directory_that_holds_a_reference_is_refused(
+    hub, tmp_path: Path, capsys
+) -> None:
+    out = tmp_path / "reference"
+    args = ["--release", UK_NATIONAL_RELEASE, "--output-dir", str(out)]
+    stub = stub_reference_evidence
+    assert tool.main(args, hub_download=hub, write_evidence=stub) == 0
+
+    assert tool.main(args, hub_download=hub, write_evidence=stub) == 1
+    assert "keeps the reference it started with" in capsys.readouterr().err
+
+
+def test_a_release_without_a_certified_current_build_is_refused(
+    tmp_path: Path, capsys
+) -> None:
+    hub = UKReferenceHub(tmp_path)
+    hub.publish(
+        UK_NATIONAL_RELEASE,
+        NATIONAL_BUILD,
+        dataset=b"national",
+        evidence={"kind": "uk_release_certification", "shippable": False},
+    )
+
+    assert (
+        tool.main(["--release", UK_NATIONAL_RELEASE, "--check"], hub_download=hub) == 1
+    )
+    assert "refused" in capsys.readouterr().err
+
+
+def test_offline_mode_is_refused(monkeypatch, capsys) -> None:
+    """A cached releases.json can name a build that is no longer current (the
+    review of microcosm#1574); run_uk_cut refuses offline mode too."""
+
+    from microcosm.build import staging_dataset
+
+    monkeypatch.setattr(staging_dataset, "hub_offline", lambda: True)
+    assert tool.main(["--release", "microcosm-uk-2024-25-national", "--check"]) == 1
+    assert "HF_HUB_OFFLINE" in capsys.readouterr().err
+
+
+def test_a_build_can_be_pinned_from_the_command_line(tmp_path, capsys) -> None:
+    hub = UKReferenceHub(tmp_path / "hub-root")
+    hub.publish(UK_NATIONAL_RELEASE, "uk-frs-calibration-attempt-older", dataset=b"o")
+    hub.publish(UK_NATIONAL_RELEASE, "uk-frs-calibration-attempt-newer", dataset=b"n")
+    assert (
+        tool.main(
+            [
+                "--release",
+                UK_NATIONAL_RELEASE,
+                "--build",
+                "uk-frs-calibration-attempt-older",
+                "--check",
+            ],
+            hub_download=hub,
+        )
+        == 0
+    )
+    summary = json.loads(capsys.readouterr().out)
+    assert summary["build"] == "uk-frs-calibration-attempt-older"
+    assert summary["selection"] == "pinned"
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_run_uk_cut.py b/packages/microcosm-build/tests/engine_free/uk/test_run_uk_cut.py
index 291ff28c80..a56bb59213 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_run_uk_cut.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_run_uk_cut.py
@@ -44,8 +44,6 @@ def test_every_declared_input_resolves_to_a_committed_pin():
         "aps_2024_25",
         "hmrc_personal_incomes_ods",
         "chronicle_uk",
-        "input_mass_reference",
-        "incumbent_efrs",
     }
     for source in sources.values():
         assert source.files
@@ -80,10 +78,6 @@ def test_the_runner_pins_are_the_build_pins():
     assert sources["frs_2024_25"].revision == frs["huggingface_revision"]
     assert sources["frs_2024_25"].archive_sha256 == frs["zip_sha256"]
     assert sources["frs_2024_25"].filename == frs["zip_filename"]
-    identity = cut._gate_reference_identity(cut.UK_DIR)
-    incumbent = sources["incumbent_efrs"]
-    assert incumbent.revision == identity["revision"]
-    assert incumbent.files[0].sha256 == identity["sha256"]
     stage_pins = cut.committed_source_pins()
     for key in (
         "frs_2024_25",
@@ -127,18 +121,6 @@ def test_an_unknown_pin_selector_is_refused(tmp_path):
         cut.load_input_sources(path)
 
 
-def test_the_hosted_mass_reference_is_the_one_the_gate_binds():
-    from microcosm.build.uk_runtime.weighted_integrity import (
-        UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256,
-    )
-
-    manifest = json.loads(cut.CUT_INPUTS.read_text())
-    pin = manifest["file_pins"]["uk_input_mass_reference.json"]
-    assert pin["canonical_evidence_sha256"] == UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256
-    source = next(s for s in manifest["sources"] if s["key"] == "input_mass_reference")
-    assert source["path_in_repo"].endswith(UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256)
-
-
 def test_every_spine_tab_flag_has_a_pinned_input():
     """The spine's licensed tabs are all fetched, under the names it reads."""
 
@@ -190,6 +172,52 @@ def _paths(tmp_path: Path) -> cut.CutPaths:
     return cut.CutPaths(tmp_path, "test", "a" * 40)
 
 
+REFERENCE_BUILD = "uk-frs-calibration-attempt-20261107T020434Z-eeb6093e"
+
+
+def _reference(paths: cut.CutPaths, *, build: str = REFERENCE_BUILD, data=b"ref"):
+    """Put a reference and its record in the cut, as the reference step does."""
+
+    from microcosm.build.uk_runtime.cut_reference import (
+        UKCutReference,
+        write_uk_cut_reference,
+    )
+
+    reference = UKCutReference(
+        release=cut.RELEASE_ID,
+        build=build,
+        repo_id=cut.PUBLISH_REPO,
+        path_in_repo=f"releases/{cut.RELEASE_ID}/{build}/microcosm_uk_2024_25.h5",
+        filename="microcosm_uk_2024_25.h5",
+        sha256=_sha(data),
+        size_bytes=len(data),
+        built_with_model_package={"name": "policyengine-uk", "version": "2.174.1"},
+        built_with_core_package={"name": "policyengine-core", "version": "3.33.3"},
+        evidence={
+            "key": "release_certification",
+            "filename": "release_certification.json",
+            "sha256": "1" * 64,
+        },
+        resolved_at="2026-11-10T12:00:00Z",
+    )
+    from microcosm.build.uk_runtime.cut_reference import (
+        UK_CUT_REFERENCE_EVIDENCE_NAME,
+    )
+    from test_support.microcosm_build.uk_cut_reference import stub_reference_evidence
+
+    paths.reference_dir.mkdir(parents=True, exist_ok=True)
+    paths.reference_h5(reference).write_bytes(data)
+    write_uk_cut_reference(paths.reference_record, reference)
+    # The reference's own certification, which the fetch keeps beside it.
+    (paths.reference_dir / UK_CUT_REFERENCE_EVIDENCE_NAME).write_text(
+        json.dumps({"kind": "uk_release_certification"})
+    )
+    stub_reference_evidence(
+        reference, paths.reference_h5(reference), paths.reference_dir
+    )
+    return reference
+
+
 def test_spine_argv_parses():
     from microcosm.build.uk_runtime import spine_build
 
@@ -206,11 +234,14 @@ def test_national_argv_parses(tmp_path, dry_run):
     from microcosm.build.uk_runtime import full_build_cli
 
     sources = {s.key: s for s in cut.load_input_sources()}
+    paths = _paths(tmp_path)
+    reference = _reference(paths)
     argv = cut.national_argv(
-        _paths(tmp_path),
+        paths,
         python="py",
         spine_sha256="b" * 64,
         sources=sources,
+        reference=reference,
         dry_run=dry_run,
         logbook_prev_row_digest="c" * 64,
     )
@@ -218,6 +249,9 @@ def test_national_argv_parses(tmp_path, dry_run):
     assert args.release_role == "national"
     assert args.dry_run is dry_run
     assert args.input_sha256 == "b" * 64
+    # The build compares its candidate with the cut's own reference.
+    assert args.reference_h5 == paths.reference_h5(reference)
+    assert args.reference_record == paths.reference_record
 
 
 @pytest.mark.parametrize("dry_run", [True, False])
@@ -228,11 +262,13 @@ def test_the_national_build_never_publishes_to_the_orrery(tmp_path, dry_run):
     from microcosm.build.uk_runtime.orrery_publication import publication_enabled
 
     sources = {s.key: s for s in cut.load_input_sources()}
+    paths = _paths(tmp_path)
     argv = cut.national_argv(
-        _paths(tmp_path),
+        paths,
         python="py",
         spine_sha256="b" * 64,
         sources=sources,
+        reference=_reference(paths),
         dry_run=dry_run,
     )
     assert "--publish-orrery" not in argv
@@ -258,6 +294,8 @@ def test_certify_and_assemble_argv_parse(tmp_path):
         )[2:]
     )
     assert certify.release_id == cut.RELEASE_ID
+    assert certify.reference_record == paths.reference_record
+    assert certify.score_receipt == paths.score_receipt
     assemble = _tool("assemble_uk_release_dir")._parse_args(
         cut.assemble_argv(paths, python="py")[2:]
     )
@@ -265,9 +303,9 @@ def test_certify_and_assemble_argv_parse(tmp_path):
 
 
 def test_score_argv_names_only_flags_the_scorer_declares(tmp_path, capsys):
-    sources = {s.key: s for s in cut.load_input_sources()}
+    paths = _paths(tmp_path)
     argv = cut.score_argv(
-        _paths(tmp_path), python="py", candidate_sha256="f" * 64, sources=sources
+        paths, python="py", candidate_sha256="f" * 64, reference=_reference(paths)
     )
     with pytest.raises(SystemExit):
         _tool("score_uk_national_candidate").main(["--help"])
@@ -513,12 +551,17 @@ def national(self, log_path):
         (run / "logbook-spool").mkdir()
         (run / "logbook-spool" / f"{BUILD_ROW}.json").write_text("{}")
 
+    def _reference(self) -> dict:
+        record = json.loads(self.paths.reference_record.read_text())
+        return {key: record[key] for key in ("release", "build", "sha256")}
+
     def score(self, log_path):
-        (self.paths.run_dir / "score_vs_incumbent.json").write_text(
+        self.paths.score_receipt.write_text(
             json.dumps(
                 {
                     "artifacts": {"candidate": {"sha256": _sha(b"candidate")}},
-                    "evaluation": {"verdict": "passed"},
+                    "reference": self._reference(),
+                    "evaluation": {"schema_version": 2},
                 }
             )
         )
@@ -529,7 +572,11 @@ def certify(self, log_path):
             self._report(shippable=True)
         )
         (run / f"{cut.CANDIDATE_NAME}.release_certification.json").write_text(
-            self._report(shippable=True, candidate={"sha256": _sha(b"candidate")})
+            self._report(
+                shippable=True,
+                candidate={"sha256": _sha(b"candidate")},
+                reference=self._reference(),
+            )
         )
 
     def assemble(self, log_path):
@@ -544,8 +591,18 @@ def publish(self, log_path):
         pass
 
 
-def _runner(tmp_path, fake=None, signer=None):
+@pytest.fixture(autouse=True)
+def _recorded_reference_stands(monkeypatch):
+    """The certify step and status re-read the recorded build's standing on
+    the Hub; it stands unless a test withdraws it."""
+
+    monkeypatch.setattr(cut, "uk_cut_reference_withdrawal", lambda reference: None)
+
+
+def _runner(tmp_path, fake=None, signer=None, *, reference=True):
     paths = _paths(tmp_path)
+    if reference:
+        _reference(paths)
     fake = fake or FakeBuild(paths, signer=signer)
     sources = {s.key: s for s in cut.load_input_sources()}
     runner = cut.Runner(
@@ -664,27 +721,62 @@ def test_retrying_the_national_run_keeps_the_failed_attempt(tmp_path):
     assert len(aside) == 1 and (aside[0] / "evidence.json").read_text() == "kept"
 
 
-def test_a_losing_candidate_is_not_certified(tmp_path):
+def test_a_candidate_that_fits_worse_than_its_reference_is_certified(tmp_path):
+    """The comparison is a report (microcosm#1095): no loss decides the cut."""
+
     runner, fake = _runner(tmp_path)
+    original_score = fake.score
+
+    def worse_score(log_path):
+        original_score(log_path)
+        receipt = json.loads(runner.paths.score_receipt.read_text())
+        receipt["evaluation"]["losses"] = {
+            "candidate_full_loss": 0.5,
+            "reference_full_loss": 0.01,
+        }
+        runner.paths.score_receipt.write_text(json.dumps(receipt))
+
+    _all(runner)
+    runner.paths.score_receipt.unlink()
+    fake.score = worse_score
+    cut.run_score(runner)
+    assert cut.score_done(runner.paths)[0]
+
+
+def test_a_comparison_with_another_reference_is_redone_then_refused(tmp_path):
+    runner, fake = _runner(tmp_path)
+    cut.run_spine(runner, staging_local_only=True)
+    cut.run_national(runner, retry=False, logbook_prev_row_digest=None)
 
-    def failing_score(log_path):
-        (runner.paths.run_dir / "score_vs_incumbent.json").write_text(
+    def other_reference_score(log_path):
+        runner.paths.score_receipt.write_text(
             json.dumps(
                 {
                     "artifacts": {"candidate": {"sha256": _sha(b"candidate")}},
-                    "evaluation": {"verdict": "failed"},
+                    "reference": {
+                        "release": cut.RELEASE_ID,
+                        "build": "x",
+                        "sha256": "0" * 64,
+                    },
+                    "evaluation": {"schema_version": 2},
                 }
             )
         )
 
-    fake.score = failing_score
-    cut.run_spine(runner, staging_local_only=True)
-    cut.run_national(runner, retry=False, logbook_prev_row_digest=None)
-    with pytest.raises(cut.CutError, match="does not pass the incumbent score"):
+    fake.score = other_reference_score
+    with pytest.raises(cut.CutError, match="another reference"):
         cut.run_score(runner)
     assert "certify" not in fake.calls
 
 
+def test_a_cut_without_a_reference_builds_nothing_that_compares(tmp_path):
+    runner, fake = _runner(tmp_path, reference=False)
+    cut.run_spine(runner, staging_local_only=True)
+    with pytest.raises(cut.CutError, match="no usable reference"):
+        cut.run_national(runner, retry=False, logbook_prev_row_digest=None)
+    assert fake.calls == ["spine"]
+
+
 @given(
     prefix=st.lists(st.text(alphabet=st.characters(blacklist_characters="{}"))),
     tag=st.from_regex(r"[a-z0-9-]{1,40}", fullmatch=True),
@@ -762,10 +854,10 @@ def test_retried_score_and_certification_keep_the_earlier_evidence(tmp_path):
     runner, fake = _runner(tmp_path)
     cut.run_spine(runner, staging_local_only=True)
     cut.run_national(runner, retry=False, logbook_prev_row_digest=None)
-    receipt = runner.paths.run_dir / "score_vs_incumbent.json"
-    receipt.write_text('{"evaluation": {"verdict": "failed"}}')
+    receipt = runner.paths.score_receipt
+    receipt.write_text('{"evaluation": {"schema_version": 1, "verdict": "failed"}}')
     cut.run_score(runner)
-    kept = list(runner.paths.run_dir.glob("score_vs_incumbent.json.superseded-*"))
+    kept = list(runner.paths.run_dir.glob("score_vs_reference.json.superseded-*"))
     assert len(kept) == 1 and "failed" in kept[0].read_text()
     certification = (
         runner.paths.run_dir / f"{cut.CANDIDATE_NAME}.release_certification.json"
@@ -1025,7 +1117,7 @@ def test_the_signing_key_reaches_only_the_steps_that_sign_or_verify(
     cut.run_spine(runner, staging_local_only=True)
     cut.run_national(runner, retry=False, logbook_prev_row_digest=None)
     # Make the score step run, so its environment is seen too.
-    (runner.paths.run_dir / "score_vs_incumbent.json").unlink(missing_ok=True)
+    runner.paths.score_receipt.unlink(missing_ok=True)
     cut.run_score(runner)
     cut.run_certify(runner)
     cut.run_assemble(runner)
@@ -1165,3 +1257,356 @@ def start():
     (check,) = cut.hub_checks()
     assert not check.ok
     assert check.detail == "RuntimeError: the emitter's spool is locked"
+
+
+# --------------------------------------------------------------------------- #
+# The reference: the current national build, resolved once per cut            #
+# --------------------------------------------------------------------------- #
+
+
+def _stub_evidence(reference, h5_path, output_dir):
+    from test_support.microcosm_build.uk_cut_reference import stub_reference_evidence
+
+    return stub_reference_evidence(reference, h5_path, output_dir)
+
+
+def _reference_hub(tmp_path):
+    from test_support.microcosm_build.uk_cut_reference import (
+        UK_NATIONAL_RELEASE,
+        UKReferenceHub,
+    )
+
+    hub = UKReferenceHub(tmp_path / "hub-root")
+    hub.publish(UK_NATIONAL_RELEASE, REFERENCE_BUILD, dataset=b"current build")
+    return hub
+
+
+def test_the_reference_is_resolved_once_and_kept(tmp_path):
+    runner, _ = _runner(tmp_path, reference=False)
+    hub = _reference_hub(tmp_path)
+
+    reference = cut.run_reference(
+        runner, hub_download=hub, write_evidence=_stub_evidence
+    )
+
+    assert reference.build == REFERENCE_BUILD
+    assert runner.paths.reference_h5(reference).read_bytes() == b"current build"
+    assert cut.reference_done(runner.paths)[0]
+    state = json.loads(runner.paths.state.read_text())["steps"]["reference"]
+    assert state["status"] == "done" and state["reference"] == reference.label
+    # A promotion after the fetch moves nothing in this cut.
+    hub.publish(cut.RELEASE_ID, "uk-frs-calibration-attempt-later", dataset=b"newer")
+    calls = len(hub.calls)
+    assert (
+        cut.run_reference(runner, hub_download=hub, write_evidence=_stub_evidence).build
+        == REFERENCE_BUILD
+    )
+    assert len(hub.calls) == calls
+
+
+def test_re_resolving_sets_the_reference_aside_and_moves_to_the_current_build(
+    tmp_path,
+):
+    runner, _ = _runner(tmp_path, reference=False)
+    hub = _reference_hub(tmp_path)
+    cut.run_reference(runner, hub_download=hub, write_evidence=_stub_evidence)
+    hub.publish(cut.RELEASE_ID, "uk-frs-calibration-attempt-later", dataset=b"newer")
+
+    reference = cut.run_reference(
+        runner, re_resolve=True, hub_download=hub, write_evidence=_stub_evidence
+    )
+
+    assert reference.build == "uk-frs-calibration-attempt-later"
+    kept = list(runner.paths.cut.glob("reference.superseded-*"))
+    assert len(kept) == 1 and (kept[0] / "reference.json").exists()
+
+
+def test_an_unusable_reference_is_never_resolved_over(tmp_path):
+    runner, _ = _runner(tmp_path)
+    runner.paths.reference_h5(cut.cut_reference(runner.paths)).write_bytes(b"x")
+    with pytest.raises(cut.CutError, match="--re-resolve-reference"):
+        cut.run_reference(
+            runner, hub_download=_reference_hub(tmp_path), write_evidence=_stub_evidence
+        )
+
+
+def test_a_hub_without_a_certified_current_build_stops_the_cut(tmp_path):
+    from test_support.microcosm_build.uk_cut_reference import UKReferenceHub
+
+    runner, _ = _runner(tmp_path, reference=False)
+    hub = UKReferenceHub(tmp_path / "hub-root")
+    hub.publish(
+        cut.RELEASE_ID,
+        REFERENCE_BUILD,
+        dataset=b"current build",
+        evidence={"kind": "uk_release_certification", "shippable": False},
+    )
+    with pytest.raises(cut.CutError, match="no reference to compare with"):
+        cut.run_reference(runner, hub_download=hub, write_evidence=_stub_evidence)
+    state = json.loads(runner.paths.state.read_text())["steps"]["reference"]
+    assert state["status"] == "failed"
+
+
+def test_a_certification_against_another_reference_is_not_done(tmp_path):
+    runner, _ = _runner(tmp_path)
+    _all(runner)
+    assert cut.certify_done(runner.paths)[0]
+    _reference(runner.paths, build="uk-frs-calibration-attempt-later", data=b"other")
+    assert cut.score_done(runner.paths) == (
+        False,
+        "score receipt compared with another reference",
+    )
+    assert cut.certify_done(runner.paths) == (
+        False,
+        "certification names another reference",
+    )
+
+
+def test_stage1_compares_with_the_cut_reference_by_default(tmp_path):
+    runner, fake = _runner(tmp_path)
+    cut.run_spine(runner, staging_local_only=True)
+    cut.run_national(runner, retry=False, logbook_prev_row_digest=None)
+    seen = {}
+
+    def stage1(argv, cwd, log_path, env):
+        seen["argv"] = argv
+        return 0
+
+    runner.execute = stage1
+    cut.run_stage1(runner, None)
+    reference = cut.cut_reference(runner.paths)
+    assert f"previous={runner.paths.reference_h5(reference)}" in seen["argv"]
+
+
+def test_status_says_when_the_current_build_has_moved(tmp_path):
+    runner, _ = _runner(tmp_path)
+    out = io.StringIO()
+    with redirect_stdout(out):
+        cut.status(runner.paths, check_current=lambda release: {"build": "later"})
+    text = out.getvalue()
+    assert f"done reference: compared with {cut.RELEASE_ID}@{REFERENCE_BUILD}" in text
+    assert "the current national build is now later" in text
+    out = io.StringIO()
+    with redirect_stdout(out):
+        cut.status(
+            runner.paths, check_current=lambda release: {"build": REFERENCE_BUILD}
+        )
+    assert "still the current national build" in out.getvalue()
+
+
+def test_the_receipt_records_the_reference(tmp_path):
+    runner, _ = _runner(tmp_path)
+    _all(runner)
+    cut.write_receipt(runner, {"tag": "t", "published": False})
+    receipt = json.loads(runner.paths.receipt.read_text())
+    assert receipt["reference"]["build"] == REFERENCE_BUILD
+    assert "incumbent_efrs" not in receipt["inputs"]
+
+
+def test_the_cut_takes_its_input_mass_reference_from_its_own_reference(tmp_path):
+    """The hosted enhanced-FRS totals are gone; certify reads the totals the
+    reference step wrote from the cut's reference build (microcosm#1095)."""
+
+    manifest = json.loads(cut.CUT_INPUTS.read_text())
+    assert "input_mass_reference" not in {s["key"] for s in manifest["sources"]}
+    assert "file_pins" not in manifest
+    runner, _ = _runner(tmp_path)
+    argv = cut.certify_argv(
+        runner.paths,
+        python="py",
+        candidate_sha256="d" * 64,
+        spine_sha256="e" * 64,
+        sources=runner.sources,
+    )
+    assert argv[argv.index("--input-mass-reference") + 1] == str(
+        runner.paths.reference_input_mass
+    )
+
+
+def test_a_reference_without_its_evidence_gets_it_written_not_re_resolved(tmp_path):
+    runner, _ = _runner(tmp_path)
+    runner.paths.reference_input_mass.unlink()
+    assert not cut.reference_done(runner.paths)[0]
+
+    reference = cut.run_reference(
+        runner, hub_download=None, write_evidence=_stub_evidence
+    )
+
+    assert reference.build == REFERENCE_BUILD
+    assert cut.reference_done(runner.paths)[0]
+
+
+def test_a_resumed_cut_keeps_its_reference_s_own_evidence_again(tmp_path):
+    """Round 2 of the review of microcosm#1574: a cut resolved before the
+    record since the baseline began never kept its reference's evidence, and
+    without it the chain would restart without a trace."""
+
+    from microcosm.build.uk_runtime.cut_reference import (
+        UK_CUT_REFERENCE_EVIDENCE_NAME,
+    )
+    from test_support.microcosm_build.uk_cut_reference import national_certification
+
+    runner, _ = _runner(tmp_path, reference=False)
+    hub = _reference_hub(tmp_path)
+    reference = cut.run_reference(
+        runner, hub_download=hub, write_evidence=_stub_evidence
+    )
+    kept = runner.paths.reference_dir / UK_CUT_REFERENCE_EVIDENCE_NAME
+    original = kept.read_bytes()
+    kept.unlink()
+    runner.paths.reference_input_mass.unlink()
+
+    again = cut.run_reference(runner, hub_download=hub, write_evidence=_stub_evidence)
+
+    assert again.build == reference.build
+    assert kept.read_bytes() == original
+    assert cut.reference_done(runner.paths)[0]
+    # A copy that no longer matches what the fetch checked is refused.
+    kept.unlink()
+    runner.paths.reference_input_mass.unlink()
+    hub.publish(
+        cut.RELEASE_ID,
+        REFERENCE_BUILD,
+        dataset=b"current build",
+        evidence=national_certification(b"current build", note="rewritten"),
+    )
+    with pytest.raises(cut.CutError, match="no longer has the sha256"):
+        cut.run_reference(runner, hub_download=hub, write_evidence=_stub_evidence)
+    assert not kept.exists()
+
+
+def test_a_reference_withdrawn_after_certification_stops_the_cut(tmp_path, monkeypatch):
+    """Round 2 of the review of microcosm#1574: once the certification
+    existed, a resumed cut skipped the check and went on to publish."""
+
+    runner, fake = _runner(tmp_path)
+    cut.run_spine(runner, staging_local_only=True)
+    cut.run_national(runner, retry=False, logbook_prev_row_digest=None)
+    cut.run_score(runner)
+    cut.run_certify(runner)
+    assert cut.certify_done(runner.paths)[0]
+    monkeypatch.setattr(
+        cut,
+        "uk_cut_reference_withdrawal",
+        lambda reference: (
+            f"{reference.label} has been withdrawn since the cut resolved it"
+        ),
+    )
+    with pytest.raises(cut.CutError, match="withdrawn since the cut resolved it"):
+        cut.run_certify(runner)
+    with pytest.raises(cut.CutError, match="withdrawn since the cut resolved it"):
+        cut.run_publish(runner, "microcosm-uk-2024-25-national-x", publish=True)
+    assert not {"publish-preflight", "publish"} & set(fake.calls)
+
+
+def test_a_reference_withdrawn_since_the_fetch_stops_certification(
+    tmp_path, monkeypatch
+):
+    """The review of microcosm#1574 (S2): the cut keeps its record, and a
+    build withdrawn since it resolved it does not certify."""
+
+    runner, fake = _runner(tmp_path)
+    cut.run_spine(runner, staging_local_only=True)
+    cut.run_national(runner, retry=False, logbook_prev_row_digest=None)
+    cut.run_score(runner)
+    monkeypatch.setattr(
+        cut,
+        "uk_cut_reference_withdrawal",
+        lambda reference: (
+            f"{reference.label} has been withdrawn since the cut resolved it"
+        ),
+    )
+    with pytest.raises(cut.CutError, match="withdrawn since the cut resolved it"):
+        cut.run_certify(runner)
+    assert "certify" not in fake.calls
+    out = io.StringIO()
+    with redirect_stdout(out):
+        cut.status(
+            runner.paths, check_current=lambda release: {"build": REFERENCE_BUILD}
+        )
+    assert "has been withdrawn since the cut resolved it" in out.getvalue()
+
+
+def test_re_resolving_refuses_the_cut_s_own_candidate(tmp_path):
+    """The review of microcosm#1574 (S1): after the cut's own promotion the
+    line's current build is this candidate."""
+
+    from test_support.microcosm_build.uk_cut_reference import UKReferenceHub
+
+    runner, _ = _runner(tmp_path)
+    cut.run_spine(runner, staging_local_only=True)
+    cut.run_national(runner, retry=False, logbook_prev_row_digest=None)
+    hub = UKReferenceHub(tmp_path / "hub-root")
+    hub.publish(cut.RELEASE_ID, "uk-frs-calibration-attempt-mine", dataset=b"candidate")
+    before = runner.paths.reference_record.read_text()
+    with pytest.raises(cut.CutError, match="own candidate"):
+        cut.run_reference(
+            runner, re_resolve=True, hub_download=hub, write_evidence=_stub_evidence
+        )
+    # The recorded reference never moved.
+    assert runner.paths.reference_record.read_text() == before
+    assert not list(runner.paths.cut.glob("reference.superseded-*"))
+
+
+def test_the_receipt_says_when_the_build_time_evaluation_is_superseded(tmp_path):
+    """The review of microcosm#1574 (N8): after --re-resolve-reference the
+    national step is not rerun, so its own comparison names the old build."""
+
+    runner, _ = _runner(tmp_path)
+    paths = runner.paths
+    assert cut._build_time_evaluation(paths) is None
+    paths.run_dir.mkdir(parents=True)
+    recorded = cut.read_uk_cut_reference(paths.reference_record).label
+    manifest = paths.run_dir / "rowwise_candidate_manifest.json"
+    manifest.write_text(json.dumps({"evaluation": {"reference": recorded}}))
+    assert cut._build_time_evaluation(paths) == {
+        "reference": recorded,
+        "superseded": False,
+    }
+    manifest.write_text(
+        json.dumps({"evaluation": {"reference": f"{cut.RELEASE_ID}@earlier"}})
+    )
+    assert cut._build_time_evaluation(paths) == {
+        "reference": f"{cut.RELEASE_ID}@earlier",
+        "superseded": True,
+    }
+
+
+def test_a_pinned_reference_build_is_fetched_and_never_silently_moved(tmp_path):
+    """The review of microcosm#1574 (S4): --reference-build pins a listed
+    build; a cut that already compares with another keeps it unless the
+    operator re-resolves."""
+
+    from test_support.microcosm_build.uk_cut_reference import UKReferenceHub
+
+    runner, _ = _runner(tmp_path, reference=False)
+    hub = UKReferenceHub(tmp_path / "hub-root")
+    hub.publish(cut.RELEASE_ID, "uk-frs-calibration-attempt-older", dataset=b"older")
+    hub.publish(cut.RELEASE_ID, REFERENCE_BUILD, dataset=b"current build")
+    reference = cut.run_reference(
+        runner,
+        build="uk-frs-calibration-attempt-older",
+        hub_download=hub,
+        write_evidence=_stub_evidence,
+    )
+    assert (reference.build, reference.selection) == (
+        "uk-frs-calibration-attempt-older",
+        "pinned",
+    )
+    with pytest.raises(
+        cut.CutError, match="--re-resolve-reference with --reference-build"
+    ):
+        cut.run_reference(
+            runner,
+            build=REFERENCE_BUILD,
+            hub_download=hub,
+            write_evidence=_stub_evidence,
+        )
+    moved = cut.run_reference(
+        runner,
+        re_resolve=True,
+        build=REFERENCE_BUILD,
+        hub_download=hub,
+        write_evidence=_stub_evidence,
+    )
+    assert (moved.build, moved.selection) == (REFERENCE_BUILD, "pinned")
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_score_uk_national_candidate.py b/packages/microcosm-build/tests/engine_free/uk/test_score_uk_national_candidate.py
index 79fdfca929..74e31f8e80 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_score_uk_national_candidate.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_score_uk_national_candidate.py
@@ -6,6 +6,10 @@
 import pandas as pd
 import pytest
 
+from microcosm.build.uk_runtime.cut_reference import (
+    UKCutReference,
+    write_uk_cut_reference,
+)
 from microcosm.build.uk_runtime.national_frame import (
     uk_national_frame,
     write_uk_national_frame,
@@ -23,6 +27,10 @@
     score_uk_national_candidate,
 )
 
+REFERENCE_RELEASE = "microcosm-uk-2024-25-national"
+REFERENCE_BUILD = "uk-frs-calibration-attempt-20261107T020434Z-eeb6093e"
+REFERENCE_LABEL = f"{REFERENCE_RELEASE}@{REFERENCE_BUILD}"
+
 
 def _registry() -> TargetRegistry:
     return TargetRegistry(
@@ -76,63 +84,101 @@ def _write(path, *, measure_a, measure_b) -> None:
     write_uk_national_frame(frame, path)
 
 
+def _reference_record(path, h5) -> UKCutReference:
+    """The record a cut's fetch writes for ``h5``, written to ``path``."""
+
+    reference = UKCutReference(
+        release=REFERENCE_RELEASE,
+        build=REFERENCE_BUILD,
+        repo_id="policyengine/populace-uk-private",
+        path_in_repo=f"releases/{REFERENCE_RELEASE}/{REFERENCE_BUILD}/{h5.name}",
+        filename=h5.name,
+        sha256=_sha256_file(h5),
+        size_bytes=h5.stat().st_size,
+        built_with_model_package={"name": "policyengine-uk", "version": "2.174.1"},
+        built_with_core_package={"name": "policyengine-core", "version": "3.33.3"},
+        evidence={
+            "key": "release_certification",
+            "filename": "release_certification.json",
+            "sha256": "1" * 64,
+        },
+        resolved_at="2026-11-10T12:00:00Z",
+    )
+    write_uk_cut_reference(path, reference)
+    return reference
+
+
 def test_score_uk_national_candidate_scores_synthetic_twins(tmp_path) -> None:
     pytest.importorskip("tables")
     candidate = tmp_path / "candidate.h5"
-    incumbent = tmp_path / "incumbent.h5"
+    reference = tmp_path / "reference.h5"
     _write(candidate, measure_a=[5.0, 5.0], measure_b=[5.0, 5.0])
-    _write(incumbent, measure_a=[4.0, 4.0], measure_b=[10.0, 10.0])
+    _write(reference, measure_a=[4.0, 4.0], measure_b=[10.0, 10.0])
 
     score = score_uk_national_candidate(
         candidate_h5=candidate,
-        incumbent_h5=incumbent,
+        reference_h5=reference,
         candidate_sha256=_sha256_file(candidate),
-        incumbent_sha256=_sha256_file(incumbent),
+        reference_sha256=_sha256_file(reference),
+        reference_label=REFERENCE_LABEL,
         target_registry=_registry(),
         calibration_year=2025,
     )
 
     assert score["artifacts"]["candidate"]["label"] == candidate.stem
-    assert score["artifacts"]["incumbent"]["label"] == "enhanced_frs_2024_25"
+    assert score["artifacts"]["reference"]["label"] == REFERENCE_LABEL
     assert score["artifacts"]["candidate"]["sha256"] == _sha256_file(candidate)
-    assert score["artifacts"]["incumbent"]["sha256"] == _sha256_file(incumbent)
-    assert score["target_drift"] == [
-        {
-            "target": "target_a@0",
-            "family": "family_a",
-            "candidate_relative_error": pytest.approx(0.0),
-            "incumbent_relative_error": pytest.approx(-0.2),
-            "winner": "candidate",
-        },
-        {
-            "target": "target_b@0",
-            "family": "family_b",
-            "candidate_relative_error": pytest.approx(-0.5),
-            "incumbent_relative_error": pytest.approx(0.0),
-            "winner": "incumbent",
-        },
+    assert score["artifacts"]["reference"]["sha256"] == _sha256_file(reference)
+    compared = score["head_to_head"]["targets"]["compared"]
+    assert [
+        (
+            row["name"],
+            row["family"],
+            row["candidate_relative_error"],
+            row["reference_relative_error"],
+            row["lower_absolute_relative_error"],
+        )
+        for row in compared
+    ] == [
+        (
+            "target_a@0",
+            "family_a",
+            pytest.approx(0.0),
+            pytest.approx(-0.2),
+            "candidate",
+        ),
+        (
+            "target_b@0",
+            "family_b",
+            pytest.approx(-0.5),
+            pytest.approx(0.0),
+            "reference",
+        ),
     ]
     assert score["candidate_full_loss"] == pytest.approx(0.25)
-    assert score["incumbent_full_loss"] == pytest.approx(0.1)
+    assert score["reference_full_loss"] == pytest.approx(0.1)
     assert score["candidate_train_loss"] == score["candidate_full_loss"]
     # With no declared split, the holdout keys report absence rather than
     # repeating the fitted loss under a name that means generalization.
     assert score["candidate_holdout_loss"] is None
-    assert score["incumbent_holdout_loss"] is None
+    assert score["reference_holdout_loss"] is None
     assert score["holdout_basis"] == "none_declared"
     assert score["loss"]["train_equals_full"] is True
-    assert score["candidate_target_wins"] == 1
-    assert score["incumbent_target_wins"] == 1
-    assert score["target_wins_by_family"] == {
+    targets = score["head_to_head"]["targets"]
+    assert (targets["candidate_lower_count"], targets["reference_lower_count"]) == (
+        1,
+        1,
+    )
+    assert score["head_to_head"]["by_family"] == {
         "family_a": {
-            "candidate_target_wins": 1,
-            "incumbent_target_wins": 0,
-            "ties": 0,
+            "candidate_lower_count": 1,
+            "reference_lower_count": 0,
+            "equal_count": 0,
         },
         "family_b": {
-            "candidate_target_wins": 0,
-            "incumbent_target_wins": 1,
-            "ties": 0,
+            "candidate_lower_count": 0,
+            "reference_lower_count": 1,
+            "equal_count": 0,
         },
     }
 
@@ -140,11 +186,11 @@ def test_score_uk_national_candidate_scores_synthetic_twins(tmp_path) -> None:
 def test_score_uk_national_candidate_cli_writes_score_block(tmp_path) -> None:
     pytest.importorskip("tables")
     candidate = tmp_path / "candidate.h5"
-    incumbent = tmp_path / "incumbent.h5"
+    reference = tmp_path / "reference.h5"
     registry_json = tmp_path / "registry.json"
     output_json = tmp_path / "score.json"
     _write(candidate, measure_a=[5.0, 5.0], measure_b=[5.0, 5.0])
-    _write(incumbent, measure_a=[4.0, 4.0], measure_b=[10.0, 10.0])
+    _write(reference, measure_a=[4.0, 4.0], measure_b=[10.0, 10.0])
     _registry().to_json(registry_json)
 
     assert (
@@ -154,10 +200,12 @@ def test_score_uk_national_candidate_cli_writes_score_block(tmp_path) -> None:
                 str(candidate),
                 "--candidate-sha256",
                 _sha256_file(candidate),
-                "--incumbent-h5",
-                str(incumbent),
-                "--incumbent-sha256",
-                _sha256_file(incumbent),
+                "--reference-h5",
+                str(reference),
+                "--reference-sha256",
+                _sha256_file(reference),
+                "--reference-label",
+                "explicit_reference",
                 "--registry-json",
                 str(registry_json),
                 "--output-json",
@@ -166,8 +214,6 @@ def test_score_uk_national_candidate_cli_writes_score_block(tmp_path) -> None:
                 "2025",
                 "--candidate-label",
                 "explicit_candidate",
-                "--incumbent-label",
-                "explicit_incumbent",
                 "--no-measure-resolution",
             ]
         )
@@ -176,30 +222,35 @@ def test_score_uk_national_candidate_cli_writes_score_block(tmp_path) -> None:
 
     score = json.loads(output_json.read_text(encoding="utf-8"))
     # The receipt is the score block itself: the release-cut certifier reads
-    # ``artifacts.candidate.sha256`` and ``evaluation.verdict`` at the top
-    # level, so a wrapper key would leave every CLI receipt unverifiable.
-    assert "score_vs_enhanced_frs" not in score
+    # ``artifacts.candidate.sha256`` and ``reference`` at the top level, so a
+    # wrapper key would leave every CLI receipt unverifiable.
+    assert "score_vs_reference" not in score
     assert score["artifacts"]["candidate"]["sha256"] == _sha256_file(candidate)
-    # Raw-column scoring has nothing to prune; the surface still closes and
-    # the verdict is decided: this candidate fits worse than the incumbent.
-    assert score["incumbent_unresolvable_pruned"]["n_pruned"] == 0
+    # Raw-column scoring has nothing to prune; the surface still closes, and
+    # a candidate that fits worse than the reference is reported, not refused.
+    assert score["reference_unresolvable_pruned"]["n_pruned"] == 0
     assert score["evaluation"]["scored_surface"] == {
         "n_scored": 2,
         "n_pruned": 0,
         "n_surface": 2,
     }
-    assert score["evaluation"]["rule_1"]["passed"] is False
-    assert score["evaluation"]["verdict"] == "failed"
+    assert "verdict" not in score["evaluation"]
+    assert (
+        score["evaluation"]["losses"]["candidate_full_loss"]
+        > (score["evaluation"]["losses"]["reference_full_loss"])
+    )
+    # An ad hoc comparison carries no record, so it never certifies a cut.
+    assert score["reference"] is None
     assert score["artifacts"]["candidate"]["label"] == "explicit_candidate"
-    assert score["artifacts"]["incumbent"]["label"] == "explicit_incumbent"
+    assert score["artifacts"]["reference"]["label"] == "explicit_reference"
     assert score["holdout_basis"] == "none_declared"
     # An undeclared holdout reports absence, never the fitted loss wearing a
     # holdout name: June's fixture holds a genuinely different holdout value,
     # so a copied one would read as generalization that was never measured.
     assert score["candidate_holdout_loss"] is None
-    assert score["incumbent_holdout_loss"] is None
+    assert score["reference_holdout_loss"] is None
     assert isinstance(score["candidate_train_loss"], float)
-    assert isinstance(score["incumbent_full_loss"], float)
+    assert isinstance(score["reference_full_loss"], float)
     assert _load_registry(registry_json).version == _registry().version
 
 
@@ -208,14 +259,16 @@ def test_verify_score_receipt_accepts_the_cli_receipt(tmp_path) -> None:
 
     pytest.importorskip("tables")
     candidate = tmp_path / "candidate.h5"
-    incumbent = tmp_path / "incumbent.h5"
+    reference = tmp_path / "reference.h5"
     registry_json = tmp_path / "registry.json"
-    output_json = tmp_path / "score_vs_incumbent.json"
-    # The candidate hits both targets; the incumbent misses both.
+    output_json = tmp_path / "score_vs_reference.json"
+    record_json = tmp_path / "reference.json"
+    # The candidate hits both targets; the reference misses both.
     _write(candidate, measure_a=[5.0, 5.0], measure_b=[10.0, 10.0])
-    _write(incumbent, measure_a=[4.0, 4.0], measure_b=[6.0, 6.0])
+    _write(reference, measure_a=[4.0, 4.0], measure_b=[6.0, 6.0])
     _registry().to_json(registry_json)
     candidate_sha = _sha256_file(candidate)
+    reference_record = _reference_record(record_json, reference)
 
     assert (
         main(
@@ -224,10 +277,10 @@ def test_verify_score_receipt_accepts_the_cli_receipt(tmp_path) -> None:
                 str(candidate),
                 "--candidate-sha256",
                 candidate_sha,
-                "--incumbent-h5",
-                str(incumbent),
-                "--incumbent-sha256",
-                _sha256_file(incumbent),
+                "--reference-h5",
+                str(reference),
+                "--reference-record",
+                str(record_json),
                 "--registry-json",
                 str(registry_json),
                 "--output-json",
@@ -241,25 +294,63 @@ def test_verify_score_receipt_accepts_the_cli_receipt(tmp_path) -> None:
     )
 
     receipt = json.loads(output_json.read_text(encoding="utf-8"))
-    assert receipt["evaluation"]["verdict"] == "passed"
-    _verify_score_receipt(receipt, candidate_sha256=candidate_sha)
+    assert receipt["evaluation"]["reference"] == REFERENCE_LABEL
+    assert receipt["reference"] == reference_record.to_record()
+    _verify_score_receipt(
+        receipt, candidate_sha256=candidate_sha, reference=reference_record
+    )
     with pytest.raises(UKReleaseCertificationError, match="artifacts.candidate.sha256"):
-        _verify_score_receipt(receipt, candidate_sha256="0" * 64)
+        _verify_score_receipt(
+            receipt, candidate_sha256="0" * 64, reference=reference_record
+        )
+    other = UKCutReference.from_record(
+        {**reference_record.to_record(), "build": "uk-frs-calibration-attempt-other"}
+    )
+    with pytest.raises(UKReleaseCertificationError, match="another reference"):
+        _verify_score_receipt(receipt, candidate_sha256=candidate_sha, reference=other)
+
+
+def test_the_cli_takes_a_record_or_an_ad_hoc_label_not_both(tmp_path, capsys) -> None:
+    candidate = tmp_path / "candidate.h5"
+    reference = tmp_path / "reference.h5"
+    candidate.write_bytes(b"c")
+    reference.write_bytes(b"r")
+    base = [
+        "--candidate-h5", str(candidate),
+        "--candidate-sha256", "0" * 64,
+        "--reference-h5", str(reference),
+        "--registry-json", str(tmp_path / "registry.json"),
+        "--output-json", str(tmp_path / "out.json"),
+    ]  # fmt: skip
+    with pytest.raises(SystemExit):
+        main(base)
+    assert "--reference-record" in capsys.readouterr().err
+    with pytest.raises(SystemExit):
+        main(
+            [
+                *base,
+                "--reference-record",
+                str(tmp_path / "reference.json"),
+                "--reference-label",
+                "x",
+            ]  # fmt: skip
+        )
 
 
 def test_scorer_refuses_artifacts_that_do_not_match_their_pins(tmp_path) -> None:
     pytest.importorskip("tables")
     candidate = tmp_path / "candidate.h5"
-    incumbent = tmp_path / "incumbent.h5"
+    reference = tmp_path / "reference.h5"
     _write(candidate, measure_a=[5.0, 5.0], measure_b=[5.0, 5.0])
-    _write(incumbent, measure_a=[4.0, 4.0], measure_b=[10.0, 10.0])
+    _write(reference, measure_a=[4.0, 4.0], measure_b=[10.0, 10.0])
 
     with pytest.raises(ValueError, match="candidate artifact sha mismatch"):
         score_uk_national_candidate(
             candidate_h5=candidate,
-            incumbent_h5=incumbent,
+            reference_h5=reference,
             candidate_sha256="0" * 64,
-            incumbent_sha256=_sha256_file(incumbent),
+            reference_sha256=_sha256_file(reference),
+            reference_label=REFERENCE_LABEL,
             target_registry=_registry(),
             calibration_year=2025,
         )
@@ -267,7 +358,7 @@ def test_scorer_refuses_artifacts_that_do_not_match_their_pins(tmp_path) -> None
 
 def test_scorer_refuses_a_register_that_is_not_a_validated_artifact(tmp_path) -> None:
     # The loose loader accepted any object with a specs list, so a
-    # hand-edited surface could decide rule 1 unnoticed.
+    # hand-edited surface could shape the comparison unnoticed.
     loose = tmp_path / "loose.json"
     loose.write_text(
         json.dumps(
@@ -300,9 +391,9 @@ def test_scorer_refuses_prepared_measures_it_cannot_materialize(tmp_path) -> Non
 
     pytest.importorskip("tables")
     candidate = tmp_path / "candidate.h5"
-    incumbent = tmp_path / "incumbent.h5"
+    reference = tmp_path / "reference.h5"
     _write(candidate, measure_a=[5.0, 5.0], measure_b=[5.0, 5.0])
-    _write(incumbent, measure_a=[4.0, 4.0], measure_b=[10.0, 10.0])
+    _write(reference, measure_a=[4.0, 4.0], measure_b=[10.0, 10.0])
     production_shaped = TargetRegistry(
         [
             TargetSpec(
@@ -321,9 +412,10 @@ def test_scorer_refuses_prepared_measures_it_cannot_materialize(tmp_path) -> Non
     with pytest.raises(RuntimeError, match="did not materialize for scoring"):
         score_uk_national_candidate(
             candidate_h5=candidate,
-            incumbent_h5=incumbent,
+            reference_h5=reference,
             candidate_sha256=_sha256_file(candidate),
-            incumbent_sha256=_sha256_file(incumbent),
+            reference_sha256=_sha256_file(reference),
+            reference_label=REFERENCE_LABEL,
             target_registry=production_shaped,
             calibration_year=2025,
         )
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_battery_bindings.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_battery_bindings.py
index 3c99e6c6cc..6e5b6cd83d 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_uk_battery_bindings.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_battery_bindings.py
@@ -52,6 +52,7 @@
 from microcosm.build.uk_runtime.weighted_integrity import UKReviewedExclusion
 from microcosm.calibrate import TargetRegistry, TargetSpec
 from microcosm.frame import engine_tables
+from test_support.microcosm_build.uk_cut_reference import reference_surface
 from tools.generate_uk_local_target_references import SUPPORT_FLOOR_DEFERRED_AREA_IDS
 
 KEY = base64.b64encode(b"\x07" * 32).decode("ascii")
@@ -69,6 +70,11 @@
 )
 
 
+# A reference that carries no input: the coverage tests' manifests declare
+# the required inputs themselves (microcosm#1095).
+NO_REFERENCE_INPUTS = reference_surface(export_columns=("person.age",))
+
+
 @pytest.fixture(autouse=True)
 def signing_env(monkeypatch) -> None:
     monkeypatch.setenv(gate_signing_key_env("uk"), KEY)
@@ -79,32 +85,41 @@ def uk_gates():
     return load_country_spec("uk").gates
 
 
-def test_declared_export_surface_preserves_claimants_and_matches_runtime(uk_gates):
+def test_declared_export_surface_matches_runtime(uk_gates):
     from microcosm.build.uk_runtime.terminal_gates import (
         UK_ALLOWED_EXTRA_EXPORT_COLUMNS,
     )
 
     entry = next(entry for entry in uk_gates.gates if entry.id == "uk_export_surface")
     declared = set(entry.parameters["allowed_extra_columns"])
-    assert "person.is_uc_claimant" in declared
     assert declared == set(UK_ALLOWED_EXTRA_EXPORT_COLUMNS)
     battery = _run_battery(
         _tables(),
-        parity=_parity(candidate_columns={"person.age", "person.is_uc_claimant"}),
+        parity=_parity(candidate_columns={"person.age", "household.lsoa_code"}),
     )
     outcome = next(o for o in battery.outcomes if o.entry.id == "uk_export_surface")
     assert outcome.status is GateStatus.PASSED
+    assert outcome.result.details["reference_name"] == REFERENCE_LABEL
+
+
+def test_export_surface_needs_the_reference_surface(uk_gates):
+    # Without the cut's reference surface the gate is evidence_absent, which
+    # blocks a release candidate, never a verdict against no reference.
+    battery = _run_battery(_tables(), parity=None)
+    outcome = next(o for o in battery.outcomes if o.entry.id == "uk_export_surface")
+    assert outcome.status is GateStatus.EVIDENCE_ABSENT
 
 
-def test_spine_export_surface_is_reference_or_allow_listed(uk_gates):
-    """Every column the spine declares leaves through the release boundary as
-    an enhanced-FRS input, an allow-listed extra or a reviewed drop.
+def test_spine_export_never_carries_a_reviewed_export_exclusion(uk_gates):
+    """The release boundary drops every column a candidate must never export.
 
-    The export-surface gate runs only at release-cut certification, on a built
-    file; war_widows_pension_reported (#1222) reached main without an
-    allow-list entry and blocked the first certification after it. This runs
-    the same gate on the spine's declared surface through the production
-    export path, against the checked-in enhanced-FRS reference.
+    Until microcosm#1095 this ran the export-surface gate on the spine's
+    declared surface against the checked-in enhanced-FRS reference, so a new
+    spine column without an allow-list entry failed here before it failed a
+    certification (#1222). The reference is now the current build of the
+    line, which the repository does not hold, so that half runs at the cut;
+    the half that needs no reference stays: a persisted copy of a reviewed
+    export exclusion overrides the engine's formula.
     """
 
     from microcosm.build.uk_runtime.graph import uk_spine_endpoint, uk_spine_graph
@@ -112,12 +127,9 @@ def test_spine_export_surface_is_reference_or_allow_listed(uk_gates):
         uk_national_frame,
         uk_release_export_frame,
     )
-    from microcosm.build.uk_runtime.parity_reference import (
-        load_efrs_parity_reference,
-    )
     from microcosm.build.uk_runtime.terminal_gates import (
+        UK_REVIEWED_EXPORT_EXCLUSIONS,
         uk_export_candidate_columns,
-        uk_export_surface_gate,
     )
 
     columns = {
@@ -135,13 +147,7 @@ def test_spine_export_surface_is_reference_or_allow_listed(uk_gates):
     }
     frame = uk_national_frame(**tables, time_period="2024", household_weights=[1.0])
     candidate = uk_export_candidate_columns(uk_release_export_frame(frame))
-    reference = {
-        f"{entity}.{name}"
-        for name, entity in load_efrs_parity_reference().input_entities.items()
-    }
-    entry = next(entry for entry in uk_gates.gates if entry.id == "uk_export_surface")
-    result = uk_export_surface_gate(candidate, reference, **dict(entry.parameters))
-    assert result.passed, result.failures
+    assert not candidate & set(UK_REVIEWED_EXPORT_EXCLUSIONS)
 
 
 def _tables(*, n: int = 4, weights=None):
@@ -195,6 +201,9 @@ def _tables(*, n: int = 4, weights=None):
         {
             "household_id": household_ids,
             "household_weight": np.asarray(weights, dtype=float),
+            # Each household its own survey source, as the input-mass gate's
+            # carriers read them (microcosm#1095).
+            "household_source_id": household_ids + 1000,
             "household_is_spi_synthetic": np.arange(n) % 2 == 1,
             "household_is_capital_gains_clone": np.arange(n) % 4 >= 2,
             "owned_land": land,
@@ -227,13 +236,20 @@ def _parity(**overrides) -> SimpleNamespace:
     return SimpleNamespace(**fields)
 
 
-def _reference() -> UKInputMassReference:
+REFERENCE_BUILD = "uk-frs-calibration-attempt-20261107T020434Z-eeb6093e"
+REFERENCE_LABEL = f"microcosm-uk-2024-25-national@{REFERENCE_BUILD}"
+
+
+def _reference(totals=None) -> UKInputMassReference:
+    """The current build's input-mass reference (microcosm#1095)."""
+
     return UKInputMassReference(
-        totals={"employment_income": 10.0},
-        filename="enhanced_frs_2023_24.h5",
-        revision="655dd07e4bb9c777b00dac044949611f1feb824f",
-        sha256="584ae33d80ca0431254610a3f8254d132da73477d31966d6446282861ecae50d",
-        vintage="2023_24",
+        totals={"employment_income": 10.0} if totals is None else totals,
+        filename="microcosm_uk_2024_25.h5",
+        revision=REFERENCE_BUILD,
+        sha256="9" * 64,
+        vintage="2024_25",
+        label=REFERENCE_LABEL,
     )
 
 
@@ -349,6 +365,12 @@ def _run_battery(
         artifacts["fit_weight_records"] = fit_records
     if parity is not None:
         artifacts["parity_evidence"] = parity
+        # The export-surface gate reads the reference's columns from the
+        # cut's reference surface (microcosm#1095); the fixture keeps them
+        # beside the parity evidence for readability.
+        artifacts["reference_surface"] = reference_surface(
+            export_columns=tuple(parity.reference_columns), label=REFERENCE_LABEL
+        )
     if armed:
         artifacts["input_mass_reference"] = _reference()
         artifacts["aggregate_admin"] = {
@@ -1088,20 +1110,13 @@ def test_fully_armed_battery_evaluates_gate_for_gate(self) -> None:
         assert "uk_soc2020_sub_major_group_enum_domain" in passed
 
     def test_input_mass_parity_compares_the_release_surface(self) -> None:
-        # The frame carries the spine's WAS property_wealth and the reference
-        # stores its own total within tolerance. Compared on the raw frame the
-        # signed exclusion would be stale and the gate would fail; the gate
-        # compares the export frame, where the column is absent, so the
-        # exclusion is in force and nothing is stale (microcosm#1106).
+        # The frame carries the spine's WAS property_wealth, which the release
+        # leaves to the engine (microcosm#1106); the current build's export
+        # does not carry it either. The gate compares the export frame, so the
+        # spine's copy never enters the comparison as a candidate-only column.
         person, benunit, household = _tables()
         household = household.assign(property_wealth=100.0)
-        reference = UKInputMassReference(
-            totals={"employment_income": 10.0, "property_wealth": 400.0},
-            filename="enhanced_frs_2023_24.h5",
-            revision="655dd07e4bb9c777b00dac044949611f1feb824f",
-            sha256="584ae33d80ca0431254610a3f8254d132da73477d31966d6446282861ecae50d",
-            vintage="2023_24",
-        )
+        reference = _reference()
         battery = _run_battery(
             (person, benunit, household),
             parity=_parity(),
@@ -1112,7 +1127,8 @@ def test_input_mass_parity_compares_the_release_surface(self) -> None:
         assert outcome.status is GateStatus.PASSED, outcome.result.failures
         details = outcome.result.details
         assert details["stale_exclusions"] == []
-        assert "property_wealth" in details["reviewed_exclusions"]
+        assert "property_wealth" not in details["candidate_only_columns"]
+        assert details["reference_label"] == REFERENCE_LABEL
 
     def test_empty_fit_records_fail_closed(self) -> None:
         # Present-but-empty is not absent: a fit stage that ran and emitted
@@ -1255,11 +1271,11 @@ def test_every_exclusion_gate_shares_the_injected_clock(self) -> None:
 
     def test_an_expired_register_fails_closed(self) -> None:
         # The committed input-mass register carries no entry since the
-        # 2026-09-21 retirements, so the expiry discipline is exercised on an
-        # injected receipt that lapses before the clock below; the other two
-        # registers still expire from their committed entries.
+        # enhanced-FRS reference retired (microcosm#1095), so the expiry
+        # discipline is exercised on an injected receipt, signed for the
+        # reference build, that lapses before the clock below.
         lapsed = {
-            "efrs-post-calibration": {
+            REFERENCE_LABEL: {
                 "owned_land": {
                     "reason": "injected: a reviewed exclusion whose window has closed",
                     "approved_by": "juaristi22",
@@ -1445,6 +1461,7 @@ def test_terminal_mode_threads_frame_engine_and_manifest(self) -> None:
                 artifacts={
                     "coverage_engine": engine,
                     "coverage_manifest": manifest,
+                    "reference_surface": NO_REFERENCE_INPUTS,
                     "spine_frame": frame,
                 },
             ),
@@ -1453,6 +1470,7 @@ def test_terminal_mode_threads_frame_engine_and_manifest(self) -> None:
         direct = uk_release_input_coverage_gate(
             _uk_gate_surface(frame),
             engine,
+            reference_surface=NO_REFERENCE_INPUTS,
             manifest=manifest,
             build_state_frame=_uk_gate_surface(frame),
         )
@@ -1507,7 +1525,10 @@ def variable_entities(self, names):
             family_coverage={},
         )
         raw = uk_release_input_coverage_gate(
-            _uk_gate_surface(frame), engine, manifest=manifest
+            _uk_gate_surface(frame),
+            engine,
+            reference_surface=NO_REFERENCE_INPUTS,
+            manifest=manifest,
         )
         result = UK_GATE_REGISTRY["release_input_coverage"].evaluate(
             EvidenceContext(
@@ -1515,6 +1536,7 @@ def variable_entities(self, names):
                 artifacts={
                     "coverage_engine": engine,
                     "coverage_manifest": manifest,
+                    "reference_surface": NO_REFERENCE_INPUTS,
                     # The spine build state the family half reads (#1115).
                     "spine_frame": frame,
                 },
@@ -2070,14 +2092,7 @@ def test_drifted_declared_pin_fails_closed(self, uk_gates) -> None:
         entry = {e.id: e for e in uk_gates.gates}["uk_input_mass_parity"]
         drifted = dict(entry.parameters)
         drifted["reference_registry"] = {
-            name: (
-                {
-                    **payload,
-                    "totals_sha256": "0" * 64,
-                }
-                if name == "efrs-post-calibration"
-                else payload
-            )
+            name: {**payload, "scope_note": "a drifted scope note"}
             for name, payload in drifted["reference_registry"].items()
         }
         binding = UK_GATE_REGISTRY["input_mass_parity"]
@@ -2823,3 +2838,50 @@ def test_bound_despite_floor_approvals_are_window_checked_on_every_line(
             "bound_despite_support_floor/census_households"
         ]
         assert result.details["out_of_line_exclusions"] == ["local_authority/LA_B"]
+
+
+class TestInputMassReferenceBuild:
+    """The exclusions a gate applies are the ones signed for its reference build."""
+
+    def test_an_exclusion_signed_for_another_build_is_dormant(self) -> None:
+        signed = {
+            "microcosm-uk-2024-25-national@uk-frs-calibration-attempt-older": {
+                "employment_income": {
+                    "reason": "injected: signed for an earlier reference build",
+                    "approved_by": "juaristi22",
+                    "adjudication": "microcosm#1095 (test)",
+                    "approved_on": "2026-11-01",
+                    "expires_on": "2027-03-01",
+                }
+            }
+        }
+        person, benunit, household = _tables()
+        battery = _run_battery(
+            (person, benunit, household),
+            parity=_parity(),
+            fit_records=(FitWeightRecord("spi_qrf", "importance"),),
+            extra_artifacts={
+                # The candidate carries far more than the reference: past the
+                # tolerance, which an exclusion for this build would excuse.
+                "input_mass_reference": _reference({"employment_income": 1.0e-3}),
+                "reviewed_input_mass_exclusions": signed,
+            },
+        )
+        outcome = {o.entry.id: o for o in battery.outcomes}["uk_input_mass_parity"]
+        # The entry is for another build, so the drift fails here.
+        assert outcome.status is GateStatus.FAILED
+        assert outcome.result.details["reviewed_exclusions"] == {}
+
+    def test_an_exclusion_key_that_names_no_build_is_refused(self) -> None:
+        person, benunit, household = _tables()
+        battery = _run_battery(
+            (person, benunit, household),
+            parity=_parity(),
+            fit_records=(FitWeightRecord("spi_qrf", "importance"),),
+            extra_artifacts={
+                "reviewed_input_mass_exclusions": {"efrs-post-calibration": {}},
+            },
+        )
+        outcome = {o.entry.id: o for o in battery.outcomes}["uk_input_mass_parity"]
+        assert outcome.status is GateStatus.FAILED
+        assert "<release>@<build>" in " ".join(outcome.result.failures)
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_candidate_score.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_candidate_score.py
index a76923c420..d964912e72 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_uk_candidate_score.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_candidate_score.py
@@ -1,7 +1,9 @@
-"""The UK candidate score on the common resolvable surface (microcosm#967).
+"""The UK head-to-head with the reference on the common resolvable surface.
 
-The pruning loop is exercised against a stand-in for the scoring frame that
-fails the incumbent's resolution the way the real resolver does — a
+microcosm#967 built the common surface; microcosm#1095 made the reference the
+current national build and the comparison a report with no verdict. The
+pruning loop is exercised against a stand-in for the scoring frame that
+fails the reference's resolution the way the real resolver does — a
 ``MeasureResolutionError`` naming the absent measure, with the resolution
 receipt's skip rows — while both frames score on raw columns, so the suite
 needs no engine.
@@ -21,9 +23,10 @@
 from microcosm.build.uk_runtime import candidate_score
 from microcosm.build.uk_runtime.candidate_score import (
     _sha256_file,
-    evaluate_uk_candidate_against_incumbent,
+    evaluate_uk_candidate_against_reference,
     evaluation_block,
-    prune_incumbent_unresolvable,
+    load_uk_reference_unresolvable_measures,
+    prune_reference_unresolvable,
     pruned_warning,
 )
 from microcosm.build.uk_runtime.national_frame import (
@@ -39,6 +42,7 @@
 from microcosm.frame import WeightKind
 
 MEASURE_B = "household.measure_b"
+REFERENCE = "microcosm-uk-2024-25-national@uk-frs-calibration-attempt-test"
 
 
 def _registry() -> TargetRegistry:
@@ -102,16 +106,16 @@ def _write(
 
 def _twins(tmp_path: Path) -> tuple[Path, Path]:
     candidate = tmp_path / "candidate.h5"
-    incumbent = tmp_path / "incumbent.h5"
+    reference = tmp_path / "reference.h5"
     # The candidate hits target_a exactly and carries measure_b; the
-    # incumbent misses target_a and never carried measure_b.
+    # reference misses target_a and never carried measure_b.
     _write(candidate, measure_a=[5.0, 5.0], measure_b=[10.0, 10.0])
-    _write(incumbent, measure_a=[4.0, 4.0])
-    return candidate, incumbent
+    _write(reference, measure_a=[4.0, 4.0])
+    return candidate, reference
 
 
 def _resolver_factory(path, frame):
-    # A resolver is present (so the incumbent is probed) but scoring stays
+    # A resolver is present (so the reference is probed) but scoring stays
     # on raw columns: the real resolver is stood in for by ``_intercept``.
     return None
 
@@ -130,14 +134,14 @@ def fake(
         factory,
         *,
         band_edge_registry=None,
-        incumbent=False,
+        reference=False,
     ):
         calls.append(
             {
                 "h5": Path(h5_path),
                 "targets": [spec.name for spec in registry.specs],
                 "band_edge_registry": band_edge_registry,
-                "incumbent": incumbent,
+                "reference": reference,
             }
         )
         if Path(h5_path) == failing_h5 and any(
@@ -152,7 +156,7 @@ def fake(
 
 _REVIEWED = {
     "household.measure_b": UKReviewedExclusion(
-        reason="the incumbent twin never carried measure_b",
+        reason="the reference twin never carried measure_b",
         approved_by="juaristi22",
         adjudication="microcosm#823 (test register)",
         approved_on="2026-09-01",
@@ -166,10 +170,11 @@ def _reviewed_register(monkeypatch):
     """Stand in for the packaged register: measure_b is a signed, in-force
     entry. Tests that need another register override the loader again."""
 
+    def reviewed(*, reference_label, source=None):
+        return dict(_REVIEWED) if reference_label == REFERENCE else {}
+
     monkeypatch.setattr(
-        candidate_score,
-        "load_uk_incumbent_unresolvable_measures",
-        lambda source=None: dict(_REVIEWED),
+        candidate_score, "load_uk_reference_unresolvable_measures", reviewed
     )
 
 
@@ -180,30 +185,31 @@ def _reviewed_register(monkeypatch):
 }
 
 
-def test_prunes_the_target_the_incumbent_cannot_materialize_and_scores_the_rest(
+def test_prunes_the_target_the_reference_cannot_materialize_and_scores_the_rest(
     monkeypatch, tmp_path
 ):
     pytest.importorskip("tables")
-    candidate, incumbent = _twins(tmp_path)
+    candidate, reference = _twins(tmp_path)
     full = _registry()
     calls = _intercept(
         monkeypatch,
-        failing_h5=incumbent,
+        failing_h5=reference,
         message=f"provider does not know {MEASURE_B}",
         receipt=_SKIP_RECEIPT,
     )
 
-    score = evaluate_uk_candidate_against_incumbent(
+    score = evaluate_uk_candidate_against_reference(
         candidate_h5=candidate,
-        incumbent_h5=incumbent,
+        reference_h5=reference,
         candidate_sha256=_sha256_file(candidate),
-        incumbent_sha256=_sha256_file(incumbent),
+        reference_sha256=_sha256_file(reference),
+        reference_label=REFERENCE,
         target_registry=full,
         calibration_year=2025,
         measure_resolver_factory=_resolver_factory,
     )
 
-    pruned = score["incumbent_unresolvable_pruned"]
+    pruned = score["reference_unresolvable_pruned"]
     assert pruned["n_pruned"] == 1
     assert pruned["n_scored"] == 1
     assert pruned["n_surface"] == 2
@@ -218,10 +224,13 @@ def test_prunes_the_target_the_incumbent_cannot_materialize_and_scores_the_rest(
     }
     # Both arms were scored on the common surface only.
     assert score["register"]["n_specs"] == 1
-    assert [row["target"] for row in score["target_drift"]] == ["target_a@0"]
-    # The candidate hit its target and the incumbent missed: rule 1 passes.
-    assert score["evaluation"]["verdict"] == "passed"
-    assert score["evaluation"]["rule_1"]["passed"] is True
+    compared = score["head_to_head"]["targets"]["compared"]
+    assert [row["name"] for row in compared] == ["target_a@0"]
+    # The candidate hit its target and the reference missed; the comparison
+    # reports it and decides nothing.
+    assert compared[0]["lower_absolute_relative_error"] == "candidate"
+    assert "verdict" not in score["evaluation"]
+    assert score["evaluation"]["reference"] == REFERENCE
     assert score["evaluation"]["scored_surface"] == {
         "n_scored": 1,
         "n_pruned": 1,
@@ -233,9 +242,9 @@ def test_prunes_the_target_the_incumbent_cannot_materialize_and_scores_the_rest(
     assert scoring_calls and all(
         call["band_edge_registry"] is full for call in scoring_calls
     )
-    # Only the incumbent may read its current income for the annual measures.
+    # Only the reference may read its current income for the annual measures.
     assert calls and all(
-        call["incumbent"] == (call["h5"] == incumbent) for call in calls
+        call["reference"] == (call["h5"] == reference) for call in calls
     )
     warning = pruned_warning(score)
     assert warning is not None
@@ -247,10 +256,10 @@ def test_binding_fallback_names_the_target_when_the_receipt_does_not(
     monkeypatch, tmp_path
 ):
     pytest.importorskip("tables")
-    candidate, incumbent = _twins(tmp_path)
+    candidate, reference = _twins(tmp_path)
     _intercept(
         monkeypatch,
-        failing_h5=incumbent,
+        failing_h5=reference,
         message=f"provider failed computing {MEASURE_B}: no such column",
         receipt={"skips": []},
     )
@@ -258,8 +267,13 @@ def test_binding_fallback_names_the_target_when_the_receipt_does_not(
         "test.target_b": {"bindings": {"policyengine": {"value_variable": "measure_b"}}}
     }
 
-    surface, pruned = prune_incumbent_unresolvable(
-        incumbent, _registry(), 2025, _resolver_factory, contract_targets=contract
+    surface, pruned = prune_reference_unresolvable(
+        reference,
+        _registry(),
+        2025,
+        _resolver_factory,
+        contract_targets=contract,
+        reference_label=REFERENCE,
     )
 
     assert [spec.name for spec in surface.specs] == ["target_a"]
@@ -268,65 +282,76 @@ def test_binding_fallback_names_the_target_when_the_receipt_does_not(
 
 def test_refuses_to_prune_blindly(monkeypatch, tmp_path):
     pytest.importorskip("tables")
-    candidate, incumbent = _twins(tmp_path)
+    candidate, reference = _twins(tmp_path)
     _intercept(
         monkeypatch,
-        failing_h5=incumbent,
+        failing_h5=reference,
         message=f"provider does not know {MEASURE_B}",
         receipt={"skips": []},
     )
 
     with pytest.raises(MeasureResolutionError, match="refusing to prune blindly"):
-        prune_incumbent_unresolvable(
-            incumbent, _registry(), 2025, _resolver_factory, contract_targets={}
+        prune_reference_unresolvable(
+            reference,
+            _registry(),
+            2025,
+            _resolver_factory,
+            contract_targets={},
+            reference_label=REFERENCE,
         )
 
 
 def test_a_failure_naming_no_measure_is_re_raised(monkeypatch, tmp_path):
     pytest.importorskip("tables")
-    candidate, incumbent = _twins(tmp_path)
+    candidate, reference = _twins(tmp_path)
     _intercept(
         monkeypatch,
-        failing_h5=incumbent,
+        failing_h5=reference,
         message="measure materialization made no progress on round 0",
         receipt={"skips": []},
     )
 
     with pytest.raises(MeasureResolutionError, match="made no progress"):
-        prune_incumbent_unresolvable(
-            incumbent, _registry(), 2025, _resolver_factory, contract_targets={}
+        prune_reference_unresolvable(
+            reference,
+            _registry(),
+            2025,
+            _resolver_factory,
+            contract_targets={},
+            reference_label=REFERENCE,
         )
 
 
 def test_pruning_off_restores_the_refusal(monkeypatch, tmp_path):
     pytest.importorskip("tables")
-    candidate, incumbent = _twins(tmp_path)
+    candidate, reference = _twins(tmp_path)
     _intercept(
         monkeypatch,
-        failing_h5=incumbent,
+        failing_h5=reference,
         message=f"provider does not know {MEASURE_B}",
         receipt=_SKIP_RECEIPT,
     )
 
     with pytest.raises(MeasureResolutionError, match="does not know"):
-        evaluate_uk_candidate_against_incumbent(
+        evaluate_uk_candidate_against_reference(
             candidate_h5=candidate,
-            incumbent_h5=incumbent,
+            reference_h5=reference,
             candidate_sha256=_sha256_file(candidate),
-            incumbent_sha256=_sha256_file(incumbent),
+            reference_sha256=_sha256_file(reference),
+            reference_label=REFERENCE,
             target_registry=_registry(),
             calibration_year=2025,
             measure_resolver_factory=_resolver_factory,
-            prune_incumbent_unresolvable_measures=False,
+            prune_reference_unresolvable_measures=False,
         )
 
 
 def test_a_candidate_side_gap_still_refuses(monkeypatch, tmp_path):
     pytest.importorskip("tables")
     candidate = tmp_path / "candidate.h5"
-    incumbent = tmp_path / "incumbent.h5"
+    reference = tmp_path / "reference.h5"
     _write(candidate, measure_a=[5.0, 5.0])
-    _write(incumbent, measure_a=[4.0, 4.0], measure_b=[10.0, 10.0])
+    _write(reference, measure_a=[4.0, 4.0], measure_b=[10.0, 10.0])
     _intercept(
         monkeypatch,
         failing_h5=candidate,
@@ -334,47 +359,84 @@ def test_a_candidate_side_gap_still_refuses(monkeypatch, tmp_path):
         receipt=_SKIP_RECEIPT,
     )
 
-    # Only the incumbent is probed for pruning; a measure the candidate
+    # Only the reference is probed for pruning; a measure the candidate
     # cannot materialize is a defect and refuses as before.
     with pytest.raises(MeasureResolutionError, match="does not know"):
-        evaluate_uk_candidate_against_incumbent(
+        evaluate_uk_candidate_against_reference(
             candidate_h5=candidate,
-            incumbent_h5=incumbent,
+            reference_h5=reference,
             candidate_sha256=_sha256_file(candidate),
-            incumbent_sha256=_sha256_file(incumbent),
+            reference_sha256=_sha256_file(reference),
+            reference_label=REFERENCE,
             target_registry=_registry(),
             calibration_year=2025,
             measure_resolver_factory=_resolver_factory,
         )
 
 
-def test_verdict_fails_when_the_incumbent_fits_better(tmp_path):
+def test_a_reference_that_fits_better_is_reported_not_refused(tmp_path):
     pytest.importorskip("tables")
     candidate = tmp_path / "candidate.h5"
-    incumbent = tmp_path / "incumbent.h5"
+    reference = tmp_path / "reference.h5"
     _write(candidate, measure_a=[5.0, 5.0], measure_b=[5.0, 5.0])
-    _write(incumbent, measure_a=[4.0, 4.0], measure_b=[10.0, 10.0])
+    _write(reference, measure_a=[4.0, 4.0], measure_b=[10.0, 10.0])
 
-    score = evaluate_uk_candidate_against_incumbent(
+    score = evaluate_uk_candidate_against_reference(
         candidate_h5=candidate,
-        incumbent_h5=incumbent,
+        reference_h5=reference,
         candidate_sha256=_sha256_file(candidate),
-        incumbent_sha256=_sha256_file(incumbent),
+        reference_sha256=_sha256_file(reference),
+        reference_label=REFERENCE,
         target_registry=_registry(),
         calibration_year=2025,
     )
 
-    assert score["incumbent_unresolvable_pruned"]["n_pruned"] == 0
+    assert score["reference_unresolvable_pruned"]["n_pruned"] == 0
     assert pruned_warning(score) is None
-    assert score["evaluation"]["scored_surface"] == {
+    evaluation = score["evaluation"]
+    assert evaluation["schema_version"] == 2
+    assert evaluation["scored_surface"] == {
         "n_scored": 2,
         "n_pruned": 0,
         "n_surface": 2,
     }
-    assert score["evaluation"]["rule_1"]["candidate_full_loss"] == pytest.approx(0.25)
-    assert score["evaluation"]["rule_1"]["incumbent_full_loss"] == pytest.approx(0.1)
-    assert score["evaluation"]["verdict"] == "failed"
-    assert evaluation_block(score) == score["evaluation"]
+    assert evaluation["losses"]["candidate_full_loss"] == pytest.approx(0.25)
+    assert evaluation["losses"]["reference_full_loss"] == pytest.approx(0.1)
+    assert evaluation["targets"] == {
+        "candidate_lower_count": 1,
+        "reference_lower_count": 1,
+        "equal_count": 0,
+    }
+    assert evaluation["no_threshold_applied"] is True
+    assert "verdict" not in evaluation
+    assert score["head_to_head"]["by_family"] == {
+        "family_a": {
+            "candidate_lower_count": 1,
+            "reference_lower_count": 0,
+            "equal_count": 0,
+        },
+        "family_b": {
+            "candidate_lower_count": 0,
+            "reference_lower_count": 1,
+            "equal_count": 0,
+        },
+    }
+    assert evaluation_block(score) == evaluation
+    assert score["reference"] is None
+
+
+def test_the_reference_record_must_name_the_scored_file(tmp_path):
+    pytest.importorskip("tables")
+    candidate, reference = _twins(tmp_path)
+    _write(reference, measure_a=[4.0, 4.0], measure_b=[10.0, 10.0])
+    release, build = REFERENCE.split("@")
+    record = {"release": release, "build": build, "sha256": _sha256_file(reference)}
+
+    score = _evaluate(candidate, reference, reference_record=record)
+    assert score["reference"] == record
+
+    with pytest.raises(ValueError, match="names another build"):
+        _evaluate(candidate, reference, reference_record={**record, "sha256": "0" * 64})
 
 
 def test_each_file_is_scored_with_the_weights_the_engine_gives_it(tmp_path):
@@ -395,40 +457,42 @@ def test_each_file_is_scored_with_the_weights_the_engine_gives_it(tmp_path):
     _write(as_solved, measure_a=[5.0, 5.0], measure_b=[10.0, 10.0], time_period="2024")
     factor = uk_weight_projection_factor(2024, 2025)
 
-    score = evaluate_uk_candidate_against_incumbent(
+    score = evaluate_uk_candidate_against_reference(
         candidate_h5=released,
-        incumbent_h5=as_solved,
+        reference_h5=as_solved,
         candidate_sha256=_sha256_file(released),
-        incumbent_sha256=_sha256_file(as_solved),
+        reference_sha256=_sha256_file(as_solved),
+        reference_label=REFERENCE,
         target_registry=_registry(),
         calibration_year=2025,
     )
 
-    rule_1 = score["evaluation"]["rule_1"]
+    losses = score["evaluation"]["losses"]
     # The release reads back its solved weights; the as-solved file reads
     # high on every row by the population growth of the year after its own.
-    assert rule_1["candidate_full_loss"] == pytest.approx(0.0, abs=1e-12)
-    assert rule_1["incumbent_full_loss"] == pytest.approx(factor - 1.0, rel=1e-9)
+    assert losses["candidate_full_loss"] == pytest.approx(0.0, abs=1e-12)
+    assert losses["reference_full_loss"] == pytest.approx(factor - 1.0, rel=1e-9)
     side = {"dataset_year": 2024, "engine_projection_factor": factor}
     assert score["weight_year"] == {
         "scored_year": 2025,
         "candidate": side,
-        "incumbent": side,
+        "reference": side,
     }
 
 
-def _evaluate(candidate, incumbent, **overrides):
+def _evaluate(candidate, reference, **overrides):
     kwargs = {
         "candidate_h5": candidate,
-        "incumbent_h5": incumbent,
+        "reference_h5": reference,
         "candidate_sha256": _sha256_file(candidate),
-        "incumbent_sha256": _sha256_file(incumbent),
+        "reference_sha256": _sha256_file(reference),
+        "reference_label": REFERENCE,
         "target_registry": _registry(),
         "calibration_year": 2025,
         "measure_resolver_factory": _resolver_factory,
     }
     kwargs.update(overrides)
-    return candidate_score.evaluate_uk_candidate_against_incumbent(**kwargs)
+    return candidate_score.evaluate_uk_candidate_against_reference(**kwargs)
 
 
 def test_an_unlisted_unresolvable_measure_refuses_instead_of_pruning(
@@ -436,52 +500,55 @@ def test_an_unlisted_unresolvable_measure_refuses_instead_of_pruning(
 ):
     """Pruning is doctrine, not inference: no signed entry, no prune."""
     pytest.importorskip("tables")
-    candidate, incumbent = _twins(tmp_path)
+    candidate, reference = _twins(tmp_path)
     _intercept(
         monkeypatch,
-        failing_h5=incumbent,
+        failing_h5=reference,
         message="provider does not know household.measure_b",
         receipt=_SKIP_RECEIPT,
     )
     monkeypatch.setattr(
-        candidate_score, "load_uk_incumbent_unresolvable_measures", lambda s=None: {}
+        candidate_score,
+        "load_uk_reference_unresolvable_measures",
+        lambda *, reference_label, source=None: {},
     )
-    with pytest.raises(MeasureResolutionError, match="not on the reviewed"):
-        _evaluate(candidate, incumbent)
+    with pytest.raises(MeasureResolutionError, match="reference-unresolvable register"):
+        _evaluate(candidate, reference)
 
 
 def test_an_expired_or_premature_entry_refuses(monkeypatch, tmp_path):
     pytest.importorskip("tables")
-    candidate, incumbent = _twins(tmp_path)
+    candidate, reference = _twins(tmp_path)
     _intercept(
         monkeypatch,
-        failing_h5=incumbent,
+        failing_h5=reference,
         message="provider does not know household.measure_b",
         receipt=_SKIP_RECEIPT,
     )
     with pytest.raises(MeasureResolutionError, match="expired"):
-        _evaluate(candidate, incumbent, evaluated_on=date(2100, 1, 1))
+        _evaluate(candidate, reference, evaluated_on=date(2100, 1, 1))
     with pytest.raises(MeasureResolutionError, match="not yet in force"):
-        _evaluate(candidate, incumbent, evaluated_on=date(2026, 8, 1))
+        _evaluate(candidate, reference, evaluated_on=date(2026, 8, 1))
 
 
 def test_pruned_rows_carry_the_register_entry_they_stand_on(monkeypatch, tmp_path):
     pytest.importorskip("tables")
-    candidate, incumbent = _twins(tmp_path)
+    candidate, reference = _twins(tmp_path)
     _intercept(
         monkeypatch,
-        failing_h5=incumbent,
+        failing_h5=reference,
         message="provider does not know household.measure_b",
         receipt=_SKIP_RECEIPT,
     )
-    score = _evaluate(candidate, incumbent, evaluated_on=date(2026, 9, 22))
-    pruned = score["incumbent_unresolvable_pruned"]
+    score = _evaluate(candidate, reference, evaluated_on=date(2026, 9, 22))
+    pruned = score["reference_unresolvable_pruned"]
     assert pruned["measures"] == ["household.measure_b"]
     assert pruned["pruned_targets"]["target_b"]["adjudication"] == (
         "microcosm#823 (test register)"
     )
     register = pruned["reviewed_register"]
-    assert register["resource"] == "incumbent_unresolvable_measures.json"
+    assert register["resource"] == "reference_unresolvable_measures.json"
+    assert register["reference"] == REFERENCE
     assert len(register["sha256"]) == 64
     assert register["entries_used"] == {
         "household.measure_b": _REVIEWED["household.measure_b"].policy_payload()
@@ -493,10 +560,10 @@ def test_a_skip_reason_is_matched_exactly_never_by_substring(monkeypatch, tmp_pa
     with no skip naming the measure and no binding, the loop refuses to
     prune blindly rather than dropping an unrelated row."""
     pytest.importorskip("tables")
-    candidate, incumbent = _twins(tmp_path)
+    candidate, reference = _twins(tmp_path)
     _intercept(
         monkeypatch,
-        failing_h5=incumbent,
+        failing_h5=reference,
         message="provider does not know household.measure_b",
         receipt={
             "skips": [
@@ -509,20 +576,20 @@ def test_a_skip_reason_is_matched_exactly_never_by_substring(monkeypatch, tmp_pa
         },
     )
     with pytest.raises(MeasureResolutionError, match="refusing to prune blindly"):
-        _evaluate(candidate, incumbent, contract_targets={})
+        _evaluate(candidate, reference, contract_targets={})
 
 
 def test_a_gap_shared_by_both_artifacts_still_refuses_on_the_candidate(
     monkeypatch, tmp_path
 ):
     """Review A1: the candidate is validated on the full surface BEFORE the
-    incumbent's gaps are pruned, so an export missing a listed measure is a
-    defect even when the incumbent lacks it too; it never scores as a win."""
+    reference's gaps are pruned, so an export missing a listed measure is a
+    defect even when the reference lacks it too; it never scores as a win."""
     pytest.importorskip("tables")
     candidate = tmp_path / "candidate.h5"
-    incumbent = tmp_path / "incumbent.h5"
+    reference = tmp_path / "reference.h5"
     _write(candidate, measure_a=[5.0, 5.0])
-    _write(incumbent, measure_a=[4.0, 4.0])
+    _write(reference, measure_a=[4.0, 4.0])
     original = candidate_score._scored_frame
     calls: list[tuple[Path, list[str]]] = []
 
@@ -533,7 +600,7 @@ def fake(
         factory,
         *,
         band_edge_registry=None,
-        incumbent=False,
+        reference=False,
     ):
         calls.append((Path(h5_path), [spec.name for spec in registry.specs]))
         if any(spec.name == "target_b" for spec in registry.specs):
@@ -545,15 +612,75 @@ def fake(
     monkeypatch.setattr(candidate_score, "_scored_frame", fake)
 
     with pytest.raises(MeasureResolutionError, match="does not know"):
-        _evaluate(candidate, incumbent, evaluated_on=date(2026, 9, 22))
-    # The first probe was the candidate on the full surface; the incumbent
+        _evaluate(candidate, reference, evaluated_on=date(2026, 9, 22))
+    # The first probe was the candidate on the full surface; the reference
     # was never asked, so nothing was pruned.
     assert calls[0] == (candidate, ["target_a", "target_b"])
     assert all(path == candidate for path, _ in calls)
 
 
+def test_the_register_lends_each_reference_only_its_own_entries(tmp_path):
+    """An entry signed for one build is dormant for every other reference."""
+
+    entry = {
+        "reason": "the earlier build never carried measure_b",
+        "approved_by": "juaristi22",
+        "adjudication": "microcosm#1095 (test register)",
+        "approved_on": "2026-11-10",
+        "expires_on": "2099-12-31",
+    }
+    register = tmp_path / "reference_unresolvable_measures.json"
+    register.write_text(
+        json.dumps(
+            {
+                "schema_version": 3,
+                "description": "test register",
+                "references": {REFERENCE: {MEASURE_B: entry}},
+            }
+        )
+    )
+
+    mine = load_uk_reference_unresolvable_measures(
+        reference_label=REFERENCE, source=register
+    )
+    other = load_uk_reference_unresolvable_measures(
+        reference_label="microcosm-uk-2024-25-national@another-build", source=register
+    )
+
+    assert list(mine) == [MEASURE_B]
+    assert other == {}
+
+
+def test_the_packaged_register_signs_only_the_current_build_s_carrier_gap():
+    """The enhanced FRS's nine entries retired with it (microcosm#1095). The
+    current national build carries no trading allowance full-relief carrier,
+    which five SPI rows filter on since microcosm#1439, as the enhanced FRS
+    did not (microcosm#1572); María signed it for that build on 2026-11-11."""
+
+    national = (
+        "microcosm-uk-2024-25-national@"
+        "uk-frs-calibration-attempt-20261107T020434Z-eeb6093e"
+    )
+    register = candidate_score.load_uk_reference_unresolvable_register()
+
+    assert {label: sorted(entries) for label, entries in register.items()} == {
+        national: ["person.trading_allowance_full_relief"]
+    }
+    entry = register[national]["person.trading_allowance_full_relief"]
+    assert entry.approved_by == "juaristi22"
+    assert not entry.premature(date(2026, 11, 11))
+    assert not entry.expired(date(2026, 11, 11))
+    # Every other reference, a promoted one included, finds nothing.
+    assert (
+        load_uk_reference_unresolvable_measures(
+            reference_label="microcosm-uk-2024-25-national@a-later-build"
+        )
+        == {}
+    )
+
+
 def _one_target_per_probe(monkeypatch, *, failing_h5: Path) -> list[str]:
-    """Fail each incumbent probe on the first measure-bound target still on the
+    """Fail each reference probe on the first measure-bound target still on the
     surface, naming that target alone, so every target takes its own probe."""
 
     original = candidate_score._scored_frame
@@ -566,7 +693,7 @@ def fake(
         factory,
         *,
         band_edge_registry=None,
-        incumbent=False,
+        reference=False,
     ):
         remaining = [spec for spec in registry.specs if spec.name != "target_a"]
         if Path(h5_path) == failing_h5 and remaining:
@@ -611,23 +738,24 @@ def _signed_targets(measures, per_measure: int):
 
 
 def test_the_probe_bound_grows_with_the_register(monkeypatch, tmp_path):
-    """Two of the nine signed measures took two probes each on 11 November
-    2026, eleven failing probes against the fixed bound of ten this replaced.
+    """Two of the enhanced FRS's nine signed measures took two probes each on
+    11 November 2026, eleven failing probes against the fixed bound of ten this replaced.
     Here four signed measures take three probes each: twelve, then the clean
     probe."""
 
     pytest.importorskip("tables")
-    _, incumbent = _twins(tmp_path)
-    probes = _one_target_per_probe(monkeypatch, failing_h5=incumbent)
+    _, reference = _twins(tmp_path)
+    probes = _one_target_per_probe(monkeypatch, failing_h5=reference)
     registry, reviewed = _signed_targets(["m1", "m2", "m3", "m4"], per_measure=3)
 
-    surface, pruned = prune_incumbent_unresolvable(
-        incumbent,
+    surface, pruned = prune_reference_unresolvable(
+        reference,
         registry,
         2025,
         _resolver_factory,
         reviewed_measures=reviewed,
         evaluated_on=date(2026, 11, 10),
+        reference_label=REFERENCE,
     )
 
     assert [spec.name for spec in surface.specs] == ["target_a"]
@@ -637,16 +765,17 @@ def test_the_probe_bound_grows_with_the_register(monkeypatch, tmp_path):
 
 def test_the_probe_bound_still_stops_a_runaway_measure(monkeypatch, tmp_path):
     pytest.importorskip("tables")
-    _, incumbent = _twins(tmp_path)
-    _one_target_per_probe(monkeypatch, failing_h5=incumbent)
+    _, reference = _twins(tmp_path)
+    _one_target_per_probe(monkeypatch, failing_h5=reference)
     registry, reviewed = _signed_targets(["m1"], per_measure=5)
 
     with pytest.raises(RuntimeError, match="still fails after 4 pruning rounds"):
-        prune_incumbent_unresolvable(
-            incumbent,
+        prune_reference_unresolvable(
+            reference,
             registry,
             2025,
             _resolver_factory,
             reviewed_measures=reviewed,
             evaluated_on=date(2026, 11, 10),
+            reference_label=REFERENCE,
         )
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_certify_release_cut_command.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_certify_release_cut_command.py
index 1e898dd769..a23258d0cc 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_uk_certify_release_cut_command.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_certify_release_cut_command.py
@@ -35,7 +35,9 @@ def test_certifier_pins_carry_the_byte_sizes_the_logbook_digest_requires(
         "build_record.json",
         "terminal_gates.json",
         "input_mass_reference.json",
-        "score_vs_incumbent.json",
+        "reference_surface.json",
+        "score_vs_reference.json",
+        "reference.json",
     ):
         placeholders[name] = tmp_path / name
         placeholders[name].write_text("{}")
@@ -77,8 +79,12 @@ def fake_run(args, state):
                 "2" * 64,
                 "--input-mass-reference",
                 str(placeholders["input_mass_reference.json"]),
+                "--reference-surface",
+                str(placeholders["reference_surface.json"]),
                 "--score-receipt",
-                str(placeholders["score_vs_incumbent.json"]),
+                str(placeholders["score_vs_reference.json"]),
+                "--reference-record",
+                str(placeholders["reference.json"]),
                 "--release-id",
                 "microcosm-uk-2024-25-national",
                 "--release-cut-gate-json",
@@ -146,7 +152,13 @@ def test_certifier_refuses_a_spine_that_is_not_the_candidates_recorded_parent(
     ledger = tmp_path / "ledger"
     ledger.mkdir()
     (ledger / "consumer_facts.jsonl").write_text('{"fact": 1}\n')
-    for name in ("terminal_gates.json", "input_mass_reference.json", "score.json"):
+    for name in (
+        "terminal_gates.json",
+        "input_mass_reference.json",
+        "reference_surface.json",
+        "score.json",
+        "reference.json",
+    ):
         (tmp_path / name).write_text("{}")
     monkeypatch.setattr(certify, "resolve_predecessor", lambda digest: None)
     monkeypatch.setattr(certify, "record_terminal_attempt", lambda **kwargs: None)
@@ -178,8 +190,12 @@ def test_certifier_refuses_a_spine_that_is_not_the_candidates_recorded_parent(
                 "2" * 64,
                 "--input-mass-reference",
                 str(tmp_path / "input_mass_reference.json"),
+                "--reference-surface",
+                str(tmp_path / "reference_surface.json"),
                 "--score-receipt",
                 str(tmp_path / "score.json"),
+                "--reference-record",
+                str(tmp_path / "reference.json"),
                 "--release-id",
                 "microcosm-uk-2024-25-national",
                 "--release-cut-gate-json",
@@ -188,3 +204,77 @@ def test_certifier_refuses_a_spine_that_is_not_the_candidates_recorded_parent(
                 str(tmp_path / "release_certification.json"),
             ]
         )
+
+
+def test_certifier_refuses_a_reference_surface_of_another_build(tmp_path: Path):
+    """The export-surface and coverage gates compare with the build the score
+    and the input-mass gate compare with (microcosm#1095)."""
+
+    import argparse
+
+    record = tmp_path / "reference.json"
+    record.write_text(
+        json.dumps(
+            {
+                "release": "microcosm-uk-2024-25-national",
+                "build": "build-a",
+                "sha256": "1" * 64,
+            }
+        )
+    )
+    surface = tmp_path / "reference_surface.json"
+
+    def write_surface(build: str, sha256: str) -> None:
+        surface.write_text(
+            json.dumps(
+                {
+                    "schema_version": 1,
+                    "kind": "uk_reference_surface",
+                    "label": f"microcosm-uk-2024-25-national@{build}",
+                    "sha256": sha256,
+                    "minimum_nondefault_mass_share": 1e-6,
+                    "export_columns": ["person.age"],
+                    "populated_inputs": ["age"],
+                    "thin_inputs": [],
+                }
+            )
+        )
+
+    args = argparse.Namespace(reference_record=record, reference_surface=surface)
+    write_surface("build-b", "2" * 64)
+    with pytest.raises(SystemExit, match="not the cut's reference"):
+        certify._reference_surface(args)
+    write_surface("build-a", "2" * 64)
+    with pytest.raises(SystemExit, match="not the cut's reference"):
+        certify._reference_surface(args)
+    write_surface("build-a", "1" * 64)
+    assert certify._reference_surface(args).label == (
+        "microcosm-uk-2024-25-national@build-a"
+    )
+
+
+def test_certifier_refuses_a_reference_record_of_the_dense_line(tmp_path: Path):
+    """The certifier compares a national cut with the national line's current
+    build (the review of microcosm#1574)."""
+
+    import argparse
+
+    record = tmp_path / "reference.json"
+    record.write_text(
+        json.dumps(
+            {
+                "release": "microcosm-uk-2024-25-dense",
+                "build": "uk-local-candidate-x",
+                "sha256": "1" * 64,
+            }
+        )
+    )
+    args = argparse.Namespace(
+        reference_record=record,
+        reference_surface=tmp_path / "reference_surface.json",
+        input_mass_reference=tmp_path / "input_mass_reference.json",
+    )
+    with pytest.raises(SystemExit, match="national line's current build"):
+        certify._reference_surface(args)
+    with pytest.raises(SystemExit, match="national line's current build"):
+        certify._input_mass_reference(args)
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_cut_reference.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_cut_reference.py
new file mode 100644
index 0000000000..d1b697d234
--- /dev/null
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_cut_reference.py
@@ -0,0 +1,350 @@
+"""A UK cut's reference: the current build of its own release line (#1095)."""
+
+from __future__ import annotations
+
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+
+import pytest
+
+from microcosm.build.uk_runtime.cut_reference import (
+    UKCutReference,
+    check_uk_cut_reference,
+    read_uk_cut_reference,
+    resolve_uk_cut_reference,
+    verify_uk_cut_reference_file,
+    write_uk_cut_reference,
+)
+from test_support.microcosm_build.uk_cut_reference import (
+    UK_DENSE_RELEASE,
+    UK_NATIONAL_RELEASE,
+    UK_REPO_ID,
+    UKReferenceHub,
+    dense_gate_summary,
+    national_certification,
+    sha256_of,
+)
+
+NATIONAL_BUILD = "uk-frs-calibration-attempt-20261107T020434Z-eeb6093e"
+EARLIER_NATIONAL_BUILD = "uk-frs-calibration-attempt-20261025T091414Z-a6299504"
+DENSE_BUILD = "uk-local-candidate-f100-s42-20261107T173210Z-38605444"
+NATIONAL_BYTES = b"national current build"
+DENSE_BYTES = b"dense current build"
+
+
+def _fixed_now() -> datetime:
+    return datetime(2026, 11, 10, 12, 0, tzinfo=UTC)
+
+
+@pytest.fixture
+def hub(tmp_path: Path) -> UKReferenceHub:
+    hub = UKReferenceHub(tmp_path)
+    hub.publish(UK_NATIONAL_RELEASE, EARLIER_NATIONAL_BUILD, dataset=b"older")
+    hub.publish(UK_NATIONAL_RELEASE, NATIONAL_BUILD, dataset=NATIONAL_BYTES)
+    hub.publish(UK_DENSE_RELEASE, DENSE_BUILD, dataset=DENSE_BYTES)
+    return hub
+
+
+def test_a_national_cut_compares_with_the_national_current_build(hub) -> None:
+    path, reference = resolve_uk_cut_reference(
+        UK_NATIONAL_RELEASE, hub_download=hub, now=_fixed_now
+    )
+
+    assert path.read_bytes() == NATIONAL_BYTES
+    assert reference.release == UK_NATIONAL_RELEASE
+    assert reference.build == NATIONAL_BUILD
+    assert reference.label == f"{UK_NATIONAL_RELEASE}@{NATIONAL_BUILD}"
+    assert reference.repo_id == UK_REPO_ID
+    assert reference.path_in_repo == (
+        f"releases/{UK_NATIONAL_RELEASE}/{NATIONAL_BUILD}/microcosm_uk_2024_25.h5"
+    )
+    assert reference.filename == "microcosm_uk_2024_25.h5"
+    assert reference.sha256 == sha256_of(NATIONAL_BYTES)
+    assert reference.size_bytes == len(NATIONAL_BYTES)
+    assert reference.built_with_model_package == {
+        "name": "policyengine-uk",
+        "version": "2.174.1",
+    }
+    assert reference.evidence["key"] == "release_certification"
+    assert reference.resolved_at == "2026-11-10T12:00:00Z"
+
+
+def test_a_dense_cut_compares_with_the_dense_current_build(hub) -> None:
+    path, reference = resolve_uk_cut_reference(UK_DENSE_RELEASE, hub_download=hub)
+
+    assert path.read_bytes() == DENSE_BYTES
+    assert reference.build == DENSE_BUILD
+    assert reference.filename == "microcosm_uk_2024_25_dense.h5"
+    assert reference.evidence["key"] == "gate_summary"
+
+
+def test_the_check_names_the_build_without_downloading_its_dataset(hub) -> None:
+    summary = check_uk_cut_reference(UK_NATIONAL_RELEASE, hub_download=hub)
+
+    assert summary["build"] == NATIONAL_BUILD
+    assert summary["sha256"] == sha256_of(NATIONAL_BYTES)
+    assert not any(call.endswith(".h5") for call in hub.calls)
+
+
+def test_a_promotion_moves_what_the_next_fetch_resolves(hub) -> None:
+    hub.publish(
+        UK_NATIONAL_RELEASE,
+        "uk-frs-calibration-attempt-20261112T000000Z-0new0000",
+        dataset=b"newer",
+    )
+
+    _, reference = resolve_uk_cut_reference(UK_NATIONAL_RELEASE, hub_download=hub)
+
+    assert reference.build == "uk-frs-calibration-attempt-20261112T000000Z-0new0000"
+
+
+@pytest.mark.parametrize(
+    ("evidence", "message"),
+    [
+        (
+            national_certification(NATIONAL_BYTES, shippable=False),
+            "not certified shippable",
+        ),
+        (
+            national_certification(NATIONAL_BYTES, candidate={"sha256": "0" * 64}),
+            "certifies another file",
+        ),
+        (
+            national_certification(
+                NATIONAL_BYTES, attestation={"signing_key_sha256": "1" * 64}
+            ),
+            "registered UK gate key",
+        ),
+        (
+            national_certification(NATIONAL_BYTES, release_id=UK_DENSE_RELEASE),
+            "certifies another release",
+        ),
+    ],
+)
+@pytest.mark.committed_gate_key_registry
+def test_a_national_build_without_a_shippable_certification_is_refused(
+    tmp_path: Path, evidence, message
+) -> None:
+    hub = UKReferenceHub(tmp_path)
+    hub.publish(
+        UK_NATIONAL_RELEASE, NATIONAL_BUILD, dataset=NATIONAL_BYTES, evidence=evidence
+    )
+
+    with pytest.raises(ValueError, match=message):
+        resolve_uk_cut_reference(UK_NATIONAL_RELEASE, hub_download=hub)
+
+
+def test_a_dense_build_with_a_failed_gate_is_refused(tmp_path: Path) -> None:
+    hub = UKReferenceHub(tmp_path)
+    hub.publish(
+        UK_DENSE_RELEASE,
+        DENSE_BUILD,
+        dataset=DENSE_BYTES,
+        evidence=dense_gate_summary(
+            uk_local_target_fit={"failures": ["x"], "passed": False, "status": "failed"}
+        ),
+    )
+
+    with pytest.raises(ValueError, match="did not pass uk_local_target_fit"):
+        resolve_uk_cut_reference(UK_DENSE_RELEASE, hub_download=hub)
+
+
+def test_a_release_without_a_current_build_is_refused(tmp_path: Path) -> None:
+    hub = UKReferenceHub(tmp_path)
+    hub.publish(
+        UK_NATIONAL_RELEASE, NATIONAL_BUILD, dataset=NATIONAL_BYTES, current=False
+    )
+
+    with pytest.raises(ValueError, match="has no current build"):
+        resolve_uk_cut_reference(UK_NATIONAL_RELEASE, hub_download=hub)
+
+
+def test_a_withdrawn_current_build_is_refused(tmp_path: Path) -> None:
+    hub = UKReferenceHub(tmp_path)
+    hub.publish(UK_NATIONAL_RELEASE, NATIONAL_BUILD, dataset=NATIONAL_BYTES)
+    record = json.loads((tmp_path / "hub" / "releases.json").read_text())
+    record["releases"][UK_NATIONAL_RELEASE]["builds"][NATIONAL_BUILD]["withdrawn"] = (
+        True
+    )
+    hub.add_file("releases.json", json.dumps(record).encode())
+
+    with pytest.raises(ValueError, match="withdrawn"):
+        resolve_uk_cut_reference(UK_NATIONAL_RELEASE, hub_download=hub)
+
+
+def test_a_line_outside_the_cut_lines_is_refused(hub) -> None:
+    with pytest.raises(ValueError, match="compares with the current build"):
+        resolve_uk_cut_reference("populace-uk-2023", hub_download=hub)
+
+
+def test_the_record_round_trips_and_pins_the_file(hub, tmp_path: Path) -> None:
+    path, reference = resolve_uk_cut_reference(
+        UK_NATIONAL_RELEASE, hub_download=hub, now=_fixed_now
+    )
+    record_path = write_uk_cut_reference(tmp_path / "cut" / "reference.json", reference)
+
+    assert read_uk_cut_reference(record_path) == reference
+    assert verify_uk_cut_reference_file(reference, path) == path
+
+    other = tmp_path / "other.h5"
+    other.write_bytes(b"x" * len(NATIONAL_BYTES))
+    with pytest.raises(ValueError, match="has sha256"):
+        verify_uk_cut_reference_file(reference, other)
+    with pytest.raises(ValueError, match="is not at"):
+        verify_uk_cut_reference_file(reference, tmp_path / "missing.h5")
+
+
+@pytest.mark.parametrize(
+    "mutate",
+    [
+        lambda record: record.pop("evidence"),
+        lambda record: record.update(kind="something_else"),
+        lambda record: record.update(schema_version=2),
+        lambda record: record.update(sha256="not-a-digest"),
+        lambda record: record.update(size_bytes=0),
+        lambda record: record.update(release="populace-uk-2023"),
+        lambda record: record.update(
+            built_with_model_package={"name": "policyengine-uk"}
+        ),
+    ],
+)
+def test_a_malformed_record_is_refused(hub, mutate) -> None:
+    _, reference = resolve_uk_cut_reference(UK_NATIONAL_RELEASE, hub_download=hub)
+    record = reference.to_record()
+    mutate(record)
+
+    with pytest.raises(ValueError):
+        UKCutReference.from_record(record)
+
+
+def test_a_build_withdrawn_after_the_fetch_no_longer_stands(hub) -> None:
+    """The review of microcosm#1574 (S2): withdrawal is re-read, read-only."""
+
+    from microcosm.build.uk_runtime.cut_reference import uk_cut_reference_withdrawal
+
+    _, reference = resolve_uk_cut_reference(UK_NATIONAL_RELEASE, hub_download=hub)
+    assert uk_cut_reference_withdrawal(reference, hub_download=hub) is None
+    hub.publish(UK_NATIONAL_RELEASE, "uk-frs-calibration-attempt-later", dataset=b"x")
+    # A promotion alone leaves the recorded build standing.
+    assert uk_cut_reference_withdrawal(reference, hub_download=hub) is None
+    hub.withdraw(UK_NATIONAL_RELEASE, reference.build)
+    assert uk_cut_reference_withdrawal(reference, hub_download=hub) == (
+        f"{reference.label} has been withdrawn since the cut resolved it"
+    )
+
+
+def test_a_listed_build_can_be_pinned_and_is_recorded_as_pinned(hub, tmp_path) -> None:
+    """The review of microcosm#1574 (S4): a line with no current build can
+    still be cut against a listed build, checked like the current one."""
+
+    from microcosm.build.uk_runtime.cut_reference import check_uk_cut_reference
+
+    assert (
+        check_uk_cut_reference(UK_NATIONAL_RELEASE, hub_download=hub)["selection"]
+        == "current"
+    )
+    checked = check_uk_cut_reference(
+        UK_NATIONAL_RELEASE, build=EARLIER_NATIONAL_BUILD, hub_download=hub
+    )
+    assert (checked["build"], checked["selection"]) == (
+        EARLIER_NATIONAL_BUILD,
+        "pinned",
+    )
+    _, reference = resolve_uk_cut_reference(
+        UK_NATIONAL_RELEASE, build=EARLIER_NATIONAL_BUILD, hub_download=hub
+    )
+    assert reference.build == EARLIER_NATIONAL_BUILD
+    assert reference.selection == "pinned"
+    assert UKCutReference.from_record(reference.to_record()) == reference
+    # The current build withdrawn, the line has none: a pin still cuts.
+    hub.withdraw(UK_NATIONAL_RELEASE, NATIONAL_BUILD)
+    with pytest.raises(ValueError, match="no current build"):
+        resolve_uk_cut_reference(UK_NATIONAL_RELEASE, hub_download=hub)
+    assert (
+        resolve_uk_cut_reference(
+            UK_NATIONAL_RELEASE, build=EARLIER_NATIONAL_BUILD, hub_download=hub
+        )[1].selection
+        == "pinned"
+    )
+    # A withdrawn build is never a reference, pinned or not.
+    with pytest.raises(ValueError, match="has been withdrawn"):
+        resolve_uk_cut_reference(
+            UK_NATIONAL_RELEASE, build=NATIONAL_BUILD, hub_download=hub
+        )
+    with pytest.raises(ValueError, match="has been withdrawn"):
+        check_uk_cut_reference(
+            UK_NATIONAL_RELEASE, build=NATIONAL_BUILD, hub_download=hub
+        )
+
+
+def test_the_chain_starts_at_a_reference_with_none_and_continues_one(
+    hub, tmp_path
+) -> None:
+    """The review of microcosm#1574 (S5): no baseline dataset is loaded."""
+
+    from microcosm.build.uk_runtime.cut_reference import (
+        UK_CUT_REFERENCE_EVIDENCE_NAME,
+        fetch_uk_cut_reference,
+        uk_cut_reference_chain,
+    )
+
+    reference = fetch_uk_cut_reference(
+        UK_NATIONAL_RELEASE, tmp_path / "ref", hub_download=hub
+    )
+    # The fetch keeps the build's own certification beside it.
+    kept = tmp_path / "ref" / UK_CUT_REFERENCE_EVIDENCE_NAME
+    assert sha256_of(kept.read_bytes()) == reference.evidence["sha256"]
+    started = uk_cut_reference_chain(
+        reference,
+        tmp_path / "ref",
+        totals={"employment_income": 10.0, "rare_flag": 2.0, "zero": 0.0},
+        carriers={"employment_income": 900, "rare_flag": 2, "zero": 40},
+        carried_inputs={"employment_income", "rare_flag"},
+    )
+    assert started == {
+        "baseline": reference.label,
+        "input_mass_ratios": {"employment_income": 1.0},
+        "input_mass_left": {},
+        "baseline_inputs": ["employment_income", "rare_flag"],
+    }
+    certification = json.loads(kept.read_text())
+    gone = {
+        "reason": "thin",
+        "last_ratio": 0.4,
+        "last_build": f"{UK_NATIONAL_RELEASE}@earlier",
+    }
+    certification["since_baseline"] = {
+        "baseline": f"{UK_NATIONAL_RELEASE}@baseline",
+        "restarted_from": None,
+        "input_mass_ratios": {"employment_income": 0.8},
+        "input_mass_left": {"gift_aid_amount": gone},
+        "baseline_inputs": ["employment_income", "gift_aid"],
+        "inputs_dropped": ["gift_aid"],
+    }
+    kept.write_text(json.dumps(certification))
+    continued = uk_cut_reference_chain(
+        reference,
+        tmp_path / "ref",
+        totals={"employment_income": 10.0},
+        carriers={"employment_income": 900},
+        carried_inputs={"employment_income"},
+    )
+    # The columns that left the chain carry forward with it (round 2).
+    assert continued == {
+        "baseline": f"{UK_NATIONAL_RELEASE}@baseline",
+        "input_mass_ratios": {"employment_income": 0.8},
+        "input_mass_left": {"gift_aid_amount": gone},
+        "baseline_inputs": ["employment_income", "gift_aid"],
+    }
+    # A missing copy is refused, not read as a reference with no chain,
+    # which would restart the chain without a trace (round 2).
+    kept.unlink()
+    with pytest.raises(ValueError, match="is missing"):
+        uk_cut_reference_chain(
+            reference,
+            tmp_path / "ref",
+            totals={"employment_income": 10.0},
+            carriers={"employment_income": 900},
+            carried_inputs={"employment_income"},
+        )
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_dense_signoff_draft.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_dense_signoff_draft.py
index 8d29d47c1b..24a5a18fbe 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_uk_dense_signoff_draft.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_dense_signoff_draft.py
@@ -1382,7 +1382,19 @@ def test_the_national_graph_review_invariant_is_kept(
 def test_the_review_registers_load_from_the_package():
     registers = REAL_REVIEW_REGISTERS()
     assert len(registers) == 4
-    assert all(registers)
+    # The input-mass register (the second) is signed per reference build
+    # since the enhanced-FRS reference retired (microcosm#1095): today the
+    # gross receipts microcosm#1550 stops writing, against both current builds.
+    degenerate, input_mass, exclusions, floor = registers
+    assert degenerate and exclusions and floor
+    assert {label: set(entries) for label, entries in input_mass.items()} == {
+        "microcosm-uk-2024-25-dense@uk-local-candidate-f100-s42-20261107T173210Z-38605444": {
+            "self_employment_gross_receipts"
+        },
+        "microcosm-uk-2024-25-national@uk-frs-calibration-attempt-20261107T020434Z-eeb6093e": {
+            "self_employment_gross_receipts"
+        },
+    }
 
 
 def test_out_inside_the_repository_is_refused(build_1, repo, capsys):
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_frs_employment.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_frs_employment.py
index e673fc6bdb..58fdf4b1c6 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_uk_frs_employment.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_frs_employment.py
@@ -16,11 +16,11 @@
     derive_frs_employment,
     derive_soc2020_major_group_from_frs,
 )
+from microcosm.build.uk_runtime.national_frame import UK_RELEASE_EXPORT_DROPPED_COLUMNS
 from microcosm.build.uk_runtime.occupation_constants import (
     UK_FRS_SOC2020_MAJOR_GROUP,
     UK_SOC2020_NO_OCCUPATION,
 )
-from microcosm.build.uk_runtime.terminal_gates import UK_ALLOWED_EXTRA_EXPORT_COLUMNS
 from test_support.paths import paths_for
 
 UK_PACKAGE = (
@@ -346,6 +346,7 @@ def test_gates_check_the_occupation_domain_and_export_the_column() -> None:
     enum = by_id["uk_soc2020_major_group_enum_domain"]
     assert (enum["gate"], enum["phase"]) == ("enum_domain", "terminal")
     assert enum["parameters"]["columns"] == ["soc2020_major_group"]
-    exported = by_id["uk_export_surface"]["parameters"]["allowed_extra_columns"]
-    assert "person.soc2020_major_group" in exported
-    assert "person.soc2020_major_group" in UK_ALLOWED_EXTRA_EXPORT_COLUMNS
+    # The column leaves with the release; the current national build exports
+    # it, so since microcosm#1095 it is part of the reference surface rather
+    # than a declared extra of the export-surface gate.
+    assert "soc2020_major_group" not in UK_RELEASE_EXPORT_DROPPED_COLUMNS["person"]
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_frs_relationships.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_frs_relationships.py
index 15736cf7b1..e19688f6ed 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_uk_frs_relationships.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_frs_relationships.py
@@ -799,13 +799,21 @@ def test_gates_declare_the_stage_health_and_enum_gates_and_export_columns() -> N
     enum = by_id["uk_ons_household_type_enum_domain"]
     assert (enum["gate"], enum["phase"]) == ("enum_domain", "assembled")
     assert enum["parameters"]["columns"] == ["ons_household_type"]
-    exported = set(by_id["uk_export_surface"]["parameters"]["allowed_extra_columns"])
-    assert {
+    # The columns leave with the release; the current national build exports
+    # them, so since microcosm#1095 they are part of the reference surface
+    # rather than declared extras of the export-surface gate.
+    from microcosm.build.uk_runtime.national_frame import (
+        UK_RELEASE_EXPORT_DROPPED_COLUMNS,
+    )
+
+    for name in (
         "person.relationship_to_head",
         "person.ons_family_role",
         "person.ons_family_index",
         "household.ons_household_type",
-    } <= exported
+    ):
+        entity, column = name.split(".")
+        assert column not in UK_RELEASE_EXPORT_DROPPED_COLUMNS.get(entity, ())
 
 
 # --- stage health -----------------------------------------------------------
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_full_build_cli.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_full_build_cli.py
index 9e78002cee..a4e63e6449 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_uk_full_build_cli.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_full_build_cli.py
@@ -104,7 +104,7 @@ def test_release_role_is_required_and_supplies_the_dense_posture(tmp_path):
     [
         (["--target-loss-cap", "5"], "--target-loss-cap"),
         (["--allow-unpinned-feed"], "--allow-unpinned-feed"),
-        (["--incumbent-h5", "incumbent.h5"], "--incumbent-h5"),
+        (["--reference-h5", "reference.h5"], "--reference-h5"),
         (["--target-weight-rule", "family_equal"], "--target-weight-rule family_equal"),
     ],
 )
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_full_gates.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_full_gates.py
index f9c92ef3c7..22b2cf889c 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_uk_full_gates.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_full_gates.py
@@ -138,11 +138,6 @@ def evidence(monkeypatch):
         weight_kind=weights.kind,
         household_weights=weights.values,
     )
-    monkeypatch.setattr(
-        runtime,
-        "load_efrs_parity_reference",
-        lambda: SimpleNamespace(input_entities={"income": "household"}),
-    )
     monkeypatch.setattr(
         runtime,
         "uk_aggregate_admin_totals",
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_graph_terminal.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_graph_terminal.py
index 6f2e20b815..54da8fc6d1 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_uk_graph_terminal.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_graph_terminal.py
@@ -1215,11 +1215,6 @@ def artifact(payload, raw=False):
             local_authority_code=np.array(["E09000001", "E07000002"]),
         ),
     )
-    monkeypatch.setattr(
-        full_gates,
-        "load_efrs_parity_reference",
-        lambda: SimpleNamespace(input_entities={}),
-    )
     monkeypatch.setattr(
         full_gates, "uk_aggregate_admin_totals", lambda frame, gates: ({}, [])
     )
@@ -1577,3 +1572,27 @@ def test_the_calibrated_gates_refuse_a_stale_terminal_code() -> None:
     )
     with pytest.raises(ValueError, match="terminal-only code"):
         kernel.run(context)
+
+
+def test_the_dense_gates_refuse_references_of_two_builds() -> None:
+    from types import SimpleNamespace
+
+    from microcosm.build.uk_runtime.graph_terminal import _require_one_reference
+
+    mass = SimpleNamespace(label="microcosm-uk-2024-25-dense@a", sha256="1" * 64)
+    same = SimpleNamespace(label="microcosm-uk-2024-25-dense@a", sha256="1" * 64)
+    other = SimpleNamespace(label="microcosm-uk-2024-25-dense@b", sha256="2" * 64)
+    _require_one_reference({"input_mass_reference": mass, "reference_surface": same})
+    _require_one_reference({"input_mass_reference": mass})
+    _require_one_reference({"reference_surface": other})
+    with pytest.raises(ValueError, match="from one reference"):
+        _require_one_reference(
+            {"input_mass_reference": mass, "reference_surface": other}
+        )
+    # Two files of one national build agree with each other, but the dense
+    # line compares with its own current build (the review of microcosm#1574).
+    national = SimpleNamespace(label="microcosm-uk-2024-25-national@b", sha256="3" * 64)
+    with pytest.raises(ValueError, match="not a build of microcosm-uk-2024-25-dense"):
+        _require_one_reference(
+            {"input_mass_reference": national, "reference_surface": national}
+        )
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_hmrc_uprating_engine_pins.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_hmrc_uprating_engine_pins.py
index 6854455af2..5aac92dfaf 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_uk_hmrc_uprating_engine_pins.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_hmrc_uprating_engine_pins.py
@@ -238,5 +238,6 @@ def test_the_build_and_the_certifier_refuse_an_unpinned_engine(monkeypatch) -> N
             parity_evidence=None,
             fit_weight_records=None,
             input_mass_reference={},
+            reference_surface=None,
             exclusions_evaluated_on=date(2026, 10, 18),
         )
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_local_incumbent_extractor.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_local_incumbent_extractor.py
index 7255ae3532..acfc8cfeba 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_uk_local_incumbent_extractor.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_local_incumbent_extractor.py
@@ -171,7 +171,7 @@ def missing_uc_inputs(resolver, grain, *, period, household_ids):
 
     monkeypatch.setattr(tool, "compute_household_metrics", missing_uc_inputs)
     with pytest.raises(
-        ValueError, match="incumbent_unresolvable_measures.json"
+        ValueError, match="does not prune unresolvable measures"
     ) as raised:
         tool.extract_incumbent_surface(
             incumbent_h5=incumbent,
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_reference_surface.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_reference_surface.py
new file mode 100644
index 0000000000..7553590962
--- /dev/null
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_reference_surface.py
@@ -0,0 +1,262 @@
+"""The column surface of a UK cut's reference build (microcosm#1095)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from microcosm.build.uk_runtime import national_frame, rowwise_dataset, weight_year
+from microcosm.build.uk_runtime.cut_reference import (
+    UK_CUT_REFERENCE_INPUT_MASS_NAME,
+    UK_CUT_REFERENCE_SURFACE_NAME,
+    uk_cut_reference_evidence_done,
+)
+from microcosm.build.uk_runtime.reference_surface import (
+    load_uk_reference_surface,
+    uk_reference_surface_payload,
+)
+from test_support.microcosm_build.uk_release_input_coverage import _StubEngine
+
+LABEL = "microcosm-uk-2024-25-national@uk-frs-calibration-attempt-test"
+SHA = "a" * 64
+
+
+def _payload(**overrides) -> dict:
+    payload = {
+        "schema_version": 1,
+        "kind": "uk_reference_surface",
+        "label": LABEL,
+        "sha256": SHA,
+        "minimum_nondefault_mass_share": 1e-6,
+        "export_columns": ["person.employment_income", "person.dividend_income"],
+        "populated_inputs": ["employment_income"],
+        "thin_inputs": ["dividend_income"],
+    }
+    payload.update(overrides)
+    return payload
+
+
+def test_a_surface_round_trips_names_and_flags(tmp_path: Path) -> None:
+    path = tmp_path / UK_CUT_REFERENCE_SURFACE_NAME
+    path.write_text(json.dumps(_payload()))
+    surface = load_uk_reference_surface(path)
+    assert surface.label == LABEL
+    assert surface.sha256 == SHA
+    assert surface.minimum_nondefault_mass_share == 1e-6
+    assert surface.export_columns == {
+        "person.employment_income",
+        "person.dividend_income",
+    }
+    assert surface.carried_inputs == {"employment_income", "dividend_income"}
+
+
+@pytest.mark.parametrize(
+    ("overrides", "message"),
+    [
+        ({"schema_version": 2}, "schema-1"),
+        ({"kind": "uk_input_mass_reference"}, "schema-1"),
+        ({"label": "no-build"}, "<release>@<build>"),
+        ({"sha256": "short"}, "sha256"),
+        ({"minimum_nondefault_mass_share": 0.0}, "effective-mass floor"),
+        ({"minimum_nondefault_mass_share": True}, "effective-mass floor"),
+        ({"populated_inputs": "employment_income"}, "list of column names"),
+        ({"thin_inputs": ["employment_income"]}, "both populated and thin"),
+        ({"export_columns": []}, "exports no column"),
+    ],
+)
+def test_a_malformed_surface_is_refused(tmp_path: Path, overrides, message) -> None:
+    path = tmp_path / UK_CUT_REFERENCE_SURFACE_NAME
+    path.write_text(json.dumps(_payload(**overrides)))
+    with pytest.raises(ValueError, match=message):
+        load_uk_reference_surface(path)
+
+
+def _reference_frame():
+    # Five households: two clones of one source household (101), two more
+    # sources, and a zero-weight row. Employment income sits on three
+    # sources, dividends on one (both clones of 101), savings interest only
+    # on the zero-weight row.
+    household = pd.DataFrame(
+        {
+            "household_id": np.arange(1, 6, dtype="int64"),
+            "household_source_id": np.asarray([101, 101, 102, 103, 104]),
+        }
+    )
+    person = pd.DataFrame(
+        {
+            "person_id": np.arange(1, 6, dtype="int64"),
+            "person_household_id": np.arange(1, 6, dtype="int64"),
+            "person_benunit_id": np.arange(1, 6, dtype="int64"),
+            "employment_income": np.asarray([1.0, 1.0, 1.0, 1.0, 0.0]),
+            "dividend_income": np.asarray([5.0, 5.0, 0.0, 0.0, 0.0]),
+            "savings_interest_income": np.asarray([0.0, 0.0, 0.0, 0.0, 9.0]),
+        }
+    )
+    benunit = pd.DataFrame({"benunit_id": np.arange(1, 6, dtype="int64")})
+    return national_frame.uk_national_frame(
+        person=person,
+        benunit=benunit,
+        household=household,
+        time_period="2024",
+        household_weights=np.asarray([10.0, 10.0, 10.0, 10.0, 0.0]),
+    )
+
+
+def test_the_payload_flags_inputs_by_how_many_source_households_carry_them(
+    monkeypatch,
+) -> None:
+    frame = _reference_frame()
+    monkeypatch.setattr(
+        rowwise_dataset, "load_uk_rowwise_dataset", lambda path: (frame, None)
+    )
+    # The test frame records no solve; the real one is put back at its own
+    # solved weights by the factor its mass log records.
+    monkeypatch.setattr(weight_year, "uk_recorded_solve_year_frame", lambda f: f)
+    engine = _StubEngine(
+        {
+            "employment_income": 0.0,
+            "dividend_income": 0.0,
+            "savings_interest_income": 0.0,
+        }
+    )
+
+    payload = uk_reference_surface_payload(
+        "reference.h5", label=LABEL, sha256=SHA, engine=engine
+    )
+
+    assert payload["label"] == LABEL
+    assert payload["sha256"] == SHA
+    assert payload["minimum_nondefault_mass_share"] == 1e-6
+    assert payload["populated_inputs"] == ["employment_income"]
+    # One source household carries dividends: listed by name only, "<3".
+    assert payload["thin_inputs"] == ["dividend_income"]
+    assert "person.savings_interest_income" in payload["export_columns"]
+    assert "person.employment_income" in payload["export_columns"]
+    # Names and flags only: no figure besides the policy floor.
+    assert set(payload) == set(_payload())
+
+
+def test_the_evidence_is_done_only_when_both_files_name_the_build(
+    tmp_path: Path,
+) -> None:
+    reference = type("Reference", (), {"label": LABEL, "sha256": SHA})()
+    mass = tmp_path / UK_CUT_REFERENCE_INPUT_MASS_NAME
+    mass.write_text(json.dumps({"label": LABEL, "identity": {"sha256": SHA}}))
+    done, reason = uk_cut_reference_evidence_done(reference, tmp_path)
+    # Evidence from before the chain (the review of microcosm#1574) is redone.
+    assert not done and "no change since the baseline" in reason
+    chain = {"baseline": LABEL, "ratios": {}}
+    mass.write_text(
+        json.dumps(
+            {"label": LABEL, "identity": {"sha256": SHA}, "since_baseline": chain}
+        )
+    )
+    done, reason = uk_cut_reference_evidence_done(reference, tmp_path)
+    # And from before it listed the columns that leave it (round 2).
+    assert not done and "left the chain" in reason
+    mass.write_text(
+        json.dumps(
+            {
+                "label": LABEL,
+                "identity": {"sha256": SHA},
+                "since_baseline": {**chain, "left": {}},
+            }
+        )
+    )
+    done, reason = uk_cut_reference_evidence_done(reference, tmp_path)
+    assert not done and UK_CUT_REFERENCE_SURFACE_NAME in reason
+
+    surface = tmp_path / UK_CUT_REFERENCE_SURFACE_NAME
+    baseline = {"label": LABEL, "inputs": ["employment_income"]}
+    surface.write_text(json.dumps({**_payload(sha256="b" * 64), "baseline": baseline}))
+    done, reason = uk_cut_reference_evidence_done(reference, tmp_path)
+    assert not done and "another build" in reason
+
+    surface.write_text(json.dumps({**_payload(), "baseline": baseline}))
+    assert uk_cut_reference_evidence_done(reference, tmp_path)[0]
+    loaded = load_uk_reference_surface(surface)
+    assert loaded.baseline_label == LABEL
+    assert loaded.baseline_inputs == {"employment_income"}
+
+
+def test_the_evidence_reads_a_dense_line_file(tmp_path: Path) -> None:
+    """A dense build's file carries one ``clone_index`` name on every table,
+    which the national loader refuses; the reference evidence opens it."""
+
+    pytest.importorskip("tables")
+    from microcosm.build.uk_runtime import (
+        clone_uk_dataset_tables_with_rowwise_geography,
+        write_uk_rowwise_dataset,
+    )
+    from microcosm.build.uk_runtime.cut_reference import (
+        uk_input_mass_reference_payload,
+    )
+
+    result = clone_uk_dataset_tables_with_rowwise_geography(
+        person=pd.DataFrame(
+            {
+                "person_id": [1001, 2001, 2002, 3001],
+                "person_household_id": [1, 2, 2, 3],
+                "person_benunit_id": [101, 201, 201, 301],
+                "employment_income": [5.0, 9.0, 11.0, 7.0],
+            }
+        ),
+        benunit=pd.DataFrame({"benunit_id": [101, 201, 301]}),
+        household=pd.DataFrame(
+            {
+                "household_id": [1, 2, 3],
+                "household_source_id": [11, 12, 13],
+                "household_weight": [10.0, 20.0, 30.0],
+                "region": ["LONDON", "WALES", "LONDON"],
+            }
+        ),
+        crosswalk=pd.DataFrame(
+            [
+                {
+                    "oa_code": "E0001",
+                    "lsoa_code": "E0101",
+                    "msoa_code": "E0201",
+                    "la_code": "E06000063",
+                    "constituency_code": "E14000001",
+                    "region_code": "E12000007",
+                    "country": "England",
+                    "population": 100,
+                },
+                {
+                    "oa_code": "W0001",
+                    "lsoa_code": "W0101",
+                    "msoa_code": "W0201",
+                    "la_code": "W06000001",
+                    "constituency_code": "W07000041",
+                    "region_code": "W99999999",
+                    "country": "Wales",
+                    "population": 80,
+                },
+            ]
+        ),
+        source_year=2024,
+    )
+    path = write_uk_rowwise_dataset(result, tmp_path / "dense.h5")
+    with pytest.raises(ValueError):
+        national_frame.load_uk_national_frame(path)
+
+    surface = uk_reference_surface_payload(
+        path,
+        label="microcosm-uk-2024-25-dense@uk-local-candidate-test",
+        sha256=SHA,
+        engine=_StubEngine({"employment_income": 0.0}),
+    )
+    assert surface["populated_inputs"] == ["employment_income"]
+    assert "household.household_clone_index" in surface["export_columns"]
+    mass = uk_input_mass_reference_payload(
+        path,
+        label="microcosm-uk-2024-25-dense@uk-local-candidate-test",
+        filename="dense.h5",
+        revision="uk-local-candidate-test",
+        sha256=SHA,
+    )
+    assert "employment_income" in mass["totals"]
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_release_assembler.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_release_assembler.py
index ee95583ccc..f12a42c039 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_uk_release_assembler.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_release_assembler.py
@@ -435,7 +435,7 @@ def test_assemble_green_release_dir(assembler_inputs, capsys) -> None:
         "terminal_gates": "terminal_gates",
         "release_cut_gates": "release_cut_gates",
         "spine_gates": "spine_gates",
-        "score_vs_enhanced_frs": "score_vs_enhanced_frs",
+        "score_vs_reference": "score_vs_reference",
     }
     assert "dataset_role" not in release_manifest
     # The spine ran the SPI stages, so the release says it rests on the tape,
@@ -666,7 +666,7 @@ def test_assemble_refuses_invalid_staging_delivery(
 
 def test_assemble_refuses_missing_score_receipt(assembler_inputs) -> None:
     assembler_inputs["score"].unlink()
-    with pytest.raises(FileNotFoundError, match="score_vs_enhanced_frs"):
+    with pytest.raises(FileNotFoundError, match="score_vs_reference"):
         _load_driver_module().main(assembler_inputs["argv"])
 
 
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_release_certification.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_release_certification.py
index 5baac52743..f739520601 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_uk_release_certification.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_release_certification.py
@@ -50,6 +50,8 @@ def _load_fixture_module():
 _TEST_KEY = _FIXTURES.TEST_KEY
 _green_certification_inputs_fixture = _FIXTURES.green_certification_inputs
 green_score_receipt = _FIXTURES.green_score_receipt
+GREEN_REFERENCE_RECORD = _FIXTURES.GREEN_REFERENCE_RECORD
+GREEN_REFERENCE_LABEL = _FIXTURES.GREEN_REFERENCE_LABEL
 _signing_key_fixture = _FIXTURES.signing_key
 _sha = _FIXTURES.sha256
 _stub_registry = _FIXTURES.stub_registry
@@ -125,22 +127,20 @@ def table(self, entity):  # pragma: no cover - never reached
     class _Registry:
         specs = ()
 
-    class _Reference:
-        input_entities = {}
-
     with pytest.raises(UKReleaseCertificationError, match="name@period"):
         uk_release_parity_evidence(
             _Frame(),
             diagnostics_targets=[{"name": "dwp.uc.households", "relative_error": 0.1}],
             reference_registry=_Registry(),
-            parity_reference=_Reference(),
         )
     evidence = uk_release_parity_evidence(
         _Frame(),
         diagnostics_targets=[{"name": "dwp.uc.households@2025", "relative_error": 0.1}],
         reference_registry=_Registry(),
-        parity_reference=_Reference(),
     )
+    # The export-surface gate reads the reference's columns from the cut's
+    # reference surface itself (microcosm#1095).
+    assert not hasattr(evidence, "reference_columns")
     assert evidence.candidate_targets == {"dwp.uc.households@2025"}
     assert evidence.target_relative_errors == {"dwp.uc.households@2025": 0.1}
     # A run built before María's ruling of 2026-10-26 dropped the withholding
@@ -159,7 +159,6 @@ class _Reference:
                 },
             ],
             reference_registry=_Registry(),
-            parity_reference=_Reference(),
         )
 
 
@@ -380,7 +379,7 @@ def test_compose_refuses_score_receipt_scored_on_another_artifact(
             {
                 "artifacts": {
                     "candidate": {"sha256": "8" * 64},
-                    "incumbent": {"sha256": candidate_sha},
+                    "reference": {"sha256": candidate_sha},
                 },
                 "provenance": {"inputs": [candidate_sha]},
             }
@@ -391,30 +390,66 @@ def test_compose_refuses_score_receipt_scored_on_another_artifact(
         compose_uk_release_certification(**green_certification_inputs)
 
 
-def test_compose_refuses_a_score_receipt_whose_verdict_is_not_passed(
+def test_compose_refuses_a_receipt_measured_against_another_reference(
     green_certification_inputs,
 ):
+    """The comparison must be with the cut's own reference (microcosm#1095)."""
     receipt = green_score_receipt(green_certification_inputs["candidate_sha256"])
-    receipt["evaluation"]["verdict"] = "failed"
-    receipt["evaluation"]["rule_1"]["passed"] = False
+    receipt["reference"]["build"] = (
+        "uk-frs-calibration-attempt-20261025T091414Z-a6299504"
+    )
     green_certification_inputs["score_receipt_path"].write_text(
         json.dumps(receipt), encoding="utf-8"
     )
-    with pytest.raises(UKReleaseCertificationError, match="verdict is 'failed'"):
+    with pytest.raises(UKReleaseCertificationError, match="another reference"):
         compose_uk_release_certification(**green_certification_inputs)
 
+    receipt = green_score_receipt(green_certification_inputs["candidate_sha256"])
+    receipt["artifacts"]["reference"]["sha256"] = "7" * 64
+    green_certification_inputs["score_receipt_path"].write_text(
+        json.dumps(receipt), encoding="utf-8"
+    )
+    with pytest.raises(UKReleaseCertificationError, match="another reference"):
+        compose_uk_release_certification(**green_certification_inputs)
+
+
+def test_compose_certifies_a_candidate_that_fits_worse_than_its_reference(
+    green_certification_inputs,
+):
+    """The comparison has no threshold: it is evidence, never a refusal."""
+    receipt = green_score_receipt(green_certification_inputs["candidate_sha256"])
+    receipt["evaluation"]["losses"] = {
+        "candidate_full_loss": 0.5,
+        "reference_full_loss": 0.01,
+    }
+    green_certification_inputs["score_receipt_path"].write_text(
+        json.dumps(receipt), encoding="utf-8"
+    )
+    certification = compose_uk_release_certification(**green_certification_inputs)
+    assert certification["shippable"] is True
+    assert certification["score_receipt"]["evaluation"]["candidate_full_loss"] == 0.5
+
 
 def test_compose_refuses_a_score_receipt_without_an_evaluation(
     green_certification_inputs,
 ):
-    # A receipt from the strict scorer carries the cross-pin but no verdict:
-    # rule 1 was never decided on a closed surface, so it cannot certify.
+    # A receipt without the head-to-head summary, or one scored against the
+    # enhanced FRS under the old strict rule, was not made against the cut's
+    # reference, so it cannot certify.
     receipt = green_score_receipt(green_certification_inputs["candidate_sha256"])
     del receipt["evaluation"]
     green_certification_inputs["score_receipt_path"].write_text(
         json.dumps(receipt), encoding="utf-8"
     )
-    with pytest.raises(UKReleaseCertificationError, match="no evaluation block"):
+    with pytest.raises(UKReleaseCertificationError, match="no schema-2 evaluation"):
+        compose_uk_release_certification(**green_certification_inputs)
+
+    receipt = green_score_receipt(green_certification_inputs["candidate_sha256"])
+    receipt["evaluation"] = {"schema_version": 1, "verdict": "passed"}
+    green_certification_inputs["score_receipt_path"].write_text(
+        json.dumps(receipt), encoding="utf-8"
+    )
+    with pytest.raises(UKReleaseCertificationError, match="no schema-2 evaluation"):
         compose_uk_release_certification(**green_certification_inputs)
 
 
@@ -434,9 +469,9 @@ def test_compose_refuses_a_score_receipt_pruned_through_an_unlisted_measure(
     green_certification_inputs,
 ):
     """Pruning from both arms is doctrine: a measure the scorer pruned must
-    carry a signed entry on the reviewed incumbent-unresolvable register."""
+    carry a signed entry on the reviewed reference-unresolvable register."""
     receipt = green_score_receipt(green_certification_inputs["candidate_sha256"])
-    receipt["incumbent_unresolvable_pruned"].update(
+    receipt["reference_unresolvable_pruned"].update(
         {"n_pruned": 1, "n_scored": 306, "measures": ["benunit.not_reviewed"]}
     )
     receipt["evaluation"]["scored_surface"].update({"n_pruned": 1, "n_scored": 306})
@@ -451,7 +486,7 @@ def test_compose_refuses_a_score_receipt_pruned_through_an_unlisted_measure(
     def _listed(approved_on: str, expires_on: str):
         return {
             "benunit.not_reviewed": UKReviewedExclusion(
-                reason="the incumbent never carried it",
+                reason="the reference never carried it",
                 approved_by="juaristi22",
                 adjudication="microcosm#823 (test)",
                 approved_on=approved_on,
@@ -496,17 +531,30 @@ def test_compose_refuses_a_build_record_without_a_recorded_parent(
         compose_uk_release_certification(**green_certification_inputs)
 
 
-def test_certification_summarises_the_score_receipt_verdict(
+def test_certification_names_its_reference_and_summarises_the_comparison(
     green_certification_inputs,
 ):
     certification = compose_uk_release_certification(**green_certification_inputs)
+    assert certification["schema_version"] == 2
+    assert certification["reference"] == {
+        "release": GREEN_REFERENCE_RECORD["release"],
+        "build": GREEN_REFERENCE_RECORD["build"],
+        "filename": GREEN_REFERENCE_RECORD["filename"],
+        "sha256": GREEN_REFERENCE_RECORD["sha256"],
+        "built_with_model_package": GREEN_REFERENCE_RECORD["built_with_model_package"],
+        "selection": "current",
+    }
+    assert certification["score_receipt"]["filename"] == "score_vs_reference.json"
     assert certification["score_receipt"]["evaluation"] == {
-        "verdict": "passed",
+        "reference": GREEN_REFERENCE_LABEL,
         "n_scored": 307,
         "n_pruned": 0,
         "n_surface": 307,
         "candidate_full_loss": 0.0096,
-        "incumbent_full_loss": 0.211,
+        "reference_full_loss": 0.0101,
+        "candidate_lower_count": 293,
+        "reference_lower_count": 12,
+        "equal_count": 2,
     }
 
 
@@ -537,6 +585,7 @@ def test_release_cut_battery_refuses_a_compiled_period_with_no_unsupported_repor
             parity_evidence=object(),
             fit_weight_records=None,
             input_mass_reference={},
+            reference_surface=object(),
             exclusions_evaluated_on=date(2026, 8, 27),
             gate_registry=_stub_registry(),
             spine_frame=object(),
@@ -564,6 +613,7 @@ def test_release_cut_battery_runs_and_signs(tmp_path: Path, monkeypatch):
         parity_evidence=SimpleNamespace(),
         fit_weight_records=None,
         input_mass_reference={},
+        reference_surface=SimpleNamespace(),
         exclusions_evaluated_on=date(2026, 8, 27),
         gate_registry=_stub_registry(),
         spine_frame=object(),
@@ -596,34 +646,174 @@ def test_certification_fields_mirror_the_data_contract(green_certification_input
 
 
 def test_compose_refuses_a_receipt_scored_under_another_register(
-    green_certification_inputs,
+    green_certification_inputs, monkeypatch
 ):
     """Against the committed register of record, the receipt's register
     digest must be the committed one (review A2, second half)."""
-    from datetime import date
+    from microcosm.build.uk_runtime import candidate_score
+    from microcosm.build.uk_runtime.weighted_integrity import UKReviewedExclusion
 
-    from microcosm.build.uk_runtime.candidate_score import (
-        load_uk_incumbent_unresolvable_measures,
-        uk_incumbent_unresolvable_register_digest,
+    measure = "benunit.reviewed_for_this_reference"
+    monkeypatch.setattr(
+        candidate_score,
+        "load_uk_reference_unresolvable_measures",
+        lambda *, reference_label, source=None: (
+            {
+                measure: UKReviewedExclusion(
+                    reason="the reference never carried it",
+                    approved_by="juaristi22",
+                    adjudication="microcosm#1095 (test)",
+                    approved_on="2026-08-01",
+                    expires_on="2027-03-01",
+                )
+            }
+            if reference_label == GREEN_REFERENCE_LABEL
+            else {}
+        ),
     )
-
-    measure = sorted(load_uk_incumbent_unresolvable_measures())[0]
     receipt = green_score_receipt(green_certification_inputs["candidate_sha256"])
-    receipt["incumbent_unresolvable_pruned"].update(
+    receipt["reference_unresolvable_pruned"].update(
         {"n_pruned": 1, "n_scored": 306, "measures": [measure]}
     )
-    receipt["incumbent_unresolvable_pruned"]["reviewed_register"]["sha256"] = "0" * 64
+    receipt["reference_unresolvable_pruned"]["reviewed_register"]["sha256"] = "0" * 64
     receipt["evaluation"]["scored_surface"].update({"n_pruned": 1, "n_scored": 306})
     path = green_certification_inputs["score_receipt_path"]
     path.write_text(json.dumps(receipt), encoding="utf-8")
-    # Inside the committed entries' window (they take force 2026-09-22).
-    green_certification_inputs["exclusions_evaluated_on"] = date(2026, 10, 1)
     with pytest.raises(UKReleaseCertificationError, match="not the committed register"):
         compose_uk_release_certification(**green_certification_inputs)
 
-    receipt["incumbent_unresolvable_pruned"]["reviewed_register"]["sha256"] = (
-        uk_incumbent_unresolvable_register_digest()["sha256"]
+    receipt["reference_unresolvable_pruned"]["reviewed_register"]["sha256"] = (
+        candidate_score.uk_reference_unresolvable_register_digest()["sha256"]
     )
     path.write_text(json.dumps(receipt), encoding="utf-8")
     certification = compose_uk_release_certification(**green_certification_inputs)
     assert certification["score_receipt"]["evaluation"]["n_pruned"] == 1
+
+
+def test_compose_refuses_a_reference_that_is_the_candidate_itself(
+    green_certification_inputs,
+):
+    """The review of microcosm#1574 (S1): after the cut's own promotion,
+    re-resolving would compare the candidate with itself."""
+
+    by_sha = dict(green_certification_inputs)
+    by_sha["reference_record"] = {
+        **by_sha["reference_record"],
+        "sha256": by_sha["candidate_sha256"],
+    }
+    with pytest.raises(UKReleaseCertificationError, match="candidate itself"):
+        compose_uk_release_certification(**by_sha)
+    by_build = dict(green_certification_inputs)
+    by_build["build_record"] = {
+        **by_build["build_record"],
+        "build_id": by_build["reference_record"]["build"],
+    }
+    with pytest.raises(UKReleaseCertificationError, match="candidate itself"):
+        compose_uk_release_certification(**by_build)
+
+
+def test_compose_refuses_a_reference_of_another_line(green_certification_inputs):
+    inputs = dict(green_certification_inputs)
+    inputs["reference_record"] = {
+        **inputs["reference_record"],
+        "release": "microcosm-uk-2024-25-dense",
+    }
+    with pytest.raises(UKReleaseCertificationError, match="national line"):
+        compose_uk_release_certification(**inputs)
+
+
+def test_the_certification_records_the_change_since_the_baseline(
+    green_certification_inputs,
+):
+    """The review of microcosm#1574 (S5): each certification records its
+    change since a fixed baseline, chained from its reference's."""
+
+    mass = _FIXTURES.GREEN_SINCE_BASELINE_MASS
+    coverage = _FIXTURES.GREEN_SINCE_BASELINE_COVERAGE
+
+    certification = compose_uk_release_certification(**green_certification_inputs)
+    assert certification["since_baseline"] == {
+        "baseline": mass["baseline"],
+        # The chain starts at the national line's origin: no restart.
+        "restarted_from": None,
+        "input_mass_ratios": mass["ratios"],
+        # Round 2 of the review: the columns that left the chain stay listed.
+        "input_mass_left": mass["left"],
+        "baseline_inputs": coverage["inputs"],
+        "inputs_dropped": coverage["dropped"],
+    }
+
+
+def _release_cut_since(baseline: str, *, left: dict | None = None) -> dict:
+    mass = {"baseline": baseline, "ratios": {"employment_income": 1.1}}
+    if left is not None:
+        mass["left"] = left
+    return {
+        "gates": {
+            "uk_input_mass_parity": {"details": {"since_baseline": mass}},
+            "uk_release_input_coverage": {
+                "details": {
+                    "since_baseline": {
+                        "baseline": baseline,
+                        "inputs": ["employment_income"],
+                        "dropped": [],
+                    }
+                }
+            },
+        }
+    }
+
+
+def test_a_chain_that_restarted_says_so():
+    """Round 2 of the review of microcosm#1574: a chain that starts at any
+    build but the national line's origin has restarted, and the
+    certification records where the line's chain began."""
+
+    from microcosm.build.uk_runtime.cut_reference import (
+        UK_NATIONAL_SINCE_BASELINE_ORIGIN,
+    )
+    from microcosm.build.uk_runtime.release_certification import _since_baseline
+
+    origin = _since_baseline(
+        _release_cut_since(UK_NATIONAL_SINCE_BASELINE_ORIGIN, left={})
+    )
+    assert origin["restarted_from"] is None
+    restarted = _since_baseline(
+        _release_cut_since("microcosm-uk-2024-25-national@older", left={})
+    )
+    assert restarted["baseline"] == "microcosm-uk-2024-25-national@older"
+    assert restarted["restarted_from"] == UK_NATIONAL_SINCE_BASELINE_ORIGIN
+
+
+def test_compose_refuses_a_release_cut_with_no_record_since_the_baseline():
+    from microcosm.build.uk_runtime.release_certification import _since_baseline
+
+    with pytest.raises(UKReleaseCertificationError, match="no change since"):
+        _since_baseline({"gates": {"uk_input_mass_parity": {"details": {}}}})
+    # Evidence from before the record listed the columns that leave it.
+    with pytest.raises(UKReleaseCertificationError, match="no change since"):
+        _since_baseline(_release_cut_since("microcosm-uk-2024-25-national@a"))
+    mixed = {
+        "gates": {
+            "uk_input_mass_parity": {
+                "details": {
+                    "since_baseline": {
+                        "baseline": "microcosm-uk-2024-25-national@a",
+                        "ratios": {},
+                        "left": {},
+                    }
+                }
+            },
+            "uk_release_input_coverage": {
+                "details": {
+                    "since_baseline": {
+                        "baseline": "microcosm-uk-2024-25-national@b",
+                        "inputs": [],
+                        "dropped": [],
+                    }
+                }
+            },
+        }
+    }
+    with pytest.raises(UKReleaseCertificationError, match="one national baseline"):
+        _since_baseline(mixed)
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_release_input_coverage.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_release_input_coverage.py
index 3775dc4696..7926d4e05b 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_uk_release_input_coverage.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_release_input_coverage.py
@@ -7,6 +7,7 @@
     UK_FAMILY_MASS_CHANGE_SEMANTICS,
     _parse_family_coverage,
     _valid_mass_record,
+    uk_effective_input_signal,
 )
 from test_support.microcosm_build.uk_release_input_coverage import *
 
@@ -96,7 +97,10 @@ def test_gate_reads_build_state_from_the_spine_frame(self) -> None:
         engine = _StubEngine({"gift_aid": 0.0})
 
         on_release = uk_release_input_coverage_gate(
-            release, engine, manifest=self._contract()
+            release,
+            engine,
+            reference_surface=NO_REFERENCE_INPUTS,
+            manifest=self._contract(),
         )
         assert not on_release.passed
         assert any(
@@ -105,7 +109,11 @@ def test_gate_reads_build_state_from_the_spine_frame(self) -> None:
         assert on_release.details["family_build_state_frame"] == "release"
 
         result = uk_release_input_coverage_gate(
-            release, engine, manifest=self._contract(), build_state_frame=spine
+            release,
+            engine,
+            reference_surface=NO_REFERENCE_INPUTS,
+            manifest=self._contract(),
+            build_state_frame=spine,
         )
         assert result.passed, result.failures
         assert result.details["family_build_state_frame"] == "spine"
@@ -127,6 +135,7 @@ def test_binding_hands_the_spine_frame_to_the_build_state_half(self) -> None:
         artifacts = {
             "coverage_engine": _StubEngine({"gift_aid": 0.0}),
             "coverage_manifest": self._contract(),
+            "reference_surface": NO_REFERENCE_INPUTS,
             "spine_frame": spine,
         }
         result = _evaluate_release_input_coverage(
@@ -150,6 +159,7 @@ def test_binding_refuses_to_judge_the_calibrated_frame_without_build_state(
         artifacts = {
             "coverage_engine": _StubEngine({"gift_aid": 0.0}),
             "coverage_manifest": self._contract(),
+            "reference_surface": NO_REFERENCE_INPUTS,
         }
         with pytest.raises(ValueError, match="spine build state"):
             _evaluate_release_input_coverage(
@@ -205,3 +215,208 @@ def test_a_record_that_adds_mass_never_satisfies_a_family(self) -> None:
             )
         )
         assert not _valid_mass_record({**conserving.__dict__, "entity": "person"})
+
+
+class TestReferenceRequiredInputs:
+    """microcosm#1095: the required inputs are the ones the reference carries."""
+
+    _ENGINE_DEFAULTS = {
+        "employment_income": 0.0,
+        "dividend_income": 0.0,
+        "property_income": 0.0,
+    }
+
+    def _frame(self, **columns):
+        return _person_frame(
+            {
+                "employment_income": np.asarray([0.0, 52_000.0]),
+                **{name: np.asarray(values) for name, values in columns.items()},
+            }
+        )
+
+    def test_the_reference_supplies_the_required_inputs(self) -> None:
+        result = uk_release_input_coverage_gate(
+            self._frame(),
+            _StubEngine(self._ENGINE_DEFAULTS),
+            reference_surface=reference_surface("employment_income", "dividend_income"),
+            manifest=_manifest(()),
+        )
+        assert not result.passed
+        assert result.details["missing"] == ["dividend_income"]
+        assert result.details["reference"] == reference_surface().label
+        assert result.details["required_from_reference"] == 2
+        assert result.details["required_by_manifest"] == []
+
+    def test_a_reviewed_exclusion_beats_the_reference(self) -> None:
+        contract = _manifest(
+            (
+                UKReleaseInputColumn(
+                    "property_income",
+                    "reviewed_exclusion",
+                    reason="formula-owned in policyengine-uk",
+                    tracking_note="microcosm#1106",
+                ),
+            )
+        )
+        result = uk_release_input_coverage_gate(
+            self._frame(),
+            _StubEngine(self._ENGINE_DEFAULTS),
+            reference_surface=reference_surface("employment_income", "property_income"),
+            manifest=contract,
+        )
+        assert result.passed, result.failures
+        assert result.details["dormant_exclusions"] == ["property_income"]
+        assert result.details["required_from_reference"] == 1
+
+    def test_an_input_the_live_engine_does_not_load_is_not_required(self) -> None:
+        result = uk_release_input_coverage_gate(
+            self._frame(),
+            _StubEngine({"employment_income": 0.0}),
+            reference_surface=reference_surface("employment_income", "retired_input"),
+            manifest=_manifest(()),
+        )
+        assert result.passed, result.failures
+
+    def test_a_thin_reference_input_is_required_and_named_by_name_only(self) -> None:
+        result = uk_release_input_coverage_gate(
+            self._frame(dividend_income=[0.0, 500.0]),
+            _StubEngine(self._ENGINE_DEFAULTS),
+            reference_surface=reference_surface(
+                "employment_income", thin=("dividend_income",)
+            ),
+            manifest=_manifest(()),
+        )
+        assert result.passed, result.failures
+        assert result.details["required_thin_in_reference"] == ["dividend_income"]
+
+    def test_a_reference_measured_at_another_floor_is_refused(self) -> None:
+        with pytest.raises(ValueError, match="effective-mass floor"):
+            uk_release_input_coverage_gate(
+                self._frame(),
+                _StubEngine(self._ENGINE_DEFAULTS),
+                reference_surface=reference_surface("employment_income", floor=1e-3),
+                manifest=_manifest(()),
+            )
+
+    def test_a_vacuous_required_set_is_refused(self) -> None:
+        with pytest.raises(ValueError, match="vacuous"):
+            uk_release_input_coverage_gate(
+                self._frame(),
+                _StubEngine(self._ENGINE_DEFAULTS),
+                reference_surface=reference_surface(),
+                manifest=_manifest(()),
+            )
+
+
+def test_effective_input_signal_measures_by_the_gates_own_rule() -> None:
+    frame = _weighted_person_frame(
+        {
+            # Signal on positive mass: carried.
+            "employment_income": np.asarray([0.0, 52_000.0, 0.0]),
+            # Signal only on a zero-weight row: not carried.
+            "dividend_income": np.asarray([500.0, 0.0, 0.0]),
+            # Signal only on dust below the reviewed floor: not carried.
+            "savings_interest_income": np.asarray([0.0, 0.0, 10.0]),
+            # Every value the engine default: not carried.
+            "property_income": np.asarray([0.0, 0.0, 0.0]),
+            # Not a loader input: never measured.
+            "not_an_input": np.asarray([1.0, 1.0, 1.0]),
+        },
+        np.asarray([0.0, 1_000.0, 1e-9]),
+    )
+    engine = _StubEngine(
+        {
+            "employment_income": 0.0,
+            "dividend_income": 0.0,
+            "savings_interest_income": 0.0,
+            "property_income": 0.0,
+        }
+    )
+    carried = uk_effective_input_signal(
+        frame, engine, minimum_nondefault_mass_share=1e-6
+    )
+    assert set(carried) == {"employment_income"}
+    entity, signal = carried["employment_income"]
+    assert entity == "person"
+    assert signal.tolist() == [False, True, False]
+
+
+def test_figures_resting_on_fewer_than_three_source_households_are_withheld() -> None:
+    """The UKDS floor of three (CD171): a required column one or two source
+    households carry keeps its verdict, and its figures leave the report."""
+
+    def gate(source_ids):
+        frame = _weighted_person_frame(
+            {
+                # Signal on two rows: one source household, or two.
+                "dividend_income": np.asarray([500.0, 500.0, 0.0, 0.0]),
+                "employment_income": np.asarray([1.0, 2.0, 3.0, 4.0]),
+            },
+            np.asarray([1_000.0, 1_000.0, 1_000.0, 1_000.0]),
+            source_ids=source_ids,
+        )
+        return uk_release_input_coverage_gate(
+            frame,
+            _StubEngine({"dividend_income": 0.0, "employment_income": 0.0}),
+            reference_surface=reference_surface("dividend_income", "employment_income"),
+            manifest=_manifest(()),
+        )
+
+    for source_ids in ([11, 11, 12, 13], [11, 12, 13, 14]):
+        result = gate(source_ids)
+        assert result.passed, result.failures
+        by_column = result.details["effective_mass_by_column"]
+        assert by_column["dividend_income"] == {
+            "entity": "person",
+            "source_households": "<3",
+            "figures": "withheld",
+        }
+        assert by_column["employment_income"]["effective_signal_mass_share"] == 1.0
+
+    # Every row a clone of one source household: even a column on every row
+    # rests on one case, so its figures are withheld too.
+    result = gate([11, 11, 11, 11])
+    assert (
+        "effective_signal_mass_share"
+        not in (result.details["effective_mass_by_column"]["employment_income"])
+    )
+    # Three source households carry it: the figures are reported.
+    spread = _weighted_person_frame(
+        {"dividend_income": np.asarray([500.0, 500.0, 500.0, 0.0])},
+        np.asarray([1_000.0] * 4),
+        source_ids=[11, 12, 13, 14],
+    )
+    reported = uk_release_input_coverage_gate(
+        spread,
+        _StubEngine({"dividend_income": 0.0}),
+        reference_surface=reference_surface("dividend_income"),
+        manifest=_manifest(()),
+    )
+    assert reported.details["effective_mass_by_column"]["dividend_income"][
+        "effective_signal_mass_share"
+    ] == pytest.approx(0.75)
+
+
+def test_coverage_names_the_baseline_inputs_no_longer_carried() -> None:
+    """The review of microcosm#1574 (S5): an input the reference stopped
+    carrying stops being required, so the record keeps the baseline's."""
+
+    import dataclasses
+
+    surface = dataclasses.replace(
+        reference_surface("employment_income"),
+        baseline_label="microcosm-uk-2024-25-national@baseline",
+        baseline_inputs=frozenset({"employment_income", "dividend_income"}),
+    )
+    result = uk_release_input_coverage_gate(
+        _person_frame({"employment_income": np.asarray([0.0, 52_000.0])}),
+        _StubEngine({"employment_income": 0.0, "dividend_income": 0.0}),
+        reference_surface=surface,
+        manifest=_manifest(()),
+    )
+    assert result.passed, result.failures
+    assert result.details["since_baseline"] == {
+        "baseline": "microcosm-uk-2024-25-national@baseline",
+        "inputs": ["dividend_income", "employment_income"],
+        "dropped": ["dividend_income"],
+    }
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_release_input_coverage_manifest.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_release_input_coverage_manifest.py
index ca6bad7068..99af48106b 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_uk_release_input_coverage_manifest.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_release_input_coverage_manifest.py
@@ -130,43 +130,35 @@ def test_hmrc_family_period_fields_come_from_the_bytes_their_hash_names() -> Non
     assert "canonical_source_manifest" not in family
 
 
-def test_promoted_manifest_requires_the_full_reference_surface() -> None:
-    reference = _resource("efrs_parity_reference.json")
+def test_manifest_declares_the_exclusions_and_leaves_the_rest_to_the_reference() -> (
+    None
+):
+    # microcosm#1095: the required inputs are the ones the cut's reference
+    # build carries, measured at gate time; the manifest declares only the
+    # reviewed exclusions: the engine-derived totals whose persisted
+    # components the reference carries (microcosm#1106, microcosm#1360) and
+    # the PIP categories the engine derives from the points (microcosm#1095),
+    # and the gross receipts microcosm#1550 stops writing, which the current
+    # builds still carry (María's signature of 2026-11-10).
     manifest = _resource("release_input_coverage_manifest.json")
-    assert manifest["counts"] == {
-        "required": 141,
-        "reviewed_exclusion": 4,
-        "total": 145,
-    }
-    assert set(manifest["columns"]) == set(reference["nonzero_shares"])
-    # Every reference input is required except the engine-derived totals; their
-    # persisted components stay required (microcosm#1106, microcosm#1360).
-    excluded = {
-        name: entry
-        for name, entry in manifest["columns"].items()
-        if entry != {"status": "required"}
-    }
-    assert set(excluded) == {
+    assert manifest["counts"] == {"reviewed_exclusion": 5}
+    assert set(manifest["columns"]) == {
         "pip_dl_category",
         "pip_m_category",
         "property_wealth",
+        "self_employment_gross_receipts",
         "tax_free_savings_income",
     }
-    for name in excluded:
-        assert excluded[name]["status"] == "reviewed_exclusion"
-    for component in (
-        "main_residence_value",
-        "other_residential_property_value",
-        "non_residential_property_value",
-        "savings_interest_income",
-    ):
-        assert manifest["columns"][component] == {"status": "required"}
+    for entry in manifest["columns"].values():
+        assert entry["status"] == "reviewed_exclusion"
+        assert entry["reason"].strip() and entry["tracking_note"].strip()
+    assert manifest["reference"]["kind"] == "current_build"
     assert manifest["restoration_evidence"] == {
         "derived_from": "efrs_parity_known_gaps.json",
         "required_columns": ["charitable_investment_gifts", "gift_aid"],
     }
     assert manifest["candidate_evidence"]["tier"] == "frs"
-    assert manifest["schema_version"] == 3
+    assert manifest["schema_version"] == 4
     assert manifest["effective_mass_coverage"] == {
         "weight_source": "household_weight",
         "minimum_nondefault_mass_share": 1e-6,
@@ -501,3 +493,21 @@ def test_engine_derived_exclusions_require_a_signature(tmp_path) -> None:
     )
     with pytest.raises(ValueError, match="ISO date"):
         load_efrs_engine_derived_exclusions(str(undated))
+
+
+def test_an_input_retired_since_the_reference_cannot_overlap_the_ledger() -> None:
+    generator = _load_generator()
+    retired = dict(generator.RETIRED_SINCE_REFERENCE_EXCLUSIONS)
+    try:
+        generator.RETIRED_SINCE_REFERENCE_EXCLUSIONS["gift_aid"] = {
+            "reason": "seeded clash",
+            "tracking_note": "seeded",
+        }
+        with pytest.raises(ValueError, match="retired since the reference"):
+            generator.build_manifest(
+                reference=_resource("efrs_parity_reference.json"),
+                known_gaps_payload=_resource("efrs_parity_known_gaps.json"),
+            )
+    finally:
+        generator.RETIRED_SINCE_REFERENCE_EXCLUSIONS.clear()
+        generator.RETIRED_SINCE_REFERENCE_EXCLUSIONS.update(retired)
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_rowwise_national_role.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_rowwise_national_role.py
index 9cfbe1551d..1cff5df858 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_uk_rowwise_national_role.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_rowwise_national_role.py
@@ -40,6 +40,10 @@
     require_committed_uk_chronicle_feed_pin,
 )
 from microcosm.build.uk_runtime.content_identity import uk_frame_content_identity
+from microcosm.build.uk_runtime.cut_reference import (
+    UKCutReference,
+    write_uk_cut_reference,
+)
 from microcosm.build.uk_runtime.national_calibration import (
     CalibrationFrameAdapter,
     national_calibration_mass_reason,
@@ -1365,15 +1369,18 @@ def test_uk_national_role_records_an_unpinned_feed_override(
     assert operations["configuration"]["allow_unpinned_feed"] is True
 
 
-# --- the end-of-build incumbent evaluation (microcosm#823 E2) -----------------
+# --- the end-of-build comparison with the reference (microcosm#823 E2, #1095) --
+
+REFERENCE_BUILD = "uk-frs-calibration-attempt-20261107T020434Z-eeb6093e"
+REFERENCE_LABEL = f"{UK_NATIONAL_RELEASE_ID}@{REFERENCE_BUILD}"
 
 
 def _fake_evaluator(receipt_of, calls: list[dict]):
-    """A stand-in for microcosm.build.uk_runtime.candidate_score (#967)."""
+    """A stand-in for microcosm.build.uk_runtime.candidate_score."""
 
     class Module:
         @staticmethod
-        def evaluate_uk_candidate_against_incumbent(**kwargs):
+        def evaluate_uk_candidate_against_reference(**kwargs):
             calls.append(kwargs)
             return receipt_of(kwargs)
 
@@ -1383,7 +1390,7 @@ def uk_default_measure_resolver_factory(scratch_dir, year):
 
         @staticmethod
         def pruned_warning(score):
-            pruned = score.get("incumbent_unresolvable_pruned") or {}
+            pruned = score.get("reference_unresolvable_pruned") or {}
             if not pruned.get("n_pruned"):
                 return None
             return "warning: pruned from BOTH arms: " + ", ".join(pruned["measures"])
@@ -1391,37 +1398,44 @@ def pruned_warning(score):
     return Module
 
 
-def _receipt(kwargs, *, verdict="passed", pruned_measures=()):
+def _receipt(kwargs, *, pruned_measures=()):
     n_pruned = len(pruned_measures)
+    targets = {"candidate_lower_count": 1, "reference_lower_count": 0, "equal_count": 0}
     return {
         "artifacts": {
             "candidate": {"sha256": kwargs["candidate_sha256"]},
-            "incumbent": {
-                "sha256": kwargs["incumbent_sha256"],
-                "label": kwargs["incumbent_label"],
+            "reference": {
+                "sha256": kwargs["reference_sha256"],
+                "label": kwargs["reference_label"],
             },
         },
         "candidate_full_loss": 0.01,
-        "incumbent_full_loss": 0.2,
-        "candidate_target_wins": 1,
-        "incumbent_target_wins": 0,
+        "reference_full_loss": 0.2,
         "register": {"n_specs": 1},
-        # Record arrays the reviewed telemetry artifact must not carry.
-        "target_drift": [
-            {
-                "target": "dwp.uc.households@2025",
-                "family": "dwp_universal_credit",
-                "candidate_relative_error": 0.01,
-                "incumbent_relative_error": 0.2,
-                "winner": "candidate",
-            }
-        ],
-        "signed_asymmetries": [{"id": "incumbent_own_registry", "description": "…"}],
+        # A record array the reviewed telemetry artifact must not carry.
+        "head_to_head": {
+            "schema_version": 1,
+            "loss": {"candidate": 0.01, "reference": 0.2},
+            "targets": {
+                **targets,
+                "compared": [
+                    {
+                        "name": "dwp.uc.households@2025",
+                        "family": "dwp_universal_credit",
+                        "candidate_relative_error": 0.01,
+                        "reference_relative_error": 0.2,
+                        "lower_absolute_relative_error": "candidate",
+                    }
+                ],
+            },
+            "by_family": {"dwp_universal_credit": targets},
+        },
+        "signed_asymmetries": [{"id": "reference_own_registry", "description": "…"}],
         "measure_resolution": {
             "candidate": {"rounds": [{"round": 0}]},
-            "incumbent": None,
+            "reference": None,
         },
-        "incumbent_unresolvable_pruned": {
+        "reference_unresolvable_pruned": {
             "n_pruned": n_pruned,
             "n_scored": 1,
             "n_surface": 1 + n_pruned,
@@ -1430,63 +1444,95 @@ def _receipt(kwargs, *, verdict="passed", pruned_measures=()):
             "families": {"dwp_universal_credit": n_pruned} if n_pruned else {},
             "note": "pruned",
         },
+        "reference": kwargs["reference_record"],
         "evaluation": {
-            "schema_version": 1,
-            "rule": "rule 1",
+            "schema_version": 2,
+            "rule": "microcosm#1095",
+            "reference": kwargs["reference_label"],
             "scored_surface": {
                 "n_scored": 1,
                 "n_pruned": n_pruned,
                 "n_surface": 1 + n_pruned,
             },
-            "rule_1": {
-                "passed": verdict == "passed",
-                "candidate_full_loss": 0.01,
-                "incumbent_full_loss": 0.2,
-                "candidate_target_wins": 1,
-                "incumbent_target_wins": 0,
-            },
-            "verdict": verdict,
+            "losses": {"candidate_full_loss": 0.01, "reference_full_loss": 0.2},
+            "targets": targets,
+            "no_threshold_applied": True,
         },
     }
 
 
-def _incumbent_argv(input_h5: Path, tmp_path: Path, *extra: str) -> list[str]:
-    incumbent = tmp_path / "incumbent.h5"
-    shutil.copyfile(input_h5, incumbent)
+def _reference_argv(input_h5: Path, tmp_path: Path, *extra: str) -> list[str]:
+    """A reference file and the record a cut's fetch writes for it."""
+
+    reference = tmp_path / "reference.h5"
+    shutil.copyfile(input_h5, reference)
+    record = UKCutReference(
+        release=UK_NATIONAL_RELEASE_ID,
+        build=REFERENCE_BUILD,
+        repo_id="policyengine/populace-uk-private",
+        path_in_repo=f"releases/{UK_NATIONAL_RELEASE_ID}/{REFERENCE_BUILD}/x.h5",
+        filename=reference.name,
+        sha256=_sha(reference),
+        size_bytes=reference.stat().st_size,
+        built_with_model_package={"name": "policyengine-uk", "version": "2.174.1"},
+        built_with_core_package={"name": "policyengine-core", "version": "3.33.3"},
+        evidence={
+            "key": "release_certification",
+            "filename": "release_certification.json",
+            "sha256": "1" * 64,
+        },
+        resolved_at="2026-11-10T12:00:00Z",
+    )
+    record_path = write_uk_cut_reference(tmp_path / "reference.json", record)
     return [
-        "--incumbent-h5",
-        str(incumbent),
-        "--incumbent-sha256",
-        _sha(incumbent),
-        "--incumbent-label",
-        "efrs_fixture",
+        "--reference-h5",
+        str(reference),
+        "--reference-record",
+        str(record_path),
         *extra,
     ]
 
 
-def test_uk_dense_role_refuses_the_incumbent_flags(tmp_path) -> None:
+def test_uk_dense_role_refuses_the_national_reference_flags(tmp_path) -> None:
     builder = candidate._load_builder_module()
     args = argparse.Namespace(
         target_loss_cap=None,
         allow_unpinned_feed=False,
         target_weight_rule="grain_equal",
-        incumbent_h5=tmp_path / "incumbent.h5",
-        incumbent_sha256=None,
+        reference_h5=tmp_path / "reference.h5",
+        reference_record=None,
     )
-    with pytest.raises(ValueError, match="--incumbent-h5/--incumbent-sha256"):
+    with pytest.raises(ValueError, match="--reference-h5/--reference-record"):
         builder._refuse_national_role_arguments(
             args, builder.uk_rowwise_posture("dense")
         )
 
 
-def test_uk_national_role_requires_the_incumbent_pair(monkeypatch, tmp_path):
+def test_uk_national_role_refuses_the_dense_reference_surface(tmp_path) -> None:
+    # The national cut's certify step reads its reference surface
+    # (microcosm#1095); the national build runs no export-surface gate.
+    builder = candidate._load_builder_module()
+    (tmp_path / "spine.h5").write_bytes(b"spine")
+    parsed = builder._parse_args(
+        _argv(
+            tmp_path / "spine.h5",
+            tmp_path / "out",
+            "--reference-surface",
+            str(tmp_path / "reference_surface.json"),
+        )
+    )
+    with pytest.raises(ValueError, match="--reference-surface"):
+        builder._validate_cli_args(parsed)
+
+
+def test_uk_national_role_requires_the_reference_pair(monkeypatch, tmp_path):
     pytest.importorskip("tables")
     builder = candidate._load_builder_module()
     input_h5, _registry, _artifact, _pin = _national_inputs(monkeypatch, tmp_path)
     out = tmp_path / "out"
     assert (
         builder.main(
-            _argv(input_h5, out, "--no-staging", "--incumbent-h5", str(input_h5))
+            _argv(input_h5, out, "--no-staging", "--reference-h5", str(input_h5))
         )
         == 1
     )
@@ -1495,17 +1541,31 @@ def test_uk_national_role_requires_the_incumbent_pair(monkeypatch, tmp_path):
     assert not (out / "microcosm_uk_2024_25.h5").exists()
 
 
-def test_uk_national_role_refuses_the_incumbent_without_the_scorer() -> None:
+def test_uk_national_role_refuses_a_reference_the_record_does_not_name(
+    monkeypatch, tmp_path
+):
+    pytest.importorskip("tables")
+    builder = candidate._load_builder_module()
+    input_h5, _registry, _artifact, _pin = _national_inputs(monkeypatch, tmp_path)
+    argv = _reference_argv(input_h5, tmp_path)
+    (tmp_path / "reference.h5").write_bytes(b"another file")
+    out = tmp_path / "out"
+
+    assert builder.main(_argv(input_h5, out, "--no-staging", *argv)) == 1
+    failure = json.loads((out / "failure.json").read_text())
+    assert "is" in failure["message"] and "bytes" in failure["message"]
+    assert not (out / "microcosm_uk_2024_25.h5").exists()
+
+
+def test_uk_national_role_refuses_the_reference_without_the_scorer() -> None:
     def missing(name: str):
         raise ImportError(name)
 
-    with pytest.raises(ValueError, match="microcosm#967"):
+    with pytest.raises(ValueError, match="head-to-head scorer"):
         national_role._load_candidate_evaluator(importer=missing)
 
 
-def test_uk_national_role_evaluates_against_the_incumbent(
-    monkeypatch, tmp_path, capsys
-):
+def test_uk_national_role_compares_with_the_reference(monkeypatch, tmp_path, capsys):
     pytest.importorskip("tables")
     builder = candidate._load_builder_module()
     input_h5, registry, _artifact, _pin = _national_inputs(monkeypatch, tmp_path)
@@ -1529,7 +1589,7 @@ def test_uk_national_role_evaluates_against_the_incumbent(
                 "--no-staging",
                 "--epochs",
                 "5",
-                *_incumbent_argv(input_h5, tmp_path),
+                *_reference_argv(input_h5, tmp_path),
             )
         )
         == 0
@@ -1538,22 +1598,27 @@ def test_uk_national_role_evaluates_against_the_incumbent(
     call = calls[0]
     assert call["candidate_h5"] == out / "microcosm_uk_2024_25.h5"
     assert call["candidate_sha256"] == _sha(out / "microcosm_uk_2024_25.h5")
-    assert call["incumbent_h5"] == tmp_path / "incumbent.h5"
-    assert call["incumbent_sha256"] == _sha(tmp_path / "incumbent.h5")
-    assert call["incumbent_label"] == "efrs_fixture"
+    assert call["reference_h5"] == tmp_path / "reference.h5"
+    assert call["reference_sha256"] == _sha(tmp_path / "reference.h5")
+    assert call["reference_label"] == REFERENCE_LABEL
+    assert call["reference_record"]["build"] == REFERENCE_BUILD
     # The registries the scorer receives are the ones the graph solved and
     # froze, by content hash.
     assert call["target_registry"].version == registry.version
     assert call["band_edge_registry"].version == registry.version
     assert call["calibration_year"] == 2025
-    receipt_path = out / "score_vs_incumbent.json"
+    receipt_path = out / "score_vs_reference.json"
     receipt = json.loads(receipt_path.read_text())
-    assert receipt["evaluation"]["verdict"] == "passed"
+    assert receipt["evaluation"]["reference"] == REFERENCE_LABEL
     manifest = json.loads((out / builder.MANIFEST_FILENAME).read_text())
     evaluation = manifest["evaluation"]
     assert evaluation["status"] == "completed"
-    assert evaluation["verdict"] == "passed"
-    assert evaluation["rule_1"]["passed"] is True
+    assert evaluation["reference"] == REFERENCE_LABEL
+    assert "verdict" not in evaluation
+    assert evaluation["losses"] == {
+        "candidate_full_loss": 0.01,
+        "reference_full_loss": 0.2,
+    }
     assert evaluation["scored_surface"] == {
         "n_scored": 1,
         "n_pruned": 1,
@@ -1562,8 +1627,8 @@ def test_uk_national_role_evaluates_against_the_incumbent(
     assert evaluation["pruned_measures"] == ["benunit.uc_calibration_child_count"]
     assert evaluation["pruned_families"] == {"dwp_universal_credit": 1}
     assert evaluation["receipt"]["sha256"] == _sha(receipt_path)
-    assert evaluation["incumbent"]["label"] == "efrs_fixture"
-    assert evaluation["incumbent"]["sha256"] == _sha(tmp_path / "incumbent.h5")
+    assert evaluation["reference_input"]["label"] == REFERENCE_LABEL
+    assert evaluation["reference_input"]["sha256"] == _sha(tmp_path / "reference.h5")
     assert manifest["outputs"]["score_receipt"]["sha256"] == _sha(receipt_path)
     # The absent measure is named loudly on stderr, never hidden.
     assert "benunit.uc_calibration_child_count" in capsys.readouterr().err
@@ -1577,7 +1642,7 @@ def test_uk_national_role_records_an_evaluation_error_without_failing(
     input_h5, _registry, _artifact, _pin = _national_inputs(monkeypatch, tmp_path)
 
     def explode(kwargs):
-        raise RuntimeError("the incumbent frame refused to load")
+        raise RuntimeError("the reference frame refused to load")
 
     module = _fake_evaluator(explode, [])
     monkeypatch.setattr(
@@ -1593,7 +1658,7 @@ def explode(kwargs):
                 "--no-staging",
                 "--epochs",
                 "5",
-                *_incumbent_argv(input_h5, tmp_path),
+                *_reference_argv(input_h5, tmp_path),
             )
         )
         == 0
@@ -1604,8 +1669,8 @@ def explode(kwargs):
     assert "refused to load" in manifest["evaluation"]["error"]
     assert manifest["evaluation"]["receipt"] is None
     assert "score_receipt" not in manifest["outputs"]
-    assert not (out / "score_vs_incumbent.json").exists()
-    assert "the incumbent evaluation failed" in capsys.readouterr().err
+    assert not (out / "score_vs_reference.json").exists()
+    assert "the comparison with the reference failed" in capsys.readouterr().err
 
 
 def test_uk_national_role_evaluates_after_staging_the_bundle(
@@ -1629,7 +1694,7 @@ def test_uk_national_role_evaluates_after_staging_the_bundle(
                 "--staging-local-only",
                 "--epochs",
                 "5",
-                *_incumbent_argv(input_h5, tmp_path),
+                *_reference_argv(input_h5, tmp_path),
             )
         )
         == 0
@@ -1638,14 +1703,14 @@ def test_uk_national_role_evaluates_after_staging_the_bundle(
     manifest = json.loads((out / builder.MANIFEST_FILENAME).read_text())
     run_id = manifest["build_id"]
     assert manifest["evaluation"]["status"] == "completed"
-    assert manifest["evaluation"]["verdict"] == "passed"
+    assert manifest["evaluation"]["reference"] == REFERENCE_LABEL
     assert manifest["outputs"]["score_receipt"]["sha256"] == _sha(
-        out / "score_vs_incumbent.json"
+        out / "score_vs_reference.json"
     )
     # The receipt is listed in the local sums beside the record and manifest.
     _sums_verify(out)
     assert any(
-        line.endswith("  score_vs_incumbent.json")
+        line.endswith("  score_vs_reference.json")
         for line in (out / "sha256sums.txt").read_text().splitlines()
     )
     bundle = validate_v2_bundle(out / "staging", run_id)
@@ -1653,28 +1718,30 @@ def test_uk_national_role_evaluates_after_staging_the_bundle(
     events = [
         (event["stage_id"], event["status"])
         for event in bundle["events"]
-        if event["stage_id"] == "incumbent_evaluation"
+        if event["stage_id"] == "reference_evaluation"
     ]
     assert events == [
-        ("incumbent_evaluation", "started"),
-        ("incumbent_evaluation", "completed"),
+        ("reference_evaluation", "started"),
+        ("reference_evaluation", "completed"),
     ]
     # The evaluation ran after the bundle was staged, before completion.
     stage_ids = [event["stage_id"] for event in bundle["events"]]
-    assert stage_ids.index("dataset_staging") < stage_ids.index("incumbent_evaluation")
-    assert stage_ids.index("incumbent_evaluation") < stage_ids.index("complete")
+    assert stage_ids.index("dataset_staging") < stage_ids.index("reference_evaluation")
+    assert stage_ids.index("reference_evaluation") < stage_ids.index("complete")
     artifacts = out / "staging" / "runs" / run_id / "artifacts"
-    staged_receipt = json.loads((artifacts / "score_vs_incumbent.json").read_text())
-    assert staged_receipt["evaluation"]["verdict"] == "passed"
-    # The staged copy keeps the verdict, the pruned block and the aggregates
-    # and drops the record arrays the reviewed-artifact policy refuses; the
-    # full receipt is beside the outputs.
-    assert "incumbent_unresolvable_pruned" in staged_receipt
-    assert staged_receipt["candidate_target_wins"] == 1
-    for key in ("target_drift", "signed_asymmetries", "measure_resolution"):
+    staged_receipt = json.loads((artifacts / "score_vs_reference.json").read_text())
+    assert staged_receipt["evaluation"]["reference"] == REFERENCE_LABEL
+    # The staged copy keeps the summary, the pruned block and the counts and
+    # drops the record arrays the reviewed-artifact policy refuses; the full
+    # receipt is beside the outputs.
+    assert "reference_unresolvable_pruned" in staged_receipt
+    assert staged_receipt["head_to_head"]["targets"]["candidate_lower_count"] == 1
+    assert "compared" not in staged_receipt["head_to_head"]["targets"]
+    for key in ("signed_asymmetries", "measure_resolution"):
         assert key not in staged_receipt
-    full_receipt = json.loads((out / "score_vs_incumbent.json").read_text())
-    assert full_receipt["target_drift"][0]["winner"] == "candidate"
+    full_receipt = json.loads((out / "score_vs_reference.json").read_text())
+    compared = full_receipt["head_to_head"]["targets"]["compared"]
+    assert compared[0]["lower_absolute_relative_error"] == "candidate"
     assert calls[0]["candidate_sha256"] == manifest["outputs"]["dataset"]["sha256"]
     # The completion marker binds the final bytes: the build record gained
     # the delivery summary and the manifest its receipts after publication,
@@ -1690,7 +1757,7 @@ def test_uk_national_role_evaluates_after_staging_the_bundle(
     assert completion["dataset"]["sha256"] == _sha(out / "microcosm_uk_2024_25.h5")
 
 
-def test_uk_national_dry_run_records_the_incumbent(monkeypatch, tmp_path, capsys):
+def test_uk_national_dry_run_records_the_reference(monkeypatch, tmp_path, capsys):
     pytest.importorskip("tables")
     builder = candidate._load_builder_module()
     input_h5, _registry, _artifact, _pin = _national_inputs(monkeypatch, tmp_path)
@@ -1706,7 +1773,7 @@ def test_uk_national_dry_run_records_the_incumbent(monkeypatch, tmp_path, capsys
                 tmp_path / "plan",
                 "--dry-run",
                 "--no-staging",
-                *_incumbent_argv(input_h5, tmp_path),
+                *_reference_argv(input_h5, tmp_path),
             )
         )
         == 0
@@ -1714,8 +1781,9 @@ def test_uk_national_dry_run_records_the_incumbent(monkeypatch, tmp_path, capsys
 
     plan = json.loads(capsys.readouterr().out)
     assert plan["dry_run"] is True
-    assert plan["incumbent"]["label"] == "efrs_fixture"
-    assert plan["incumbent"]["sha256"] == _sha(tmp_path / "incumbent.h5")
+    assert plan["reference"]["label"] == REFERENCE_LABEL
+    assert plan["reference"]["sha256"] == _sha(tmp_path / "reference.h5")
+    assert "record" not in plan["reference"]
     assert not (tmp_path / "plan").exists()
 
 
@@ -1725,13 +1793,14 @@ def test_uk_national_role_loads_the_real_scorer_by_its_public_name() -> None:
     module = national_role._load_candidate_evaluator()
     assert module.__name__ == "microcosm.build.uk_runtime.candidate_score"
     assert callable(module.uk_default_measure_resolver_factory)
-    assert callable(module.evaluate_uk_candidate_against_incumbent)
+    assert callable(module.evaluate_uk_candidate_against_reference)
 
 
 def test_uk_score_receipt_telemetry_summary_keeps_the_pruned_block() -> None:
-    """The staged copy drops the three per-target arrays and keeps the
-    pruned block whole, including a populated pruned_targets mapping (the
-    block a real run fills with 120 rows; Vahid's #965 note 2)."""
+    """The staged copy drops the per-target comparisons and the two other
+    record arrays and keeps the pruned block whole, including a populated
+    pruned_targets mapping (the block a real run fills with many rows;
+    Vahid's #965 note 2)."""
     pruned_targets = {
         f"dwp/uc/family_{i}": {
             "name": f"dwp/uc/family_{i}",
@@ -1744,10 +1813,18 @@ def test_uk_score_receipt_telemetry_summary_keeps_the_pruned_block() -> None:
     }
     score = {
         "artifacts": {"candidate": {"sha256": "1" * 64}},
-        "target_drift": [{"target": "a@0", "error": 0.1}],
+        "head_to_head": {
+            "targets": {
+                "candidate_lower_count": 1,
+                "reference_lower_count": 0,
+                "equal_count": 0,
+                "compared": [{"name": "a@0", "lower_absolute_relative_error": "x"}],
+            },
+            "by_family": {},
+        },
         "signed_asymmetries": [{"id": "x"}],
         "measure_resolution": {"candidate": {"rounds": []}},
-        "incumbent_unresolvable_pruned": {
+        "reference_unresolvable_pruned": {
             "n_pruned": 3,
             "n_scored": 1,
             "n_surface": 4,
@@ -1757,15 +1834,21 @@ def test_uk_score_receipt_telemetry_summary_keeps_the_pruned_block() -> None:
             "reviewed_register": {"resource": "r.json", "sha256": "2" * 64},
             "note": "pruned",
         },
-        "evaluation": {"verdict": "passed"},
+        "evaluation": {"reference": REFERENCE_LABEL},
     }
     summary = national_role._score_receipt_telemetry_summary(score)
     assert set(summary) == {
         "artifacts",
-        "incumbent_unresolvable_pruned",
+        "head_to_head",
+        "reference_unresolvable_pruned",
         "evaluation",
     }
-    assert summary["incumbent_unresolvable_pruned"]["pruned_targets"] == pruned_targets
+    assert summary["head_to_head"]["targets"] == {
+        "candidate_lower_count": 1,
+        "reference_lower_count": 0,
+        "equal_count": 0,
+    }
+    assert summary["reference_unresolvable_pruned"]["pruned_targets"] == pruned_targets
 
     # No list of mappings survives (the staging content policy's record
     # array refusal); the pruned rows are a mapping keyed by target name.
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_terminal_gates.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_terminal_gates.py
index e43da9db75..c911cdc5a6 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_uk_terminal_gates.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_terminal_gates.py
@@ -2,8 +2,10 @@
 
 from __future__ import annotations
 
+import json
 import math
 from datetime import UTC, date, datetime
+from pathlib import Path
 from types import SimpleNamespace
 from unittest.mock import patch
 
@@ -29,7 +31,7 @@
     uk_zero_weight_strata_gate,
 )
 from microcosm.build.uk_runtime.weighted_integrity import (
-    UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256,
+    UK_CURRENT_BUILD_REFERENCE,
     UKInputMassReferenceDescriptor,
     UKReviewedExclusion,
 )
@@ -301,18 +303,57 @@ def test_ported_june_parity_gates_retain_their_named_failures() -> None:
     assert fit.name == "target_fit"
 
 
-def test_export_surface_allows_claimant_roles_but_not_unreviewed_columns() -> None:
+def test_export_surface_allows_declared_extras_but_not_unreviewed_columns() -> None:
     reference = {"person.age"}
-    assert uk_export_surface_gate(
-        reference | {"person.is_uc_claimant"}, reference
-    ).passed
+    assert uk_export_surface_gate(reference | {"household.lsoa_code"}, reference).passed
     unrelated = uk_export_surface_gate(
-        reference | {"person.is_uc_claimant", "person.unreviewed_extra"}, reference
+        reference | {"household.lsoa_code", "person.unreviewed_extra"}, reference
     )
     assert not unrelated.passed
     assert any("unreviewed_extra" in failure for failure in unrelated.failures)
 
 
+def test_export_surface_reports_a_declared_extra_the_reference_now_carries() -> None:
+    # microcosm#1095: a promotion moves the reference past a declared extra;
+    # the entry is reported as redundant, never failed.
+    reference = {"person.age", "household.lsoa_code"}
+    result = uk_export_surface_gate(reference, reference)
+    assert result.passed
+    assert result.details["redundant_allowed_extra_columns"] == ["household.lsoa_code"]
+
+
+def test_export_surface_names_the_reference_build() -> None:
+    result = uk_export_surface_gate(
+        {"person.age"},
+        {"person.age", "person.dropped_input"},
+        reference_name="microcosm-uk-2024-25-national@build-a",
+    )
+    assert not result.passed
+    assert "microcosm-uk-2024-25-national@build-a" in result.failures[0]
+    assert result.details["reference_name"] == "microcosm-uk-2024-25-national@build-a"
+
+
+def test_export_surface_extras_are_not_exported_by_the_current_national_build() -> None:
+    # The standing list holds only what the current national build does not
+    # export (microcosm#1095): the dense line's geography and clone columns.
+    from microcosm.build.uk_runtime.terminal_gates import (
+        UK_ALLOWED_EXTRA_EXPORT_COLUMNS,
+    )
+
+    gates = json.loads(
+        (
+            Path(__file__).resolve().parents[3] / "src/microcosm/build/uk/gates.json"
+        ).read_text()
+    )
+    entry = next(gate for gate in gates["gates"] if gate["id"] == "uk_export_surface")
+    assert entry["parameters"]["allowed_extra_columns"] == list(
+        UK_ALLOWED_EXTRA_EXPORT_COLUMNS
+    )
+    assert len(UK_ALLOWED_EXTRA_EXPORT_COLUMNS) == len(
+        set(UK_ALLOWED_EXTRA_EXPORT_COLUMNS)
+    )
+
+
 def test_export_candidate_columns_and_release_frame_carry_consumer_area_code_names() -> (
     None
 ):
@@ -398,7 +439,6 @@ def test_export_candidate_columns_strip_ids_and_carry_the_weight() -> None:
         uk_release_export_frame,
     )
     from microcosm.build.uk_runtime.terminal_gates import (
-        UK_ALLOWED_EXTRA_EXPORT_COLUMNS,
         UK_REVIEWED_EXPORT_EXCLUSIONS,
         uk_export_candidate_columns,
     )
@@ -435,8 +475,9 @@ def test_export_candidate_columns_strip_ids_and_carry_the_weight() -> None:
     }
     exported = uk_release_export_frame(frame)
     # microcosm#1106: the WAS total leaves; its engine components stay.
-    # microcosm#1194: the build identifiers stay beside the renumbered ones,
-    # as reviewed extras of the export surface.
+    # microcosm#1194: the build identifiers stay beside the renumbered ones;
+    # the current national build exports them too, so since microcosm#1095
+    # they are part of the reference surface, not declared extras.
     carriers = {
         f"{entity}.{column}" for entity, column in UK_BUILD_IDENTIFIER_COLUMNS.items()
     }
@@ -447,7 +488,6 @@ def test_export_candidate_columns_strip_ids_and_carry_the_weight() -> None:
         "household.household_weight",
         *carriers,
     }
-    assert carriers <= set(UK_ALLOWED_EXTRA_EXPORT_COLUMNS)
     assert exported.weights_for("household").values.tolist() == [1.0, 2.0]
     assert exported.mass_log == frame.mass_log
     # The boundary drops the reviewed export exclusions, the internal
@@ -865,41 +905,46 @@ def test_ported_june_parity_gates_reject_empty_evidence() -> None:
     assert "evidence is empty" in " ".join(fit.failures)
 
 
-def _input_mass_reference(totals=None) -> UKInputMassReference:
+REFERENCE_BUILD = "uk-frs-calibration-attempt-20261107T020434Z-eeb6093e"
+
+
+def _input_mass_reference(totals=None, carriers=None) -> UKInputMassReference:
     return UKInputMassReference(
         totals=({"employment_income": 10.0} if totals is None else totals),
-        filename="enhanced_frs_2024_25.h5",
-        revision="a9e52499b6a6cca100a5ce4f36ca27b2e8a213df",
-        sha256=("e433e532b17bd8ce76030156285816e33d44e93edabd2204adbef71d19a68712"),
+        filename="microcosm_uk_2024_25.h5",
+        revision=REFERENCE_BUILD,
+        sha256="9" * 64,
         vintage="2024_25",
+        label=f"microcosm-uk-2024-25-national@{REFERENCE_BUILD}",
+        carriers=carriers,
     )
 
 
 def _input_mass_descriptor() -> UKInputMassReferenceDescriptor:
-    return UKInputMassReferenceDescriptor(
-        name="efrs-post-calibration",
-        filename="enhanced_frs_2024_25.h5",
-        revision="a9e52499b6a6cca100a5ce4f36ca27b2e8a213df",
-        sha256="e433e532b17bd8ce76030156285816e33d44e93edabd2204adbef71d19a68712",
-        vintage="2024_25",
-        totals_sha256=UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256,
-        scope_note="Seeded scoped-reference note.",
-    )
+    return UK_CURRENT_BUILD_REFERENCE.descriptor_for(_input_mass_reference())
 
 
 def _input_mass_policy(**overrides) -> UKInputMassParityPolicy:
-    fields = {"relative_tolerance": 0.5, "minimum_reference_total": 0.0}
+    fields = {
+        "relative_tolerance": 0.5,
+        "minimum_reference_total": 0.0,
+        # Within a 0.5 tolerance a drop past 0.5 already fails; 1.0 adds none.
+        "maximum_relative_drop": 1.0,
+    }
     fields.update(overrides)
     return UKInputMassParityPolicy(**fields)
 
 
-def _input_mass_gate(candidate_totals, reference=None, *, policy=None):
+def _input_mass_gate(
+    candidate_totals, reference=None, *, policy=None, candidate_carriers=None
+):
     with patch(VALIDATE_REFERENCE, return_value=None):
         return uk_input_mass_parity_gate(
             candidate_totals,
             _input_mass_reference() if reference is None else reference,
             descriptor=_input_mass_descriptor(),
             policy=_input_mass_policy() if policy is None else policy,
+            candidate_carriers=candidate_carriers,
         )
 
 
@@ -910,7 +955,10 @@ def test_zeroed_input_column_fails_by_name() -> None:
     assert gate.name == "input_mass_parity"
     assert "employment_income" in gate.failures[0]
     assert "mass is zero" in gate.failures[0]
-    assert gate.details["reference_identity"]["filename"] == ("enhanced_frs_2024_25.h5")
+    assert gate.details["reference_identity"]["filename"] == "microcosm_uk_2024_25.h5"
+    assert gate.details["reference_label"] == (
+        f"microcosm-uk-2024-25-national@{REFERENCE_BUILD}"
+    )
 
 
 def test_999_permille_mass_loss_fails_by_name() -> None:
@@ -935,6 +983,100 @@ def test_stale_weighted_integrity_exclusions_fail() -> None:
     assert "Stale reviewed input-mass exclusions" in gate.failures[0]
 
 
+def test_a_drop_past_the_limit_fails_inside_a_wide_tolerance() -> None:
+    """The symmetric tolerance above one fails no drop short of zero; the drop
+    limit bounds how much of its reference total a column may lose
+    (microcosm#1095)."""
+
+    policy = _input_mass_policy(relative_tolerance=6.0, maximum_relative_drop=0.9)
+    within = _input_mass_gate({"employment_income": 1.5}, policy=policy)
+    assert within.passed, within.failures
+    assert within.details["excess_drops"] == []
+    assert within.details["maximum_relative_drop"] == 0.9
+
+    beyond = _input_mass_gate({"employment_income": 0.5}, policy=policy)
+    assert not beyond.passed
+    assert beyond.details["excess_drops"] == ["employment_income"]
+    assert any(
+        failure.startswith("employment_income:")
+        and "beyond the reviewed maximum drop 0.9" in failure
+        for failure in beyond.failures
+    )
+    # Growth inside the tolerance still passes.
+    assert _input_mass_gate({"employment_income": 60.0}, policy=policy).passed
+
+
+def test_a_reviewed_exclusion_covers_a_drop_and_stays_live() -> None:
+    policy = _input_mass_policy(
+        relative_tolerance=6.0,
+        maximum_relative_drop=0.9,
+        reviewed_exclusions={"employment_income": _entry("Seeded drop entry.")},
+    )
+    gate = _input_mass_gate({"employment_income": 0.5}, policy=policy)
+    assert gate.passed, gate.failures
+    assert gate.details["excess_drops"] == []
+    # The column still drops past the limit, so the entry is not stale.
+    assert gate.details["stale_exclusions"] == []
+
+
+def test_a_thin_column_drop_fails_by_name_only() -> None:
+    reference = _input_mass_reference(
+        totals={"employment_income": 10.0, "rare_flag": 4.0},
+        carriers={"employment_income": 900, "rare_flag": 2},
+    )
+    gate = _input_mass_gate(
+        {"employment_income": 10.0, "rare_flag": 0.2},
+        reference,
+        policy=_input_mass_policy(relative_tolerance=6.0, maximum_relative_drop=0.9),
+        candidate_carriers={"employment_income": 950, "rare_flag": 2},
+    )
+    assert not gate.passed
+    rare = [failure for failure in gate.failures if failure.startswith("rare_flag:")]
+    assert len(rare) == 1
+    assert "figures are withheld" in rare[0]
+    assert "0.95" not in rare[0]
+
+
+@pytest.mark.parametrize("drop", [-0.1, 1.5, float("nan")])
+def test_the_drop_limit_is_a_share(drop) -> None:
+    with pytest.raises(ValueError, match="maximum_relative_drop"):
+        _input_mass_policy(maximum_relative_drop=drop)
+
+
+def test_a_thin_column_is_checked_but_its_figures_are_withheld() -> None:
+    """One or two source households on a side: the verdict stands, the
+    figures never reach the report (microcosm#1095)."""
+
+    reference = _input_mass_reference(
+        totals={"employment_income": 10.0, "rare_flag": 4.0},
+        carriers={"employment_income": 900, "rare_flag": 2},
+    )
+    gate = _input_mass_gate(
+        {"employment_income": 30.0, "rare_flag": 0.0},
+        reference,
+        candidate_carriers={"employment_income": 950, "rare_flag": 0},
+    )
+
+    assert not gate.passed
+    rare = [failure for failure in gate.failures if failure.startswith("rare_flag:")]
+    assert rare == [
+        "rare_flag: its mass check failed on a column one or two source "
+        "households carry on one side; the figures are withheld."
+    ]
+    employment = [f for f in gate.failures if f.startswith("employment_income:")]
+    assert employment and "30" in employment[0]
+    assert "rare_flag" not in gate.details["worst_drifts"]
+    assert "employment_income" in gate.details["worst_drifts"]
+    assert gate.details["withheld_thin_columns"] == ["rare_flag"]
+
+
+def test_without_carriers_nothing_is_withheld() -> None:
+    gate = _input_mass_gate({"employment_income": 0.0})
+
+    assert gate.details["withheld_thin_columns"] == []
+    assert "mass is zero" in gate.failures[0]
+
+
 def test_weighted_integrity_type_errors_are_named() -> None:
     with pytest.raises(TypeError, match="reference must be UKInputMassReference"):
         uk_input_mass_parity_gate(
@@ -1182,3 +1324,173 @@ def test_degenerate_gate_skips_columns_the_release_boundary_drops() -> None:
         _dataset(), dropped_at_export={"household": ("not_a_column",)}
     )
     assert inert.passed is True and inert.details["dropped_at_export"] == []
+
+
+def test_the_gross_receipts_exclusions_are_signed_for_the_current_builds() -> None:
+    """microcosm#1550 stops writing self_employment_gross_receipts; the current
+    builds carry it, so it is excluded against them (María, 2026-11-10)."""
+
+    from microcosm.build.uk_runtime.terminal_gates import (
+        UK_REVIEWED_EXPORT_EXCLUSIONS,
+    )
+    from microcosm.build.uk_runtime.weighted_integrity import (
+        uk_default_input_mass_reviewed_exclusions,
+    )
+
+    register = uk_default_input_mass_reviewed_exclusions()
+    lines = {
+        "microcosm-uk-2024-25-national@uk-frs-calibration-attempt-20261107T020434Z-eeb6093e": (
+            "national",
+        ),
+        "microcosm-uk-2024-25-dense@uk-local-candidate-f100-s42-20261107T173210Z-38605444": (
+            "local",
+        ),
+    }
+    assert set(register) == set(lines)
+    for label, line in lines.items():
+        entry = register[label]["self_employment_gross_receipts"]
+        assert entry.approved_by == "juaristi22"
+        assert entry.approved_on == "2026-11-10"
+        assert entry.release_lines == line
+    assert "person.self_employment_gross_receipts" in UK_REVIEWED_EXPORT_EXCLUSIONS
+    gate = uk_export_surface_gate(
+        {"person.age", "person.self_employment_gross_receipts"},
+        {"person.age", "person.self_employment_gross_receipts"},
+    )
+    assert not gate.passed
+    assert gate.details["forbidden_candidate_columns"] == [
+        "person.self_employment_gross_receipts"
+    ]
+    assert uk_export_surface_gate(
+        {"person.age"}, {"person.age", "person.self_employment_gross_receipts"}
+    ).passed
+
+
+def test_a_signed_input_mass_entry_covers_the_missing_column_for_its_build() -> None:
+    policy = _input_mass_policy(
+        relative_tolerance=6.0,
+        maximum_relative_drop=0.9,
+        reviewed_exclusions={
+            "self_employment_gross_receipts": _entry("Seeded retired column.")
+        },
+    )
+    reference = _input_mass_reference(
+        totals={"employment_income": 10.0, "self_employment_gross_receipts": 5.0},
+    )
+    gate = _input_mass_gate({"employment_income": 10.0}, reference, policy=policy)
+    assert gate.passed, gate.failures
+    assert gate.details["stale_exclusions"] == []
+    unsigned = _input_mass_gate(
+        {"employment_income": 10.0},
+        reference,
+        policy=_input_mass_policy(relative_tolerance=6.0, maximum_relative_drop=0.9),
+    )
+    assert not unsigned.passed
+
+
+def test_the_input_mass_gate_continues_the_change_since_the_baseline() -> None:
+    """The review of microcosm#1574 (S5): each column's ratio to the fixed
+    baseline is the reference's ratio times this comparison's."""
+
+    import dataclasses
+
+    reference = dataclasses.replace(
+        _input_mass_reference(
+            totals={"employment_income": 10.0, "rare_flag": 4.0, "gone": 2.0},
+            carriers={"employment_income": 900, "rare_flag": 2, "gone": 50},
+        ),
+        since_baseline={
+            "baseline": "microcosm-uk-2024-25-national@baseline",
+            "ratios": {"employment_income": 0.5, "rare_flag": 1.0, "gone": 1.0},
+            "left": {"earlier": _left("thin", 0.7, "earlier")},
+        },
+    )
+    gate = _input_mass_gate(
+        {"employment_income": 12.0, "rare_flag": 4.0},
+        reference,
+        policy=_input_mass_policy(relative_tolerance=6.0, maximum_relative_drop=0.9),
+        candidate_carriers={"employment_income": 950, "rare_flag": 2},
+    )
+    # Thin and absent columns leave the chain and stay listed, beside the
+    # columns that left before; the rest continue it.
+    assert gate.details["since_baseline"] == {
+        "baseline": "microcosm-uk-2024-25-national@baseline",
+        "ratios": {"employment_income": pytest.approx(0.6)},
+        "left": {
+            "earlier": _left("thin", 0.7, "earlier"),
+            "gone": _left("absent", 1.0, REFERENCE_BUILD),
+            "rare_flag": _left("thin", 1.0, REFERENCE_BUILD),
+        },
+    }
+    plain = _input_mass_gate({"employment_income": 10.0})
+    assert "since_baseline" not in plain.details
+
+
+def _left(reason: str, last_ratio: float, build: str) -> dict:
+    return {
+        "reason": reason,
+        "last_ratio": last_ratio,
+        "last_build": f"microcosm-uk-2024-25-national@{build}",
+    }
+
+
+def test_a_column_that_leaves_the_chain_stays_listed() -> None:
+    """Round 2 of the review of microcosm#1574: a column driven down and then
+    thin, or carried to zero, used to vanish from the record. Three cuts in a
+    row, each comparing with the build before it."""
+
+    import dataclasses
+
+    policy = _input_mass_policy(relative_tolerance=6.0, maximum_relative_drop=0.9)
+
+    def since_baseline(reference_totals, reference_carriers, chain, totals, carriers):
+        reference = dataclasses.replace(
+            _input_mass_reference(totals=reference_totals, carriers=reference_carriers),
+            since_baseline=chain,
+        )
+        gate = _input_mass_gate(
+            totals, reference, policy=policy, candidate_carriers=carriers
+        )
+        return gate.details["since_baseline"]
+
+    # a falls to a fifth, b to a tenth on two source households, and c grows
+    # from a zero reference total: only a's ratio continues.
+    first = since_baseline(
+        {"a": 100.0, "b": 100.0, "c": 0.0},
+        {"a": 50, "b": 40, "c": 0},
+        {
+            "baseline": "microcosm-uk-2024-25-national@baseline",
+            "ratios": {"a": 0.2, "b": 0.2, "c": 0.5},
+            "left": {},
+        },
+        {"a": 20.0, "b": 10.0, "c": 5.0},
+        {"a": 50, "b": 2, "c": 10},
+    )
+    assert first["ratios"] == {"a": pytest.approx(0.04)}
+    assert first["left"] == {
+        "b": _left("thin", 0.2, REFERENCE_BUILD),
+        "c": _left("zero_reference_total", 0.5, REFERENCE_BUILD),
+    }
+    # Carried to zero, as under a reviewed exclusion: a records zero once.
+    second = since_baseline(
+        {"a": 20.0, "b": 10.0, "c": 5.0},
+        {"a": 50, "b": 2, "c": 10},
+        first,
+        {"a": 0.0, "b": 10.0, "c": 5.0},
+        {"a": 0, "b": 2, "c": 10},
+    )
+    assert second["ratios"] == {"a": 0.0}
+    assert second["left"] == first["left"]
+    # Then its reference total is zero; it leaves, and stays listed too.
+    third = since_baseline(
+        {"a": 0.0, "b": 10.0, "c": 5.0},
+        {"a": 0, "b": 2, "c": 10},
+        second,
+        {"a": 0.0, "b": 10.0, "c": 5.0},
+        {"a": 0, "b": 2, "c": 10},
+    )
+    assert third["ratios"] == {}
+    assert third["left"] == {
+        "a": _left("zero_reference_total", 0.0, REFERENCE_BUILD),
+        **first["left"],
+    }
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_uc_deduction_attributes.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_uc_deduction_attributes.py
index aa74492505..696a33f85d 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_uk_uc_deduction_attributes.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_uc_deduction_attributes.py
@@ -137,8 +137,8 @@ def test_persisted_draws_are_not_the_engine_fallback_and_stay_exported() -> None
     that is pinned here alongside the divergence.
     """
 
-    from microcosm.build.uk_runtime.terminal_gates import (
-        UK_ALLOWED_EXTRA_EXPORT_COLUMNS,
+    from microcosm.build.uk_runtime.national_frame import (
+        UK_RELEASE_EXPORT_DROPPED_COLUMNS,
     )
 
     ids = np.arange(1, 4097, dtype=np.int64)
@@ -148,5 +148,7 @@ def test_persisted_draws_are_not_the_engine_fallback_and_stay_exported() -> None
     assert agreement < 1e-3, agreement
 
     for column in ("uc_deduction_random_draw", "uc_deduction_type_random_draw"):
-        assert f"benunit.{column}" in UK_ALLOWED_EXTRA_EXPORT_COLUMNS
+        # The draws leave with the release (part of the current build's
+        # export surface since microcosm#1095, no longer a declared extra).
+        assert column not in UK_RELEASE_EXPORT_DROPPED_COLUMNS.get("benunit", ())
         assert column in _stage().outputs
diff --git a/packages/microcosm-build/tests/engine_free/uk/test_uk_weighted_integrity.py b/packages/microcosm-build/tests/engine_free/uk/test_uk_weighted_integrity.py
index 9b2be23958..271c2bac07 100644
--- a/packages/microcosm-build/tests/engine_free/uk/test_uk_weighted_integrity.py
+++ b/packages/microcosm-build/tests/engine_free/uk/test_uk_weighted_integrity.py
@@ -25,8 +25,8 @@
     SPI_INCOME_QRF_OUTPUT_COLUMNS,
 )
 from microcosm.build.uk_runtime.weighted_integrity import (
+    UK_CURRENT_BUILD_REFERENCE,
     UK_INPUT_MASS_EXCLUSION_REGISTER_RESOURCE,
-    UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256,
     UK_INPUT_MASS_REFERENCE_REGISTRY,
     UKInputMassParityPolicy,
     UKInputMassReference,
@@ -39,6 +39,7 @@
     load_uk_reference_scoped_exclusion_register,
     load_uk_reviewed_exclusion_register,
     uk_default_input_mass_reviewed_exclusions,
+    uk_input_mass_carriers,
     uk_input_mass_parity_gate,
     uk_input_mass_totals,
     uk_qrf_tail_concentration_columns,
@@ -94,12 +95,17 @@ def _frame(
     )
 
 
+REFERENCE_BUILD = "uk-frs-calibration-attempt-20261107T020434Z-eeb6093e"
+REFERENCE_LABEL = f"microcosm-uk-2024-25-national@{REFERENCE_BUILD}"
+
+
 def _reference(totals, **overrides) -> UKInputMassReference:
     fields = {
-        "filename": "enhanced_frs_2024_25.h5",
-        "revision": "a9e52499b6a6cca100a5ce4f36ca27b2e8a213df",
-        "sha256": ("e433e532b17bd8ce76030156285816e33d44e93edabd2204adbef71d19a68712"),
+        "filename": "microcosm_uk_2024_25.h5",
+        "revision": REFERENCE_BUILD,
+        "sha256": "9" * 64,
         "vintage": "2024_25",
+        "label": REFERENCE_LABEL,
     }
     fields.update(overrides)
     return UKInputMassReference(totals=totals, **fields)
@@ -107,12 +113,12 @@ def _reference(totals, **overrides) -> UKInputMassReference:
 
 def _descriptor(**overrides) -> UKInputMassReferenceDescriptor:
     fields = {
-        "name": "efrs-post-calibration",
-        "filename": "enhanced_frs_2024_25.h5",
-        "revision": "a9e52499b6a6cca100a5ce4f36ca27b2e8a213df",
-        "sha256": "e433e532b17bd8ce76030156285816e33d44e93edabd2204adbef71d19a68712",
+        "name": "current_build",
+        "filename": "microcosm_uk_2024_25.h5",
+        "revision": REFERENCE_BUILD,
+        "sha256": "9" * 64,
         "vintage": "2024_25",
-        "totals_sha256": UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256,
+        "totals_sha256": "8" * 64,
         "scope_note": "Seeded scoped-reference note.",
     }
     fields.update(overrides)
@@ -120,7 +126,12 @@ def _descriptor(**overrides) -> UKInputMassReferenceDescriptor:
 
 
 def _policy(**overrides) -> UKInputMassParityPolicy:
-    fields = {"relative_tolerance": 0.5, "minimum_reference_total": 0.0}
+    fields = {
+        "relative_tolerance": 0.5,
+        "minimum_reference_total": 0.0,
+        # Within a 0.5 tolerance a drop past 0.5 already fails; 1.0 adds none.
+        "maximum_relative_drop": 1.0,
+    }
     fields.update(overrides)
     return UKInputMassParityPolicy(**fields)
 
@@ -277,80 +288,34 @@ def test_input_mass_reference_identity_is_recorded() -> None:
     )
 
     assert gate.details["reference_identity"] == {
-        "filename": "enhanced_frs_2024_25.h5",
-        "revision": "a9e52499b6a6cca100a5ce4f36ca27b2e8a213df",
-        "sha256": ("e433e532b17bd8ce76030156285816e33d44e93edabd2204adbef71d19a68712"),
+        "filename": "microcosm_uk_2024_25.h5",
+        "revision": REFERENCE_BUILD,
+        "sha256": "9" * 64,
         "vintage": "2024_25",
     }
+    assert gate.details["reference_label"] == REFERENCE_LABEL
 
 
-def test_input_mass_reference_rejects_substituted_totals_at_approved_identity(
-    tmp_path,
-) -> None:
-    caller_self_reference = _reference(
-        {"employment_income": 1.0},
-    )
-
-    with pytest.raises(ValueError, match="reference totals must match the reviewed"):
-        uk_input_mass_parity_gate(
-            {"employment_income": 1.0},
-            caller_self_reference,
-            descriptor=_descriptor(),
-            policy=_policy(),
-        )
-    path = tmp_path / "self-reference.json"
-    path.write_text(
-        json.dumps(
-            {
-                "schema_version": 1,
-                "identity": caller_self_reference.identity,
-                "totals": dict(caller_self_reference.totals),
-            }
-        ),
-        encoding="utf-8",
-    )
-    with pytest.raises(ValueError, match="did not match any reviewed reference"):
-        load_uk_input_mass_reference(path)
+def test_the_descriptor_is_made_from_the_reference_itself() -> None:
+    """The spec names the kind; the identity and totals digest the gate checks
+    are the reference build's own (microcosm#1095)."""
 
+    reference = _reference({"employment_income": 1.0})
+    descriptor = UK_CURRENT_BUILD_REFERENCE.descriptor_for(reference)
 
-def test_input_mass_reference_identity_pin_cannot_be_shadowed_from_cwd(
-    tmp_path,
-    monkeypatch,
-) -> None:
-    shadow = {
-        "schema_version": 3,
-        "source": {
-            "repo_id": "caller/repo",
-            "repo_type": "model",
-            "filename": "caller.h5",
-            "revision": "caller",
-            "sha256": "b" * 64,
-            "url": "https://example.invalid/caller.h5",
-            "vintage": "caller",
-            "period": "2023",
-            "size_bytes": 1,
-        },
-        "nonzero_shares": {"employment_income": 1.0},
-        "input_entities": {"employment_income": "person"},
-    }
-    (tmp_path / "efrs_parity_reference.json").write_text(
-        json.dumps(shadow), encoding="utf-8"
-    )
-    monkeypatch.chdir(tmp_path)
-    caller_reference = _reference(
-        {"employment_income": 1.0},
-        filename="caller.h5",
-        revision="caller",
-        sha256="b" * 64,
-        vintage="caller",
+    assert descriptor.identity == reference.identity
+    gate = uk_input_mass_parity_gate(
+        {"employment_income": 1.0}, reference, descriptor=descriptor, policy=_policy()
     )
-
-    with pytest.raises(ValueError, match="identity must match the reviewed"):
+    assert gate.passed
+    other = _reference({"employment_income": 2.0})
+    with pytest.raises(ValueError, match="reference totals must match the reviewed"):
         uk_input_mass_parity_gate(
-            {"employment_income": 1.0},
-            caller_reference,
-            descriptor=_descriptor(),
-            policy=_policy(),
+            {"employment_income": 1.0}, other, descriptor=descriptor, policy=_policy()
+        )
+    with pytest.raises(ValueError, match="names no build"):
+        UK_CURRENT_BUILD_REFERENCE.descriptor_for(
+            _reference({"employment_income": 1.0}, label=None)
         )
 
 
@@ -409,30 +374,28 @@ def test_input_mass_policy_and_reference_validation() -> None:
 
 
 def test_input_mass_reference_registry_coercion_is_closed_world() -> None:
-    descriptor = next(iter(UK_INPUT_MASS_REFERENCE_REGISTRY.values()))
-
     coerced = coerce_input_mass_reference_registry(
-        {"efrs-post-calibration": descriptor.spec_payload()}, label="fixture"
+        {"current_build": UK_CURRENT_BUILD_REFERENCE.spec_payload()}, label="fixture"
     )
 
     assert coerced == dict(UK_INPUT_MASS_REFERENCE_REGISTRY)
-    extra = descriptor.spec_payload()
-    extra["unexpected"] = "ignored?"
-    with pytest.raises(ValueError, match="fields must be exactly"):
-        coerce_input_mass_reference_registry(
-            {"efrs-post-calibration": extra}, label="fixture"
-        )
-    malformed = descriptor.spec_payload()
-    malformed["identity"] = {**descriptor.identity, "sha256": "A" * 64}
-    with pytest.raises(ValueError, match="sha256 must be a lowercase sha256"):
-        coerce_input_mass_reference_registry(
-            {"efrs-post-calibration": malformed}, label="fixture"
-        )
-    bad_totals = descriptor.spec_payload()
-    bad_totals["totals_sha256"] = "not-a-sha"
-    with pytest.raises(ValueError, match="totals_sha256"):
+    extra = {**UK_CURRENT_BUILD_REFERENCE.spec_payload(), "unexpected": "x"}
+    with pytest.raises(ValueError, match="must be exactly"):
+        coerce_input_mass_reference_registry({"current_build": extra}, label="fixture")
+    # A reference pinned by file identity, as the enhanced FRS was, is refused.
+    pinned = {
+        "identity": {
+            "filename": "a.h5",
+            "revision": "r",
+            "sha256": "0" * 64,
+            "vintage": "v",
+        },
+        "totals_sha256": "0" * 64,
+        "scope_note": "pinned",
+    }
+    with pytest.raises(ValueError, match="no longer accepted"):
         coerce_input_mass_reference_registry(
-            {"efrs-post-calibration": bad_totals}, label="fixture"
+            {"efrs-post-calibration": pinned}, label="fixture"
         )
 
 
@@ -541,42 +504,18 @@ def test_committed_exclusion_registers_load() -> None:
         resource=UK_INPUT_MASS_EXCLUSION_REGISTER_RESOURCE,
     )
 
-    assert set(input_mass) == {"efrs-post-calibration"}
-    # The 2026-09-21 retirements (charitable_investment_gifts and owned_land
-    # measured inside the fence on the first national candidate) stand; the
-    # certifier rehearsal on the 2026-09-30 build earned the FRS education
-    # input the enhanced-FRS reference barely carries (microcosm#1063 c9).
-    # The gate fails an entry as stale the day a build brings the column
-    # inside the fence, which the 2 October final build did for adult_ema
-    # (+74% against the reference): its entry is retired. The 3 October final
-    # build's certifier earned three more, signed 2026-10-04: the FRS
-    # access-fund outlier at the weight bound (expiring with the owed period
-    # rule) and the SPI channel's two legacy-benefit leaves. All three are
-    # retired with the microcosm#1095 ports: spi_benefit_coherence zeroes
-    # income-based JSA and Working Tax Credit on SPI rows, and on the
-    # review-head arm the columns sit at +316% and +103% of the reference and
-    # the access fund at +62%, its household off the weight bound, all inside
-    # the fence, so the gate fails them as stale. property_wealth joins with
-    # microcosm#1106 (signed 2026-10-11): the release leaves it to the engine,
-    # so the reference carries a column the candidate no longer ships. The
-    # QRF tail register went with its gate (microcosm#1276).
-    # tax_free_savings_income joins with microcosm#1360 (signed 2026-10-28):
-    # under the additive ISA income contract the candidate stores ISA interest
-    # apart, and the engine sums it into the column the reference stores.
-    assert set(input_mass["efrs-post-calibration"]) == {
-        "dfe_education_spending",
-        "property_wealth",
-        "tax_free_savings_income",
+    # The enhanced-FRS reference's three entries (dfe_education_spending,
+    # property_wealth, tax_free_savings_income) retired with it
+    # (microcosm#1095); entries are now signed for one reference build: the
+    # gross receipts microcosm#1550 stops writing, against both current builds.
+    assert {label: set(entries) for label, entries in input_mass.items()} == {
+        "microcosm-uk-2024-25-dense@uk-local-candidate-f100-s42-20261107T173210Z-38605444": {
+            "self_employment_gross_receipts"
+        },
+        "microcosm-uk-2024-25-national@uk-frs-calibration-attempt-20261107T020434Z-eeb6093e": {
+            "self_employment_gross_receipts"
+        },
     }
-    for record in input_mass["efrs-post-calibration"].values():
-        assert record.approved_by == "juaristi22"
-        assert record.approved_on in {"2026-10-02", "2026-10-11", "2026-10-28"}
-        assert record.expires_on in {"2027-04-02", "2027-04-11", "2027-04-28"}
-        assert (
-            "microcosm#1063" in record.adjudication
-            or "microcosm#1106" in record.adjudication
-            or "microcosm#1360" in record.adjudication
-        )
     assert uk_default_input_mass_reviewed_exclusions() is (
         uk_default_input_mass_reviewed_exclusions()
     )
@@ -875,8 +814,9 @@ def test_uk_input_mass_gate_is_the_shared_gate_plus_recorded_identity() -> None:
     """Without exclusions the UK wrapper must reproduce the US gate verbatim.
 
     Same failure lines, same verdict, same details — the UK result may only
-    add the reference identity and the (empty) stale/dormant register fields
-    the #609 discipline requires on top of the shared gate.
+    add the reference identity, the (empty) stale/dormant register fields
+    the #609 discipline requires, and the drop limit (microcosm#1095), which
+    at 1.0 adds no failure on top of the shared gate.
     """
 
     from microcosm.build.gates import input_mass_parity_gate
@@ -921,43 +861,120 @@ def test_uk_input_mass_gate_is_the_shared_gate_plus_recorded_identity() -> None:
         "reference",
         "reference_scope_note",
         "reference_identity",
+        "reference_label",
+        "withheld_thin_columns",
+        "maximum_relative_drop",
+        "excess_drops",
+    }
+    assert ported.details["excess_drops"] == []
+
+
+def test_input_mass_reference_round_trips_the_cut_schema(tmp_path) -> None:
+    path = tmp_path / "input_mass_reference.json"
+    payload = {
+        "schema_version": 2,
+        "kind": "uk_input_mass_reference",
+        "label": REFERENCE_LABEL,
+        "identity": {
+            "filename": "microcosm_uk_2024_25.h5",
+            "revision": REFERENCE_BUILD,
+            "sha256": "9" * 64,
+            "vintage": "2024_25",
+        },
+        "totals": {"employment_income": 10.5},
+        "carriers": {"employment_income": 7},
     }
+    path.write_text(json.dumps(payload))
 
+    reference = load_uk_input_mass_reference(path)
 
-def test_input_mass_reference_round_trips_the_measurement_schema(tmp_path) -> None:
-    path = tmp_path / "reference.json"
-    path.write_text(
-        json.dumps(
+    assert reference.label == REFERENCE_LABEL
+    assert reference.revision == REFERENCE_BUILD
+    assert dict(reference.totals) == {"employment_income": 10.5}
+    assert dict(reference.carriers) == {"employment_income": 7}
+    for broken, message in (
+        ({"schema_version": 1}, "retired with microcosm#1095"),
+        ({"label": "microcosm-uk-2024-25-national@other"}, "does not name the build"),
+        ({"carriers": None}, "'carriers' objects"),
+    ):
+        path.write_text(json.dumps({**payload, **broken}))
+        with pytest.raises(ValueError, match=message):
+            load_uk_input_mass_reference(path)
+
+
+def test_input_mass_reference_reads_the_record_since_the_baseline(tmp_path) -> None:
+    """Round 2 of the review of microcosm#1574: the columns that left the
+    chain come with it, each with why, its last ratio and its last build."""
+
+    path = tmp_path / "input_mass_reference.json"
+    gone = {"reason": "thin", "last_ratio": 0.4, "last_build": REFERENCE_LABEL}
+    since = {
+        "baseline": REFERENCE_LABEL,
+        "ratios": {"employment_income": 1.0},
+        "left": {"gift_aid": gone},
+    }
+    payload = {
+        "schema_version": 2,
+        "kind": "uk_input_mass_reference",
+        "label": REFERENCE_LABEL,
+        "identity": {
+            "filename": "microcosm_uk_2024_25.h5",
+            "revision": REFERENCE_BUILD,
+            "sha256": "9" * 64,
+            "vintage": "2024_25",
+        },
+        "totals": {"employment_income": 10.5},
+        "carriers": {"employment_income": 7},
+        "since_baseline": since,
+    }
+    path.write_text(json.dumps(payload))
+
+    assert load_uk_input_mass_reference(path).since_baseline == since
+    for left in (
+        {"gift_aid": {**gone, "reason": "vanished"}},
+        {"gift_aid": {**gone, "last_ratio": -1.0}},
+        # A column is in the chain or has left it, never both.
+        {"employment_income": gone},
+        None,
+    ):
+        broken = {**since, "left": left}
+        path.write_text(json.dumps({**payload, "since_baseline": broken}))
+        with pytest.raises(ValueError, match="columns that left the chain"):
+            load_uk_input_mass_reference(path)
+
+
+def test_carriers_count_source_households_not_rows() -> None:
+    """Clones repeat their source household; a person counts its household's."""
+
+    household_ids = np.arange(1, 5, dtype=np.int64)
+    frame = uk_national_frame(
+        person=pd.DataFrame(
             {
-                "schema_version": 1,
-                "identity": {
-                    "filename": "enhanced_frs_2024_25.h5",
-                    "revision": "a9e52499b6a6cca100a5ce4f36ca27b2e8a213df",
-                    "sha256": (
-                        "e433e532b17bd8ce76030156285816e33d44e93edabd2204adbef71d19a68712"
-                    ),
-                    "vintage": "2024_25",
-                },
-                "totals": {"employment_income": 10.5},
+                "person_id": np.arange(101, 105, dtype=np.int64),
+                "person_household_id": household_ids,
+                "person_benunit_id": np.arange(201, 205, dtype=np.int64),
+                "employment_income": np.arange(1, 5, dtype=float),
+                "rare_flag": np.array([True, True, False, False]),
             }
-        )
+        ),
+        benunit=pd.DataFrame({"benunit_id": np.arange(201, 205, dtype=np.int64)}),
+        household=pd.DataFrame(
+            {
+                "household_id": household_ids,
+                "household_weight": np.ones(4),
+                "council_tax": np.full(4, 10.0),
+                # Two clones of one source household, and two others.
+                "household_source_id": np.array([7, 7, 8, 9], dtype=np.int64),
+            }
+        ),
+        time_period="2023",
     )
 
-    # The licensed 131-column totals are intentionally unavailable to CI;
-    # make the small fixture present the reviewed digest while checking the
-    # measurement schema and registry identity resolution.
-    with patch.object(
-        weighted_integrity,
-        "_input_mass_reference_evidence_sha256",
-        return_value=UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256,
-    ):
-        reference = load_uk_input_mass_reference(path)
+    carriers = uk_input_mass_carriers(frame)
 
-    assert reference.filename == "enhanced_frs_2024_25.h5"
-    assert dict(reference.totals) == {"employment_income": 10.5}
-    with pytest.raises(ValueError, match="schema_version"):
-        path.write_text(json.dumps({"schema_version": 9}))
-        load_uk_input_mass_reference(path)
+    assert carriers["rare_flag"] == 1
+    assert carriers["employment_income"] == 3
+    assert carriers["council_tax"] == 3
 
 
 def test_expired_exclusion_stops_suppressing_and_names_its_receipt() -> None:
diff --git a/packages/microcosm-build/tests/engine_free/us/test_us_release_head_to_head_scorer.py b/packages/microcosm-build/tests/engine_free/us/test_us_release_head_to_head_scorer.py
index 8c393fa2fe..16c16c7fc6 100644
--- a/packages/microcosm-build/tests/engine_free/us/test_us_release_head_to_head_scorer.py
+++ b/packages/microcosm-build/tests/engine_free/us/test_us_release_head_to_head_scorer.py
@@ -1332,3 +1332,52 @@ def corrupt_materialize(slice_frame, specs, **kwargs):
         assert type(caught.value) is expected_type
         errors.append((type(caught.value), str(caught.value).encode("utf-8")))
     assert errors[0] == errors[1]
+
+
+def test_the_comparison_payload_keeps_the_us_scorecard_names() -> None:
+    """The shared comparison (microcosm.build.head_to_head) leaves this
+    payload, and so the written scorecard, exactly as it was."""
+
+    def side(errors, loss, status):
+        return {
+            "fiscal": {
+                "targets": [
+                    {
+                        "name": name,
+                        "period": 2024,
+                        "absolute_relative_error": abs(error),
+                    }
+                    for name, error in errors
+                ],
+                "weighted_loss": loss,
+            },
+            "terminal_battery": {"status": status},
+        }
+
+    module = _load_head_to_head_module()
+    payload = module._comparison_payload(
+        side([("a", 0.2), ("b", 0.1), ("c", 0.3)], 0.5, "computed_finished_h5"),
+        side([("a", 0.1), ("b", 0.1), ("c", -0.4)], 0.25, "computed_finished_h5"),
+    )
+
+    assert payload["decision"] == "owner_decides_flip"
+    assert payload["fiscal_weighted_loss"] == {
+        "incumbent": 0.5,
+        "candidate": 0.25,
+        "candidate_minus_incumbent": -0.25,
+    }
+    per_target = payload["per_target_absolute_relative_error"]
+    assert (
+        per_target["candidate_lower_count"],
+        per_target["equal_count"],
+        per_target["incumbent_lower_count"],
+    ) == (1, 1, 1)
+    assert per_target["targets"][2] == {
+        "name": "c",
+        "period": 2024,
+        "incumbent_absolute_relative_error": 0.3,
+        "candidate_absolute_relative_error": 0.4,
+        "candidate_minus_incumbent_absolute_relative_error": 0.4 - 0.3,
+        "lower_absolute_relative_error": "incumbent",
+    }
+    assert payload["terminal_battery"]["head_to_head_comparable"] is True
diff --git a/packages/microcosm-build/tests/uk_certification_fixtures.py b/packages/microcosm-build/tests/uk_certification_fixtures.py
index 0e7d7a1d9f..6721c0ce1c 100644
--- a/packages/microcosm-build/tests/uk_certification_fixtures.py
+++ b/packages/microcosm-build/tests/uk_certification_fixtures.py
@@ -42,6 +42,24 @@ def signing_key(monkeypatch):
     monkeypatch.setenv(gate_signing_key_env("uk"), TEST_KEY)
 
 
+GREEN_SINCE_BASELINE_MASS = {
+    "baseline": "microcosm-uk-2024-25-national@uk-frs-calibration-attempt-20261107T020434Z-eeb6093e",
+    "ratios": {"employment_income": 1.02, "dividend_income": 0.97},
+    "left": {
+        "gift_aid": {
+            "reason": "thin",
+            "last_ratio": 0.9,
+            "last_build": "microcosm-uk-2024-25-national@uk-frs-calibration-attempt-20261107T020434Z-eeb6093e",
+        }
+    },
+}
+GREEN_SINCE_BASELINE_COVERAGE = {
+    "baseline": GREEN_SINCE_BASELINE_MASS["baseline"],
+    "inputs": ["dividend_income", "employment_income", "gift_aid"],
+    "dropped": ["gift_aid"],
+}
+
+
 def stub_registry():
     """Return a registry that passes every declared gate over the real spec."""
 
@@ -52,6 +70,10 @@ def stub_registry():
 
     details_by_gate = {
         "cgt_projection_entrants": {"projection_engine": STUB_PROJECTION_ENGINE},
+        # The release cut's change since the baseline (the review of
+        # microcosm#1574): the certification records it from these two gates.
+        "input_mass_parity": {"since_baseline": GREEN_SINCE_BASELINE_MASS},
+        "release_input_coverage": {"since_baseline": GREEN_SINCE_BASELINE_COVERAGE},
     }
 
     def passing(name):
@@ -120,20 +142,68 @@ def sha256(path: Path) -> str:
 GREEN_PARENT_SPINE_SHA256 = "a" * 64
 
 
+#: The reference the green fixture's cut recorded (microcosm#1095).
+GREEN_REFERENCE_RECORD = {
+    "kind": "uk_cut_reference",
+    "schema_version": 1,
+    "release": "microcosm-uk-2024-25-national",
+    "build": "uk-frs-calibration-attempt-20261107T020434Z-eeb6093e",
+    "repo_id": "policyengine/populace-uk-private",
+    "path_in_repo": (
+        "releases/microcosm-uk-2024-25-national/"
+        "uk-frs-calibration-attempt-20261107T020434Z-eeb6093e/microcosm_uk_2024_25.h5"
+    ),
+    "filename": "microcosm_uk_2024_25.h5",
+    "sha256": "9" * 64,
+    "size_bytes": 1,
+    "built_with_model_package": {"name": "policyengine-uk", "version": "2.174.1"},
+    "built_with_core_package": {"name": "policyengine-core", "version": "3.33.3"},
+    "evidence": {
+        "key": "release_certification",
+        "filename": "release_certification.json",
+        "sha256": "8" * 64,
+    },
+    "resolved_at": "2026-11-10T12:00:00Z",
+    "selection": "current",
+}
+GREEN_REFERENCE_LABEL = (
+    f"{GREEN_REFERENCE_RECORD['release']}@{GREEN_REFERENCE_RECORD['build']}"
+)
+
+
 def green_score_receipt(candidate_sha: str) -> dict:
     """A score receipt the certifier accepts: measured on the candidate's
-    bytes, scored on a closed common surface, rule 1 passed."""
+    bytes against the cut's reference, on a closed common surface."""
 
+    targets = {
+        "candidate_lower_count": 293,
+        "reference_lower_count": 12,
+        "equal_count": 2,
+    }
     return {
         "artifacts": {
             "candidate": {"sha256": candidate_sha, "size_bytes": 15},
-            "incumbent": {"sha256": "9" * 64, "size_bytes": 1},
+            "reference": {
+                "label": GREEN_REFERENCE_LABEL,
+                "sha256": GREEN_REFERENCE_RECORD["sha256"],
+                "size_bytes": 1,
+            },
         },
         "candidate_full_loss": 0.0096,
-        "incumbent_full_loss": 0.211,
-        "candidate_target_wins": 293,
-        "incumbent_target_wins": 12,
-        "incumbent_unresolvable_pruned": {
+        "reference_full_loss": 0.0101,
+        "head_to_head": {
+            "schema_version": 1,
+            "decision": "owner_decides",
+            "no_threshold_applied": True,
+            "loss": {
+                "candidate": 0.0096,
+                "reference": 0.0101,
+                "candidate_minus_reference": 0.0096 - 0.0101,
+            },
+            "targets": {**targets, "compared": []},
+            "by_family": {},
+        },
+        "reference_unresolvable_pruned": {
             "n_pruned": 0,
             "n_scored": 307,
             "n_surface": 307,
@@ -141,24 +211,22 @@ def green_score_receipt(candidate_sha: str) -> dict:
             "measures": [],
             "families": {},
             "reviewed_register": {
-                "resource": "incumbent_unresolvable_measures.json",
+                "resource": "reference_unresolvable_measures.json",
                 "sha256": None,
+                "reference": GREEN_REFERENCE_LABEL,
                 "entries_used": {},
             },
             "note": "nothing pruned",
         },
+        "reference": dict(GREEN_REFERENCE_RECORD),
         "evaluation": {
-            "schema_version": 1,
-            "rule": "microcosm#578 rule 1 on the common surface",
+            "schema_version": 2,
+            "rule": "microcosm#1095: the candidate and the current build",
+            "reference": GREEN_REFERENCE_LABEL,
             "scored_surface": {"n_scored": 307, "n_pruned": 0, "n_surface": 307},
-            "rule_1": {
-                "passed": True,
-                "candidate_full_loss": 0.0096,
-                "incumbent_full_loss": 0.211,
-                "candidate_target_wins": 293,
-                "incumbent_target_wins": 12,
-            },
-            "verdict": "passed",
+            "losses": {"candidate_full_loss": 0.0096, "reference_full_loss": 0.0101},
+            "targets": targets,
+            "no_threshold_applied": True,
         },
     }
 
@@ -242,7 +310,7 @@ def green_certification_inputs(tmp_path: Path):
             "terminal_gate_json": {"sha256": seam_report_sha},
         },
     }
-    score_receipt = tmp_path / "score_vs_enhanced_frs.json"
+    score_receipt = tmp_path / "score_vs_reference.json"
     score_receipt.write_text(
         json.dumps(green_score_receipt(candidate_sha)), encoding="utf-8"
     )
@@ -258,6 +326,7 @@ def green_certification_inputs(tmp_path: Path):
         "spine_sidecar": sidecar,
         "build_record": build_record,
         "score_receipt_path": score_receipt,
+        "reference_record": dict(GREEN_REFERENCE_RECORD),
         "exclusions_evaluated_on": date(2026, 8, 27),
         "certification_path": tmp_path / "release_certification.json",
     }
diff --git a/packages/microcosm-data/src/microcosm/data/contract.py b/packages/microcosm-data/src/microcosm/data/contract.py
index dd10dfb794..1323b545ad 100644
--- a/packages/microcosm-data/src/microcosm/data/contract.py
+++ b/packages/microcosm-data/src/microcosm/data/contract.py
@@ -426,25 +426,19 @@ def _is_hierarchy_diagnostics_version(value: object) -> bool:
 # armed. Held in lockstep with the committed spec by the build-shard sync
 # tests. The QRF tail-concentration gate and its pins were removed in
 # microcosm#1276.
-_UK_INPUT_MASS_RELATIVE_TOLERANCE = 4.521811483823806
+_UK_INPUT_MASS_RELATIVE_TOLERANCE = 5.9984285545209834
 _UK_INPUT_MASS_MINIMUM_REFERENCE_TOTAL = 0.0
-# Independent publication pin for the active reviewed reference source. The data
-# shard cannot import the build shard, so keep this in lockstep with
-# uk/gates.json reference_registry["efrs-post-calibration"].identity.
-_UK_INPUT_MASS_ACTIVE_REFERENCE = "efrs-post-calibration"
-_UK_INPUT_MASS_REFERENCE_IDENTITY = {
-    "filename": "enhanced_frs_2024_25.h5",
-    "revision": "a9e52499b6a6cca100a5ce4f36ca27b2e8a213df",
-    "sha256": "e433e532b17bd8ce76030156285816e33d44e93edabd2204adbef71d19a68712",
-    "vintage": "2024_25",
-}
-# Independent publication pin for the canonical
-# {"reference": {"identity": ..., "totals": ...}} evidence emitted from the
-# reviewed 131-column enhanced-FRS reference. The totals remain uncommitted
-# under the UKDS EUL; keep this in lockstep with
-# UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256 in the build shard.
-_UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256 = (
-    "fd41cb5f6cf6c4ef812320f21d1942173d49ce6f8725b21fbc9d9ca5423d298c"
+# The share of its reference total a column may lose (microcosm#1095).
+_UK_INPUT_MASS_MAXIMUM_RELATIVE_DROP = 0.9
+# The reference kind the spec names (microcosm#1095): the current build of the
+# cut's own line. The report records which build that was; the data shard
+# cannot import the build shard, so keep this in lockstep with uk/gates.json.
+_UK_INPUT_MASS_ACTIVE_REFERENCE = "current_build"
+_UK_INPUT_MASS_REFERENCE_IDENTITY_FIELDS = frozenset(
+    {"filename", "revision", "sha256", "vintage"}
+)
+_UK_CUT_REFERENCE_RELEASES = frozenset(
+    {"microcosm-uk-2024-25-national", "microcosm-uk-2024-25-dense"}
 )
 _UK_TERMINAL_GATE_DETAIL_FIELDS = {
     "uk_release_input_coverage": frozenset(
@@ -534,6 +528,8 @@ def _is_hierarchy_diagnostics_version(value: object) -> bool:
             "reference_name",
             "relative_tolerance",
             "minimum_reference_total",
+            "maximum_relative_drop",
+            "excess_drops",
             "columns_checked",
             "columns_below_reference_floor",
             "candidate_only_columns",
@@ -575,13 +571,13 @@ def _is_hierarchy_diagnostics_version(value: object) -> bool:
 # fingerprint derives from the manifest digest. Editing the spec moves all
 # three here in the same reviewed change.
 _UK_GATE_BATTERY_POLICY_SHA256 = (
-    "0d148ddccb8f126e4d64cfce94e820cec8d2adaccfc57fb87bb5f5ef2fc09106"
+    "9cd311cb488a3050d1c15ab7d96c14cd899f2bdb1f0f0da2a8e36252290cf99b"
 )
 _UK_GATE_BATTERY_GATES_MANIFEST_SHA256 = (
-    "d3b13d6ce2a87aa0d9b87066cd46c3aa03b6c031dbb4c9d5ec44dc33e273bf63"
+    "f30e991b5c81ca2a55b451e4d340028790648cb9d760f25a9ae9e1cdb9414276"
 )
 _UK_GATE_BATTERY_SPEC_FINGERPRINT = (
-    "a7c86e189ecaea1061f7e280f0c63d5a6e13449e4a1f3a1be618eae8909a12e0"
+    "80267b3772f143ee31a4674c3d13fd273c255449b23ac298ef3c67ef210296b5"
 )
 #: Spec entry id -> the legacy gate name whose observable detail checks
 #: apply unchanged (the battery re-keys the report by entry id; the gate
@@ -819,13 +815,10 @@ def _is_hierarchy_diagnostics_version(value: object) -> bool:
         "uk_cgt_projection_entrants",
     }
 )
-# The input-mass binding's evidence payload wraps the reviewed reference
-# digest as {"reference_evidence_sha256": ...} before the executor's
-# canonical hash; this pins the wrapped digest so the entry's evidence line
-# still binds the enhanced-FRS incumbent totals.
-_UK_GATE_BATTERY_INPUT_MASS_EVIDENCE_SHA256 = (
-    "24bb96f93de3bda45425b797a2f5069df7477bf3a56616080cc04376beab56e5"
-)
+# The input-mass binding's evidence payload digests the reference build's
+# own totals (microcosm#1095), so it differs from cut to cut and is not pinned:
+# the entry's details name the build, and its evidence line binds that build's
+# totals.
 # The degenerate binding's evidence payload digests the resolved exclusion
 # records; for a release that must be the committed register, so its digest
 # is a vintage pin that moves with every reviewed register edit (the same
@@ -998,9 +991,119 @@ def _uk_line_cut_tag_re(release_id: str) -> re.Pattern[str] | None:
     "calibration_seam": "terminal_gates.json",
     "release_cut": "release_cut_gates.json",
 }
-_UK_CERTIFICATION_SCORE_RECEIPT_FILE = "score_vs_enhanced_frs.json"
-_UK_RELEASE_CERTIFICATION_SCHEMA_VERSION = 1
+#: The head-to-head receipt against the cut's reference, the current
+#: national build (microcosm#1095); certification schema 1 named
+#: ``score_vs_enhanced_frs.json``, a strict score against the enhanced FRS.
+#: Only new builds are validated (the assemblers call this contract), at the
+#: spec they are assembled under, so schema 1 has no path here.
+_UK_CERTIFICATION_SCORE_RECEIPT_FILE = "score_vs_reference.json"
+_UK_RELEASE_CERTIFICATION_SCHEMA_VERSION = 2
+_UK_CERTIFICATION_REFERENCE_FIELDS = frozenset(
+    {"release", "build", "filename", "sha256", "built_with_model_package", "selection"}
+)
+#: How a cut chose its reference: the national line's current build, or a
+#: listed build pinned for a line with none (microcosm#1095).
+_UK_CERTIFICATION_REFERENCE_SELECTIONS = frozenset({"current", "pinned"})
 _UK_RELEASE_CERTIFICATION_KIND = "uk_release_certification"
+_UK_CERTIFICATION_SINCE_BASELINE_FIELDS = frozenset(
+    {
+        "baseline",
+        "restarted_from",
+        "input_mass_ratios",
+        "input_mass_left",
+        "baseline_inputs",
+        "inputs_dropped",
+    }
+)
+#: Mirrors of microcosm-build's ``UK_NATIONAL_SINCE_BASELINE_ORIGIN`` (where
+#: the national record of change since the baseline starts; a chain that
+#: starts elsewhere has restarted) and ``UK_SINCE_BASELINE_LEFT_REASONS``
+#: (why a column leaves that record), from round 2 of the review of
+#: microcosm#1574.
+_UK_NATIONAL_SINCE_BASELINE_ORIGIN = (
+    f"{_UK_NATIONAL_RELEASE_ID}@uk-frs-calibration-attempt-20261107T020434Z-eeb6093e"
+)
+_UK_SINCE_BASELINE_LEFT_REASONS = ("absent", "zero_reference_total", "thin")
+
+
+def _check_uk_certification_since_baseline(
+    since: object, *, file: str, failures: list[str]
+) -> None:
+    """The certification's record of change since a fixed national baseline."""
+
+    if not isinstance(since, Mapping) or set(since) != (
+        _UK_CERTIFICATION_SINCE_BASELINE_FIELDS
+    ):
+        failures.append(
+            f"{file} since_baseline must record exactly "
+            f"{sorted(_UK_CERTIFICATION_SINCE_BASELINE_FIELDS)}."
+        )
+        return
+    baseline = since.get("baseline")
+    ratios = since.get("input_mass_ratios")
+    left = since.get("input_mass_left")
+    inputs = since.get("baseline_inputs")
+    dropped = since.get("inputs_dropped")
+    names_ok = all(
+        isinstance(names, list)
+        and all(isinstance(name, str) and name for name in names)
+        for names in (inputs, dropped)
+    )
+
+    def national_build(label: object) -> bool:
+        return (
+            isinstance(label, str)
+            and label.startswith(f"{_UK_NATIONAL_RELEASE_ID}@")
+            and label != f"{_UK_NATIONAL_RELEASE_ID}@"
+        )
+
+    def ratio(value: object) -> bool:
+        return (
+            isinstance(value, int | float)
+            and not isinstance(value, bool)
+            and math.isfinite(float(value))
+            and float(value) >= 0.0
+        )
+
+    if (
+        not national_build(baseline)
+        or not isinstance(ratios, Mapping)
+        or not all(ratio(value) for value in ratios.values())
+        or not isinstance(left, Mapping)
+        or not all(
+            isinstance(entry, Mapping)
+            and set(entry) == {"reason", "last_ratio", "last_build"}
+            and entry["reason"] in _UK_SINCE_BASELINE_LEFT_REASONS
+            and ratio(entry["last_ratio"])
+            and national_build(entry["last_build"])
+            and column not in ratios
+            for column, entry in left.items()
+        )
+        or not names_ok
+        or not set(dropped) <= set(inputs)
+    ):
+        failures.append(
+            f"{file} since_baseline must name a national baseline build, a "
+            "finite non-negative ratio per column, each column that left the "
+            "chain with its reason, last ratio and last national build, and "
+            "the baseline's inputs with those this build no longer carries."
+        )
+        return
+    # A chain that starts anywhere but the line's origin has restarted, and
+    # says so (round 2 of the review of microcosm#1574).
+    expected = (
+        None
+        if baseline == _UK_NATIONAL_SINCE_BASELINE_ORIGIN
+        else _UK_NATIONAL_SINCE_BASELINE_ORIGIN
+    )
+    if since.get("restarted_from") != expected:
+        failures.append(
+            f"{file} since_baseline must record restarted_from {expected!r}: "
+            f"the national chain starts at {_UK_NATIONAL_SINCE_BASELINE_ORIGIN}, "
+            "and one that starts at another build has restarted."
+        )
+
+
 _UK_CERTIFICATION_SHARED_GATE_IDS = frozenset({"uk_aggregate_admin"})
 _UK_CERTIFICATION_EXCLUDED_GATE_IDS = frozenset(
     {
@@ -1139,10 +1242,10 @@ def _uk_line_cut_tag_re(release_id: str) -> re.Pattern[str] | None:
     },
     "release_cut": {
         "gates_manifest_sha256": (
-            "21c3d7bc17d2e80dccc87d9d063f96dd51f6f93e9631cf429bdc7fbc7be16fc3"
+            "ec65cc4e465293f7ec6838e2bb6baa7cdd1e239db0aefb40abc0b663b927471d"
         ),
         "policy_sha256": (
-            "49bd5dbb2a744ad9c61bd67c67ccfaf34a3d25a0fb321acd4a98b060d123b8bb"
+            "47183e92f6acff807240aa9fff121a18650e336ff877f5507caf88611c0014d4"
         ),
     },
 }
@@ -1156,6 +1259,10 @@ def _uk_line_cut_tag_re(release_id: str) -> re.Pattern[str] | None:
         # The spine whose stage receipts the release cut measured, bound by
         # the certifier to the parent the calibration recorded.
         "parent_spine",
+        # The current national build the cut was compared with.
+        "reference",
+        # The change since a fixed baseline, chained across cuts.
+        "since_baseline",
         "parts",
         "spec",
         "doctrine",
@@ -2394,6 +2501,30 @@ def _check_uk_terminal_gate_links(
             )
 
 
+def _uk_input_mass_reference_named(identity: object, label: object) -> bool:
+    """Whether an input-mass report names the UK build it compared with."""
+
+    if not isinstance(identity, Mapping) or set(identity) != set(
+        _UK_INPUT_MASS_REFERENCE_IDENTITY_FIELDS
+    ):
+        return False
+    if not isinstance(label, str) or label.count("@") != 1:
+        return False
+    release, build = label.split("@", 1)
+    sha256 = identity.get("sha256")
+    return (
+        release in _UK_CUT_REFERENCE_RELEASES
+        and bool(build)
+        and identity.get("revision") == build
+        and isinstance(sha256, str)
+        and _SHA256_RE.fullmatch(sha256) is not None
+        and all(
+            isinstance(identity.get(field), str) and identity.get(field)
+            for field in ("filename", "vintage")
+        )
+    )
+
+
 def _uk_terminal_observable_matches(observed: object, expected: object) -> bool:
     """Compare JSON observables without letting booleans masquerade as counts."""
 
@@ -2629,12 +2760,14 @@ def _check_uk_terminal_gate_observables(
                 f"{_UK_TERMINAL_GATE_REPORT_FILE} input_mass_parity.details."
                 "reference_scope_note must be a non-empty string."
             )
-        identity = input_mass.get("reference_identity")
-        if identity != _UK_INPUT_MASS_REFERENCE_IDENTITY:
+        if not _uk_input_mass_reference_named(
+            input_mass.get("reference_identity"), input_mass.get("reference_label")
+        ):
             failures.append(
-                f"{_UK_TERMINAL_GATE_REPORT_FILE} input_mass_parity.details."
-                "reference_identity must match the active reviewed "
-                f"efrs-post-calibration reference {_UK_INPUT_MASS_REFERENCE_IDENTITY}."
+                f"{_UK_TERMINAL_GATE_REPORT_FILE} input_mass_parity.details must "
+                "name the reference build it compared with: reference_label "
+                "<release>@<build> of a UK line, and reference_identity with that "
+                "build's file name and sha256."
             )
         if not _uk_terminal_observable_matches(
             input_mass.get("relative_tolerance"),
@@ -2654,6 +2787,20 @@ def _check_uk_terminal_gate_observables(
                 "minimum_reference_total must equal the committed spec value "
                 f"{_UK_INPUT_MASS_MINIMUM_REFERENCE_TOTAL}."
             )
+        if not _uk_terminal_observable_matches(
+            input_mass.get("maximum_relative_drop"),
+            _UK_INPUT_MASS_MAXIMUM_RELATIVE_DROP,
+        ):
+            failures.append(
+                f"{_UK_TERMINAL_GATE_REPORT_FILE} input_mass_parity.details."
+                "maximum_relative_drop must equal the committed spec value "
+                f"{_UK_INPUT_MASS_MAXIMUM_RELATIVE_DROP}."
+            )
+        if input_mass.get("excess_drops") != []:
+            failures.append(
+                f"{_UK_TERMINAL_GATE_REPORT_FILE} passing input-mass parity "
+                "requires details.excess_drops to be an empty list."
+            )
         if input_mass.get("stale_exclusions") != []:
             failures.append(
                 f"{_UK_TERMINAL_GATE_REPORT_FILE} passing input-mass parity "
@@ -2942,15 +3089,6 @@ def _check_uk_terminal_gate_report(
                 f"{_UK_TERMINAL_GATE_REPORT_FILE} attestation.evidence_sha256 "
                 "must exactly match build_manifest.json terminal_gate_evidence."
             )
-        if (
-            "input_mass_parity" in build_evidence
-            and evidence.get("input_mass_parity")
-            != _UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256
-        ):
-            failures.append(
-                f"{_UK_TERMINAL_GATE_REPORT_FILE} input_mass_parity evidence "
-                "digest must bind the reviewed enhanced-FRS incumbent totals."
-            )
         diagnostic_weights: Mapping | None = None
         if calibration_diagnostics is not None:
             uk = calibration_diagnostics.get("uk_diagnostics")
@@ -3322,15 +3460,6 @@ def _check_uk_gate_battery_report(
             value=digest,
             failures=failures,
         )
-    if (
-        "uk_input_mass_parity" in evidence
-        and evidence.get("uk_input_mass_parity")
-        != _UK_GATE_BATTERY_INPUT_MASS_EVIDENCE_SHA256
-    ):
-        failures.append(
-            f"{file} uk_input_mass_parity evidence digest must bind the "
-            "reviewed enhanced-FRS incumbent totals."
-        )
     if (
         "uk_degenerate_release_surface" in evidence
         and evidence.get("uk_degenerate_release_surface")
@@ -3499,6 +3628,39 @@ def _check_uk_release_certification(
             f"{file} release_id {certification.get('release_id')!r} does not "
             f"match the release under validation ({release_id!r})."
         )
+    reference = certification.get("reference")
+    if (
+        not isinstance(reference, Mapping)
+        or set(reference) != _UK_CERTIFICATION_REFERENCE_FIELDS
+    ):
+        failures.append(
+            f"{file} reference must name the build the cut was compared with: "
+            f"exactly {sorted(_UK_CERTIFICATION_REFERENCE_FIELDS)}."
+        )
+    else:
+        package = reference.get("built_with_model_package")
+        if (
+            reference.get("release") != _UK_NATIONAL_RELEASE_ID
+            or not isinstance(reference.get("build"), str)
+            or not reference.get("build")
+            or not isinstance(reference.get("filename"), str)
+            or not reference.get("filename")
+            or not isinstance(reference.get("sha256"), str)
+            or not _SHA256_RE.fullmatch(reference.get("sha256"))
+            or not isinstance(package, Mapping)
+            or set(package) != {"name", "version"}
+            or package.get("name") != "policyengine-uk"
+            or not isinstance(package.get("version"), str)
+            or reference.get("selection") not in _UK_CERTIFICATION_REFERENCE_SELECTIONS
+        ):
+            failures.append(
+                f"{file} reference must be a build of {_UK_NATIONAL_RELEASE_ID} "
+                "with its file name, sha256 digest, built-with policyengine-uk "
+                "version and selection (current or pinned)."
+            )
+    _check_uk_certification_since_baseline(
+        certification.get("since_baseline"), file=file, failures=failures
+    )
     parent_spine = certification.get("parent_spine")
     parent_sha = (
         parent_spine.get("sha256") if isinstance(parent_spine, Mapping) else None
diff --git a/packages/microcosm-data/src/microcosm/data/loader.py b/packages/microcosm-data/src/microcosm/data/loader.py
index ed61d2dd00..e5535d85e4 100644
--- a/packages/microcosm-data/src/microcosm/data/loader.py
+++ b/packages/microcosm-data/src/microcosm/data/loader.py
@@ -63,12 +63,16 @@
 )
 
 __all__ = [
+    "CertifiedRelease",
     "available",
     "available_variants",
     "resolve",
     "latest_year",
     "download",
+    "download_build_file",
+    "download_certified",
     "load",
+    "resolve_certified",
 ]
 
 _SHA256_PATTERN = re.compile(r"[0-9a-fA-F]{64}")
@@ -99,7 +103,7 @@ class _PackageCertification:
 
 
 @dataclass(frozen=True)
-class _CertifiedRelease:
+class CertifiedRelease:
     """A release's certified dataset: where it is and what it was built with.
 
     For a build-folder release, ``build`` is the build that was loaded,
@@ -117,6 +121,9 @@ class _CertifiedRelease:
     build: str | None = None
 
 
+_CertifiedRelease = CertifiedRelease
+
+
 class _CertifiedPackageCompatibilityError(ValueError):
     """Installed package versions do not satisfy a release certificate."""
 
@@ -707,9 +714,13 @@ def _resolve_certified_release(
 
 
 def _verified_download(
-    spec: DatasetSpec, *, build: str | None = None
+    spec: DatasetSpec,
+    *,
+    build: str | None = None,
+    hub_download: _HubDownload | None = None,
 ) -> tuple[Path, _CertifiedRelease]:
-    hub_download = _hub_download()
+    if hub_download is None:
+        hub_download = _hub_download()
     certified = _resolve_certified_release(spec, hub_download=hub_download, build=build)
     artifact_path = Path(
         hub_download(
@@ -765,6 +776,118 @@ def download(
     return path
 
 
+def resolve_certified(
+    country: str,
+    year: int | None = None,
+    *,
+    variant: str = DEFAULT_VARIANT,
+    build: str | None = None,
+    hub_download: _HubDownload | None = None,
+) -> CertifiedRelease:
+    """Say which build :func:`download_certified` would download, without it.
+
+    Reads only the release record and the build's manifest, with the same
+    checks; the dataset itself is neither downloaded nor verified.
+    """
+    spec = resolve(country, year, variant=variant)
+    return _resolve_certified_release(spec, hub_download=hub_download, build=build)
+
+
+def download_certified(
+    country: str,
+    year: int | None = None,
+    *,
+    variant: str = DEFAULT_VARIANT,
+    build: str | None = None,
+    hub_download: _HubDownload | None = None,
+) -> tuple[Path, CertifiedRelease]:
+    """Download and SHA-verify a certified dataset, and say which build it is.
+
+    The same resolution and checks as :func:`download`, returning with the
+    path the build's record: its release, build, artifact path and SHA-256,
+    and the model and Core versions it was built with. Unlike :func:`load`,
+    it neither enforces the installed engine's versions nor constructs a
+    dataset, so a comparison can read a build under the engine it runs (a UK
+    cut compares its candidate with the current build this way).
+
+    Raises:
+        ImportError: If ``huggingface_hub`` is not installed.
+        ValueError: If release metadata or the artifact digest is invalid.
+    """
+    spec = resolve(country, year, variant=variant)
+    return _verified_download(spec, build=build, hub_download=hub_download)
+
+
+def download_build_file(
+    certified: CertifiedRelease,
+    key: str,
+    *,
+    hub_download: _HubDownload | None = None,
+) -> Path:
+    """Download one file a build's release manifest declares, SHA-verified.
+
+    ``key`` names an entry of the build's ``release_manifest.json``
+    ``artifacts``; the file is read from the build's own folder, which never
+    changes after publishing.
+
+    Raises:
+        ValueError: If the release keeps the tagged layout (no build folder),
+            the manifest declares no such artifact, or its digest differs.
+    """
+    if certified.build is None:
+        raise ValueError(
+            f"Release {certified.release_id!r} keeps the tagged layout; only a "
+            "build published into its own folder declares its files there."
+        )
+    if hub_download is None:
+        hub_download = _hub_download()
+    folder = build_folder(certified.release_id, certified.build)
+    manifest = _load_manifest(
+        Path(
+            hub_download(
+                repo_id=certified.artifact_repo_id,
+                filename=f"{folder}/release_manifest.json",
+                repo_type="dataset",
+            )
+        ),
+        repo_id=certified.artifact_repo_id,
+        release_id=certified.release_id,
+    )
+    artifacts = _required_mapping(
+        manifest, "artifacts", release_id=certified.release_id
+    )
+    artifact = artifacts.get(key)
+    if not isinstance(artifact, Mapping):
+        raise ValueError(
+            f"Build {certified.build!r} of release {certified.release_id!r} "
+            f"declares no artifact {key!r}."
+        )
+    name = artifact.get("path")
+    expected = artifact.get("sha256")
+    if not isinstance(name, str) or not name or "/" in name:
+        raise ValueError(
+            f"Build {certified.build!r} artifact {key!r} has no bare file name."
+        )
+    if not isinstance(expected, str) or not _SHA256_PATTERN.fullmatch(expected):
+        raise ValueError(
+            f"Build {certified.build!r} artifact {key!r} has no valid sha256."
+        )
+    path = Path(
+        hub_download(
+            repo_id=certified.artifact_repo_id,
+            filename=f"{folder}/{name}",
+            repo_type="dataset",
+        )
+    )
+    observed = _sha256(path)
+    if observed != expected.lower():
+        raise ValueError(
+            f"sha256 verification failed for build {certified.build!r} artifact "
+            f"{key!r}: expected {expected.lower()}; observed {observed}."
+        )
+    return path
+
+
 def _dataset_class(spec: DatasetSpec):
     try:
         module = importlib.import_module(spec.engine_module)
diff --git a/packages/microcosm-data/tests/engine_free/shared/test_contract.py b/packages/microcosm-data/tests/engine_free/shared/test_contract.py
index 24f448da45..70a18e5368 100644
--- a/packages/microcosm-data/tests/engine_free/shared/test_contract.py
+++ b/packages/microcosm-data/tests/engine_free/shared/test_contract.py
@@ -89,47 +89,26 @@
     "release_parity": ("export_surface", "target_surface", "target_fit"),
     "input_mass_parity": ("input_mass_parity",),
 }
+UK_INPUT_MASS_REFERENCE_BUILD = "uk-frs-calibration-attempt-20261107T020434Z-eeb6093e"
+UK_INPUT_MASS_REFERENCE_LABEL = (
+    f"microcosm-uk-2024-25-national@{UK_INPUT_MASS_REFERENCE_BUILD}"
+)
 UK_INPUT_MASS_REFERENCE_IDENTITY = {
-    "filename": "enhanced_frs_2024_25.h5",
-    "revision": "a9e52499b6a6cca100a5ce4f36ca27b2e8a213df",
-    "sha256": "e433e532b17bd8ce76030156285816e33d44e93edabd2204adbef71d19a68712",
+    "filename": "microcosm_uk_2024_25.h5",
+    "revision": UK_INPUT_MASS_REFERENCE_BUILD,
+    "sha256": "9" * 64,
     "vintage": "2024_25",
 }
-UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256 = (
-    "fd41cb5f6cf6c4ef812320f21d1942173d49ce6f8725b21fbc9d9ca5423d298c"
-)
-UK_INPUT_MASS_ACTIVE_REFERENCE = "efrs-post-calibration"
+UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256 = "8" * 64
+UK_INPUT_MASS_ACTIVE_REFERENCE = "current_build"
 UK_INPUT_MASS_REFERENCE_SCOPE_NOTE = (
-    "Channel-blind post-calibration enhanced-FRS production incumbent, pinned "
-    "to the 2024-25 line; structurally lacks the SPI clone channel, so "
-    "SPI-channel-exclusive columns are comparable only through per-reference "
-    "reviewed exclusions."
+    "The current build of the cut's own release line, as releases.json named "
+    "it when the cut fetched its inputs (microcosm#1095): totals at each "
+    "build's own solved weights, on the export surface."
 )
-# The committed per-reference register (microcosm#1063 c9): the policy payloads
-# sealed into the input-mass evidence digest.
-UK_INPUT_MASS_REVIEWED_EXCLUSIONS: dict[str, dict[str, str]] = {
-    "dfe_education_spending": {
-        "reason": "The candidate carries DfE education spending through the build (GBP 98.8bn against the incumbent's GBP 52.8m, +187,061%): the enhanced-FRS reference carries almost none of this input, so the comparison measures the reference's omission, not the candidate's. The input stays on the release surface and in the coverage manifest.",
-        "approved_by": "juaristi22",
-        "adjudication": "microcosm#1063 c9 (certifier rehearsal R5 on the 2026-09-30 build, 2026-10-01; ruling 2026-10-02 in session)",
-        "approved_on": "2026-10-02",
-        "expires_on": "2027-04-02",
-    },
-    "property_wealth": {
-        "reason": "The candidate no longer ships household.property_wealth: policyengine-uk derives it as the sum of main_residence_value, other_residential_property_value and non_residential_property_value, and a persisted copy overrides that sum and has no uprating index (microcosm#1106, the uk-data#543 defect). The enhanced-FRS reference stores its own WAS total, so the column is present in the reference and absent from the candidate, which this gate otherwise fails whatever the tolerance. The gate compares the release surface (the export frame, reviewed exclusions dropped) on both paths, the national seam and the release cut; the three components stay compared.",
-        "approved_by": "juaristi22",
-        "adjudication": "microcosm#1106 (#1145): part B measured on the A9 candidate at 2025 and on the final-head arm c7 of 2026-10-11; ruling 2026-10-11 in session",
-        "approved_on": "2026-10-11",
-        "expires_on": "2027-04-11",
-    },
-    "tax_free_savings_income": {
-        "reason": "The candidate no longer ships person.tax_free_savings_income: policyengine-uk derives it as the sum of individual_savings_account_interest_income, which the candidate stores apart from non-ISA interest under the additive ISA income contract, and a persisted copy overrides that sum and is never uprated (microcosm#1360). The enhanced-FRS reference stores it in the legacy gross layout, so the column is present in the reference and absent from the candidate, which this gate otherwise fails whatever the tolerance. Non-ISA savings_interest_income stays compared; it falls below the reference's gross total by the ISA part.",
-        "approved_by": "juaristi22",
-        "adjudication": "microcosm#1360 folded into microcosm#1418's PR B (ruling 2026-10-28 in session)",
-        "approved_on": "2026-10-28",
-        "expires_on": "2027-04-28",
-    },
-}
+# The committed per-reference register is empty since the enhanced-FRS
+# reference retired (microcosm#1095).
+UK_INPUT_MASS_REVIEWED_EXCLUSIONS: dict[str, dict[str, str]] = {}
 GIT_COMMIT = "5fa48f07436a806ad75ff76fd22cfb8613bddbe0"
 DATASET_SHA = "d" * 64
 CALIBRATION_SHA = "a" * 64
@@ -227,20 +206,20 @@ def _trusted_terminal_gate_signing_key(monkeypatch) -> None:
 UK_GATE_BATTERY_PRODUCER = "microcosm.build.gate_battery"
 UK_GATE_BATTERY_SIGNING_KEY_ENV = "MICROCOSM_UK_TERMINAL_GATE_SIGNING_KEY"
 UK_GATE_BATTERY_POLICY_SHA256 = (
-    "0d148ddccb8f126e4d64cfce94e820cec8d2adaccfc57fb87bb5f5ef2fc09106"
+    "9cd311cb488a3050d1c15ab7d96c14cd899f2bdb1f0f0da2a8e36252290cf99b"
 )
 UK_GATE_BATTERY_GATES_MANIFEST_SHA256 = (
-    "d3b13d6ce2a87aa0d9b87066cd46c3aa03b6c031dbb4c9d5ec44dc33e273bf63"
+    "f30e991b5c81ca2a55b451e4d340028790648cb9d760f25a9ae9e1cdb9414276"
 )
 UK_GATE_BATTERY_SPEC_FINGERPRINT = (
-    "a7c86e189ecaea1061f7e280f0c63d5a6e13449e4a1f3a1be618eae8909a12e0"
+    "80267b3772f143ee31a4674c3d13fd273c255449b23ac298ef3c67ef210296b5"
 )
 UK_GATE_BATTERY_DEGENERATE_EVIDENCE_SHA256 = (
     "a6ebc171cadf45b691a2b83632bc1f87f3116ad31aebf073e3786ce90ecc0307"
 )
-UK_GATE_BATTERY_INPUT_MASS_EVIDENCE_SHA256 = (
-    "24bb96f93de3bda45425b797a2f5069df7477bf3a56616080cc04376beab56e5"
-)
+# The input-mass evidence digest covers the reference build's own totals, so
+# it is not pinned (microcosm#1095); a fixture value stands in.
+UK_GATE_BATTERY_INPUT_MASS_EVIDENCE_SHA256 = "7" * 64
 #: Spec entry id -> (neutral gate name, phase, legacy detail-schema name).
 #: microcosm#1240: the two report-only high-value homes gates.
 UK_DIAGNOSTIC_ENTRY_IDS = frozenset(
@@ -1182,8 +1161,10 @@ def _terminal_gate_details(name: str) -> dict:
         return {
             "candidate_name": "uk_release_candidate",
             "reference_name": UK_INPUT_MASS_REFERENCE_IDENTITY["filename"],
-            "relative_tolerance": 4.521811483823806,
+            "relative_tolerance": 5.9984285545209834,
             "minimum_reference_total": 0.0,
+            "maximum_relative_drop": 0.9,
+            "excess_drops": [],
             "columns_checked": 1,
             "columns_below_reference_floor": 0,
             "candidate_only_columns": [],
@@ -1198,6 +1179,8 @@ def _terminal_gate_details(name: str) -> dict:
             "reference": UK_INPUT_MASS_ACTIVE_REFERENCE,
             "reference_scope_note": UK_INPUT_MASS_REFERENCE_SCOPE_NOTE,
             "reference_identity": dict(UK_INPUT_MASS_REFERENCE_IDENTITY),
+            "reference_label": UK_INPUT_MASS_REFERENCE_LABEL,
+            "withheld_thin_columns": [],
         }
     if name == "take_up_signal":
         # Mirrors uk_take_up_signal_gate's per-column detail block.
@@ -1808,9 +1791,7 @@ def _write_uk_national_release_dir(tmp_path: Path) -> Path:
     (national / "release_cut_gates.json").write_text(
         json.dumps({"fixture": "release_cut"})
     )
-    (national / "score_vs_enhanced_frs.json").write_text(
-        json.dumps({"fixture": "score"})
-    )
+    (national / "score_vs_reference.json").write_text(json.dumps({"fixture": "score"}))
     certification = _green_uk_certification(
         TEST_UK_TERMINAL_GATE_SIGNING_KEY_BYTES,
         release_id=UK_NATIONAL_RELEASE_ID,
@@ -1820,7 +1801,7 @@ def _write_uk_national_release_dir(tmp_path: Path) -> Path:
             "calibration_seam": _sha256(national / "terminal_gates.json"),
             "release_cut": _sha256(national / "release_cut_gates.json"),
         },
-        score_receipt_sha256=_sha256(national / "score_vs_enhanced_frs.json"),
+        score_receipt_sha256=_sha256(national / "score_vs_reference.json"),
     )
     certification_path = national / "release_certification.json"
     certification_path.write_text(json.dumps(certification))
@@ -3250,37 +3231,33 @@ def test_exact_k_uk_terminal_rejects_unreviewed_input_mass_identity(
         validate_release_dir(directory)
 
     failures = "\n".join(excinfo.value.failures)
-    assert "reference_identity must match the active reviewed" in failures
+    assert "must name the reference build it compared with" in failures
 
 
-def test_exact_k_uk_terminal_rejects_substituted_input_mass_totals(
+def test_exact_k_uk_terminal_requires_the_reference_label(
     tmp_path: Path,
 ) -> None:
+    """The report must say which build it compared with (microcosm#1095)."""
+
     directory = _write_uk_release_dir(
         tmp_path,
         UK_EXACT_K_RELEASE_ID,
         tier="frs",
     )
-    payload, _evidence = _terminal_gate_payload(
+    payload, evidence = _terminal_gate_payload(
         release_id=UK_EXACT_K_RELEASE_ID,
         calibration_diagnostics_sha256=_sha256(
             directory / "calibration_diagnostics.json"
         ),
         evidence_stages=("input_mass_parity",),
     )
-    substituted = _canonical_sha256(
-        {
-            "reference": {
-                "identity": dict(UK_INPUT_MASS_REFERENCE_IDENTITY),
-                "totals": {"employment_income": 1.0},
-            }
-        }
+    payload["gates"]["input_mass_parity"]["details"]["reference_label"] = (
+        "microcosm-uk-2024-25-national@another-build"
     )
-    payload["attestation"]["evidence_sha256"]["input_mass_parity"] = substituted
     _refresh_terminal_gate_attestation(payload)
     build_path = directory / "build_manifest.json"
     build = json.loads(build_path.read_text())
-    build["terminal_gate_evidence"] = dict(payload["attestation"]["evidence_sha256"])
+    build["terminal_gate_evidence"] = evidence
     build_path.write_text(json.dumps(build))
     _write_terminal_and_refresh_manifest_hashes(directory, payload)
 
@@ -3288,7 +3265,7 @@ def test_exact_k_uk_terminal_rejects_substituted_input_mass_totals(
         validate_release_dir(directory)
 
     failures = "\n".join(excinfo.value.failures)
-    assert "must bind the reviewed enhanced-FRS incumbent totals" in failures
+    assert "must name the reference build it compared with" in failures
 
 
 def test_exact_k_uk_terminal_rejects_evidence_gate_without_its_stage(
@@ -5008,18 +4985,7 @@ def test_uk_gate_battery_pins_are_in_lockstep_with_the_contract() -> None:
         contract_module._UK_GATE_BATTERY_DEGENERATE_EVIDENCE_SHA256
         == UK_GATE_BATTERY_DEGENERATE_EVIDENCE_SHA256
     )
-    assert (
-        contract_module._UK_GATE_BATTERY_INPUT_MASS_EVIDENCE_SHA256
-        == UK_GATE_BATTERY_INPUT_MASS_EVIDENCE_SHA256
-    )
-    assert UK_GATE_BATTERY_INPUT_MASS_EVIDENCE_SHA256 == _canonical_sha256(
-        {
-            "reference": UK_INPUT_MASS_ACTIVE_REFERENCE,
-            "reference_evidence_sha256": UK_INPUT_MASS_REFERENCE_EVIDENCE_SHA256,
-            "exclusions_policy": "committed",
-            "reviewed_exclusions": UK_INPUT_MASS_REVIEWED_EXCLUSIONS,
-        }
-    )
+    assert not hasattr(contract_module, "_UK_GATE_BATTERY_INPUT_MASS_EVIDENCE_SHA256")
 
 
 def test_exact_k_uk_gate_battery_report_validates_end_to_end(tmp_path: Path) -> None:
@@ -5065,6 +5031,33 @@ def test_exact_k_uk_gate_battery_rejects_loosened_input_mass_tolerance(
     )
 
 
+def test_exact_k_uk_gate_battery_rejects_a_loosened_input_mass_drop_limit(
+    tmp_path: Path,
+) -> None:
+    # The drop limit is committed spec too (microcosm#1095).
+    directory, payload = _write_battery_release(tmp_path)
+    details = payload["gates"]["uk_input_mass_parity"]["details"]
+    details["maximum_relative_drop"] = 1.0
+    _rewrite_battery_report(directory, payload)
+
+    assert "maximum_relative_drop must equal the committed spec value" in (
+        _battery_failures(directory)
+    )
+
+
+def test_exact_k_uk_gate_battery_rejects_a_passing_report_with_excess_drops(
+    tmp_path: Path,
+) -> None:
+    directory, payload = _write_battery_release(tmp_path)
+    details = payload["gates"]["uk_input_mass_parity"]["details"]
+    details["excess_drops"] = ["employment_income"]
+    _rewrite_battery_report(directory, payload)
+
+    assert "requires details.excess_drops to be an empty list" in (
+        _battery_failures(directory)
+    )
+
+
 def test_exact_k_uk_gate_battery_rejects_a_blocked_report(tmp_path: Path) -> None:
     directory, payload = _write_battery_release(tmp_path)
     payload["blocked_at_phase"] = "terminal"
@@ -5312,9 +5305,12 @@ def test_exact_k_uk_gate_battery_rejects_a_recorded_signing_error(
     assert "attestation must contain exactly" in _battery_failures(directory)
 
 
-def test_exact_k_uk_gate_battery_rejects_an_unpinned_input_mass_evidence(
+def test_exact_k_uk_gate_battery_accepts_any_reference_builds_evidence(
     tmp_path: Path,
 ) -> None:
+    """The input-mass evidence digest covers the reference build's totals,
+    which change with every cut, so no digest is pinned (microcosm#1095)."""
+
     directory, payload = _write_battery_release(tmp_path)
     payload["evidence_sha256"]["uk_input_mass_parity"] = "b" * 64
     _rewrite_battery_report(directory, payload)
@@ -5324,7 +5320,7 @@ def test_exact_k_uk_gate_battery_rejects_an_unpinned_input_mass_evidence(
     build_path.write_text(json.dumps(build))
     _refresh_terminal_manifest_hashes(directory)
 
-    assert "bind the reviewed enhanced-FRS" in _battery_failures(directory)
+    validate_release_dir(directory)
 
 
 def test_exact_k_uk_gate_battery_rejects_mixed_manifest_evidence_vocabulary(
@@ -6060,7 +6056,7 @@ def _green_uk_certification(
             "statuses": {"passed": len(scope)},
         }
     certification = {
-        "schema_version": 1,
+        "schema_version": 2,
         "kind": "uk_release_certification",
         "country": "uk",
         "release_id": release_id,
@@ -6071,6 +6067,37 @@ def _green_uk_certification(
             "size_bytes": 1,
         },
         "parent_spine": {"sha256": "a" * 64},
+        "reference": {
+            "release": "microcosm-uk-2024-25-national",
+            "build": "uk-frs-calibration-attempt-20261107T020434Z-eeb6093e",
+            "filename": "microcosm_uk_2024_25.h5",
+            "sha256": "9" * 64,
+            "built_with_model_package": {
+                "name": "policyengine-uk",
+                "version": "2.174.1",
+            },
+            "selection": "current",
+        },
+        "since_baseline": {
+            "baseline": (
+                "microcosm-uk-2024-25-national@"
+                "uk-frs-calibration-attempt-20261107T020434Z-eeb6093e"
+            ),
+            "restarted_from": None,
+            "input_mass_ratios": {"employment_income": 1.02},
+            "input_mass_left": {
+                "gift_aid": {
+                    "reason": "thin",
+                    "last_ratio": 0.9,
+                    "last_build": (
+                        "microcosm-uk-2024-25-national@"
+                        "uk-frs-calibration-attempt-20261107T020434Z-eeb6093e"
+                    ),
+                }
+            },
+            "baseline_inputs": ["employment_income", "gift_aid"],
+            "inputs_dropped": ["gift_aid"],
+        },
         "parts": parts,
         "spec": {
             "gates_manifest_sha256": contract._UK_GATE_BATTERY_GATES_MANIFEST_SHA256,
@@ -6086,7 +6113,7 @@ def _green_uk_certification(
         "doctrine": {"payload": {"epochs": 1500}, "overrides": {}},
         "diagnostics_sha256": diagnostics_sha256,
         "score_receipt": {
-            "filename": "score_vs_enhanced_frs.json",
+            "filename": "score_vs_reference.json",
             "sha256": score_receipt_sha256,
         },
         "exclusions_evaluated_on": "2026-08-27",
@@ -6195,6 +6222,78 @@ def test_uk_release_certification_refusals(monkeypatch) -> None:
         for line in _certification_failures(certification, monkeypatch, key)
     )
 
+    # Schema 2 names the build the cut was compared with (microcosm#1095);
+    # a schema-1 certification against the enhanced FRS no longer validates.
+    certification = _green_uk_certification(key)
+    del certification["reference"]
+    assert any(
+        "exactly the certification fields" in line
+        for line in _certification_failures(certification, monkeypatch, key)
+    )
+    for broken in (
+        {"release": "microcosm-uk-2024-25-dense"},
+        {"sha256": "not-a-digest"},
+        {"built_with_model_package": {"name": "policyengine-us", "version": "1"}},
+        # A pinned reference is recorded as such (the review of microcosm#1574).
+        {"selection": "latest"},
+    ):
+        certification = _green_uk_certification(key)
+        certification["reference"].update(broken)
+        assert any(
+            "reference must be a build of" in line
+            for line in _certification_failures(certification, monkeypatch, key)
+        ), broken
+    # The change since a fixed baseline (the review of microcosm#1574).
+    left = _green_uk_certification(key)["since_baseline"]["input_mass_left"]["gift_aid"]
+    for broken in (
+        {"baseline": "microcosm-uk-2024-25-dense@x"},
+        {"input_mass_ratios": {"employment_income": -1.0}},
+        {"inputs_dropped": ["not_a_baseline_input"]},
+        # Round 2 of the review: each column that left the chain says why,
+        # with its last ratio and build, and is no longer in the ratios.
+        {"input_mass_left": {"gift_aid": {**left, "reason": "vanished"}}},
+        {"input_mass_left": {"gift_aid": {**left, "last_ratio": -0.5}}},
+        {"input_mass_left": {"gift_aid": {**left, "last_build": "elsewhere"}}},
+        {"input_mass_left": {"employment_income": left}},
+        {"input_mass_left": ["gift_aid"]},
+    ):
+        certification = _green_uk_certification(key)
+        certification["since_baseline"].update(broken)
+        assert any(
+            "since_baseline must name a national baseline" in line
+            for line in _certification_failures(certification, monkeypatch, key)
+        ), broken
+    certification = _green_uk_certification(key)
+    del certification["since_baseline"]["inputs_dropped"]
+    assert any(
+        "since_baseline must record exactly" in line
+        for line in _certification_failures(certification, monkeypatch, key)
+    )
+    # A chain that starts anywhere but the national origin has restarted,
+    # and says so; one that starts there has not.
+    origin = contract._UK_NATIONAL_SINCE_BASELINE_ORIGIN
+    for baseline, restarted_from, ok in (
+        (origin, None, True),
+        (origin, origin, False),
+        ("microcosm-uk-2024-25-national@older", origin, True),
+        ("microcosm-uk-2024-25-national@older", None, False),
+    ):
+        certification = _green_uk_certification(key)
+        certification["since_baseline"].update(
+            {"baseline": baseline, "restarted_from": restarted_from}
+        )
+        failures = _certification_failures(certification, monkeypatch, key)
+        assert ok != any("restarted_from" in line for line in failures), (
+            baseline,
+            restarted_from,
+        )
+    certification = _green_uk_certification(key)
+    certification["schema_version"] = 1
+    assert any(
+        "schema_version must be the integer 2" in line
+        for line in _certification_failures(certification, monkeypatch, key)
+    )
+
 
 def test_national_line_artifacts_require_the_certification(tmp_path) -> None:
     # A release that ships any national-line gate part without the composed
diff --git a/packages/microcosm-data/tests/engine_free/shared/test_loader.py b/packages/microcosm-data/tests/engine_free/shared/test_loader.py
index 132afaba9d..b3c50f052f 100644
--- a/packages/microcosm-data/tests/engine_free/shared/test_loader.py
+++ b/packages/microcosm-data/tests/engine_free/shared/test_loader.py
@@ -644,6 +644,113 @@ def test_download_verifies_the_build_folder_dataset(
         download("uk", 2025)
 
 
+def test_download_certified_returns_the_current_builds_record(
+    tmp_path: Path,
+) -> None:
+    hub = _build_folder_hub(tmp_path, manifest=_uk_build_folder_manifest())
+
+    # The fake build claims policyengine-uk ==2.89.2, which is not installed:
+    # a comparison reads a build under its own engine, so nothing refuses.
+    path, certified = loader.download_certified("uk", 2025, hub_download=hub)
+
+    folder = f"releases/{UK_NATIONAL_RELEASE_ID}/{UK_NATIONAL_BUILD}"
+    assert path.read_bytes() == UK_TAGGED_ARTIFACT
+    assert certified.release_id == UK_NATIONAL_RELEASE_ID
+    assert certified.build == UK_NATIONAL_BUILD
+    assert certified.artifact_path == f"{folder}/microcosm_uk_2024_25.h5"
+    assert certified.artifact_sha256 == hashlib.sha256(UK_TAGGED_ARTIFACT).hexdigest()
+    assert certified.model.built_version == "2.89.2"
+
+
+def _declare_build_file(
+    hub: FakeHubDownload,
+    tmp_path: Path,
+    manifest: dict,
+    *,
+    key: str,
+    name: str,
+    content: bytes,
+    declared: bytes | None = None,
+) -> None:
+    """Declare ``name`` in the build's manifest and serve ``content`` for it."""
+    manifest["artifacts"][key] = {
+        "kind": "diagnostics",
+        "path": name,
+        "repo_id": UK_REPO_ID,
+        "sha256": hashlib.sha256(content if declared is None else declared).hexdigest(),
+        "role": key,
+    }
+    folder = f"releases/{manifest['release']}/{manifest['build']}"
+    hub._add(
+        tmp_path,
+        UK_REPO_ID,
+        f"{folder}/release_manifest.json",
+        None,
+        json.dumps(manifest).encode(),
+    )
+    hub._add(tmp_path, UK_REPO_ID, f"{folder}/{name}", None, content)
+
+
+def test_download_build_file_reads_a_declared_file_from_the_build_folder(
+    tmp_path: Path,
+) -> None:
+    manifest = _uk_build_folder_manifest()
+    hub = _build_folder_hub(tmp_path, manifest=manifest)
+    _declare_build_file(
+        hub,
+        tmp_path,
+        manifest,
+        key="release_certification",
+        name="release_certification.json",
+        content=b'{"shippable": true}',
+    )
+    _, certified = loader.download_certified("uk", 2025, hub_download=hub)
+
+    path = loader.download_build_file(
+        certified, "release_certification", hub_download=hub
+    )
+
+    folder = f"releases/{UK_NATIONAL_RELEASE_ID}/{UK_NATIONAL_BUILD}"
+    assert path.read_bytes() == b'{"shippable": true}'
+    assert hub.calls[-1] == (UK_REPO_ID, f"{folder}/release_certification.json", None)
+    with pytest.raises(ValueError, match="declares no artifact 'gate_summary'"):
+        loader.download_build_file(certified, "gate_summary", hub_download=hub)
+
+
+def test_download_build_file_refuses_a_file_whose_digest_differs(
+    tmp_path: Path,
+) -> None:
+    manifest = _uk_build_folder_manifest()
+    hub = _build_folder_hub(tmp_path, manifest=manifest)
+    _declare_build_file(
+        hub,
+        tmp_path,
+        manifest,
+        key="release_certification",
+        name="release_certification.json",
+        content=b'{"shippable": false}',
+        declared=b'{"shippable": true}',
+    )
+    _, certified = loader.download_certified("uk", 2025, hub_download=hub)
+
+    with pytest.raises(ValueError, match="sha256 verification failed"):
+        loader.download_build_file(certified, "release_certification", hub_download=hub)
+
+
+def test_download_build_file_needs_a_build_folder_release() -> None:
+    tagged = loader.CertifiedRelease(
+        release_id=UK_NATIONAL_RELEASE_ID,
+        artifact_repo_id=UK_REPO_ID,
+        artifact_path="microcosm_uk_2024_25.h5",
+        artifact_revision=UK_NATIONAL_CUT_TAG,
+        artifact_sha256="0" * 64,
+        model=loader._PackageCertification("policyengine-uk", ("==2.89.2",), "2.89.2"),
+        core=loader._PackageCertification("policyengine-core", ("==3.27.1",), "3.27.1"),
+    )
+    with pytest.raises(ValueError, match="keeps the tagged layout"):
+        loader.download_build_file(tagged, "release_certification")
+
+
 def test_uk_2023_follows_latest_json_until_its_repository_has_releases_json(
     tmp_path: Path,
 ) -> None:
diff --git a/test_support/microcosm_build/uk_cut_reference.py b/test_support/microcosm_build/uk_cut_reference.py
new file mode 100644
index 0000000000..7df4493b3f
--- /dev/null
+++ b/test_support/microcosm_build/uk_cut_reference.py
@@ -0,0 +1,273 @@
+"""A stand-in for the UK repository's build folders, for cut-reference tests.
+
+``UKReferenceHub`` answers ``hf_hub_download`` calls from memory for
+``policyengine/populace-uk-private``: its ``releases.json`` and the build
+folders of the national and dense lines, each with a release manifest, a
+dataset and the evidence a cut's fetch reads (the national certification or
+the dense gate summary). A missing file raises the Hub's not-found error.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Any
+
+from test_support.microcosm_data.build_folders import build_folder_release_manifest
+from test_support.microcosm_data.hub_errors import missing_on_hub
+
+UK_REPO_ID = "policyengine/populace-uk-private"
+UK_NATIONAL_RELEASE = "microcosm-uk-2024-25-national"
+UK_DENSE_RELEASE = "microcosm-uk-2024-25-dense"
+UK_REGISTERED_KEY_SHA256 = (
+    "66bf0e29dbdabc2e3d7a79f21f43ac28d17b592faaf91e67c9bcf9b30c09a6ff"
+)
+
+_LINES = {
+    UK_NATIONAL_RELEASE: ("national", "microcosm_uk_2024_25"),
+    UK_DENSE_RELEASE: ("local_area", "microcosm_uk_2024_25_dense"),
+}
+
+
+def sha256_of(content: bytes) -> str:
+    return hashlib.sha256(content).hexdigest()
+
+
+def national_certification(dataset: bytes, **overrides: Any) -> dict[str, Any]:
+    """A certification with the fields a cut's fetch reads, shippable."""
+
+    certification: dict[str, Any] = {
+        "kind": "uk_release_certification",
+        "release_id": UK_NATIONAL_RELEASE,
+        "shippable": True,
+        "candidate": {"sha256": sha256_of(dataset)},
+        "attestation": {"signing_key_sha256": UK_REGISTERED_KEY_SHA256},
+    }
+    certification.update(overrides)
+    return certification
+
+
+def dense_gate_summary(**gate_overrides: dict[str, Any]) -> dict[str, Any]:
+    """A gate summary whose gates all passed, unless overridden."""
+
+    gates: dict[str, Any] = {
+        "uk_local_target_fit": {"failures": [], "passed": True, "status": "passed"},
+        "uk_local_weight_ratio": {"failures": [], "passed": True, "status": "passed"},
+    }
+    gates.update(gate_overrides)
+    return {
+        "schema_version": 1,
+        "gates": gates,
+        "diagnostic_gates": {},
+        "signed_report": "uk_local_gates.json",
+        "source": "microcosm_uk_2024_25_dense",
+    }
+
+
+class UKReferenceHub:
+    """In-memory ``hf_hub_download`` for the UK repository's build folders."""
+
+    def __init__(self, root: Path) -> None:
+        self.root = root
+        self.calls: list[str] = []
+        self._files: dict[str, Path] = {}
+        self._releases: dict[str, dict[str, Any]] = {
+            release: {"role": role, "current": None, "builds": {}}
+            for release, (role, _) in _LINES.items()
+        }
+        self._write_record()
+
+    def add_file(self, filename: str, content: bytes) -> None:
+        local = self.root / "hub" / filename
+        local.parent.mkdir(parents=True, exist_ok=True)
+        local.write_bytes(content)
+        self._files[filename] = local
+
+    def _write_record(self) -> None:
+        record = {
+            "schema_version": 1,
+            "default": UK_NATIONAL_RELEASE,
+            "releases": self._releases,
+        }
+        self.add_file("releases.json", json.dumps(record).encode())
+
+    def publish(
+        self,
+        release: str,
+        build: str,
+        *,
+        dataset: bytes,
+        evidence: dict[str, Any] | None = None,
+        current: bool = True,
+        model_version: str = "2.174.1",
+    ) -> None:
+        """Publish ``build`` of ``release`` into its folder; make it current."""
+
+        _, dataset_key = _LINES[release]
+        folder = f"releases/{release}/{build}"
+        evidence_key = (
+            "release_certification"
+            if release == UK_NATIONAL_RELEASE
+            else "gate_summary"
+        )
+        if evidence is None:
+            evidence = (
+                national_certification(dataset)
+                if release == UK_NATIONAL_RELEASE
+                else dense_gate_summary()
+            )
+        evidence_bytes = json.dumps(evidence).encode()
+        is_national = release == UK_NATIONAL_RELEASE
+        tagged = {
+            "schema_version": 1,
+            "data_package": {"name": "microcosm-data", "version": "0.1.0"},
+            "dataset_role": (
+                "national_default" if is_national else "non_default_local_area"
+            ),
+            "default_datasets": {"national": dataset_key} if is_national else {},
+            "build": {
+                "built_with_core_package": {
+                    "name": "policyengine-core",
+                    "version": "3.33.3",
+                },
+                "built_with_model_package": {
+                    "name": "policyengine-uk",
+                    "version": model_version,
+                },
+            },
+            "compatible_core_packages": [
+                {"name": "policyengine-core", "specifier": "==3.33.3"}
+            ],
+            "compatible_model_packages": [
+                {"name": "policyengine-uk", "specifier": f"=={model_version}"}
+            ],
+            "artifacts": {
+                dataset_key: {
+                    "kind": "microdata",
+                    "path": f"{dataset_key}.h5",
+                    "repo_id": UK_REPO_ID,
+                    "sha256": sha256_of(dataset),
+                },
+                evidence_key: {
+                    "kind": "diagnostics",
+                    "path": f"{evidence_key}.json",
+                    "repo_id": UK_REPO_ID,
+                    "sha256": sha256_of(evidence_bytes),
+                },
+            },
+        }
+        manifest = build_folder_release_manifest(tagged, release=release, build=build)
+        self.add_file(f"{folder}/release_manifest.json", json.dumps(manifest).encode())
+        self.add_file(f"{folder}/{dataset_key}.h5", dataset)
+        self.add_file(f"{folder}/{evidence_key}.json", evidence_bytes)
+        entry = self._releases[release]
+        entry["builds"][build] = {
+            "published_at": "2026-11-07T03:26:09+00:00",
+            "withdrawn": False,
+        }
+        if current:
+            entry["current"] = build
+        self._write_record()
+
+    def withdraw(self, release: str, build: str, *, current: str | None = None) -> None:
+        """Mark ``build`` withdrawn; the release's current moves to ``current``."""
+
+        entry = self._releases[release]
+        entry["builds"][build]["withdrawn"] = True
+        if entry["current"] == build or current is not None:
+            entry["current"] = current
+        self._write_record()
+
+    def __call__(
+        self,
+        *,
+        repo_id: str,
+        filename: str,
+        repo_type: str,
+        revision: str | None = None,
+    ) -> str:
+        assert repo_type == "dataset"
+        assert repo_id == UK_REPO_ID
+        self.calls.append(filename)
+        try:
+            return str(self._files[filename])
+        except KeyError as exc:
+            raise missing_on_hub(repo_id, filename, revision) from exc
+
+
+def stub_reference_evidence(reference, h5_path, output_dir):
+    """Write a reference's evidence without reading its dataset as a frame.
+
+    The stand-in datasets here are a few bytes, not H5 files; the input-mass
+    file carries the identity the done-checks read and one synthetic column.
+    """
+
+    from microcosm.build.uk_runtime.cut_reference import (
+        UK_CUT_REFERENCE_INPUT_MASS_NAME,
+        UK_CUT_REFERENCE_SURFACE_NAME,
+    )
+
+    destination = Path(output_dir) / UK_CUT_REFERENCE_INPUT_MASS_NAME
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    destination.write_text(
+        json.dumps(
+            {
+                "schema_version": 2,
+                "kind": "uk_input_mass_reference",
+                "label": reference.label,
+                "identity": {
+                    "filename": reference.filename,
+                    "revision": reference.build,
+                    "sha256": reference.sha256,
+                    "vintage": "2024_25",
+                },
+                "totals": {"employment_income": 1.0},
+                "carriers": {"employment_income": 3},
+                "since_baseline": {
+                    "baseline": reference.label,
+                    "ratios": {"employment_income": 1.0},
+                    "left": {},
+                },
+            }
+        )
+    )
+    surface = Path(output_dir) / UK_CUT_REFERENCE_SURFACE_NAME
+    surface.write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "kind": "uk_reference_surface",
+                "label": reference.label,
+                "sha256": reference.sha256,
+                "minimum_nondefault_mass_share": 1e-6,
+                "baseline": {"label": reference.label, "inputs": ["employment_income"]},
+                "export_columns": ["person.employment_income"],
+                "populated_inputs": ["employment_income"],
+                "thin_inputs": [],
+            }
+        )
+    )
+    return {"input_mass_reference": destination, "reference_surface": surface}
+
+
+def reference_surface(
+    *carried: str,
+    thin: tuple[str, ...] = (),
+    export_columns: tuple[str, ...] = ("person.employment_income",),
+    label: str = "microcosm-uk-2024-25-national@uk-frs-calibration-attempt-test",
+    sha256: str = "0" * 64,
+    floor: float = 1e-6,
+):
+    """A reference surface carrying ``carried`` inputs (and ``thin`` ones)."""
+
+    from microcosm.build.uk_runtime.reference_surface import UKReferenceSurface
+
+    return UKReferenceSurface(
+        label=label,
+        sha256=sha256,
+        export_columns=frozenset(export_columns),
+        populated_inputs=frozenset(carried),
+        thin_inputs=frozenset(thin),
+        minimum_nondefault_mass_share=floor,
+    )
diff --git a/test_support/microcosm_build/uk_release_input_coverage.py b/test_support/microcosm_build/uk_release_input_coverage.py
index b27357aedf..66e407c1f2 100644
--- a/test_support/microcosm_build/uk_release_input_coverage.py
+++ b/test_support/microcosm_build/uk_release_input_coverage.py
@@ -28,6 +28,7 @@
     uk_release_input_coverage_gate,
 )
 from microcosm.frame import EntitySchema, Frame, MassChangeRecord, WeightKind, Weights
+from test_support.microcosm_build.uk_cut_reference import reference_surface
 from test_support.paths import paths_for
 
 _TEST_PATHS = paths_for("microcosm-build")
@@ -71,10 +72,14 @@ def _weighted_person_frame(
     weight_kind: WeightKind = WeightKind.DESIGN,
     mass_log: tuple[MassChangeRecord, ...] = (),
     time_period: str | None = None,
+    source_ids: np.ndarray | None = None,
 ) -> Frame:
     weights = np.asarray(household_weights, dtype=float)
     n = len(weights)
     ids = np.arange(1, n + 1, dtype="int64")
+    household = pd.DataFrame({"household_id": ids})
+    if source_ids is not None:
+        household["household_source_id"] = np.asarray(source_ids)
     person = pd.DataFrame(
         {
             "person_id": ids,
@@ -87,7 +92,7 @@ def _weighted_person_frame(
         {
             "person": person,
             "benunit": pd.DataFrame({"benunit_id": ids}),
-            "household": pd.DataFrame({"household_id": ids}),
+            "household": household,
         },
         EntitySchema(group_entities=("benunit", "household")),
         {"household": Weights(values=weights, kind=weight_kind)},
@@ -121,6 +126,11 @@ def variable_entities(self, names) -> dict[str, str]:
         return {name: self._entities[name] for name in names if name in self._entities}
 
 
+#: A reference that carries no input: the test's manifest declares the
+#: required inputs itself, as every test did before microcosm#1095.
+NO_REFERENCE_INPUTS = reference_surface(export_columns=("person.age",))
+
+
 def _manifest(
     columns: tuple[UKReleaseInputColumn, ...],
     *,
diff --git a/tools/assemble_uk_release_dir.py b/tools/assemble_uk_release_dir.py
index d4ab612d2c..863cec7184 100644
--- a/tools/assemble_uk_release_dir.py
+++ b/tools/assemble_uk_release_dir.py
@@ -464,9 +464,10 @@ def _stage_and_finalize(
             "release_cut_gates.json",
         ),
         "spine_gates": (spine_report_path, "spine_gates.json"),
-        "score_vs_enhanced_frs": (
+        # The head-to-head with the reference (microcosm#1095).
+        "score_vs_reference": (
             args.score_receipt,
-            "score_vs_enhanced_frs.json",
+            "score_vs_reference.json",
         ),
     }
 
@@ -553,8 +554,8 @@ def artifact(key: str, kind: str, path: str, sha256: str) -> dict[str, str]:
                         "spine report",
                     ),
                     (
-                        "score_vs_enhanced_frs",
-                        evidence["score_vs_enhanced_frs"],
+                        "score_vs_reference",
+                        evidence["score_vs_reference"],
                         "score receipt",
                     ),
                 )
diff --git a/tools/build_uk_efrs_parity_reference.py b/tools/build_uk_efrs_parity_reference.py
index 74e0076c43..d4f56447f1 100644
--- a/tools/build_uk_efrs_parity_reference.py
+++ b/tools/build_uk_efrs_parity_reference.py
@@ -116,8 +116,9 @@ def _parse_args() -> argparse.Namespace:
         metavar="PATH",
         help=(
             "Write weighted per-column totals of the artifact's effective "
-            "input surface, in the schema the input_mass_parity terminal gate "
-            "consumes (#609), and exit. This does NOT regenerate the committed "
+            "input surface, in the schema-1 shape the input_mass_parity terminal "
+            "gate consumed (#609) until microcosm#1095 moved it to the current "
+            "build of the cut's own line, and exit. This does NOT regenerate the committed "
             "coverage reference: the destination must be outside the "
             "repository, because the totals are an operational gate input "
             "derived from licensed microdata."
diff --git a/tools/build_uk_release_input_coverage_manifest.py b/tools/build_uk_release_input_coverage_manifest.py
index 060679efe0..299c026498 100644
--- a/tools/build_uk_release_input_coverage_manifest.py
+++ b/tools/build_uk_release_input_coverage_manifest.py
@@ -168,6 +168,27 @@
     "charitable_investment_gifts",
     "gift_aid",
 )
+#: Inputs the current builds carry that a later build stops carrying on
+#: purpose (microcosm#1095). The coverage gate requires what the cut's
+#: reference carries, so each is a reviewed exclusion until a promotion moves
+#: the reference past it; then it is dormant and leaves. Signed rulings, not
+#: enhanced-FRS parity debt, so they sit here rather than in the ledger.
+RETIRED_SINCE_REFERENCE_EXCLUSIONS: dict[str, dict[str, str]] = {
+    "self_employment_gross_receipts": {
+        "reason": (
+            "microcosm#1550 (microcosm#1439) stops writing it: the trading "
+            "allowance stage stores each trader's trading_allowance_claim_status "
+            "and leaves gross receipts at the engine's zero, since neither the "
+            "FRS nor the SPI records them. The current builds (national "
+            "eeb6093e, dense 38605444) still carry the receipts encoding "
+            "microcosm#1428 wrote (María's signature of 2026-11-10)."
+        ),
+        "tracking_note": (
+            "microcosm#1095: remove once neither line's current build carries it."
+        ),
+    },
+}
+
 RESTORED_REQUIRED_COLUMN_EVIDENCE = {
     "charitable_investment_gifts": {
         "effective_signal_mass_share": 0.00028055329260683216,
@@ -858,53 +879,49 @@ def build_manifest(
 ) -> dict[str, Any]:
     reference = reference or _load(REFERENCE_PATH)
     known_gaps_payload = known_gaps_payload or _load(KNOWN_GAPS_PATH)
+    # The ledger is still checked against the frozen enhanced-FRS facts it
+    # was measured on; neither decides the required inputs any more.
     _validate_known_gaps(reference, known_gaps_payload)
     known_gaps = known_gaps_payload["known_gaps"]
     restored_required = set(known_gaps_payload["restored_required_columns"])
-    populated_layers = {
-        name
-        for name, share in reference["nonzero_shares"].items()
-        if float(share) > 0.0
-    }
-    columns: dict[str, dict[str, str]] = {}
     engine_derived = known_gaps_payload["engine_derived_exclusions"]
-    for name in sorted(populated_layers):
-        exclusion = known_gaps.get(name) or engine_derived.get(name)
-        if exclusion is not None:
-            columns[name] = {
-                "status": "reviewed_exclusion",
-                "reason": str(exclusion["reason"]),
-                "tracking_note": str(exclusion["tracking_note"]),
-            }
-        else:
-            columns[name] = {"status": "required"}
-
-    required = sorted(
-        name for name, entry in columns.items() if entry["status"] == "required"
-    )
-    reviewed = sorted(
-        name
-        for name, entry in columns.items()
-        if entry["status"] == "reviewed_exclusion"
-    )
-    source = reference["source"]
+    # Schema 4 (microcosm#1095): the required inputs are the ones the cut's
+    # reference build carries, measured at gate time, so the manifest
+    # declares only the reviewed exclusions.
+    retired = RETIRED_SINCE_REFERENCE_EXCLUSIONS
+    clash = sorted(set(retired) & ({*known_gaps, *engine_derived} | restored_required))
+    if clash:
+        raise ValueError(
+            "An input retired since the reference cannot also be a known gap, an "
+            f"engine-derived exclusion or a restored input: {clash}."
+        )
+    columns: dict[str, dict[str, str]] = {}
+    for name in sorted({*known_gaps, *engine_derived, *retired}):
+        exclusion = known_gaps.get(name) or engine_derived.get(name) or retired[name]
+        columns[name] = {
+            "status": "reviewed_exclusion",
+            "reason": str(exclusion["reason"]),
+            "tracking_note": str(exclusion["tracking_note"]),
+        }
     candidate_source = known_gaps_payload["candidate_evidence"]["source"]
     return {
-        "schema_version": 3,
+        "schema_version": 4,
         "description": (
-            "Declared full-coverage contract for a UK release: every populated "
-            "effective loader input in the pinned enhanced FRS must be persisted "
-            "with non-default signal, or carry a reviewed exclusion with the "
-            "campaign reason and tracking note."
+            "Release input-coverage contract for a UK cut: every loader input "
+            "the current build of the cut's line carries must be persisted "
+            "with non-default signal on the reviewed share of effective "
+            "population mass, unless it carries a reviewed exclusion here "
+            "with its reason and tracking note (microcosm#1095)."
         ),
         "reference": {
-            "derived_from": REFERENCE_PATH.name,
-            "filename": str(source["filename"]),
-            "revision": str(source["revision"]),
-            "sha256": str(source["sha256"]),
-            "vintage": str(source["vintage"]),
-            "period": str(source["period"]),
-            "populated_input_columns": len(populated_layers),
+            "kind": "current_build",
+            "required_inputs": (
+                "The loader inputs the current build of the cut's line "
+                "carries, measured by the coverage gate's own rule; the "
+                "cut's reference step records them in reference_surface.json. "
+                "Until microcosm#1095 they were the populated inputs of the "
+                "frozen enhanced-FRS reference."
+            ),
         },
         "candidate_evidence": {
             "derived_from": KNOWN_GAPS_PATH.name,
@@ -1040,25 +1057,20 @@ def build_manifest(
             ),
         },
         "derivation": (
-            "Surface = efrs_parity_reference.json populated effective loader "
-            "inputs. status='required' when the sha-pinned candidate evidence "
-            "records non-default signal on at least the reviewed owning-entity "
-            "effective-mass share OR the column is pinned in "
-            "restored_required_columns after a source-family restoration; all "
-            "remaining surface columns are reviewed_exclusion with reason "
+            "Columns = the reviewed exclusions of efrs_parity_known_gaps.json: "
+            "its known gaps, with reason "
             f"{EXCLUSION_REASON!r} and a UK_COVERAGE_PROGRESS.md tracking note, "
-            "except the engine_derived_exclusions, which are reviewed_exclusion "
-            "with their own reason because the engine computes them from "
-            "persisted inputs. "
-            "The final release gate applies the same effective-mass floor, and "
-            "distributional restorations must pass it on their required source "
-            "channel."
+            "and its engine_derived_exclusions, with their own reason because "
+            "the engine computes them from persisted inputs; and the inputs "
+            "the current builds carry that a later build stops carrying on "
+            "purpose, each a signed ruling until a promotion moves the "
+            "reference past it. Every other input "
+            "the cut's reference build carries is required. The gate applies "
+            "one effective-mass floor to the reference and the candidate, and "
+            "distributional restorations must pass it on their required "
+            "source channel."
         ),
-        "counts": {
-            "required": len(required),
-            "reviewed_exclusion": len(reviewed),
-            "total": len(columns),
-        },
+        "counts": {"reviewed_exclusion": len(columns)},
         "columns": columns,
     }
 
@@ -1394,8 +1406,9 @@ def main() -> int:
     _write_or_check(MANIFEST_PATH, manifest, check=args.check)
     action = "current" if args.check else "wrote"
     print(
-        f"{action}: {MANIFEST_PATH} — {manifest['counts']['required']} required, "
-        f"{manifest['counts']['reviewed_exclusion']} reviewed exclusions"
+        f"{action}: {MANIFEST_PATH} — "
+        f"{manifest['counts']['reviewed_exclusion']} reviewed exclusions; the "
+        "required inputs come from each cut's reference build"
     )
     return 0
 
diff --git a/tools/certify_uk_release_cut.py b/tools/certify_uk_release_cut.py
index 8f8c18682d..6739c5c85d 100644
--- a/tools/certify_uk_release_cut.py
+++ b/tools/certify_uk_release_cut.py
@@ -12,9 +12,12 @@
 only from the certification this driver writes.
 
 The battery always runs at release-candidate strictness: evidence_absent
-gaps block. The rule-1 score receipt is cross-pinned into the certification
-(the audit's third carried defect), so the score is signed run evidence
-rather than a null slot.
+gaps block. The head-to-head score receipt is cross-pinned into the
+certification (the audit's third carried defect), so the comparison is signed
+run evidence rather than a null slot. The certification names the reference
+the cut was compared with, the current national build the cut recorded
+(``--reference-record``, microcosm#1095), and refuses a receipt measured
+against any other.
 """
 
 from __future__ import annotations
@@ -57,13 +60,14 @@
     load_uk_calibration_measure_exclusions,
 )
 from microcosm.build.uk_runtime.national_frame import load_uk_national_frame
-from microcosm.build.uk_runtime.parity_reference import load_efrs_parity_reference
+from microcosm.build.uk_runtime.reference_surface import load_uk_reference_surface
 from microcosm.build.uk_runtime.release_certification import (
     compose_uk_release_certification,
     rehydrate_uk_fit_weight_records,
     run_uk_release_cut_battery,
     uk_release_parity_evidence,
 )
+from microcosm.build.uk_runtime.release_identity import UK_NATIONAL_RELEASE_ID
 from microcosm.build.uk_runtime.release_input_coverage import (
     PolicyEngineUKCoverageEngine,
 )
@@ -330,11 +334,11 @@ def _run(args: argparse.Namespace, state: AttemptState) -> dict[str, object]:
     # (importance weights, mass receipts); the candidate is calibrated.
     spine_frame, _spine_provenance = load_uk_national_frame(args.spine_h5)
     engine = PolicyEngineUKCoverageEngine()
+    reference_surface = _reference_surface(args)
     parity_evidence = uk_release_parity_evidence(
         frame,
         diagnostics_targets=diagnostics["targets"],
         reference_registry=reference_registry,
-        parity_reference=load_efrs_parity_reference(),
     )
     report = run_uk_release_cut_battery(
         frame,
@@ -349,7 +353,8 @@ def _run(args: argparse.Namespace, state: AttemptState) -> dict[str, object]:
         local_ledger_unsupported=local_ledger_unsupported,
         parity_evidence=parity_evidence,
         fit_weight_records=rehydrate_uk_fit_weight_records(sidecar),
-        input_mass_reference=load_uk_input_mass_reference(args.input_mass_reference),
+        input_mass_reference=_input_mass_reference(args),
+        reference_surface=reference_surface,
         exclusions_evaluated_on=evaluated_on,
         spine_frame=spine_frame,
     )
@@ -372,6 +377,7 @@ def _run(args: argparse.Namespace, state: AttemptState) -> dict[str, object]:
         spine_sidecar=sidecar,
         build_record=build_record,
         score_receipt_path=args.score_receipt,
+        reference_record=json.loads(args.reference_record.read_text()),
         exclusions_evaluated_on=evaluated_on,
         certification_path=args.certification_json,
     )
@@ -389,6 +395,62 @@ def _run(args: argparse.Namespace, state: AttemptState) -> dict[str, object]:
     }
 
 
+def _national_reference_record(args: argparse.Namespace) -> dict:
+    """The cut's reference record, refused unless it names a national build.
+
+    The certifier certifies the national line, so its reference is the
+    national line's (the review of microcosm#1574): a dense build's files
+    agree with a dense record, so the line itself is checked here.
+    """
+
+    reference = json.loads(args.reference_record.read_text())
+    if reference.get("release") != UK_NATIONAL_RELEASE_ID:
+        raise SystemExit(
+            f"error: the reference record names {reference.get('release')}, not "
+            f"{UK_NATIONAL_RELEASE_ID}; the certifier compares a national cut with "
+            "the national line's current build."
+        )
+    return reference
+
+
+def _input_mass_reference(args: argparse.Namespace):
+    """The cut's input-mass reference, refused unless it is the cut's reference.
+
+    The score and the input-mass gate compare with one build (microcosm#1095):
+    the reference record names it, and the input-mass file must too.
+    """
+
+    reference = _national_reference_record(args)
+    loaded = load_uk_input_mass_reference(args.input_mass_reference)
+    label = f"{reference.get('release')}@{reference.get('build')}"
+    if loaded.label != label or loaded.sha256 != reference.get("sha256"):
+        raise SystemExit(
+            f"error: the input-mass reference names {loaded.label} "
+            f"({loaded.sha256}), not the cut's reference {label}; write it from "
+            "the cut's reference (tools/run_uk_cut.py's reference step)."
+        )
+    return loaded
+
+
+def _reference_surface(args: argparse.Namespace):
+    """The cut's reference surface, refused unless it is the cut's reference.
+
+    The export-surface and input-coverage gates compare with the build the
+    score and the input-mass gate compare with (microcosm#1095).
+    """
+
+    reference = _national_reference_record(args)
+    loaded = load_uk_reference_surface(args.reference_surface)
+    label = f"{reference.get('release')}@{reference.get('build')}"
+    if loaded.label != label or loaded.sha256 != reference.get("sha256"):
+        raise SystemExit(
+            f"error: the reference surface names {loaded.label} "
+            f"({loaded.sha256}), not the cut's reference {label}; write it from "
+            "the cut's reference (tools/run_uk_cut.py's reference step)."
+        )
+    return loaded
+
+
 def _parse_args(argv: list[str] | None) -> argparse.Namespace:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--candidate-h5", required=True, type=Path)
@@ -407,7 +469,19 @@ def _parse_args(argv: list[str] | None) -> argparse.Namespace:
     parser.add_argument("--ledger-facts-sha256", required=True, type=_sha256)
     parser.add_argument("--ledger-manifest-sha256", required=True, type=_sha256)
     parser.add_argument("--input-mass-reference", required=True, type=Path)
+    parser.add_argument(
+        "--reference-surface",
+        required=True,
+        type=Path,
+        help="The export surface and carried inputs of the cut's reference.",
+    )
     parser.add_argument("--score-receipt", required=True, type=Path)
+    parser.add_argument(
+        "--reference-record",
+        required=True,
+        type=Path,
+        help="The cut's record of the reference it was compared with.",
+    )
     parser.add_argument("--release-id", required=True)
     parser.add_argument("--release-cut-gate-json", type=Path)
     parser.add_argument("--certification-json", type=Path)
@@ -429,6 +503,8 @@ def _parse_args(argv: list[str] | None) -> argparse.Namespace:
         "--release-cut-gate-json": args.release_cut_gate_json,
         "--certification-json": args.certification_json,
         "--score-receipt": args.score_receipt,
+        "--reference-record": args.reference_record,
+        "--reference-surface": args.reference_surface,
     }
     resolved: dict[Path, str] = {}
     for flag, path in distinct.items():
diff --git a/tools/extract_uk_local_incumbent_surface.py b/tools/extract_uk_local_incumbent_surface.py
index 243ca6a82c..5adb5cf315 100644
--- a/tools/extract_uk_local_incumbent_surface.py
+++ b/tools/extract_uk_local_incumbent_surface.py
@@ -216,10 +216,9 @@ def extract_incumbent_surface(
                 f"{incumbent_h5}: the local UC child bands read "
                 "benunit.uc_calibration_child_count, and this incumbent lacks "
                 f"its relationship inputs ({error.args[0]}). The enhanced FRS "
-                "is known not to carry that measure "
-                "(uk/incumbent_unresolvable_measures.json); the local extractor "
-                "does not prune listed measures, so use a Microcosm release as "
-                "the incumbent."
+                "is known not to carry that measure, and the local extractor "
+                "does not prune unresolvable measures, so use a Microcosm "
+                "release as the incumbent."
             ) from error
     metrics = metric_frames[0].copy()
     for frame in metric_frames[1:]:
diff --git a/tools/resolve_uk_reference.py b/tools/resolve_uk_reference.py
new file mode 100644
index 0000000000..65b99b90cc
--- /dev/null
+++ b/tools/resolve_uk_reference.py
@@ -0,0 +1,131 @@
+"""Resolve the current build a UK cut compares with, and keep its record.
+
+A UK cut checks and certifies its candidate against the current build of its
+own release line, as the Hub's ``releases.json`` names it (microcosm#1095):
+the national line against the national, the dense line against the dense.
+``tools/run_uk_cut.py`` resolves its reference itself, once, when it fetches
+its inputs. This command does the same for runs outside it, such as a dense
+build, and checks what a cut would compare with now::
+
+    uv run --no-sync python tools/resolve_uk_reference.py --release microcosm-uk-2024-25-dense --check
+    uv run --no-sync python tools/resolve_uk_reference.py --release microcosm-uk-2024-25-dense --output-dir ~/microcosm-uk-work/dense/reference
+
+``--check`` reads the release record, the build's manifest and its
+certification evidence, and downloads no dataset. ``--output-dir`` downloads
+the dataset, verifies its SHA-256, copies it there and writes
+``reference.json`` beside it, with ``input_mass_reference.json`` (the
+build's input-mass totals and carriers, licensed-data aggregates that stay
+with the run) and ``reference_surface.json`` (the columns it exports and the
+loader inputs it carries, names and flags only). A dense build takes
+``--input-mass-reference`` and ``--reference-surface`` from it. It refuses a
+directory that already holds a reference, so a run keeps the one it started
+with.
+
+Reading ``policyengine/populace-uk-private`` needs ``HF_TOKEN``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+from microcosm.build.uk_runtime.cut_reference import (
+    UK_CUT_REFERENCE_RECORD_NAME,
+    UK_CUT_REFERENCE_RELEASES,
+    check_uk_cut_reference,
+    fetch_uk_cut_reference,
+    write_uk_cut_reference_evidence,
+)
+
+
+def _parse_args(argv: Sequence[str] | None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument(
+        "--release", required=True, choices=sorted(UK_CUT_REFERENCE_RELEASES)
+    )
+    parser.add_argument(
+        "--build",
+        help=(
+            "Pin a listed build instead of the line's current one, for a line "
+            "with no current build; checked like the current build and recorded "
+            "as pinned."
+        ),
+    )
+    mode = parser.add_mutually_exclusive_group(required=True)
+    mode.add_argument("--check", action="store_true")
+    mode.add_argument("--output-dir", type=Path)
+    return parser.parse_args(argv)
+
+
+def fetch_reference(
+    release: str,
+    output_dir: Path,
+    *,
+    build: str | None = None,
+    hub_download=None,
+    write_evidence=write_uk_cut_reference_evidence,
+) -> dict:
+    """Download the current build of ``release`` into ``output_dir``.
+
+    Beside the dataset and its record go the evidence the gates read from it:
+    its input-mass totals and carriers (``input_mass_reference.json``) and its
+    surface (``reference_surface.json``), which a dense build takes with
+    ``--input-mass-reference`` and ``--reference-surface``.
+    """
+
+    reference = fetch_uk_cut_reference(
+        release, output_dir, build=build, hub_download=hub_download
+    )
+    written = write_evidence(reference, output_dir / reference.filename, output_dir)
+    return {
+        "reference": reference.label,
+        "sha256": reference.sha256,
+        "dataset": str(output_dir / reference.filename),
+        "record": str(output_dir / UK_CUT_REFERENCE_RECORD_NAME),
+        **{name: str(path) for name, path in written.items()},
+    }
+
+
+def main(
+    argv: Sequence[str] | None = None,
+    *,
+    hub_download=None,
+    write_evidence=write_uk_cut_reference_evidence,
+) -> int:
+    args = _parse_args(argv)
+    from microcosm.build.staging_dataset import hub_offline
+
+    if hub_offline():
+        # A cached releases.json can name a build that is no longer current
+        # (the review of microcosm#1574); run_uk_cut refuses offline too.
+        print(
+            "refused: unset HF_HUB_OFFLINE: the reference is the line's current "
+            "build, which only the Hub's releases.json can say.",
+            file=sys.stderr,
+        )
+        return 1
+    try:
+        if args.check:
+            summary = check_uk_cut_reference(
+                args.release, build=args.build, hub_download=hub_download
+            )
+        else:
+            summary = fetch_reference(
+                args.release,
+                args.output_dir.expanduser(),
+                build=args.build,
+                hub_download=hub_download,
+                write_evidence=write_evidence,
+            )
+    except ValueError as exc:
+        print(f"refused: {exc}", file=sys.stderr)
+        return 1
+    print(json.dumps(summary, indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tools/run_uk_cut.py b/tools/run_uk_cut.py
index f66e93c031..38ea236d99 100644
--- a/tools/run_uk_cut.py
+++ b/tools/run_uk_cut.py
@@ -19,6 +19,14 @@
 or a release directory. Re-run ``all`` after fixing the cause; a failed
 national run is moved aside only with ``--retry-national``.
 
+The cut checks and certifies its candidate against the current build of the
+national line, as the Hub's ``releases.json`` names it (microcosm#1095). The
+``reference`` step resolves it once per cut, into ``<cut>/reference/`` with
+its record; every later step reads that record, so a promotion while the cut
+runs does not change what it is compared with. ``--re-resolve-reference``
+sets the cut's reference aside and resolves the current build again; the
+score and the certification then run again against it.
+
 Outward-facing steps are opt-in. ``--publish`` publishes for inspection
 only, always with ``--no-latest --tag-only``, so the repository's main
 branch and its ``latest-*.json`` pointers never move. Promotion and the
@@ -54,6 +62,22 @@
 from pathlib import Path
 from typing import Any, Protocol
 
+from microcosm.build.uk_runtime.cut_reference import (
+    UK_CUT_REFERENCE_EVIDENCE_NAME,
+    UK_CUT_REFERENCE_INPUT_MASS_NAME,
+    UK_CUT_REFERENCE_RECORD_NAME,
+    UK_CUT_REFERENCE_SURFACE_NAME,
+    UKCutReference,
+    check_uk_cut_reference,
+    fetch_uk_cut_reference,
+    keep_uk_cut_reference_evidence,
+    read_uk_cut_reference,
+    uk_cut_reference_evidence_done,
+    uk_cut_reference_withdrawal,
+    verify_uk_cut_reference_file,
+    write_uk_cut_reference_evidence,
+)
+
 REPO_ROOT = Path(__file__).resolve().parents[1]
 UK_DIR = REPO_ROOT / "packages/microcosm-build/src/microcosm/build/uk"
 CUT_INPUTS = REPO_ROOT / "tools/uk_cut_inputs.json"
@@ -166,21 +190,10 @@ def committed_source_pins(uk_dir: Path = UK_DIR) -> dict[str, dict[str, Any]]:
     return pins
 
 
-def _gate_reference_identity(uk_dir: Path) -> Mapping[str, str]:
-    gates = json.loads((uk_dir / "gates.json").read_text())
-    entries = gates["gates"] if isinstance(gates, Mapping) else gates
-    for entry in entries:
-        if entry.get("gate") == "input_mass_parity":
-            params = entry["parameters"]
-            return params["reference_registry"][params["reference"]]["identity"]
-    raise CutError("gates.json declares no input_mass_parity reference identity.")
-
-
 #: The ``*_pin`` selectors a source may carry, each naming the committed pin
 #: a field is read from. Any other ``*_pin`` is refused, never ignored.
 PIN_SELECTORS: Mapping[str, frozenset[str]] = {
     "archive_sha256_pin": frozenset({"frs_release"}),
-    "revision_pin": frozenset({"gates:input_mass_parity"}),
     "path_in_repo_pin": frozenset({"chronicle_feed"}),
 }
 
@@ -208,7 +221,6 @@ def load_input_sources(
     stage_pins = committed_source_pins(uk_dir)
     feed = json.loads((uk_dir / "chronicle_feed.json").read_text())
     frs_release = json.loads((uk_dir / "frs_release.json").read_text())
-    reference = _gate_reference_identity(uk_dir)
     extra = manifest.get("file_pins", {})
     sources: list[InputSource] = []
     for raw in manifest["sources"]:
@@ -230,13 +242,6 @@ def load_input_sources(
                     "consumer_facts.jsonl": feed["facts_sha256"],
                 }[member]
                 files.append(PinnedFile(member, digest))
-            elif key == "incumbent_efrs":
-                if member != reference["filename"]:
-                    raise CutError(
-                        f"incumbent member {member} is not the gate's "
-                        f"reference {reference['filename']}."
-                    )
-                files.append(PinnedFile(member, reference["sha256"]))
             elif member in extra:
                 files.append(PinnedFile(member, extra[member]["sha256"]))
             elif member in stage_pins:
@@ -255,8 +260,6 @@ def load_input_sources(
                 raise CutError(
                     "frs_2024_25 revision disagrees with uk/frs_release.json."
                 )
-        if raw.get("revision_pin") == "gates:input_mass_parity":
-            revision = reference["revision"]
         if raw["kind"] == "url" and not url:
             raise CutError(f"{key}: the pin carries no https URL.")
         sources.append(
@@ -604,6 +607,29 @@ def spine_h5(self) -> Path:
     def run_dir(self) -> Path:
         return self.cut / "national"
 
+    @property
+    def reference_dir(self) -> Path:
+        return self.cut / "reference"
+
+    @property
+    def reference_record(self) -> Path:
+        return self.reference_dir / UK_CUT_REFERENCE_RECORD_NAME
+
+    def reference_h5(self, reference: UKCutReference) -> Path:
+        return self.reference_dir / reference.filename
+
+    @property
+    def reference_input_mass(self) -> Path:
+        return self.reference_dir / UK_CUT_REFERENCE_INPUT_MASS_NAME
+
+    @property
+    def reference_surface(self) -> Path:
+        return self.reference_dir / UK_CUT_REFERENCE_SURFACE_NAME
+
+    @property
+    def score_receipt(self) -> Path:
+        return self.run_dir / "score_vs_reference.json"
+
     @property
     def candidate_h5(self) -> Path:
         return self.run_dir / f"{CANDIDATE_NAME}.h5"
@@ -675,11 +701,11 @@ def national_argv(
     python: str,
     spine_sha256: str,
     sources: Mapping[str, InputSource],
+    reference: UKCutReference,
     dry_run: bool,
     logbook_prev_row_digest: str | None = None,
 ) -> list[str]:
     chronicle = {pin.name: pin.sha256 for pin in sources["chronicle_uk"].files}
-    incumbent = sources["incumbent_efrs"].files[0]
     argv = [
         python,
         str(REPO_ROOT / "tools/build_uk_full.py"),
@@ -689,8 +715,8 @@ def national_argv(
         "--ledger-facts", str(paths.inputs / "chronicle_uk"),
         "--ledger-facts-sha256", chronicle["consumer_facts.jsonl"],
         "--ledger-manifest-sha256", chronicle["manifest.json"],
-        "--incumbent-h5", str(paths.input_file("incumbent", incumbent.name)),
-        "--incumbent-sha256", incumbent.sha256,
+        "--reference-h5", str(paths.reference_h5(reference)),
+        "--reference-record", str(paths.reference_record),
         # The build otherwise submits its graph to the public Orrery whenever
         # staging is remote; the graph files stay in the run directory.
         "--no-publish-orrery",
@@ -704,20 +730,19 @@ def national_argv(
 
 
 def score_argv(
-    paths: CutPaths, *, python: str, candidate_sha256: str, sources: Mapping
+    paths: CutPaths, *, python: str, candidate_sha256: str, reference: UKCutReference
 ) -> list[str]:
-    incumbent = sources["incumbent_efrs"].files[0]
     return [
         python,
         str(REPO_ROOT / "tools/score_uk_national_candidate.py"),
         "--candidate-h5", str(paths.candidate_h5),
         "--candidate-sha256", candidate_sha256,
-        "--incumbent-h5", str(paths.input_file("incumbent", incumbent.name)),
-        "--incumbent-sha256", incumbent.sha256,
+        "--reference-h5", str(paths.reference_h5(reference)),
+        "--reference-record", str(paths.reference_record),
         "--registry-json", str(paths.run_dir / "national_target_registry.json"),
         "--band-edge-registry-json",
         str(paths.run_dir / "national_contract_registry.json"),
-        "--output-json", str(paths.run_dir / "score_vs_incumbent.json"),
+        "--output-json", str(paths.score_receipt),
     ]  # fmt: skip
 
 
@@ -731,7 +756,6 @@ def certify_argv(
     logbook_prev_row_digest: str | None = None,
 ) -> list[str]:
     chronicle = {pin.name: pin.sha256 for pin in sources["chronicle_uk"].files}
-    reference = sources["input_mass_reference"].files[0]
     argv = [
         python,
         str(REPO_ROOT / "tools/certify_uk_release_cut.py"),
@@ -747,9 +771,10 @@ def certify_argv(
         "--ledger-facts", str(paths.inputs / "chronicle_uk"),
         "--ledger-facts-sha256", chronicle["consumer_facts.jsonl"],
         "--ledger-manifest-sha256", chronicle["manifest.json"],
-        "--input-mass-reference",
-        str(paths.input_file("input_mass_reference", reference.name)),
-        "--score-receipt", str(paths.run_dir / "score_vs_incumbent.json"),
+        "--input-mass-reference", str(paths.reference_input_mass),
+        "--reference-surface", str(paths.reference_surface),
+        "--score-receipt", str(paths.score_receipt),
+        "--reference-record", str(paths.reference_record),
         "--release-id", RELEASE_ID,
     ]  # fmt: skip
     if logbook_prev_row_digest:
@@ -771,7 +796,7 @@ def assemble_argv(paths: CutPaths, *, python: str) -> list[str]:
         str(paths.run_dir / f"{CANDIDATE_NAME}.terminal_gates.json"),
         "--release-cut-gate-json",
         str(paths.run_dir / f"{CANDIDATE_NAME}.release_cut_gates.json"),
-        "--score-receipt", str(paths.run_dir / "score_vs_incumbent.json"),
+        "--score-receipt", str(paths.score_receipt),
         "--out-dir", "releases",
     ]  # fmt: skip
 
@@ -869,19 +894,54 @@ def candidate_sha256(paths: CutPaths) -> str:
     return str(record["artifacts"]["staging_h5"]["sha256"])
 
 
+def reference_done(paths: CutPaths) -> tuple[bool, str]:
+    """The cut's reference: a record, and the file it names."""
+
+    if not paths.reference_record.exists():
+        return False, "no reference yet"
+    try:
+        reference = read_uk_cut_reference(paths.reference_record)
+        verify_uk_cut_reference_file(reference, paths.reference_h5(reference))
+    except ValueError as error:
+        return False, str(error)
+    evidence, detail = uk_cut_reference_evidence_done(reference, paths.reference_dir)
+    if not evidence:
+        return False, detail
+    return True, f"compared with {reference.label}"
+
+
+def cut_reference(paths: CutPaths) -> UKCutReference:
+    """The reference the cut recorded; a step that needs it refuses without it."""
+
+    done, detail = reference_done(paths)
+    if not done:
+        raise CutError(f"the cut has no usable reference: {detail}.")
+    return read_uk_cut_reference(paths.reference_record)
+
+
+def _names_the_reference(record: object, reference: UKCutReference) -> bool:
+    return isinstance(record, Mapping) and (
+        record.get("release"),
+        record.get("build"),
+        record.get("sha256"),
+    ) == (reference.release, reference.build, reference.sha256)
+
+
 def score_done(paths: CutPaths) -> tuple[bool, str]:
-    """The fields the certifier reads: the scored candidate and the verdict."""
+    """The fields the certifier reads: the candidate and the reference scored."""
 
-    receipt = _read_json(paths.run_dir / "score_vs_incumbent.json")
+    receipt = _read_json(paths.score_receipt)
     if receipt is None:
         return False, "no score receipt"
     scored = ((receipt.get("artifacts") or {}).get("candidate") or {}).get("sha256")
     if scored != candidate_sha256(paths):
         return False, "score receipt names another candidate"
-    verdict = (receipt.get("evaluation") or {}).get("verdict")
-    if verdict != "passed":
-        return False, f"score verdict is {verdict!r}"
-    return True, "score passed"
+    if (receipt.get("evaluation") or {}).get("schema_version") != 2:
+        return False, "score receipt is not a head-to-head with the reference"
+    reference = cut_reference(paths)
+    if not _names_the_reference(receipt.get("reference"), reference):
+        return False, "score receipt compared with another reference"
+    return True, f"compared with {reference.label}"
 
 
 def certify_done(paths: CutPaths) -> tuple[bool, str]:
@@ -892,6 +952,8 @@ def certify_done(paths: CutPaths) -> tuple[bool, str]:
         return False, "certification is not shippable"
     if (cert.get("candidate") or {}).get("sha256") != candidate_sha256(paths):
         return False, "certification names another candidate"
+    if not _names_the_reference(cert.get("reference"), cut_reference(paths)):
+        return False, "certification names another reference"
     return True, "certified shippable"
 
 
@@ -1467,6 +1529,113 @@ def run_spine(runner: Runner, *, staging_local_only: bool, retry: bool = False)
         raise CutError(f"the spine finished but is not usable: {detail}")
 
 
+def run_reference(
+    runner: Runner,
+    *,
+    re_resolve: bool = False,
+    build: str | None = None,
+    hub_download=None,
+    write_evidence=write_uk_cut_reference_evidence,
+) -> UKCutReference:
+    """Resolve the current national build once per cut, and keep its record.
+
+    Beside the dataset and its record go the evidence the gates read from it
+    (its input-mass totals and carriers, and its surface: the columns it
+    exports and the inputs it carries). A reference whose evidence is
+    missing gets it written again; nothing re-resolves. ``build`` pins a
+    listed build instead of the current one (``--reference-build``, for a
+    line with no current build); it is checked and recorded as pinned.
+    """
+
+    paths = runner.paths
+    if build is not None and not re_resolve and paths.reference_record.exists():
+        recorded = read_uk_cut_reference(paths.reference_record)
+        if recorded.build != build:
+            raise CutError(
+                f"the cut compares with {recorded.label}; pass "
+                "--re-resolve-reference with --reference-build to move it to "
+                f"{build}."
+            )
+    if re_resolve and (paths.run_dir / "build_record.json").exists():
+        # After the cut's own promotion the line's current build is this
+        # candidate, and a comparison with itself passes every gate (the review
+        # of microcosm#1574). Checked before the recorded reference moves.
+        current = check_uk_cut_reference(
+            RELEASE_ID, build=build, hub_download=hub_download
+        )
+        record = _read_json(paths.run_dir / "build_record.json") or {}
+        if current.get("sha256") == candidate_sha256(paths) or current.get(
+            "build"
+        ) == record.get("build_id"):
+            raise CutError(
+                f"the national line's current build {current.get('build')} is this "
+                "cut's own candidate; a cut cannot compare with itself, so keep the "
+                "recorded reference (drop --re-resolve-reference)."
+            )
+    if re_resolve and paths.reference_dir.exists():
+        aside = paths.reference_dir.with_name(
+            f"reference.superseded-{datetime.now(UTC):%Y%m%dT%H%M%S%fZ}"
+        )
+        paths.reference_dir.rename(aside)
+        runner.log(f"[reference] kept the earlier reference as {aside.name}")
+    done, detail = reference_done(paths)
+    if done:
+        runner.log(f"[reference] done: {detail}")
+        return read_uk_cut_reference(paths.reference_record)
+    if paths.reference_record.exists():
+        reference = read_uk_cut_reference(paths.reference_record)
+        try:
+            verify_uk_cut_reference_file(reference, paths.reference_h5(reference))
+        except ValueError:
+            pass
+        else:
+            try:
+                # The change since the baseline continues from the reference's
+                # own evidence, which a cut resolved before the record began
+                # never kept; without it the chain would restart without a
+                # trace (round 2 of the review of microcosm#1574).
+                if not (paths.reference_dir / UK_CUT_REFERENCE_EVIDENCE_NAME).is_file():
+                    keep_uk_cut_reference_evidence(
+                        reference, paths.reference_dir, hub_download=hub_download
+                    )
+                    runner.log(
+                        f"[reference] kept the evidence of {reference.label} again"
+                    )
+                write_evidence(
+                    reference, paths.reference_h5(reference), paths.reference_dir
+                )
+            except ValueError as error:
+                raise CutError(
+                    f"the cut's reference evidence cannot be written: {error}"
+                ) from error
+            runner.log(f"[reference] wrote the evidence for {reference.label}")
+            return reference
+    if paths.reference_dir.exists():
+        raise CutError(
+            f"{paths.reference_dir} holds an unusable reference ({detail}); pass "
+            "--re-resolve-reference to set it aside and resolve the current "
+            "build again."
+        )
+    runner.record("reference", status="running", started_at=_now())
+    try:
+        reference = fetch_uk_cut_reference(
+            RELEASE_ID, paths.reference_dir, build=build, hub_download=hub_download
+        )
+        write_evidence(reference, paths.reference_h5(reference), paths.reference_dir)
+    except ValueError as error:
+        runner.record("reference", status="failed", error=str(error)[:600])
+        raise CutError(f"the cut has no reference to compare with: {error}") from error
+    runner.record(
+        "reference",
+        status="done",
+        finished_at=_now(),
+        reference=reference.label,
+        sha256=reference.sha256,
+    )
+    runner.log(f"[reference] compared with {reference.label} ({reference.sha256})")
+    return reference
+
+
 def run_national(
     runner: Runner, *, retry: bool, logbook_prev_row_digest: str | None
 ) -> None:
@@ -1493,6 +1662,7 @@ def run_national(
         python=runner.python,
         spine_sha256=spine,
         sources=runner.sources,
+        reference=cut_reference(paths),
         logbook_prev_row_digest=logbook_prev_row_digest,
     )
     dry_run = runner.state()["steps"].get("national-dry-run", {})
@@ -1511,19 +1681,19 @@ def run_score(runner: Runner) -> None:
         runner.log(f"[score] done: {detail}")
         return
     runner.log(f"[score] re-scoring the candidate ({detail})")
-    _set_aside(runner, "score", paths.run_dir / "score_vs_incumbent.json")
+    _set_aside(runner, "score", paths.score_receipt)
     runner.run(
         "score",
         score_argv(
             paths,
             python=runner.python,
             candidate_sha256=candidate_sha256(paths),
-            sources=runner.sources,
+            reference=cut_reference(paths),
         ),
     )
     done, detail = score_done(paths)
     if not done:
-        raise CutError(f"the candidate does not pass the incumbent score: {detail}")
+        raise CutError(f"the comparison with the reference is not usable: {detail}")
 
 
 def national_logbook_row(paths: CutPaths) -> str:
@@ -1543,8 +1713,28 @@ def national_logbook_row(paths: CutPaths) -> str:
     return rows[0].stem
 
 
+def _refuse_a_withdrawn_reference(paths: CutPaths) -> None:
+    """Refuse to certify or publish against a build withdrawn since the fetch.
+
+    Withdrawal is checked at fetch; a build withdrawn since must neither
+    certify nor publish (the review of microcosm#1574). Read-only: the cut
+    keeps its record.
+    """
+
+    withdrawn = uk_cut_reference_withdrawal(cut_reference(paths))
+    if withdrawn:
+        raise CutError(
+            f"{withdrawn}; the cut keeps its recorded reference, so pass "
+            "--re-resolve-reference to compare with the line's current build, "
+            "which certifies the cut again."
+        )
+
+
 def run_certify(runner: Runner) -> None:
     paths = runner.paths
+    # Before the early return: a cut certified against a build withdrawn
+    # since must not go on to publish (round 2 of the review).
+    _refuse_a_withdrawn_reference(paths)
     done, detail = certify_done(paths)
     if done:
         runner.log(f"[certify] done: {detail}")
@@ -1591,6 +1781,10 @@ def stage1_done(paths: CutPaths, previous_h5: Path) -> tuple[bool, str]:
 def run_stage1(runner: Runner, previous_h5: Path | None) -> None:
     paths = runner.paths
     output = paths.diagnostics / "stage1_comparison.json"
+    if previous_h5 is None and reference_done(paths)[0]:
+        # The interim stage-1 comparison (microcosm#1276) is with the cut's
+        # own reference unless the operator names another file.
+        previous_h5 = paths.reference_h5(cut_reference(paths))
     if previous_h5 is not None:
         done, detail = stage1_done(paths, previous_h5)
         if done:
@@ -1600,8 +1794,8 @@ def run_stage1(runner: Runner, previous_h5: Path | None) -> None:
     if previous_h5 is None:
         runner.record("stage1", status="skipped", reason="no --previous-h5")
         runner.log(
-            "[stage1] skipped: pass --previous-h5 <promoted cut's H5> for the "
-            "interim stage-1 comparison (diagnostic; microcosm#1276)"
+            "[stage1] skipped: the cut has no reference; pass --previous-h5 for "
+            "the interim stage-1 comparison (diagnostic; microcosm#1276)"
         )
         return
     paths.diagnostics.mkdir(parents=True, exist_ok=True)
@@ -1670,6 +1864,8 @@ def tag_published(tag: str) -> bool:
 
 def run_publish(runner: Runner, tag: str, *, publish: bool) -> None:
     paths = runner.paths
+    # Again here, for a publish step run on its own (round 2 of the review).
+    _refuse_a_withdrawn_reference(paths)
     runner.run(
         "publish-preflight",
         publish_argv(paths, python=runner.python, tag=tag, preflight_only=True),
@@ -1691,6 +1887,31 @@ def run_publish(runner: Runner, tag: str, *, publish: bool) -> None:
     )
 
 
+def _build_time_evaluation(paths: CutPaths) -> dict[str, Any] | None:
+    """The national build's own comparison, and whether the cut superseded it.
+
+    After ``--re-resolve-reference`` the national step is not rerun, so the
+    build's manifest still names the earlier reference while the score
+    receipt and the certification name the cut's (the review of
+    microcosm#1574).
+    """
+
+    manifest = _read_json(paths.run_dir / "rowwise_candidate_manifest.json") or {}
+    evaluation = manifest.get("evaluation")
+    if not isinstance(evaluation, Mapping) or "reference" not in evaluation:
+        return None
+    built_against = str(evaluation["reference"])
+    current = (
+        read_uk_cut_reference(paths.reference_record).label
+        if paths.reference_record.exists()
+        else None
+    )
+    return {
+        "reference": built_against,
+        "superseded": current is not None and built_against != current,
+    }
+
+
 def write_receipt(runner: Runner, extra: Mapping[str, Any]) -> None:
     paths = runner.paths
     receipt = {
@@ -1712,6 +1933,12 @@ def write_receipt(runner: Runner, extra: Mapping[str, Any]) -> None:
             }
             for source in runner.sources.values()
         },
+        "reference": (
+            read_uk_cut_reference(paths.reference_record).to_record()
+            if paths.reference_record.exists()
+            else None
+        ),
+        "build_time_evaluation": _build_time_evaluation(paths),
         "spine_sha256": spine_sha256(paths),
         "candidate_sha256": candidate_sha256(paths)
         if (paths.run_dir / "build_record.json").exists()
@@ -1779,7 +2006,27 @@ def _parse(argv: Sequence[str] | None) -> argparse.Namespace:
         help="move an unfinished spine attempt aside and build a fresh one",
     )
     parser.add_argument("--retry-national", action="store_true")
-    parser.add_argument("--previous-h5", type=Path, help="for the stage-1 comparison")
+    parser.add_argument(
+        "--previous-h5",
+        type=Path,
+        help="for the stage-1 comparison; by default the cut's reference",
+    )
+    parser.add_argument(
+        "--re-resolve-reference",
+        action="store_true",
+        help=(
+            "set the cut's reference aside and compare with the national "
+            "line's current build again"
+        ),
+    )
+    parser.add_argument(
+        "--reference-build",
+        help=(
+            "pin a listed national build as the reference instead of the "
+            "current one, for a line with no current build; checked like the "
+            "current build and recorded as pinned"
+        ),
+    )
     parser.add_argument(
         "--logbook-prev-row-digest",
         help=(
@@ -1860,9 +2107,10 @@ def preflight(args: argparse.Namespace, paths: CutPaths) -> list[Check]:
     return checks
 
 
-def status(paths: CutPaths) -> None:
+def status(paths: CutPaths, *, check_current=None, check_withdrawal=None) -> None:
     print(f"cut {paths.cut}")
     for name, check in (
+        ("reference", reference_done),
         ("spine", spine_done),
         ("national", national_done),
         ("score", score_done),
@@ -1874,6 +2122,34 @@ def status(paths: CutPaths) -> None:
         except Exception as error:  # an earlier step is missing
             done, detail = False, f"not reached ({type(error).__name__})"
         print(f"  {'done' if done else 'todo'} {name}: {detail}")
+    if paths.reference_record.exists():
+        print(f"  {_current_build_note(paths, check_current, check_withdrawal)}")
+
+
+def _current_build_note(
+    paths: CutPaths, check_current=None, check_withdrawal=None
+) -> str:
+    """Whether the national line's current build has moved since the fetch."""
+
+    recorded = read_uk_cut_reference(paths.reference_record)
+    try:
+        current = (check_current or check_uk_cut_reference)(RELEASE_ID)
+        withdrawn = (check_withdrawal or uk_cut_reference_withdrawal)(recorded)
+    except Exception as error:  # the Hub's answer is only a note here
+        return f"note: could not read the current build ({type(error).__name__})"
+    if withdrawn:
+        return f"note: {withdrawn} (--re-resolve-reference to move it)"
+    if recorded.selection == "pinned":
+        return (
+            f"note: the reference is pinned to {recorded.build}; the current "
+            f"national build is {current.get('build')}"
+        )
+    if current.get("build") == recorded.build:
+        return "note: the reference is still the current national build"
+    return (
+        f"note: the current national build is now {current.get('build')}; this "
+        f"cut compares with {recorded.build} (--re-resolve-reference to move it)"
+    )
 
 
 def main(argv: Sequence[str] | None = None) -> int:
@@ -1922,6 +2198,9 @@ def main(argv: Sequence[str] | None = None) -> int:
         if args.command == "preflight":
             return 0
         runner = Runner(paths=paths, sources=sources)
+        run_reference(
+            runner, re_resolve=args.re_resolve_reference, build=args.reference_build
+        )
         run_spine(
             runner, staging_local_only=not args.spine_telemetry, retry=args.retry_spine
         )
diff --git a/tools/score_uk_national_candidate.py b/tools/score_uk_national_candidate.py
index 7657454d9d..589b2440bb 100644
--- a/tools/score_uk_national_candidate.py
+++ b/tools/score_uk_national_candidate.py
@@ -1,10 +1,18 @@
-"""Score a UK national candidate against the incumbent on one frozen register.
+"""Compare a UK national candidate with the reference on one frozen register.
 
-The score core lives in ``microcosm.build.uk_runtime.candidate_score``; this
-command loads the frozen register, verifies both artifacts against their
-digests, scores on the surface both can materialize (pruning the rows the
-incumbent cannot, loudly, unless ``--no-prune-incumbent-unresolvable``) and
+The comparison core lives in ``microcosm.build.uk_runtime.candidate_score``
+(over the country-neutral ``microcosm.build.head_to_head``); this command
+loads the frozen register, verifies both artifacts against their digests,
+compares them on the surface both can materialize (pruning the rows the
+reference cannot, loudly, unless ``--no-prune-reference-unresolvable``) and
 writes the receipt the release-cut certifier reads.
+
+The reference is the current national build a cut recorded when it fetched
+it (microcosm#1095): pass ``--reference-record`` with its file. An ad hoc
+comparison may name a file with ``--reference-sha256`` and
+``--reference-label`` instead; its receipt carries no reference record, so
+it never certifies a cut. The comparison decides nothing: it has no
+threshold, like the US head-to-head.
 """
 
 from __future__ import annotations
@@ -24,11 +32,8 @@
     _relative_errors,
     _scored_frame,
     _sha256_file,
-    _target_drift,
-    _target_wins,
-    _target_wins_by_family,
     _verify_artifact,
-    evaluate_uk_candidate_against_incumbent,
+    evaluate_uk_candidate_against_reference,
     pruned_warning,
     score_uk_national_candidate,
 )
@@ -40,12 +45,47 @@ def _write_json(path: str | Path, payload: dict[str, Any]) -> Path:
     return output
 
 
+def _reference(args: argparse.Namespace, parser: argparse.ArgumentParser):
+    """The reference's sha, label and record, from the record when given."""
+
+    if args.reference_record is not None:
+        if args.reference_sha256 is not None or args.reference_label is not None:
+            parser.error(
+                "--reference-record names the reference; drop --reference-sha256 "
+                "and --reference-label."
+            )
+        from microcosm.build.uk_runtime.cut_reference import (
+            read_uk_cut_reference,
+            verify_uk_cut_reference_file,
+        )
+
+        record = read_uk_cut_reference(args.reference_record)
+        verify_uk_cut_reference_file(record, args.reference_h5)
+        return record.sha256, record.label, record.to_record()
+    if args.reference_sha256 is None or args.reference_label is None:
+        parser.error(
+            "pass --reference-record, or both --reference-sha256 and "
+            "--reference-label for an ad hoc comparison."
+        )
+    return args.reference_sha256, args.reference_label, None
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--candidate-h5", required=True, type=Path)
     parser.add_argument("--candidate-sha256", required=True)
-    parser.add_argument("--incumbent-h5", required=True, type=Path)
-    parser.add_argument("--incumbent-sha256", required=True)
+    parser.add_argument("--reference-h5", required=True, type=Path)
+    parser.add_argument(
+        "--reference-record",
+        type=Path,
+        help="The cut's record of the reference build (tools/resolve_uk_reference.py).",
+    )
+    parser.add_argument(
+        "--reference-sha256", help="Ad hoc only: the reference file's SHA-256."
+    )
+    parser.add_argument(
+        "--reference-label", help="Ad hoc only: the reference's label in the receipt."
+    )
     parser.add_argument("--registry-json", required=True, type=Path)
     parser.add_argument("--output-json", required=True, type=Path)
     parser.add_argument("--calibration-year", type=int)
@@ -53,11 +93,6 @@ def main(argv: list[str] | None = None) -> int:
         "--candidate-label",
         help="Override the candidate label; by default it is the candidate H5 stem.",
     )
-    parser.add_argument(
-        "--incumbent-label",
-        default="enhanced_frs_2024_25",
-        help="Override the incumbent/reference label.",
-    )
     parser.add_argument(
         "--band-edge-registry-json",
         type=Path,
@@ -68,12 +103,13 @@ def main(argv: list[str] | None = None) -> int:
         ),
     )
     parser.add_argument(
-        "--no-prune-incumbent-unresolvable",
+        "--no-prune-reference-unresolvable",
         action="store_true",
         help=(
-            "Refuse the score when the incumbent cannot materialize a target "
-            "instead of pruning that target from both arms and reporting it. "
-            "The default prunes and warns, naming every absent measure."
+            "Refuse the comparison when the reference cannot materialize a "
+            "target instead of pruning that target from both arms and "
+            "reporting it. The default prunes and warns, naming every absent "
+            "measure."
         ),
     )
     parser.add_argument(
@@ -86,6 +122,7 @@ def main(argv: list[str] | None = None) -> int:
         ),
     )
     args = parser.parse_args(argv)
+    reference_sha256, reference_label, reference_record = _reference(args, parser)
     registry = _load_registry(args.registry_json)
     band_edge_registry = (
         None
@@ -104,34 +141,38 @@ def main(argv: list[str] | None = None) -> int:
             args.output_json.parent, int(calibration_year)
         )
     )
-    score = evaluate_uk_candidate_against_incumbent(
+    score = evaluate_uk_candidate_against_reference(
         candidate_h5=args.candidate_h5,
-        incumbent_h5=args.incumbent_h5,
+        reference_h5=args.reference_h5,
         candidate_sha256=args.candidate_sha256,
-        incumbent_sha256=args.incumbent_sha256,
+        reference_sha256=reference_sha256,
         target_registry=registry,
         calibration_year=int(calibration_year),
+        reference_label=reference_label,
         measure_resolver_factory=factory,
         candidate_label=args.candidate_label,
-        incumbent_label=args.incumbent_label,
         band_edge_registry=band_edge_registry,
-        prune_incumbent_unresolvable_measures=not args.no_prune_incumbent_unresolvable,
+        prune_reference_unresolvable_measures=not args.no_prune_reference_unresolvable,
+        reference_record=reference_record,
     )
     warning = pruned_warning(score)
     if warning is not None:
         print(warning, file=sys.stderr, flush=True)
     # The receipt is the score block itself: the release-cut certifier reads
-    # ``artifacts.candidate.sha256`` and ``evaluation.verdict`` at the top
-    # level, and the assembler copies the bytes into the release directory
-    # unchanged.
+    # ``artifacts.candidate.sha256`` and ``reference`` at the top level, and
+    # the assembler copies the bytes into the release directory unchanged.
     _write_json(args.output_json, score)
     evaluation = score["evaluation"]
+    targets = evaluation["targets"]
     print(
-        f"evaluation {evaluation['verdict']}: candidate loss "
-        f"{evaluation['rule_1']['candidate_full_loss']:.6f} vs incumbent "
-        f"{evaluation['rule_1']['incumbent_full_loss']:.6f} on "
+        f"comparison with {evaluation['reference']} (no threshold): candidate "
+        f"loss {evaluation['losses']['candidate_full_loss']:.6f} vs reference "
+        f"{evaluation['losses']['reference_full_loss']:.6f} on "
         f"{evaluation['scored_surface']['n_scored']} of "
-        f"{evaluation['scored_surface']['n_surface']} targets",
+        f"{evaluation['scored_surface']['n_surface']} targets; lower error on "
+        f"{targets['candidate_lower_count']} for the candidate, "
+        f"{targets['reference_lower_count']} for the reference, "
+        f"{targets['equal_count']} equal",
         flush=True,
     )
     return 0
diff --git a/tools/score_us_release_head_to_head.py b/tools/score_us_release_head_to_head.py
index 098540048e..eda715e2d7 100644
--- a/tools/score_us_release_head_to_head.py
+++ b/tools/score_us_release_head_to_head.py
@@ -72,6 +72,13 @@
 import pandas as pd
 import score_us_fiscal_targets as fiscal_scorer
 
+from microcosm.build.head_to_head import (
+    LOWER_CANDIDATE,
+    LOWER_EQUAL,
+    LOWER_REFERENCE,
+    ScoredTarget,
+    compare_scored_targets,
+)
 from microcosm.build.us_runtime.congressional_district_vintage import (
     CONGRESSIONAL_DISTRICT_VINTAGE_CROSSWALK_SHA256_ATTR,
     CONGRESSIONAL_DISTRICT_VINTAGE_TARGET_ATTR,
@@ -2094,44 +2101,55 @@ def _comparison_payload(
         raise TypeError("Artifact target payloads must be lists.")
     if len(incumbent_rows) != len(candidate_rows):
         raise ValueError("Fiscal target payload lengths differ after contract checks.")
-    target_comparisons: list[dict[str, object]] = []
-    candidate_lower = 0
-    equal = 0
-    incumbent_lower = 0
-    for incumbent_row, candidate_row in zip(
-        incumbent_rows,
-        candidate_rows,
-        strict=True,
-    ):
-        key = (incumbent_row["name"], incumbent_row["period"])
-        candidate_key = (candidate_row["name"], candidate_row["period"])
-        if candidate_key != key:
-            raise ValueError(
-                f"Target comparison contracts differ: {key!r} vs {candidate_key!r}."
+    # The country-neutral comparison (microcosm.build.head_to_head); this
+    # payload keeps the US scorecard's own names, so its bytes are unchanged.
+    head_to_head = compare_scored_targets(
+        [
+            ScoredTarget(
+                name=row["name"],
+                period=row["period"],
+                relative_error=float(row["absolute_relative_error"]),
             )
-        incumbent_error = float(incumbent_row["absolute_relative_error"])
-        candidate_error = float(candidate_row["absolute_relative_error"])
-        if candidate_error < incumbent_error:
-            candidate_lower += 1
-            lower = "candidate"
-        elif candidate_error > incumbent_error:
-            incumbent_lower += 1
-            lower = "incumbent"
-        else:
-            equal += 1
-            lower = "equal"
-        target_comparisons.append(
-            {
-                "name": key[0],
-                "period": key[1],
-                "incumbent_absolute_relative_error": incumbent_error,
-                "candidate_absolute_relative_error": candidate_error,
-                "candidate_minus_incumbent_absolute_relative_error": (
-                    candidate_error - incumbent_error
-                ),
-                "lower_absolute_relative_error": lower,
-            }
-        )
+            for row in candidate_rows
+        ],
+        [
+            ScoredTarget(
+                name=row["name"],
+                period=row["period"],
+                relative_error=float(row["absolute_relative_error"]),
+            )
+            for row in incumbent_rows
+        ],
+        candidate_loss=float(candidate_fiscal["weighted_loss"]),
+        reference_loss=float(incumbent_fiscal["weighted_loss"]),
+    )
+    lower_names = {
+        LOWER_CANDIDATE: "candidate",
+        LOWER_REFERENCE: "incumbent",
+        LOWER_EQUAL: "equal",
+    }
+    target_comparisons: list[dict[str, object]] = [
+        {
+            "name": comparison.name,
+            "period": comparison.period,
+            "incumbent_absolute_relative_error": (
+                comparison.reference_absolute_relative_error
+            ),
+            "candidate_absolute_relative_error": (
+                comparison.candidate_absolute_relative_error
+            ),
+            "candidate_minus_incumbent_absolute_relative_error": (
+                comparison.candidate_absolute_relative_error
+                - comparison.reference_absolute_relative_error
+            ),
+            "lower_absolute_relative_error": lower_names[comparison.lower],
+        }
+        for comparison in head_to_head.comparisons
+    ]
+    counts = head_to_head.counts
+    candidate_lower = counts["candidate_lower_count"]
+    equal = counts["equal_count"]
+    incumbent_lower = counts["reference_lower_count"]
     incumbent_loss = float(incumbent_fiscal["weighted_loss"])
     candidate_loss = float(candidate_fiscal["weighted_loss"])
     incumbent_battery = incumbent["terminal_battery"]
diff --git a/tools/uk_cut_inputs.json b/tools/uk_cut_inputs.json
index b5eccd5e88..d311206274 100644
--- a/tools/uk_cut_inputs.json
+++ b/tools/uk_cut_inputs.json
@@ -1,6 +1,6 @@
 {
   "version": 1,
-  "about": "Where tools/run_uk_cut.py fetches each input of a Microcosm UK national cut. This file says only where; every expected sha256 and size is read from the committed pins (uk/source_stages.json, uk/frs_release.json, uk/chronicle_feed.json, uk/gates.json, weighted_integrity.py), so a file is accepted only if it is byte-identical to what the build itself will check. A *_pin field reads its value from those pins instead: path_in_repo_pin chronicle_feed puts the Chronicle artifact under chronicle-uk/<the feed's source commit>, so it follows every re-pin. revision null reads the repository's main branch, and every file is still verified against its pin (docs/uk-cut-anyone.md).",
+  "about": "Where tools/run_uk_cut.py fetches each input of a Microcosm UK national cut. This file says only where; every expected sha256 and size is read from the committed pins (uk/source_stages.json, uk/frs_release.json, uk/chronicle_feed.json), so a file is accepted only if it is byte-identical to what the build itself will check. A *_pin field reads its value from those pins instead: path_in_repo_pin chronicle_feed puts the Chronicle artifact under chronicle-uk/<the feed's source commit>, so it follows every re-pin. revision null reads the repository's main branch, and every file is still verified against its pin (docs/uk-cut-anyone.md).",
   "sources": [
     {
       "key": "frs_2024_25",
@@ -138,37 +138,6 @@
         "manifest.json",
         "consumer_facts.jsonl"
       ]
-    },
-    {
-      "key": "input_mass_reference",
-      "kind": "hf_files",
-      "repo_id": "policyengine/microcosm-uk-build-inputs",
-      "repo_type": "dataset",
-      "revision": "95e0cb20fb37811c3f9009854d882a7415194926",
-      "path_in_repo": "input-mass-reference/fd41cb5f6cf6c4ef812320f21d1942173d49ce6f8725b21fbc9d9ca5423d298c",
-      "directory": "input_mass_reference",
-      "members": [
-        "uk_input_mass_reference.json"
-      ]
-    },
-    {
-      "key": "incumbent_efrs",
-      "kind": "hf_files",
-      "repo_id": "policyengine/policyengine-uk-data-private",
-      "repo_type": "model",
-      "revision_pin": "gates:input_mass_parity",
-      "path_in_repo": "",
-      "directory": "incumbent",
-      "members": [
-        "enhanced_frs_2024_25.h5"
-      ]
-    }
-  ],
-  "file_pins": {
-    "uk_input_mass_reference.json": {
-      "sha256": "b3490f5bbc46581f2b5f81560a249b8983e37f80c67f00988cd3ed960a7f81c4",
-      "canonical_evidence_sha256": "fd41cb5f6cf6c4ef812320f21d1942173d49ce6f8725b21fbc9d9ca5423d298c",
-      "note": "Byte pin of the hosted file; the build's own loader checks the canonical evidence digest. Regenerated at microcosm 0eac9bbbd (policyengine-uk 2.89.0); see the receipt beside it."
     }
-  }
+  ]
 }