Archive 4 checkpoints (1-4)

paper-releases/20260928/diffusion/data/protocol/paired_finetune/tools/build_full_cells.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""Full-axis (20,097-gene) counts of the retained cells, in cells_panel6k.npz row order (CPU only).
+
+Recipe conditions (a pseudobulk of K sampled cells, as in pretraining) need every canonical gene: the conditioner
+normalises by the full-axis total and its scalars (detected fraction, log mean/SD, top-1 % share) span all genes.
+This reads each retained cell from its library's canonical.h5ad by obs index (barcode), in the order of
+data/<dataset>/cells_obs.parquet, and writes data/<dataset>/cells_full.npz (CSR int32).
+
+Checks (fail-closed): the panel columns equal cells_panel6k.npz exactly, and each row's cells sum to
+features.npz pseudo_raw_sum on the full axis.
+usage: build_full_cells.py DATASET
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+from pathlib import Path
+
+import h5py
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+TASK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+POSITIONS = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/artifacts/panel_ladder_floor01_1m_20260923/tiers/6k/gene_positions.npy")
+LIBRARY_ROOT = {
+    "immicro": Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/strict_qc_v1_20260913/singlecell/GSE314416"),
+    "ye2026_sepsis": Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/ye2026_sepsis_v1_20260927/singlecell"),
+    "giroux2022": Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/giroux2022_v1_20260928/singlecell"),
+}
+
+
+def sha(p: Path) -> str:
+    h = hashlib.sha256()
+    with open(p, "rb") as f:
+        for b in iter(lambda: f.read(1 << 24), b""):
+            h.update(b)
+    return h.hexdigest()
+
+
+def read_library(h5: Path, barcodes: np.ndarray) -> sp.csr_matrix:
+    with h5py.File(h5, "r") as f:
+        g = f["X"]
+        indptr, indices, data = g["indptr"][:], g["indices"][:], g["data"][:]
+        n_genes = int(f["var/_index"].shape[0])
+        obs_index = np.asarray([x.decode() if isinstance(x, bytes) else str(x) for x in f["obs/_index"][:]])
+    pos = pd.Series(np.arange(obs_index.size), index=obs_index)
+    if pos.index.duplicated().any():
+        raise SystemExit(f"{h5}: duplicate obs index")
+    rows = pos.reindex(barcodes)
+    if rows.isna().any():
+        raise SystemExit(f"{h5}: {int(rows.isna().sum())} barcodes not found")
+    full = sp.csr_matrix((data, indices, indptr), shape=(indptr.size - 1, n_genes))
+    sub = full[rows.to_numpy(np.int64)]
+    if sub.nnz and not np.array_equal(sub.data, np.round(sub.data)):
+        raise SystemExit(f"{h5}: non-integer counts")
+    return sub.astype(np.int32).tocsr()
+
+
+def main(ds: str) -> int:
+    d = TASK / "data" / ds
+    obs = pd.read_parquet(d / "cells_obs.parquet")
+    panel = np.load(d / "cells_panel6k.npz", allow_pickle=False)
+    feat = np.load(d / "features.npz", allow_pickle=False)
+    positions = np.load(POSITIONS).astype(np.int64)
+    if len(obs) != int(panel["shape"][0]):
+        raise SystemExit("cells_obs rows differ from cells_panel6k rows")
+    root = LIBRARY_ROOT[ds]
+    parts, order = [], []
+    for lib, sub in obs.groupby("library_id", sort=True):
+        m = read_library(root / str(lib) / "canonical.h5ad", sub["barcode"].astype(str).to_numpy())
+        parts.append(m)
+        order.append(sub.index.to_numpy())
+        print(f"{lib}: {m.shape[0]} cells", flush=True)
+    X = sp.vstack(parts, format="csr")
+    inv = np.empty(len(obs), dtype=np.int64)
+    inv[np.concatenate(order)] = np.arange(len(obs))
+    X = X[inv].tocsr()             # back to cells_panel6k order
+    P = sp.csr_matrix((panel["data"], panel["indices"], panel["indptr"]), shape=tuple(panel["shape"]))
+    rs = panel["row_sample"].astype(np.int64)
+    if bool((np.diff(rs) < 0).any()):
+        raise SystemExit("cells are not sorted by dataset row")
+    want = np.nan_to_num(feat["pseudo_raw_sum"].astype(np.float64), nan=0.0)
+    bounds = np.searchsorted(rs, np.arange(int(rs.max()) + 2))
+    bad_panel = bad_sum = 0
+    for r in range(int(rs.max()) + 1):          # row by row keeps peak memory at one donor's cells
+        a, b = int(bounds[r]), int(bounds[r + 1])
+        Xr = X[a:b]
+        bad_panel += int((Xr[:, positions] != P[a:b]).nnz)
+        bad_sum += int(not np.array_equal(np.asarray(Xr.sum(axis=0, dtype=np.float64)).ravel(), want[r]))
+    if bad_panel:
+        raise SystemExit(f"full-axis cells differ from cells_panel6k on the panel columns ({bad_panel} entries)")
+    if bad_sum:
+        raise SystemExit(f"per-row full-axis sums differ from pseudo_raw_sum for {bad_sum} rows")
+    out = d / "cells_full.npz"
+    np.savez(out, data=X.data.astype(np.int32), indices=X.indices.astype(np.int32), indptr=X.indptr.astype(np.int64),
+             shape=np.array(X.shape, dtype=np.int64), row_sample=rs.astype(np.int32))
+    info = {"dataset": ds, "n_cells": int(X.shape[0]), "nnz": int(X.nnz), "sha256": sha(out),
+            "checks": {"panel_columns_equal_cells_panel6k": True, "row_sums_equal_pseudo_raw_sum": True}}
+    (d / "cells_full.BUILD.json").write_text(json.dumps(info, indent=1))
+    print(json.dumps(info))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1]))

paper-releases/20260928/diffusion/data/protocol/paired_finetune/tools/build_immicro_cells.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""ImMicro fine-tuning cells: the 107 baseline donors' retained cells on the model's 6,000-gene panel.
+
+Cells are exactly the ones the ImMicro utility study kept (observed_cells.parquet, kind == 'baseline',
+flag_conservative_review_pass), read from the 54 canonical per-library h5ad files by their row index.
+Columns follow the checkpoint's gene_positions (indices into the canonical 20,097 axis).
+
+Outputs (data/immicro/):
+  cells_panel6k.npz   CSR int32 counts [n_cells, 6000], row_sample (index into features.npz rows),
+                      panel_gene_ids, panel_measured (sc_valid[:, positions])
+  cells_obs.parquet   the observed_cells rows in the same order
+  samples.csv         row, sample_id, donor_id, group (pool), n_cells
+  features.npz        symlink to the ImMicro features file (bulk_raw, pseudo_raw_sum, masks)
+  BUILD.json          sources, sha256, checks
+
+Check (fail-closed): per donor, the summed panel counts equal features.npz pseudo_raw_sum[:, positions]
+exactly, and cell counts equal qc_cell_counts.  CPU only.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import h5py
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+TASK = M8 / "plans/paired_finetune_intradataset_20260927"
+OUT = TASK / "data/immicro"
+FEATURES = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/analyses/offset_sample_size_20260914/features.npz")
+SC_DIR = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/strict_qc_v1_20260913/singlecell/GSE314416")
+OBSERVED = M8 / "plans/utility_studies_final6k_20260925/immicro/out/observed_cells.parquet"
+POSITIONS = M8 / "artifacts/panel_ladder_floor01_1m_20260923/tiers/6k/gene_positions.npy"
+POSITIONS_SHA = "653ffa45ac519000baa41086c52408009391d6e68cfb218bc6a50d34163fcb24"
+
+
+def sha256_file(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(1 << 24), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def read_rows(h5: Path, barcodes: np.ndarray, positions: np.ndarray) -> sp.csr_matrix:
+    """Cells (by obs index = barcode, as build_observed.py keys them) of the canonical CSR X, panel columns only."""
+    with h5py.File(h5, "r") as f:
+        g = f["X"]
+        indptr = g["indptr"][:]
+        n_genes = int(f["var/_index"].shape[0])
+        data = g["data"][:]
+        indices = g["indices"][:]
+        obs_index = np.asarray([x.decode() if isinstance(x, bytes) else str(x) for x in f["obs/_index"][:]])
+    pos = pd.Series(np.arange(len(obs_index)), index=obs_index)
+    if pos.index.duplicated().any():
+        raise SystemExit(f"{h5}: duplicate obs index")
+    rows = pos.reindex(barcodes)
+    if rows.isna().any():
+        raise SystemExit(f"{h5}: {int(rows.isna().sum())} barcodes not found")
+    rows = rows.to_numpy(np.int64)
+    full = sp.csr_matrix((data, indices, indptr), shape=(len(indptr) - 1, n_genes))
+    sub = full[rows][:, positions]
+    if sub.nnz and not np.array_equal(sub.data, np.round(sub.data)):
+        raise SystemExit(f"{h5}: non-integer counts")
+    return sub.astype(np.int32)
+
+
+def main() -> int:
+    if sha256_file(POSITIONS) != POSITIONS_SHA:
+        raise SystemExit("gene_positions.npy sha differs from the final run's")
+    positions = np.load(POSITIONS).astype(np.int64)
+    feat = np.load(FEATURES, allow_pickle=False)
+    donors = feat["donor_ids"].astype(str)
+    gene_ids = feat["gene_ids"].astype(str)
+    row_of = {d: i for i, d in enumerate(donors)}
+
+    obs = pd.read_parquet(OBSERVED)
+    obs = obs[obs["kind"] == "baseline"].copy()
+    missing = sorted(set(obs["donor_id"]) - set(donors))
+    if missing:
+        raise SystemExit(f"baseline donors absent from features.npz: {missing[:5]}")
+    obs["row_sample"] = obs["donor_id"].map(row_of).astype(np.int32)
+    # deterministic order: donor row, then library, then row index inside the library
+    obs = obs.sort_values(["row_sample", "library_id", "cell_index"], kind="mergesort").reset_index(drop=True)
+
+    blocks, block_obs = [], []
+    for lib, sub in obs.groupby("library_id", sort=True):
+        h5 = SC_DIR / lib / "canonical.h5ad"
+        m = read_rows(h5, sub["barcode"].astype(str).to_numpy(), positions)
+        blocks.append(m)
+        block_obs.append(sub)
+        print(f"{lib}: {m.shape[0]} cells", flush=True)
+    X = sp.vstack(blocks, format="csr")
+    cobs = pd.concat(block_obs, ignore_index=True)
+    order = np.lexsort((cobs["cell_index"].to_numpy(), cobs["library_id"].to_numpy(), cobs["row_sample"].to_numpy()))
+    X = X[order]
+    cobs = cobs.iloc[order].reset_index(drop=True)
+    row_sample = cobs["row_sample"].to_numpy(np.int32)
+
+    # fail-closed checks against the features file
+    ind = sp.csr_matrix((np.ones(len(row_sample)), (row_sample, np.arange(len(row_sample)))),
+                        shape=(len(donors), len(row_sample)))
+    sums = np.asarray((ind @ X.astype(np.float64)).todense())
+    want = np.nan_to_num(feat["pseudo_raw_sum"][:, positions].astype(np.float64), nan=0.0)
+    if not np.array_equal(sums, want):
+        bad = int((sums != want).any(axis=1).sum())
+        raise SystemExit(f"per-donor panel sums differ from pseudo_raw_sum for {bad} donors")
+    counts = np.bincount(row_sample, minlength=len(donors))
+    if not np.array_equal(counts, feat["qc_cell_counts"].astype(np.int64)):
+        raise SystemExit("per-donor cell counts differ from qc_cell_counts")
+
+    OUT.mkdir(parents=True, exist_ok=True)
+    panel_measured = feat["sc_valid"][:, positions].astype(bool)
+    np.savez(OUT / "cells_panel6k.npz", data=X.data.astype(np.int32), indices=X.indices.astype(np.int32),
+             indptr=X.indptr.astype(np.int64), shape=np.array(X.shape, dtype=np.int64), row_sample=row_sample,
+             panel_gene_ids=gene_ids[positions], panel_measured=panel_measured)
+    cobs.drop(columns=["row_sample"]).assign(row_sample=row_sample).to_parquet(OUT / "cells_obs.parquet", index=False)
+    pd.DataFrame({"row": np.arange(len(donors)), "sample_id": donors, "donor_id": donors,
+                  "group": feat["pools"].astype(str), "n_cells": counts}).to_csv(OUT / "samples.csv", index=False)
+    link = OUT / "features.npz"
+    if link.is_symlink() or link.exists():
+        link.unlink()
+    link.symlink_to(FEATURES)
+    build = {
+        "written_utc": datetime.now(timezone.utc).isoformat(),
+        "features": str(FEATURES), "features_sha256": sha256_file(FEATURES),
+        "observed_cells": str(OBSERVED), "observed_cells_sha256": sha256_file(OBSERVED),
+        "gene_positions": str(POSITIONS), "gene_positions_sha256": POSITIONS_SHA,
+        "n_cells": int(X.shape[0]), "nnz": int(X.nnz), "n_samples": int(len(donors)),
+        "cells_per_sample": {"min": int(counts.min()), "median": float(np.median(counts)), "max": int(counts.max())},
+        "checks": {"panel_sums_equal_pseudo_raw_sum": True, "cell_counts_equal_qc_cell_counts": True},
+        "cells_panel6k_sha256": sha256_file(OUT / "cells_panel6k.npz"),
+    }
+    (OUT / "BUILD.json").write_text(json.dumps(build, indent=1))
+    print(json.dumps(build, indent=1))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/20260928/diffusion/data/protocol/paired_finetune/tools/build_realbulk_conditions.py

@@ -0,0 +1,312 @@
+#!/usr/bin/env python3
+"""Condition NPZs that let one frozen model be driven by separately measured bulk.
+
+Every earlier paired-cohort experiment stopped at the condition vector: it showed that raw clinical bulk
+lands far from the pseudobulk the model was trained on, and that a ten-pair gene-wise multiplier removes
+most of that distance.  No cells were ever generated from a corrected bulk.  This script writes the inputs
+that close that gap, as three arms per cohort that differ **only** in the expression vector handed to the
+conditioner:
+
+  raw     the separately measured bulk, exactly as the assay reports it
+  cal     the same bulk after the published ten-pair gene-wise multiplier, fitted with the donor's whole
+          group held out, so no evaluated donor contributes to its own correction
+  pseudo  the pseudobulk of that donor's own single cells -- the input distribution the model was trained
+          on, and therefore the ceiling this cohort can reach
+
+Sources (read, never rewritten):
+  ImMicro   analyses/offset_sample_size_20260914/features.npz           107 healthy donors, 7 pools
+  Randolph  analyses/offset_two_cohort_20260915/paired_features/Randolph.npz  89 donors x NI/IAV, 15 day groups
+
+Depth policy follows the published calibration experiments: both modalities enter the model at K=1000 cells
+and one fixed depth anchor, so the two depth scalars of the conditioner agree and the arms differ only in
+expression shape.  This is a fixed-depth condition experiment; it does not reconstruct a donor's true
+sequencing depth.
+
+Usage:
+  build_realbulk_conditions.py --cohort ImMicro --out-dir <dir> [--cells-per-bulk 1500] [--n-calibration 10]
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+
+DATALAKE = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/analyses")
+SOURCES = {
+    "ImMicro": DATALAKE / "offset_sample_size_20260914/features.npz",
+    "Randolph": DATALAKE / "offset_two_cohort_20260915/paired_features/Randolph.npz",
+}
+# the anchor the published two-cohort and affine-calibration experiments used for both assays
+DEPTH_ANCHOR = 3869.603120208939
+RECIPE_K = 1000
+SCHEMA = "pbisc_sdd.realbulk_conditions.v1"
+NATIVE_SCHEMA = "pbisc_sdd.realbulk_conditions.native_depth.v1"
+ARMS = ("raw", "cal", "pseudo")
+
+
+class InputError(RuntimeError):
+    """A cohort cannot be assembled without inventing data."""
+
+
+def sha256_file(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(1 << 24), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def cpm(x: np.ndarray) -> np.ndarray:
+    """Rows to a fixed relative-expression scale of 1e6."""
+    x = np.asarray(x, dtype=np.float64)
+    total = x.sum(axis=1, keepdims=True)
+    if not np.isfinite(x).all() or (x < 0).any():
+        raise InputError("expression contains negative or non-finite values")
+    if (total <= 0).any():
+        raise InputError("an expression row sums to zero")
+    return x / total * 1e6
+
+
+def drop_unmeasured_nan(x: np.ndarray, valid: np.ndarray, label: str) -> np.ndarray:
+    """Both sources mark an unmeasured coordinate with NaN. Turn those into zeros, and only those.
+
+    A NaN inside the measured support would be a real defect in the source, so it is refused rather than
+    silently filled.
+    """
+    x = np.asarray(x, dtype=np.float64)
+    nan = np.isnan(x)
+    inside = int((nan & valid).sum())
+    if inside:
+        raise InputError(f"{label}: {inside} NaN values inside the measured support")
+    out = np.where(nan, 0.0, x)
+    if not np.isfinite(out).all():
+        raise InputError(f"{label}: non-finite values remain after clearing unmeasured coordinates")
+    return out
+
+
+def load_cohort(name: str) -> dict:
+    """Canonical 20,097-gene bulk, pseudobulk, assay supports and grouping for one cohort."""
+    path = SOURCES[name]
+    if not path.is_file():
+        raise InputError(f"source missing: {path}")
+    d = np.load(path, allow_pickle=False)
+    if name == "ImMicro":
+        out = {
+            "gene_ids": d["gene_ids"].astype(str),
+            "sample_ids": d["donor_ids"].astype(str),
+            "donor_ids": d["donor_ids"].astype(str),
+            "groups": d["pools"].astype(str),
+            "conditions": np.array(["baseline"] * len(d["donor_ids"]), dtype=np.str_),
+            "bulk": np.asarray(d["bulk_raw"], dtype=np.float64),
+            "pseudo": np.asarray(d["pseudo_raw_sum"], dtype=np.float64),
+            "bulk_valid": np.asarray(d["bulk_valid"], dtype=bool),
+            "sc_valid": np.asarray(d["sc_valid"], dtype=bool),
+            "n_cells": np.asarray(d["qc_cell_counts"], dtype=np.int64),
+        }
+    elif name == "Randolph":
+        n = int(d["bulk_original_units_canonical"].shape[0])
+        out = {
+            "gene_ids": d["gene_ids"].astype(str),
+            "sample_ids": d["sample_ids"].astype(str),
+            "donor_ids": d["donor_ids"].astype(str),
+            "groups": d["cv_groups"].astype(str),
+            "conditions": d["conditions"].astype(str),
+            "bulk": np.asarray(d["bulk_original_units_canonical"], dtype=np.float64),
+            "pseudo": np.asarray(d["pseudo_raw_UMI_canonical"], dtype=np.float64),
+            "bulk_valid": np.asarray(d["bulk_valid"], dtype=bool),
+            # the Randolph pseudobulk support is one fixed vector for the whole study
+            "sc_valid": np.repeat(np.asarray(d["pseudo_valid"], dtype=bool)[None, :], n, axis=0),
+            "n_cells": np.full(n, -1, dtype=np.int64),
+        }
+    else:
+        raise InputError(f"unknown cohort {name}")
+    out["source_path"] = path
+    out["source_sha256"] = sha256_file(path)
+    n, g = out["bulk"].shape
+    for key in ("pseudo", "bulk_valid", "sc_valid"):
+        if out[key].shape != (n, g):
+            raise InputError(f"{name}: {key} has shape {out[key].shape}, expected {(n, g)}")
+    for key in ("sample_ids", "donor_ids", "groups", "conditions"):
+        if out[key].shape != (n,):
+            raise InputError(f"{name}: {key} has shape {out[key].shape}, expected {(n,)}")
+    if g != 20097:
+        raise InputError(f"{name}: expected the canonical 20,097-gene axis, got {g}")
+    out["bulk"] = drop_unmeasured_nan(out["bulk"], out["bulk_valid"], f"{name} bulk")
+    out["pseudo"] = drop_unmeasured_nan(out["pseudo"], out["sc_valid"], f"{name} pseudobulk")
+    return out
+
+
+def gene_multiplier(bulk: np.ndarray, pseudo: np.ndarray, valid: np.ndarray) -> np.ndarray:
+    """The published estimator: alpha_g = mean(P_g) / mean(B_g) over the calibration donors.
+
+    Both sides are on the 1e6 relative scale.  The ratio is only estimated where both training means reach
+    1 unit; elsewhere alpha stays 1, because a ratio of two values near zero carries no information.  The
+    genes left at 1 are a real limitation of this estimator, not a neutral choice.
+    """
+    if bulk.shape != pseudo.shape or bulk.ndim != 2:
+        raise InputError("calibration bulk and pseudobulk must share a 2-D shape")
+    if bulk.shape[0] == 0:
+        raise InputError("no calibration donors")
+    b = cpm(bulk).mean(axis=0)
+    p = cpm(pseudo).mean(axis=0)
+    alpha = np.ones_like(b)
+    usable = valid & (b >= 1.0) & (p >= 1.0)
+    alpha[usable] = p[usable] / b[usable]
+    return alpha
+
+
+def calibration_donors(groups: np.ndarray, held_out: str, n_calibration: int, seed: int) -> np.ndarray:
+    """Row indices of the calibration donors, all from groups other than the held-out one."""
+    pool = np.flatnonzero(groups != held_out)
+    if pool.size < n_calibration:
+        raise InputError(f"group {held_out}: only {pool.size} donors outside it, need {n_calibration}")
+    rng = np.random.default_rng(seed)
+    return np.sort(rng.choice(pool, size=n_calibration, replace=False))
+
+
+def calibrated_bulk(data: dict, n_calibration: int, seed: int) -> tuple[np.ndarray, dict]:
+    """Apply a group-held-out ten-pair multiplier to every sample."""
+    bulk, pseudo = data["bulk"], data["pseudo"]
+    groups = data["groups"]
+    out = np.zeros_like(bulk)
+    record: dict[str, dict] = {}
+    for gi, group in enumerate(sorted(set(groups.tolist()))):
+        rows = np.flatnonzero(groups == group)
+        cal = calibration_donors(groups, group, n_calibration, seed + gi)
+        # a gene is usable for calibration only where both assays measured it in every calibration donor
+        valid = data["bulk_valid"][cal].all(axis=0) & data["sc_valid"][cal].all(axis=0)
+        alpha = gene_multiplier(bulk[cal], pseudo[cal], valid)
+        out[rows] = cpm(bulk[rows]) * alpha[None, :]
+        record[group] = {
+            "n_evaluated": int(rows.size),
+            "calibration_rows": cal.tolist(),
+            "calibration_samples": data["sample_ids"][cal].tolist(),
+            "n_genes_with_estimated_alpha": int((alpha != 1.0).sum()),
+            "alpha_median": float(np.median(alpha[alpha != 1.0])) if (alpha != 1.0).any() else 1.0,
+        }
+    return out, record
+
+
+def to_condition_counts(expression: np.ndarray, measured: np.ndarray,
+                        totals: np.ndarray | None = None) -> np.ndarray:
+    """A count vector per sample, zero wherever the assay did not measure.
+
+    With ``totals`` omitted every sample enters at one fixed depth, which is the policy the published
+    calibration experiments used so that the conditioner's two depth scalars agree between assays.  With
+    ``totals`` given, each sample keeps that depth instead: this is how the SLE benchmark conditions are
+    built, and it is the only way to ask whether standardizing depth is what removes donor identity.
+    """
+    x = np.where(measured, np.asarray(expression, dtype=np.float64), 0.0)
+    if totals is None:
+        return cpm(x) / 1e6 * (RECIPE_K * DEPTH_ANCHOR)
+    totals = np.asarray(totals, dtype=np.float64).reshape(-1, 1)
+    if totals.shape[0] != x.shape[0] or not np.isfinite(totals).all() or (totals <= 0).any():
+        raise InputError("native totals must be one positive finite value per sample")
+    return cpm(x) / 1e6 * totals
+
+
+def build(cohort: str, out_dir: Path, cells_per_bulk: int, n_calibration: int, seed: int,
+          depth_policy: str = "fixed") -> int:
+    data = load_cohort(cohort)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    cal_bulk, cal_record = calibrated_bulk(data, n_calibration, seed)
+    n = data["bulk"].shape[0]
+    # the generated cells must live in the space the observed cells live in, for every arm
+    output_mask = data["sc_valid"]
+    expression = {"raw": data["bulk"], "cal": cal_bulk, "pseudo": data["pseudo"]}
+    measured = {"raw": data["bulk_valid"], "cal": data["bulk_valid"], "pseudo": data["sc_valid"]}
+    if depth_policy == "native":
+        # the donor's own sequencing depth and cell count, as the SLE benchmark conditions carry them.
+        # For the bulk arms this borrows the depth of that donor's single cells, which a bulk-only cohort
+        # would not know; it is a diagnostic of what depth standardization costs, not a deployable recipe.
+        totals = data["pseudo"].sum(axis=1)
+        k_vector = data["n_cells"].astype(np.int64)
+        if bool((k_vector <= 0).any()):
+            raise InputError(f"{cohort}: native depth needs a positive cell count for every sample")
+    else:
+        totals = None
+        k_vector = np.full(n, RECIPE_K, dtype=np.int64)
+
+    manifest = {
+        "schema_version": SCHEMA if depth_policy == "fixed" else NATIVE_SCHEMA,
+        "cohort": cohort,
+        "depth_policy": depth_policy,
+        "source": str(data["source_path"]),
+        "source_sha256": data["source_sha256"],
+        "n_samples": int(n),
+        "n_donors": int(len(set(data["donor_ids"].tolist()))),
+        "groups": sorted(set(data["groups"].tolist())),
+        "recipe_k": RECIPE_K if depth_policy == "fixed" else "per-sample observed cell count",
+        "depth_anchor": DEPTH_ANCHOR if depth_policy == "fixed" else "per-sample observed pseudobulk total",
+        "cells_per_bulk": int(cells_per_bulk),
+        "n_calibration_pairs": int(n_calibration),
+        "calibration_seed": int(seed),
+        "calibration_per_group": cal_record,
+        "arms": {},
+        "written_utc": datetime.now(timezone.utc).isoformat(),
+    }
+    for arm in ARMS:
+        counts = to_condition_counts(expression[arm], measured[arm], totals)
+        frac = measured[arm].astype(np.float32)
+        if bool((counts[frac == 0] != 0).any()):
+            raise InputError(f"{cohort}/{arm}: an unmeasured coordinate carries a non-zero count")
+        suffix = "" if depth_policy == "fixed" else f"_{depth_policy}"
+        path = out_dir / f"conditions_{cohort}_{arm}{suffix}.npz"
+        np.savez(
+            path,
+            schema_version=np.array(SCHEMA),
+            bulk_counts=counts,
+            bulk_measurement_fraction=frac,
+            output_availability_mask=output_mask,
+            recipe_k=k_vector,
+            cells_per_bulk=np.full(n, int(cells_per_bulk), dtype=np.int64),
+            sample_ids=data["sample_ids"],
+            donor_ids=data["donor_ids"],
+            conditions=data["conditions"],
+            groups=data["groups"],
+            gene_ids=data["gene_ids"],
+            donor_n_cells=data["n_cells"],
+            arm=np.array(arm),
+        )
+        manifest["arms"][arm] = {
+            "path": str(path),
+            "sha256": sha256_file(path),
+            "n_measured_genes_median": int(np.median(measured[arm].sum(axis=1))),
+            "detected_fraction_median": float(np.median((counts > 0).mean(axis=1))),
+        }
+        print(f"[{cohort}] {arm:6s} -> {path.name}  "
+              f"measured {manifest['arms'][arm]['n_measured_genes_median']:5d} genes  "
+              f"detected {manifest['arms'][arm]['detected_fraction_median']:.3f}")
+    suffix = "" if depth_policy == "fixed" else f"_{depth_policy}"
+    (out_dir / f"MANIFEST_{cohort}{suffix}.json").write_text(json.dumps(manifest, indent=2))
+    print(f"[{cohort}] manifest written: {out_dir / f'MANIFEST_{cohort}{suffix}.json'}")
+    return 0
+
+
+def main(argv=None) -> int:
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--cohort", choices=sorted(SOURCES), required=True)
+    p.add_argument("--out-dir", type=Path, required=True)
+    p.add_argument("--cells-per-bulk", type=int, default=1500)
+    p.add_argument("--n-calibration", type=int, default=10)
+    p.add_argument("--seed", type=int, default=20260922)
+    p.add_argument(
+        "--depth-policy",
+        choices=("fixed", "native"),
+        default="fixed",
+        help="fixed: one depth and K=1000 for every sample (the published calibration policy). "
+             "native: the donor's own pseudobulk total and cell count, as the SLE conditions use.",
+    )
+    a = p.parse_args(argv)
+    if a.cells_per_bulk <= 0 or a.n_calibration <= 0:
+        raise SystemExit("cells-per-bulk and n-calibration must be positive")
+    return build(a.cohort, a.out_dir, a.cells_per_bulk, a.n_calibration, a.seed, a.depth_policy)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/20260928/diffusion/data/protocol/paired_finetune/tools/ft_common.py

@@ -0,0 +1,720 @@
+"""Shared code of the fine-tuning benchmark scorer (tools/score_ft.py).  CPU only; never imports torch.
+
+Every statistic is imported from the published tools and not retyped:
+  IC  utility_studies_final6k_20260925/immicro/tools/immicro_common.py
+        composition, composition L1, leave-one-out cohort mean, closest-donor retrieval,
+        IC.ER = realbulk_generation_20260922/evaluate_realbulk.py (cpm_log1p, paired_r)
+  SB  utility_studies_final6k_20260925/umap/cell_immicro_5arm/tools/stage_b_embed.py
+        cp10k_log1p, project, knn_radius, precision_coverage, depth_match (thin_to_detected)
+  PR  aifi_scanvi_rebuild_20260916/poisson_readout.py  poisson_integerise
+  EV  bulk2sc-paper/scripts/evaluate_generated_vs_truth.py  log1p_cpm, group_log_fold_change, pearson,
+        welch_bh_deg + top_deg_genes + jaccard (the benchmark's top-50 DEG overlap, Welch backend)
+
+New here (and only here): the dataset adapters, the observed reference cache, the donor-keyed subsample rule,
+the per-cell-type contrast (mean CP10K) and its bulk-broadcast baseline, the donor x type DEG aggregates
+(deg_reference.npz, adds DC to the four contrast types) and the row selection that feeds EV's DEG test.
+"""
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import json
+import os
+import re
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+TASK = M8 / "plans/paired_finetune_intradataset_20260927"
+UTIL = M8 / "plans/utility_studies_final6k_20260925"
+CACHE_ROOT = TASK / "scoring_cache"
+
+sys.path.insert(0, str(UTIL / "immicro/tools"))
+import immicro_common as IC  # noqa: E402
+
+
+def _load_module(name: str, path: Path):
+    if name in sys.modules:
+        return sys.modules[name]
+    spec = importlib.util.spec_from_file_location(name, path)
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules[name] = mod
+    spec.loader.exec_module(mod)  # module level of both files: constants + imports only
+    return mod
+
+
+SB_PATH = UTIL / "umap/cell_immicro_5arm/tools/stage_b_embed.py"
+EV_PATH = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/bulk2sc-paper/scripts/evaluate_generated_vs_truth.py")
+SB = _load_module("stage_b_embed_5arm", SB_PATH)
+EV = _load_module("evaluate_generated_vs_truth", EV_PATH)
+PR = SB.PR
+
+GATE = tuple(IC.GATE)
+CONTRAST_TYPES = ("T cell", "B cell", "Monocyte", "NK cell")
+POISSON_SEED = int(SB.POISSON_SEED)      # 20260916, one read-out per generated cell
+SUB_SEED = int(SB.SUB_SEED)              # 20260925
+GEN_SUB_SEED = SUB_SEED + 1              # stage_b_embed: generated subsample stream
+DEPTH_SEED = SUB_SEED + 4                # stage_b_embed: depth-matching stream
+N_SUB = int(SB.N_SUB)                    # 150 cells per donor
+K_NN = int(SB.K_NN)                      # 10
+CP10K = float(SB.CP10K)
+PCA_DIM = 50
+MIN_DETECT_FRAC = 0.01
+CONTROL_RE = re.compile(r"(?i)(control|healthy|^hc$|^hv$|^ctrl|normal)")
+ANNOT_MODEL_SHA = "bf3655899e5abee435340fc008656c4a17342da0f30b70cfd43de8e9223e1930"  # f01common scANVI model.pt
+ANNOT_RUNS = (IC.ANNOT_RUN, UTIL / "immicro/annotator_mirror/aifi_scanvi_f01common_v1")  # server_1, server_2 mirror
+assert POISSON_SEED == IC.SEED
+
+
+def log(msg: str) -> None:
+    print(f"{datetime.now().strftime('%H:%M:%S')} {msg}", flush=True)
+
+
+def sha(path: Path) -> str:
+    return IC.sha256_file(path)
+
+
+def now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+# --------------------------------------------------------------------------- datasets
+@dataclass(frozen=True)
+class DatasetSpec:
+    name: str
+    data_dir: Path
+    features: Path
+    dataset_id: str
+    batch_prefix: str
+    labels: str          # "immicro_frozen": the published frozen labels; "predict": label the observed cells here
+    contrast: str        # "none" | "auto" (control = groups matching CONTROL_RE, case = every other group)
+
+
+DATASETS = {
+    "immicro": DatasetSpec("immicro", TASK / "data/immicro", IC.FEATURES, "GSE314416_ImMicro", IC.BATCH_PREFIX,
+                           "immicro_frozen", "none"),
+    "ye2026_sepsis": DatasetSpec("ye2026_sepsis", TASK / "data/ye2026_sepsis", TASK / "data/ye2026_sepsis/features.npz",
+                                 "Ye2026_sepsis", "Ye2026_sepsis_", "predict", "auto"),
+    # added 2026-09-28, built the same way as ye2026_sepsis (observed cells labelled by the frozen annotator)
+    "imperial_eskd": DatasetSpec("imperial_eskd", TASK / "data/imperial_eskd", TASK / "data/imperial_eskd/features.npz",
+                                 "Imperial_eskd", "Imperial_eskd_", "predict", "auto"),
+    "giroux2022": DatasetSpec("giroux2022", TASK / "data/giroux2022", TASK / "data/giroux2022/features.npz",
+                              "Giroux2022", "Giroux2022_", "predict", "auto"),
+    "ji2025_chili": DatasetSpec("ji2025_chili", TASK / "data/ji2025_chili", TASK / "data/ji2025_chili/features.npz",
+                                "Ji2025_chili", "Ji2025_chili_", "predict", "auto"),
+}
+
+
+def load_features(path: Path) -> dict:
+    """features.npz of one paired dataset: sample order, groups, canonical gene axis, masks, observed pseudobulk."""
+    path = Path(path)
+    if not path.is_file():
+        raise SystemExit(f"features file missing: {path}")
+    f = np.load(path, allow_pickle=False)
+    keys = set(f.files)
+
+    def pick(*names, required=True):
+        for n in names:
+            if n in keys:
+                return n
+        if required:
+            raise SystemExit(f"{path}: none of {names} present (keys: {sorted(keys)})")
+        return None
+
+    sid = pick("sample_ids", "donor_ids")
+    did = pick("donor_ids", "sample_ids")
+    gk = pick("groups", "pools", required=False)
+    pk = pick("pseudo_raw_sum", "pseudo_raw_UMI_canonical", "pseudo")
+    out = {"path": str(path), "sha256": sha(path), "keys": {"sample_ids": sid, "donor_ids": did, "groups": gk, "pseudo": pk},
+           "sample_ids": f[sid].astype(str), "donor_ids": f[did].astype(str), "gene_ids": f["gene_ids"].astype(str),
+           "bulk_valid": np.asarray(f["bulk_valid"], bool), "sc_valid": np.asarray(f["sc_valid"], bool),
+           "pseudo": np.asarray(f[pk], np.float64)}
+    n = out["sample_ids"].size
+    out["groups"] = f[gk].astype(str) if gk else np.full(n, "", dtype=object).astype(str)
+    if len(set(out["sample_ids"])) != n:
+        raise SystemExit(f"{path}: sample ids are not unique")
+    # longitudinal datasets (Imperial, Giroux, Ji) carry several samples per donor: the scored unit is the sample;
+    # the composition null then leaves out every sample of the scored sample's donor (lodo_mean)
+    out["multi_sample_donors"] = len(set(out["donor_ids"])) != n
+    for k in ("bulk_valid", "sc_valid", "pseudo"):
+        if out[k].shape != (n, out["gene_ids"].size):
+            raise SystemExit(f"{path}: {k} shape {out[k].shape}")
+    return out
+
+
+def gene_sets(feat: dict) -> dict:
+    """Panel (6k, NPZ order), scoring genes, annotation query genes -- all read from their source files.
+
+    scoring genes = panel genes both assays measured in every sample of the dataset (bulk_valid.all & sc_valid.all):
+    evaluate_realbulk.py's rule; used for pseudobulk r, precision/coverage, depth and the contrast.
+    query genes = the 1,006-gene annotation list minus genes the dataset's sc assay did not measure in every sample
+    (for ImMicro this is exactly the published observed query, observed_query_genes.txt).
+    """
+    panel_ids = np.asarray(IC.load_panel6k().gene_id.astype(str).to_numpy(), dtype=str)
+    cpos = {g: i for i, g in enumerate(feat["gene_ids"])}
+    miss = [g for g in panel_ids if g not in cpos]
+    if miss:
+        raise SystemExit(f"{len(miss)} panel genes absent from the features gene axis (e.g. {miss[:3]})")
+    panel_canon = np.asarray([cpos[g] for g in panel_ids], dtype=np.int64)
+    measured = feat["bulk_valid"].all(0)[panel_canon] & feat["sc_valid"].all(0)[panel_canon]
+    score_idx = np.flatnonzero(measured)
+    annot = IC.load_annotation_list()
+    dropped = [g for g in annot if g not in cpos or not feat["sc_valid"][:, cpos[g]].all()]
+    query = [g for g in annot if g not in set(dropped)]
+    ppos = {g: i for i, g in enumerate(panel_ids)}
+    qmiss = [g for g in query if g not in ppos]
+    if qmiss:
+        raise SystemExit(f"{len(qmiss)} annotation genes absent from the 6k panel (e.g. {qmiss[:3]})")
+    model_genes = [str(x) for x in pd.read_csv(annotator_run() / "genes.csv").gene_id]
+    return {"panel_ids": panel_ids, "panel_canon": panel_canon, "score_idx": score_idx, "score_ids": panel_ids[score_idx],
+            "score_canon": panel_canon[score_idx], "query_ids": query,
+            "query_panel_idx": np.asarray([ppos[g] for g in query], dtype=np.int64), "dropped_annotation_genes": dropped,
+            "model_genes_missing_from_query": int(len(set(model_genes) - set(query)))}
+
+
+def annotator_run(explicit: Path | None = None) -> Path:
+    for cand in ([Path(explicit)] if explicit else list(ANNOT_RUNS)):
+        if (cand / "scanvi_model/model.pt").is_file():
+            return cand
+    raise SystemExit(f"frozen annotator not found in {ANNOT_RUNS}")
+
+
+# --------------------------------------------------------------------------- observed cells
+def cell_keys(table: pd.DataFrame) -> tuple[np.ndarray, str]:
+    """Stable per-cell key (the within-donor canonical order).  Falls back to file order."""
+    for cols in (("library_id", "barcode"), ("sample_id", "barcode"), ("barcode",), ("cell_id",), ("obs_name",)):
+        if all(c in table.columns for c in cols):
+            k = table[list(cols)].astype(str).agg("|".join, axis=1).to_numpy() if len(cols) > 1 else table[cols[0]].astype(str).to_numpy()
+            if len(set(k)) == len(k):
+                return k.astype(str), "+".join(cols)
+    return np.char.mod("%012d", np.arange(len(table))).astype(str), "file order"
+
+
+def load_cells_datadir(spec: DatasetSpec, gs: dict) -> dict | None:
+    """data/<dataset>/cells_panel6k.npz + cells_obs.parquet (coordinator's layout); None when absent."""
+    npz, obs = spec.data_dir / "cells_panel6k.npz", spec.data_dir / "cells_obs.parquet"
+    if not (npz.is_file() and obs.is_file()):
+        return None
+    z = np.load(npz, allow_pickle=False)
+    if not np.array_equal(z["panel_gene_ids"].astype(str), gs["panel_ids"]):
+        raise SystemExit(f"{npz}: panel_gene_ids differ from the 6k panel file")
+    X = sp.csr_matrix((z["data"], z["indices"], z["indptr"]), shape=tuple(int(x) for x in z["shape"]))
+    table = pd.read_parquet(obs)
+    rs = np.asarray(z["row_sample"], dtype=np.int64)
+    if len(table) != X.shape[0] or rs.size != X.shape[0]:
+        raise SystemExit(f"{npz}: {X.shape[0]} rows, {len(table)} obs rows, {rs.size} row_sample")
+    return {"X": X, "sample_row": rs, "table": table, "source": f"datadir:{spec.data_dir}",
+            "inputs_sha256": {str(npz): sha(npz), str(obs): sha(obs)}}
+
+
+def load_cells_immicro_h5ad(feat: dict, gs: dict, donors: list[str] | None = None) -> dict:
+    """ImMicro baseline cells (observed_cells.parquet kind == 'baseline') read from the canonical per-library h5ads
+    by barcode, exactly as umap/cell_immicro/tools/stage_a_real_and_inputs.py does; panel columns only."""
+    import anndata as ad
+    cells = pd.read_parquet(IC.TASK / "out/observed_cells.parquet")
+    base = cells[cells.kind == "baseline"]
+    if donors is not None:
+        base = base[base.donor_id.isin(donors)]
+    row_of = {s: i for i, s in enumerate(feat["sample_ids"])}
+    blocks, tabs, shas = [], [], {}
+    for lib, sub in base.groupby("library_id", sort=True):
+        path = IC.SC_DIR / lib / "canonical.h5ad"
+        A = ad.read_h5ad(path)
+        if not np.array_equal(A.var_names.astype(str).to_numpy(), feat["gene_ids"]):
+            raise SystemExit(f"{lib}: gene axis differs from features.npz")
+        pos = pd.Series(np.arange(A.n_obs), index=A.obs_names.astype(str))
+        r = pos.reindex(sub.barcode.to_numpy())
+        if r.isna().any():
+            raise SystemExit(f"{lib}: {int(r.isna().sum())} barcodes missing")
+        X = A.X.tocsr() if sp.issparse(A.X) else sp.csr_matrix(A.X)
+        Xs = X[r.to_numpy(dtype=np.int64)]
+        if not np.allclose(np.asarray(Xs.sum(axis=1)).ravel(), sub.cell_total_canonical.to_numpy()):
+            raise SystemExit(f"{lib}: canonical totals differ from observed_cells.parquet")
+        Xp = Xs[:, gs["panel_canon"]].tocsr()
+        if Xp.nnz and not np.array_equal(Xp.data, np.round(Xp.data)):
+            raise SystemExit(f"{lib}: non-integer counts")
+        blocks.append(Xp.astype(np.int32))
+        tabs.append(sub)
+        shas[str(path)] = f"size={path.stat().st_size}"
+        del A, X, Xs
+    X = sp.vstack(blocks, format="csr")
+    table = pd.concat(tabs, ignore_index=True)
+    return {"X": X, "sample_row": table.donor_id.map(row_of).to_numpy(np.int64), "table": table,
+            "source": f"immicro_h5ad:{IC.SC_DIR}", "inputs_sha256": {str(IC.TASK / 'out/observed_cells.parquet'):
+                                                                       sha(IC.TASK / "out/observed_cells.parquet"), **shas}}
+
+
+def immicro_frozen_labels(table: pd.DataFrame) -> tuple[np.ndarray, dict]:
+    """The published frozen f01common labels of the observed ImMicro cells, joined on observed cell_index."""
+    ldir = IC.TASK / "labels/observed_immicro"
+    man = json.loads((ldir / "labels.manifest.json").read_text())
+    if man["model"]["model_pt_sha256"] != ANNOT_MODEL_SHA:
+        raise SystemExit("observed ImMicro labels were not made with the f01common annotator")
+    lab = pd.read_parquet(ldir / "labels.parquet", columns=["cell_index", "celltype_l1_pred"]).set_index("cell_index")
+    out = lab.celltype_l1_pred.reindex(table.cell_index.to_numpy())
+    if out.isna().any():
+        raise SystemExit(f"{int(out.isna().sum())} observed cells without a frozen label")
+    info = {"source": str(ldir / "labels.parquet"), "sha256": sha(ldir / "labels.parquet"),
+            "model_pt_sha256": man["model"]["model_pt_sha256"],
+            "zero_padded_model_genes": man["gene_space"]["model_genes_missing_from_query_zero_padded"]}
+    return out.astype(str).to_numpy(), info
+
+
+# --------------------------------------------------------------------------- frozen annotation (predict_scanvi.py)
+def run_annotator(counts_query: sp.csr_matrix, query_ids: list[str], sample_key: np.ndarray, *, work: Path, method: str,
+                  spec: DatasetSpec, split: str, threads: int, annot: Path, expected_zero_pad: int,
+                  source_note: dict) -> tuple[pd.DataFrame, dict]:
+    """Label integer cells with the frozen f01common scANVI exactly as score_generated.py does (CPU, zero query
+    epochs, batch_key = prefix + sample key).  Keeps labels.parquet + manifest, deletes the query h5ad and the
+    probability tables."""
+    import anndata as ad
+    work.mkdir(parents=True, exist_ok=True)
+    q = counts_query.astype(np.float32).tocsr()
+    q.eliminate_zeros()
+    obs = pd.DataFrame({"cell_index": np.arange(q.shape[0]), "sample_id": np.asarray(sample_key, dtype=object),
+                        "source": method})
+    obs["batch_key"] = pd.Categorical([f"{spec.batch_prefix}{s}" for s in obs.sample_id])
+    obs["aifi_l2_train"] = pd.Categorical(["Unknown"] * len(obs), categories=["Unknown"])
+    obs.index = pd.Index([f"{method}:{i}" for i in range(len(obs))])
+    qa = ad.AnnData(X=q, obs=obs, var=pd.DataFrame(index=pd.Index(query_ids, name="gene_id")))
+    qa.layers["counts"] = qa.X.copy()
+    qa.uns["query_build"] = {"set": method, **source_note}
+    qpath = work / "query.h5ad"
+    qa.write_h5ad(qpath)
+    del qa, q
+    lab_dir = work / "labels"
+    cmd = [str(IC.SCANVI_PY), "-u", str(IC.PREDICT), "--model-dir", str(annot / "scanvi_model"), "--query", str(qpath),
+           "--out-dir", str(lab_dir), "--method-name", method, "--dataset-id", spec.dataset_id, "--split", split,
+           "--sample-id-col", "sample_id", "--batch-key-col", "batch_key", "--batch-prefix", spec.batch_prefix,
+           "--seed", str(POISSON_SEED), "--device", "cpu", "--num-threads", str(threads), "--eval-batch-size", "2048",
+           "--allow-missing-genes"]
+    env = dict(os.environ, CUDA_VISIBLE_DEVICES="", PYTHONNOUSERSITE="1", OMP_NUM_THREADS=str(threads),
+               MKL_NUM_THREADS=str(threads), OPENBLAS_NUM_THREADS=str(threads))
+    t0 = time.monotonic()
+    res = subprocess.run(cmd, env=env, capture_output=True, text=True)
+    (work / "predict_scanvi.log").write_text(res.stdout + "\n--- stderr ---\n" + res.stderr)
+    qpath.unlink(missing_ok=True)
+    for extra in ("soft_probabilities_l2.parquet", "probabilities_l1.parquet"):
+        (lab_dir / extra).unlink(missing_ok=True)
+    if res.returncode != 0:
+        raise SystemExit(f"predict_scanvi.py failed (see {work / 'predict_scanvi.log'})")
+    man = json.loads((lab_dir / "labels.manifest.json").read_text())
+    if man["model"]["model_pt_sha256"] != ANNOT_MODEL_SHA:
+        raise SystemExit("annotator model sha differs from the f01common model")
+    zp = man["gene_space"]["model_genes_missing_from_query_zero_padded"]
+    if zp != expected_zero_pad:
+        raise SystemExit(f"annotation contract differs: {zp} zero-padded model genes, expected {expected_zero_pad}")
+    lab = pd.read_parquet(lab_dir / "labels.parquet")
+    if len(lab) != len(sample_key) or not np.array_equal(lab.cell_index.to_numpy(), np.arange(len(sample_key))):
+        raise SystemExit("labels are not row-aligned with the query cells")
+    extra = sorted(set(lab.celltype_l1_pred.astype(str)) - set(GATE))
+    if extra:
+        raise SystemExit(f"labels outside the six-type gate: {extra}")
+    info = {"labels_parquet": str(lab_dir / "labels.parquet"), "model_pt_sha256": man["model"]["model_pt_sha256"],
+            "zero_padded_model_genes": zp, "label_counts": man["label_counts"]["celltype_l1_pred"],
+            "mean_l2_max_prob": man["confidence"]["mean_l2_max_prob"], "predict_seconds": round(time.monotonic() - t0, 1),
+            "command": cmd[2:]}
+    return lab, info
+
+
+# --------------------------------------------------------------------------- donor-keyed subsample rule
+def donor_rng(seed: int, donor: str) -> np.random.Generator:
+    """A stream that depends only on (seed, donor id): the same donor draws the same cells in every fold and arm."""
+    key = int.from_bytes(hashlib.sha256(str(donor).encode()).digest()[:8], "little")
+    return np.random.default_rng([int(seed), key])
+
+
+def reference_split(n_cells: int, donor: str, n_sub: int = N_SUB) -> tuple[np.ndarray, np.ndarray]:
+    """Positions (in the donor's canonical cell order) of R1 (PCA / k-NN reference) and R2 (held-out real control):
+    one permutation from donor_rng(SUB_SEED, donor); R1 = first n, R2 = next n, n = min(150, n_cells // 2)."""
+    n = min(int(n_sub), int(n_cells) // 2)
+    if n < 1:
+        raise SystemExit(f"{donor}: {n_cells} observed cells, cannot draw a reference")
+    perm = donor_rng(SUB_SEED, donor).permutation(int(n_cells))
+    return np.sort(perm[:n]), np.sort(perm[n:2 * n])
+
+
+def generated_subsample(n_gen: int, n_ref: int, donor: str) -> np.ndarray:
+    """Positions (in the donor's NPZ cell order) of the generated cells embedded for precision/coverage: n_ref cells
+    (the donor's R1 size) drawn without replacement with donor_rng(SUB_SEED + 1, donor)."""
+    if n_gen < n_ref:
+        raise SystemExit(f"{donor}: {n_gen} generated cells, fewer than the {n_ref} reference cells")
+    return np.sort(donor_rng(GEN_SUB_SEED, donor).choice(int(n_gen), size=int(n_ref), replace=False))
+
+
+# --------------------------------------------------------------------------- per donor x cell type aggregates
+def type_aggregates(X: sp.csr_matrix, donor_idx: np.ndarray, labels: np.ndarray, n_donors: int,
+                    types=CONTRAST_TYPES) -> dict:
+    """Per (donor, type) on the columns of X: cell count, summed counts, summed per-cell CP10K (library = the columns
+    of X; a cell with no counts contributes zeros, as SB.cp10k_log1p) and the number of cells with count > 0."""
+    X = X.tocsr().astype(np.float64)
+    lib = np.asarray(X.sum(axis=1)).ravel()
+    cp = (sp.diags(np.divide(CP10K, lib, out=np.zeros_like(lib), where=lib > 0)) @ X).tocsr()
+    det = X.copy()
+    det.data = (det.data > 0).astype(np.float64)
+    T, G = len(types), X.shape[1]
+    out = {"n": np.zeros((n_donors, T), np.int64), "sum": np.zeros((n_donors, T, G)), "cp10k": np.zeros((n_donors, T, G)),
+           "det": np.zeros((n_donors, T, G))}
+    labels = np.asarray(labels).astype(str)
+    donor_idx = np.asarray(donor_idx, np.int64)
+    for ti, t in enumerate(types):
+        m = np.flatnonzero(labels == t)
+        if m.size == 0:
+            continue
+        ind = sp.csr_matrix((np.ones(m.size), (donor_idx[m], np.arange(m.size))), shape=(n_donors, m.size))
+        out["n"][:, ti] = np.bincount(donor_idx[m], minlength=n_donors)
+        out["sum"][:, ti] = (ind @ X[m]).toarray()
+        out["cp10k"][:, ti] = (ind @ cp[m]).toarray()
+        out["det"][:, ti] = (ind @ det[m]).toarray()
+    return out
+
+
+def lfc_mean_cp10k(n: np.ndarray, cp_sum: np.ndarray, case: np.ndarray, ctrl: np.ndarray) -> np.ndarray | None:
+    """Primary contrast statistic: log2(mean CP10K + 1) of case minus control.  The group mean is donor-balanced: the
+    mean over the group's donors (those with >= 1 cell of the type) of the donor's mean per-cell CP10K."""
+    have = n > 0
+    c, h = case & have, ctrl & have
+    if c.sum() < 1 or h.sum() < 1:
+        return None
+    mc = (cp_sum[c] / n[c, None]).mean(0)
+    mh = (cp_sum[h] / n[h, None]).mean(0)
+    return np.log2(mc + 1.0) - np.log2(mh + 1.0)
+
+
+def lfc_pseudobulk(n: np.ndarray, counts_sum: np.ndarray, case: np.ndarray, ctrl: np.ndarray) -> np.ndarray | None:
+    """Secondary: the SLE benchmark evaluator's statistic (EV.group_log_fold_change): donor x type pseudobulk,
+    log1p(CPM) with library = all columns, mean(case) - mean(control), natural log."""
+    rows = (n > 0) & (case | ctrl)
+    if rows.sum() == 0:
+        return None
+    return EV.group_log_fold_change(counts_sum[rows], case[rows])
+
+
+def bulk_lfc(bulk: np.ndarray, case: np.ndarray, ctrl: np.ndarray) -> dict:
+    """Broadcast baseline from the input bulk (condition NPZ bulk_counts on the scoring genes), both statistics."""
+    lib = bulk.sum(1, keepdims=True)
+    if (lib <= 0).any():
+        raise SystemExit("a condition bulk has no counts on the scoring genes")
+    cp = bulk / lib * CP10K
+    prim = np.log2(cp[case].mean(0) + 1.0) - np.log2(cp[ctrl].mean(0) + 1.0) if case.any() and ctrl.any() else None
+    rows = case | ctrl
+    sec = EV.group_log_fold_change(bulk[rows], case[rows]) if rows.any() else None
+    return {"mean_cp10k": prim, "pseudobulk_log1p_cpm": sec}
+
+
+def resid(y, x):
+    """OLS residual of y on [1, x] (sle_broadcast/scripts/residual_specificity.py)."""
+    X = np.column_stack([np.ones_like(x), x])
+    beta, *_ = np.linalg.lstsq(X, y, rcond=None)
+    return y - X @ beta
+
+
+def contrast_scores(obs_lfc, gen_lfc, blk_lfc, genes: np.ndarray) -> dict:
+    """Pearson r of generated vs observed logFC, of broadcast vs observed, and the partial r of generated with
+    observed given the broadcast (OLS residuals, as residual_specificity.py)."""
+    out = {"n_genes": int(genes.sum()), "r_generated": float("nan"), "r_broadcast": float("nan"),
+           "partial_r_generated_given_broadcast": float("nan"), "r_generated_vs_broadcast": float("nan")}
+    if obs_lfc is None or genes.sum() < 3:
+        return out
+    o = obs_lfc[genes]
+    if gen_lfc is not None:
+        out["r_generated"] = EV.pearson(gen_lfc[genes], o)
+    if blk_lfc is not None:
+        out["r_broadcast"] = EV.pearson(blk_lfc[genes], o)
+    if gen_lfc is not None and blk_lfc is not None:
+        b = blk_lfc[genes]
+        out["partial_r_generated_given_broadcast"] = EV.pearson(resid(o, b), resid(gen_lfc[genes], b))
+        out["r_generated_vs_broadcast"] = EV.pearson(gen_lfc[genes], b)
+    return out
+
+
+# --------------------------------------------------------------------------- top-50 DEG overlap (benchmark score)
+# The SLE benchmark's "top-50 DEG" (total_top50_overlap of evaluate_generated_vs_truth.py, Welch backend; the 81 / 84
+# of utility_studies_final6k_20260925/sle) and its bulk-broadcast analogue (sle_broadcast/scripts/sle_broadcast.py,
+# "broadcast_input_bulk").  The statistic is EV's own functions; only the donor-row selection is written here.
+DEG_TYPES = CONTRAST_TYPES + ("DC",)
+DEG_TOP_N = int(EV.DEFAULT_TOP_N)        # 50
+DEG_FDR = float(EV.DEFAULT_FDR)          # 0.05
+DEG_STATISTIC = "welch_top50_deg"        # contrast.csv rows of this score
+DEG_REF_NPZ = "deg_reference.npz"
+DEG_REF_MANIFEST = "deg_reference_manifest.json"
+SHORT_TYPE = {"T cell": "T", "B cell": "B", "Monocyte": "Mono", "NK cell": "NK", "DC": "DC", "Other": "Other"}
+assert DEG_TYPES[:len(CONTRAST_TYPES)] == CONTRAST_TYPES and DEG_TOP_N == 50 and DEG_FDR == 0.05
+
+
+def deg_top(n: np.ndarray, counts_sum: np.ndarray, case: np.ndarray, ctrl: np.ndarray, genes) -> dict:
+    """One side's top-50 list for one cell type, as evaluate_generated_vs_truth.evaluate (its _deg + top_deg_genes):
+    rows = the donor x type pseudobulks with >= 1 cell of the type (EV.aggregate_pseudobulk keeps only those), limited
+    to case | control donors; EV.welch_bh_deg (log1p CPM over the given columns, two-sided Welch, BH over the genes with
+    a defined p-value; None unless both arms have >= 2 such donors); EV.top_deg_genes (FDR < 0.05, descending |logFC|,
+    first 50, fewer when fewer are significant)."""
+    n, case, ctrl = np.asarray(n), np.asarray(case, bool), np.asarray(ctrl, bool)
+    rows = (n > 0) & (case | ctrl)
+    deg = EV.welch_bh_deg(np.asarray(counts_sum, np.float64)[rows], case[rows]) if rows.any() else None
+    return {"top": EV.top_deg_genes(deg, genes, top_n=DEG_TOP_N, fdr=DEG_FDR), "defined": deg is not None,
+            "n_significant": int(deg.significant(DEG_FDR).size) if deg is not None else 0,
+            "n_tested": int(deg.tested.sum()) if deg is not None else 0,
+            "n_case_donors": int((rows & case).sum()), "n_control_donors": int((rows & ctrl).sum())}
+
+
+def deg_overlap(ref_top: list, other_top: list) -> dict:
+    """EV's per-type top50_overlap_count (|intersection|) and top50_jaccard (EV.jaccard; NaN for two empty lists)."""
+    return {"overlap": len(set(ref_top) & set(other_top)), "jaccard": EV.jaccard(ref_top, other_top)}
+
+
+def write_deg_reference(out_dir: Path, man: dict, n: np.ndarray, sums: np.ndarray, check: dict) -> dict:
+    """deg_reference.npz: per scored-reference donor x DEG_TYPES cell count and summed counts on the scoring genes
+    (observed cells, observed labels), bound to reference.npz by its sha256.  Written atomically."""
+    out_dir = Path(out_dir)
+    npz = out_dir / DEG_REF_NPZ
+    tmp = out_dir / (DEG_REF_NPZ[:-4] + ".tmp.npz")
+    np.savez_compressed(tmp, deg_types=np.asarray(DEG_TYPES), deg_n=np.asarray(n, np.int64),
+                        deg_sum=np.asarray(sums, np.float64), reference_sha256=np.asarray(man["reference_sha256"]))
+    os.replace(tmp, npz)
+    dman = {"schema": "paired_ft_deg_reference.v1", "dataset": man["dataset"], "written_utc": now(),
+            "deg_reference_npz": str(npz), "sha256": sha(npz), "reference_sha256": man["reference_sha256"],
+            "types": list(DEG_TYPES), "n_cells": dict(zip(DEG_TYPES, np.asarray(n).sum(0).tolist())),
+            "donors_with_cells": dict(zip(DEG_TYPES, (np.asarray(n) > 0).sum(0).tolist())), "checks": check}
+    (out_dir / DEG_REF_MANIFEST).write_text(json.dumps(dman, indent=1, default=str) + "\n")
+    log(f"DEG reference: {npz} ({', '.join(f'{t} {c}' for t, c in dman['n_cells'].items())} cells)")
+    return dman
+
+
+def build_deg_reference(spec: DatasetSpec, cache_dir: Path) -> dict:
+    """deg_reference.npz for an existing reference cache, from the same observed cells and the same observed labels
+    (no re-annotation).  Fail-closed: features / cells inputs / labels must be the ones in reference_manifest.json,
+    and the four contrast types must equal the reference's agg_n / agg_sum exactly."""
+    cache_dir = Path(cache_dir)
+    ref, man = load_reference(cache_dir)
+    feat = load_features(spec.features)
+    if feat["sha256"] != man["features"]["sha256"]:
+        raise SystemExit(f"{spec.features}: sha differs from the one the reference was built from")
+    gs = gene_sets(feat)
+    if not np.array_equal(gs["score_ids"], ref["score_ids"].astype(str)):
+        raise SystemExit("scoring genes differ from the reference")
+    if man["cells"]["source"].startswith("datadir:"):
+        cells = load_cells_datadir(spec, gs)
+        if cells is None or cells["inputs_sha256"] != man["cells"]["inputs_sha256"]:
+            raise SystemExit(f"{spec.data_dir}: observed cell files differ from the ones the reference was built from")
+    elif spec.name == "immicro":
+        cells = load_cells_immicro_h5ad(feat, gs)
+    else:
+        raise SystemExit(f"unknown cells source {man['cells']['source']}")
+    table = cells["table"].reset_index(drop=True)
+    if spec.labels == "immicro_frozen":
+        labels, info = immicro_frozen_labels(table)
+        if info["sha256"] != man["labels"]["sha256"]:
+            raise SystemExit("frozen ImMicro labels differ from the reference's")
+    else:
+        lab_path = cache_dir / "observed_labels" / "labels" / "labels.parquet"
+        if sha(lab_path) != man["labels"]["sha256"]:
+            raise SystemExit(f"{lab_path}: sha differs from the reference manifest")
+        lab = pd.read_parquet(lab_path, columns=["cell_index", "celltype_l1_pred"])
+        if len(lab) != len(table) or not np.array_equal(lab.cell_index.to_numpy(), np.arange(len(table))):
+            raise SystemExit("observed labels are not row-aligned with the observed cells")
+        labels = lab.celltype_l1_pred.astype(str).to_numpy()
+    srow = cells["sample_row"]
+    D = feat["sample_ids"].size
+    have = np.bincount(srow, minlength=D) > 0
+    donors = feat["sample_ids"][have]
+    if not np.array_equal(donors, ref["donors"].astype(str)):
+        raise SystemExit("donor order differs from the reference")
+    remap = np.full(D, -1)
+    remap[np.flatnonzero(have)] = np.arange(donors.size)
+    Xs = cells["X"].tocsr()[:, gs["score_idx"]].tocsr()
+    del cells
+    agg = type_aggregates(Xs, remap[srow], np.asarray(labels, dtype=str), donors.size, types=DEG_TYPES)
+    k = len(CONTRAST_TYPES)
+    same = bool(np.array_equal(agg["n"][:, :k], ref["agg_n"])
+                and np.array_equal(agg["sum"][:, :k].astype(np.float32), ref["agg_sum"]))
+    if not same:
+        raise SystemExit("recomputed contrast-type aggregates differ from reference.npz (cells or labels misaligned)")
+    return write_deg_reference(cache_dir, man, agg["n"], agg["sum"],
+                               {"contrast_types_equal_reference_agg": same, "built_from": "existing cache"})
+
+
+def load_deg_reference(cache_dir: Path, man: dict, ref: dict) -> dict:
+    """DEG aggregates for scoring: deg_reference.npz when present (fail-closed on a stale file), else the four
+    contrast types from reference.npz (then DC is not scored)."""
+    npz, mpath = Path(cache_dir) / DEG_REF_NPZ, Path(cache_dir) / DEG_REF_MANIFEST
+    if not npz.is_file():
+        return {"types": CONTRAST_TYPES, "n": ref["agg_n"].astype(np.int64), "sum": ref["agg_sum"].astype(np.float64),
+                "source": "reference.npz agg_n / agg_sum (four contrast types)", "sha256": None,
+                "note": f"no {DEG_REF_NPZ} in {cache_dir}: DC not scored "
+                        f"(score_ft.py --dataset {man['dataset']} --build-deg-reference adds it)"}
+    dman = json.loads(mpath.read_text())
+    s = sha(npz)
+    z = np.load(npz, allow_pickle=False)
+    if s != dman["sha256"] or dman["reference_sha256"] != man["reference_sha256"] \
+            or str(z["reference_sha256"]) != man["reference_sha256"]:
+        raise SystemExit(f"{npz} does not belong to the current reference.npz (rebuild with --build-deg-reference)")
+    return {"types": tuple(z["deg_types"].astype(str)), "n": z["deg_n"].astype(np.int64),
+            "sum": z["deg_sum"].astype(np.float64), "source": str(npz), "sha256": s, "note": None}
+
+
+# --------------------------------------------------------------------------- reference cache
+def build_reference(spec: DatasetSpec, out_dir: Path, *, source: str = "auto", threads: int = 8,
+                    annot: Path | None = None, check_donors: int = 3) -> dict:
+    """Per-dataset observed reference: everything the scorer needs from the observed cells, independent of fold/arm.
+
+    Stored: donor order/groups, n cells, observed six-type composition, observed pseudobulk on the scoring genes,
+    R1/R2 reference cells (counts on the scoring genes, donor-keyed rule), per-cell library on the scoring genes,
+    and per donor x contrast-type aggregates (n, summed counts, summed CP10K, detection counts)."""
+    t0 = time.monotonic()
+    out_dir.mkdir(parents=True, exist_ok=True)
+    feat = load_features(spec.features)
+    gs = gene_sets(feat)
+    annot = annotator_run(annot)
+    cells = None
+    checks: dict = {}
+    if source in ("auto", "datadir"):
+        cells = load_cells_datadir(spec, gs)
+        if cells is None and source == "datadir":
+            raise SystemExit(f"{spec.data_dir}: cells_panel6k.npz / cells_obs.parquet missing")
+    if cells is None:
+        if spec.name != "immicro":
+            raise SystemExit(f"{spec.data_dir}: no observed cells (cells_panel6k.npz + cells_obs.parquet)")
+        log("reading ImMicro observed cells from the canonical h5ad libraries")
+        cells = load_cells_immicro_h5ad(feat, gs)
+    elif spec.name == "immicro" and check_donors > 0 and IC.SC_DIR.is_dir():
+        pick = list(feat["sample_ids"][np.linspace(0, feat["sample_ids"].size - 1, check_donors).astype(int)])
+        log(f"checking {cells['source']} against the canonical h5ads for {pick}")
+        ref = load_cells_immicro_h5ad(feat, gs, pick)
+        a_keys, _ = cell_keys(ref["table"])
+        m = np.isin(cells["sample_row"], [int(np.flatnonzero(feat["sample_ids"] == d)[0]) for d in pick])
+        b_keys, _ = cell_keys(cells["table"].loc[m].reset_index(drop=True))
+        oa, ob = np.argsort(a_keys, kind="stable"), np.argsort(b_keys, kind="stable")
+        same = np.array_equal(a_keys[oa], b_keys[ob]) and (ref["X"][oa] != cells["X"][np.flatnonzero(m)][ob]).nnz == 0
+        checks["datadir_equals_h5ad_for_donors"] = {"donors": pick, "equal": bool(same)}
+        if not same:
+            raise SystemExit(f"{cells['source']} differs from the canonical h5ads for {pick}")
+    X = cells["X"].tocsr()
+    srow = cells["sample_row"]
+    table = cells["table"].reset_index(drop=True)
+    if spec.labels == "immicro_frozen":
+        labels, label_info = immicro_frozen_labels(table)
+    else:
+        lab_path = out_dir / "observed_labels" / "labels" / "labels.parquet"
+        log(f"labelling {X.shape[0]} observed cells with the frozen annotator")
+        lab, label_info = run_annotator(X[:, gs["query_panel_idx"]], gs["query_ids"], feat["sample_ids"][srow],
+                                        work=out_dir / "observed_labels", method=f"observed_{spec.name}", spec=spec,
+                                        split="observed", threads=threads, annot=annot,
+                                        expected_zero_pad=gs["model_genes_missing_from_query"],
+                                        source_note={"kind": "real_counts", "readout": "real_counts", "seed": None,
+                                                     "source": cells["source"]})
+        labels = lab.celltype_l1_pred.astype(str).to_numpy()
+        label_info["sha256"] = sha(lab_path)
+    labels = np.asarray(labels, dtype=str)
+    keys, key_rule = cell_keys(table)
+    order = np.lexsort((keys, srow))
+    X, srow, labels, keys = X[order], srow[order], labels[order], keys[order]
+    # fail-closed: every sample's summed panel counts equal the features pseudobulk exactly
+    D = feat["sample_ids"].size
+    have = np.bincount(srow, minlength=D) > 0
+    ind = sp.csr_matrix((np.ones(srow.size), (srow, np.arange(srow.size))), shape=(D, srow.size))
+    sums = (ind @ X.astype(np.float64)).toarray()
+    want = np.nan_to_num(feat["pseudo"][:, gs["panel_canon"]], nan=0.0)
+    bad = np.flatnonzero(have & (sums != want).any(1))
+    checks["panel_sums_equal_features_pseudobulk"] = {"n_samples_checked": int(have.sum()), "n_mismatch": int(bad.size)}
+    if bad.size:
+        raise SystemExit(f"observed cells do not sum to the features pseudobulk for {bad.size} samples, e.g. "
+                         f"{feat['sample_ids'][bad[:3]].tolist()}")
+    donors_idx = np.flatnonzero(have)
+    donors = feat["sample_ids"][donors_idx]
+    remap = np.full(D, -1)
+    remap[donors_idx] = np.arange(donors_idx.size)
+    didx = remap[srow]
+    S = donors.size
+    Xs = X[:, gs["score_idx"]].tocsr()
+    del X
+    lib = np.asarray(Xs.sum(axis=1)).ravel()
+    n_cells = np.bincount(didx, minlength=S)
+    comp = IC.composition(pd.Series(labels), pd.Series(donors[didx]), donors).to_numpy()
+    starts = np.r_[0, np.cumsum(n_cells)[:-1]]
+    r1, r2, n_ref = [], [], np.zeros(S, np.int64)
+    for s in range(S):
+        a, b = reference_split(n_cells[s], donors[s])
+        r1.append(starts[s] + a)
+        r2.append(starts[s] + b)
+        n_ref[s] = a.size
+    r1, r2 = np.concatenate(r1), np.concatenate(r2)
+    agg = type_aggregates(Xs, didx, labels, S)
+    pb = feat["pseudo"][donors_idx][:, gs["score_canon"]]
+    if not np.isfinite(pb).all():
+        raise SystemExit("features pseudobulk has non-finite values on the scoring genes")
+
+    def pack(prefix, M):
+        M = M.tocsr()
+        return {f"{prefix}_data": M.data.astype(np.int32), f"{prefix}_indices": M.indices.astype(np.int32),
+                f"{prefix}_indptr": M.indptr.astype(np.int64), f"{prefix}_shape": np.asarray(M.shape, np.int64)}
+
+    arrays = {"donors": donors.astype(str), "groups": feat["groups"][donors_idx].astype(str), "n_cells": n_cells,
+              "composition": comp, "pseudobulk": pb, "score_ids": gs["score_ids"], "score_idx": gs["score_idx"],
+              "panel_ids": gs["panel_ids"], "query_ids": np.asarray(gs["query_ids"]),
+              **pack("r1", Xs[r1]), "r1_donor": didx[r1], "r1_label": labels[r1], "r1_key": keys[r1],
+              **pack("r2", Xs[r2]), "r2_donor": didx[r2], "r2_label": labels[r2], "r2_key": keys[r2],
+              "n_ref": n_ref, "cell_lib": lib.astype(np.float32), "cell_donor": didx.astype(np.int32),
+              "cell_mono": (labels == "Monocyte"),
+              "agg_types": np.asarray(CONTRAST_TYPES), "agg_n": agg["n"], "agg_sum": agg["sum"].astype(np.float32),
+              "agg_cp10k": agg["cp10k"].astype(np.float32), "agg_det": agg["det"].astype(np.int32)}
+    npz = out_dir / "reference.npz"
+    np.savez_compressed(npz, **arrays)
+    man = {"schema": "paired_ft_scoring_reference.v1", "dataset": spec.name, "written_utc": now(),
+           "reference_npz": str(npz), "reference_sha256": sha(npz), "reference_bytes": npz.stat().st_size,
+           "features": {"path": feat["path"], "sha256": feat["sha256"], "keys": feat["keys"]},
+           "cells": {"source": cells["source"], "inputs_sha256": cells["inputs_sha256"], "n_cells": int(lib.size),
+                     "key_rule": key_rule},
+           "labels": label_info, "annotator_run": str(annot),
+           "n_donors": int(S), "samples_without_cells": feat["sample_ids"][~have].tolist(),
+           "gene_sets": {"panel": int(gs["panel_ids"].size), "scoring": int(gs["score_idx"].size),
+                         "query": len(gs["query_ids"]), "dropped_annotation_genes": gs["dropped_annotation_genes"],
+                         "model_genes_missing_from_query": gs["model_genes_missing_from_query"]},
+           "reference_rule": {"n_sub": N_SUB, "seed": SUB_SEED, "rule": "per donor: canonical order = sort by cell key; "
+                              "permutation from default_rng([20260925, sha256(donor)[:8] as uint64 LE]); R1 = first "
+                              "min(150, n//2), R2 = next same number"},
+           "n_ref": {"min": int(n_ref.min()), "median": float(np.median(n_ref)), "total": int(n_ref.sum())},
+           "checks": checks, "seconds": round(time.monotonic() - t0, 1)}
+    (out_dir / "reference_manifest.json").write_text(json.dumps(man, indent=1, default=str) + "\n")
+    log(f"reference: {S} donors, {lib.size} cells, R1 {r1.size}, {npz.stat().st_size / 2**20:.1f} MiB, {man['seconds']} s")
+    extra = type_aggregates(Xs, didx, labels, S, types=DEG_TYPES[len(CONTRAST_TYPES):])
+    write_deg_reference(out_dir, man, np.concatenate([agg["n"], extra["n"]], axis=1),
+                        np.concatenate([agg["sum"], extra["sum"]], axis=1),
+                        {"contrast_types_equal_reference_agg": True, "built_from": "build_reference"})
+    return man
+
+
+def load_reference(cache_dir: Path) -> tuple[dict, dict]:
+    man_path = cache_dir / "reference_manifest.json"
+    if not man_path.is_file():
+        raise SystemExit(f"no reference at {cache_dir}; run score_ft.py --dataset NAME --build-reference first")
+    man = json.loads(man_path.read_text())
+    npz = cache_dir / "reference.npz"
+    if sha(npz) != man["reference_sha256"]:
+        raise SystemExit(f"{npz}: sha differs from its manifest")
+    z = np.load(npz, allow_pickle=False)
+    ref = {k: z[k] for k in z.files}
+    for p in ("r1", "r2"):
+        ref[p] = sp.csr_matrix((ref.pop(f"{p}_data"), ref.pop(f"{p}_indices"), ref.pop(f"{p}_indptr")),
+                               shape=tuple(int(x) for x in ref.pop(f"{p}_shape")))
+    return ref, man
+
+
+def lodo_mean(frac: np.ndarray, donor_of: np.ndarray) -> np.ndarray:
+    """Leave-donor-out cohort mean: for sample i, the mean over samples of other donors.  Equals the leave-one-out
+    mean (immicro_common.loo_mean) when every donor has one sample."""
+    frac = np.asarray(frac, dtype=np.float64)
+    donor_of = np.asarray(donor_of).astype(str)
+    out = np.full_like(frac, np.nan)
+    for i in range(frac.shape[0]):
+        m = donor_of != donor_of[i]
+        if m.any():
+            out[i] = frac[m].mean(axis=0)
+    return out