Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261002T085943Z-deck-restructure-contrast-metrics-zeroshot-len/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/contrast_extra.py

@@ -0,0 +1,1220 @@
+#!/usr/bin/env python3
+"""Rank-based, threshold-free and reliability-aware disease-signal metrics for the paired fine-tuning benchmark.
+
+CPU only; never imports torch (CUDA hidden). Added 2026-10-02. Every scored unit (one few-pair draw = the draw<j> and
+draw<j>_scsemi5 calls; one pooled 5-fold call; or any score_ft.py call with --design scored) is re-read exactly as
+tools/score_ft.py scored it, and the per-cell-type case-vs-control quantities are rebuilt with the scorer's own
+functions (ft_common / score_ft / evaluate_generated_vs_truth):
+
+  1. Spearman r of generated vs observed logFC next to the scorer's Pearson r (same genes = scoring genes detected in
+     >= 1 % of the observed cells of the type, minus --exclude-genes; same statistic `mean_cp10k`, also
+     `pseudobulk_log1p_cpm`), and Spearman of the bulk broadcast. Reproduction: Pearson r, broadcast r and partial r
+     must equal the call's contrast.csv (|diff| <= 1e-9).
+  2. Split-half ceiling (arm-independent): each scored sample's observed cells of each type (T, B, Monocyte, NK) are
+     split into halves A / B (5 seeds 20260926..20260930; per sample x type a permutation from
+     default_rng([seed, sha256(sample|type)[:8]]); A = first floor(n/2) positions in canonical cell order); the
+     `mean_cp10k` logFC of A and of B (same genes, same donor balancing) -> r(A, B) Pearson and Spearman; Spearman-Brown
+     full-data reliability 2r/(1+r) and the noise-free ceiling sqrt(2r/(1+r)). On the same footing:
+     r(generated, half B) and r(bulk broadcast, half B).
+  3. limma-voom DEG sensitivity on the donor x type pseudobulks the Welch top-50 DEG uses (observed summed counts;
+     generated = summed Poisson read-out counts of the generated cells, exactly what score_ft.deg_block feeds the
+     Welch test; broadcast = the arm's condition bulk_counts): edgeR TMM + voom + lmFit + eBayes, BH, FDR < 0.05,
+     top 50 by |logFC| (EV.top_deg_genes) -> overlap with the observed limma top-50, summed over the scored types.
+     Gene filter per side: "nonzero" (primary; = the evaluator's edgeR default) and "filterByExpr" (secondary).
+     The existing Welch top-50 overlap is recomputed and must equal the call's contrast.csv and deg_top50_lists.csv.
+  4. CAT curves (Irizarry 2005) at k = 10, 20, 50, 100, 200, 500 on the limma ranking by |moderated t| (primary
+     filter): CAT(k) = |obs top-k  &  pred top-k with the same logFC sign| / k; chance k / (2 G) with G = genes tested on
+     both sides (any sign: k / G). RBO_ext (Webber 2010, eq. 32, p = 0.98) of the signed rankings (t descending;
+     t ascending reported too). The broadcast is ranked by the limma t of its bulk.
+  5. Chance level of the top-50 overlaps (Welch and limma): sum over types of |obs list| x |pred list| / G
+     (hypergeometric mean; G = genes tested on both sides).
+
+usage (CPU; run through tools/run_contrast_unit.sh):
+  contrast_extra.py --design fewshot --dataset ye2026_sepsis [--draws 0,1,2,3,4] [--threads 4]
+  contrast_extra.py --design pooled  --dataset ye2026_sepsis
+  contrast_extra.py --design scored  --dataset ye2026_sepsis --score-dir scores/ye2026_sepsis/cal_budget_20261001/pooled \
+      --arms zs__cal_n5,zs__cal_n10,zs__cal_n20,zs__cal_n40 --unit cal_budget_20261001/pooled
+  contrast_extra.py --collect          # scores_contrast/{fewshot,pooled,learning_curve,scored}_*.csv + reproduction_check.csv
+Giroux: few-pair and pooled units read scores_nosex/ (196 sex-linked genes excluded; the exclusion recorded in the
+call's summary.json is applied); --design scored on giroux2022 requires a call with that exclusion or --exclude-genes.
+Outputs: scores_contrast/<ds>/<unit>/{contrast.csv, ceiling.csv, deg_limma.csv, cat.csv, rbo.csv, headline.csv,
+         repro.json, manifest.json, limma/{jobs.csv, limma_status.csv, versions.txt, R.log}}.
+"""
+from __future__ import annotations
+
+import os
+import sys
+
+
+def _threads_from_argv(default: int = 4) -> int:
+    for i, a in enumerate(sys.argv):
+        if a == "--threads" and i + 1 < len(sys.argv):
+            return int(sys.argv[i + 1])
+        if a.startswith("--threads="):
+            return int(a.split("=", 1)[1])
+    return default
+
+
+_THR = str(_threads_from_argv())
+for _k in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS", "NUMBA_NUM_THREADS"):
+    os.environ[_k] = _THR
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+
+import argparse  # noqa: E402
+import hashlib  # noqa: E402
+import json  # noqa: E402
+import re  # noqa: E402
+import shutil  # noqa: E402
+import subprocess  # noqa: E402
+import time  # noqa: E402
+from pathlib import Path  # noqa: E402
+
+import numpy as np  # noqa: E402
+import pandas as pd  # noqa: E402
+import scipy.sparse as sp  # noqa: E402
+from scipy.stats import rankdata  # noqa: E402
+
+TOOLS = Path(__file__).resolve().parent
+sys.path.insert(0, str(TOOLS))
+import ft_common as F  # noqa: E402
+import score_ft as S  # noqa: E402  (module level: argparse/env only; main() is not run)
+
+EV = F.EV
+TASK = F.TASK
+SCORES = TASK / "scores"
+NOSEX = TASK / "scores_nosex"
+OUT_ROOT = TASK / "scores_contrast"
+R_SCRIPT = TOOLS / "contrast_extra_limma.R"
+RSCRIPT = Path("/home/sj_server_1/miniforge3/bin/Rscript")
+CODE_FILES = (Path(__file__).resolve(), R_SCRIPT, TOOLS / "ft_common.py", TOOLS / "score_ft.py", F.EV_PATH)
+REMOTE = "spark-0110"
+MIN_FREE_GIB = 40.0
+MAX_THREADS = 14
+
+SPLIT_SEEDS = tuple(20260926 + s for s in range(5))   # SLE split-half seeds (sle_broadcast_splithalf.py)
+CAT_KS = (10, 20, 50, 100, 200, 500)
+RBO_P = 0.98
+LIMMA_FILTERS = ("nonzero", "filterByExpr")
+PRIMARY_FILTER = "nonzero"
+STATS = ("mean_cp10k", "pseudobulk_log1p_cpm")
+DATASETS = ("immicro", "ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili")
+DISEASE = ("ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili")
+SOURCE_TREE = {"giroux2022": NOSEX}                     # Giroux disease metrics without sex-linked genes
+POOLED_CALL = {"ye2026_sepsis": "pooled_deg"}           # the sepsis pooled call that carries the DEG score
+SEX_EXCL = TASK / "data/sex_linked_genes/sex_linked_genes_exclude.csv"
+REPRO_TOL = 1e-9
+
+ARM_LABEL = {"zs_raw": "Zero-shot, real bulk", "zs__raw": "Zero-shot, real bulk",
+             "zs_cal": "Zero-shot + calibration", "zs__cal": "Zero-shot + calibration",
+             "scsemi5": "scSemiProfiler, 5 donors", "lora5": "LoRA, 5 donors",
+             "real_lora__raw": "LoRA, all training pairs", "real_full__raw": "Full FT, all training pairs",
+             "pseudo_full__cal": "sc-only fine-tune (+ calibration)", "pseudo_full__raw": "sc-only fine-tune, real bulk",
+             "zs_pseudo": "Zero-shot, sc pseudobulk input (reference)",
+             "zs__pseudo": "Zero-shot, sc pseudobulk input (reference)",
+             "lora_multik__raw": "LoRA, multi-K", "lora_recipe__raw": "LoRA + recipes",
+             "scsemi__raw": "scSemiProfiler, all training pairs (5-fold CV)",
+             **{f"lora_n{n}__raw": f"LoRA, {n} pairs + inner-val" for n in (5, 10, 20, 40)},
+             **{f"zs__cal_n{n}": f"Zero-shot + calibration (alpha from {n} pairs + inner-val)" for n in (5, 10, 20, 40)},
+             **{f"scsemi_n{n}__raw": f"scSemiProfiler, {n} pairs + inner-val" for n in (5, 10, 20, 40)}}
+ROLE = {"lora5": "lora", "real_lora__raw": "lora", "scsemi5": "scsemi", "scsemi__raw": "scsemi",
+        "zs_raw": "zs_raw", "zs__raw": "zs_raw", "zs_cal": "zs_cal", "zs__cal": "zs_cal"}
+SCORED: dict = {}                      # --design scored: {"dir": Path, "arms": tuple, "unit": str}
+
+
+def log(msg: str) -> None:
+    F.log(msg)
+
+
+# =========================================================================== pure metric functions
+def spearman(a, b) -> float:
+    """Spearman rank correlation = Pearson r (EV.pearson) of the average-tie ranks; NaN when degenerate."""
+    a = np.asarray(a, np.float64)
+    b = np.asarray(b, np.float64)
+    if a.shape != b.shape or a.size < 3:
+        return float("nan")
+    return EV.pearson(rankdata(a), rankdata(b))
+
+
+def spearman_brown(r: float) -> float:
+    """Full-data reliability from a split-half correlation: 2 r / (1 + r) (Spearman 1910; Brown 1910)."""
+    if r is None or not np.isfinite(r) or r <= -1:
+        return float("nan")
+    return 2.0 * r / (1.0 + r)
+
+
+def noise_free_ceiling(r: float) -> float:
+    """Expected r of a noise-free predictor with the full-data observed vector: sqrt(2 r / (1 + r)); NaN if <= 0."""
+    sb = spearman_brown(r)
+    return float(np.sqrt(sb)) if np.isfinite(sb) and sb > 0 else float("nan")
+
+
+def prefix_overlaps(short: list, long: list) -> np.ndarray:
+    """X_d for d = 1..len(long): |short[:min(d, s)] & long[:d]| (lists without duplicates)."""
+    s, l_ = len(short), len(long)
+    seen_s, seen_l = set(), set()
+    x, out = 0, np.zeros(l_, np.int64)
+    for d in range(l_):
+        b = long[d]
+        if d < s:
+            a = short[d]
+            if a == b:
+                x += 1
+            else:
+                x += (a in seen_l) + (b in seen_s)
+            seen_s.add(a)
+        else:
+            x += b in seen_s
+        seen_l.add(b)
+        out[d] = x
+    return out
+
+
+def rbo_ext(list1, list2, p: float = RBO_P) -> float:
+    """Extrapolated rank-biased overlap RBO_ext (Webber, Moffat & Zobel 2010, ACM TOIS 28:20, eq. 32; eq. 30 for equal
+    lengths). Lists are rankings without duplicates (item 0 = top). With s = |shorter|, l = |longer|, X_d = overlap of
+    the depth-d prefixes (the shorter list fully seen beyond s):
+      RBO_ext = (1-p)/p * ( sum_{d=1..l} X_d/d p^d + sum_{d=s+1..l} X_s (d-s)/(s d) p^d ) + ((X_l - X_s)/l + X_s/s) p^l.
+    NaN when a list is empty."""
+    a, b = list(list1), list(list2)
+    if len(set(a)) != len(a) or len(set(b)) != len(b):
+        raise ValueError("rbo_ext: lists must not contain duplicates")
+    if not a or not b:
+        return float("nan")
+    short, long = (a, b) if len(a) <= len(b) else (b, a)
+    s, l_ = len(short), len(long)
+    X = prefix_overlaps(short, long).astype(np.float64)
+    d = np.arange(1, l_ + 1, dtype=np.float64)
+    w = np.power(p, d)
+    term1 = float(np.sum(X / d * w))
+    xs = X[s - 1]
+    dd = d[s:]
+    term2 = float(np.sum(xs * (dd - s) / (s * dd) * w[s:])) if l_ > s else 0.0
+    xl = X[l_ - 1]
+    return (1.0 - p) / p * (term1 + term2) + ((xl - xs) / l_ + xs / s) * p ** l_
+
+
+def cat_curve(obs_order: np.ndarray, obs_sign: np.ndarray, pred_order: np.ndarray | None, pred_sign: np.ndarray | None,
+              ks=CAT_KS) -> list[dict]:
+    """Correspondence-at-the-top (Irizarry et al. 2005): for each k the fraction of the observed top-k genes that are in
+    the predictor's top-k, with the same sign (cat_same_sign) and regardless of sign (cat_any_sign). Orders are gene
+    indices ranked best first; signs are full-length arrays indexed by gene. pred_order None = the predictor's test is
+    undefined -> 0 (as the benchmark's top-50 overlap). Denominator = min(k, len(obs_order))."""
+    out = []
+    for k in ks:
+        top_o = np.asarray(obs_order[:k], np.int64)
+        kk = int(top_o.size)
+        if kk == 0:
+            out.append({"k": k, "k_eff": 0, "cat_same_sign": float("nan"), "cat_any_sign": float("nan")})
+            continue
+        if pred_order is None:
+            out.append({"k": k, "k_eff": kk, "cat_same_sign": 0.0, "cat_any_sign": 0.0})
+            continue
+        top_p = np.asarray(pred_order[:k], np.int64)
+        both = np.intersect1d(top_o, top_p, assume_unique=True)
+        same = int((obs_sign[both] == pred_sign[both]).sum())
+        out.append({"k": k, "k_eff": kk, "cat_same_sign": same / kk, "cat_any_sign": both.size / kk})
+    return out
+
+
+def cat_chance(k: int, G: int) -> tuple[float, float]:
+    """Expected CAT(k) of a random ranking over G genes: k / (2 G) with the same-sign requirement (sign a fair coin),
+    k / G regardless of sign."""
+    if G <= 0:
+        return float("nan"), float("nan")
+    return min(k, G) / (2.0 * G), min(k, G) / float(G)
+
+
+def expected_overlap(n: int, m: int, G: int) -> float:
+    """Hypergeometric mean of |A & B| for a fixed n-set A and a random m-set B among G genes: n m / G."""
+    return float(n) * float(m) / float(G) if G > 0 else float("nan")
+
+
+def rank_orders(t: np.ndarray) -> dict:
+    """Gene-index orders of one limma result (NaN t = not tested): by |t| descending, by t descending, by t ascending
+    (stable; ties keep the fixed gene order)."""
+    idx = np.flatnonzero(np.isfinite(t))
+    tt = t[idx]
+    return {"abs": idx[np.argsort(-np.abs(tt), kind="stable")], "up": idx[np.argsort(-tt, kind="stable")],
+            "down": idx[np.argsort(tt, kind="stable")], "sign": np.sign(np.nan_to_num(t, nan=0.0)),
+            "tested": np.isfinite(t)}
+
+
+# =========================================================================== file helpers
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as fh:
+        for block in iter(lambda: fh.read(1 << 24), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def free_gib(path: Path) -> float:
+    st = os.statvfs(path)
+    return st.f_bavail * st.f_frsize / 2**30
+
+
+def resolve_file(path: Path, want_sha: str, fetch_root: Path, fetched: list, receipt: bool) -> Path:
+    """The scored file: the local file if present, else a sha-checked copy from server_2 (same absolute path) under
+    fetch_root (with its .log receipt next to it when receipt=True, so score_ft.open_arm can check output_sha256)."""
+    path = Path(path)
+    if path.is_file():
+        return path
+    rel = path.relative_to(TASK)
+    dst = fetch_root / rel
+    marker = path.with_suffix(".moved")
+    if dst.is_file() and (not receipt or dst.with_suffix(".log").is_file()):
+        if sha256(dst) == want_sha:
+            if dst not in fetched:
+                fetched.append(dst)
+            return dst
+        dst.unlink()
+    size = int(subprocess.run(["ssh", "-n", REMOTE, f"stat -c %s '{path}'"], capture_output=True, text=True,
+                              check=True).stdout.strip())
+    need = size / 2**30 + MIN_FREE_GIB
+    fetch_root.mkdir(parents=True, exist_ok=True)
+    if free_gib(fetch_root) < need:
+        raise SystemExit(f"disk: {free_gib(fetch_root):.1f} GiB free < {need:.1f} GiB needed to fetch {path}")
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    log(f"fetching {rel} ({size / 2**30:.2f} GiB) from {REMOTE}")
+    subprocess.run(["rsync", "-a", "--bwlimit=200000", f"{REMOTE}:{path}", str(dst)], check=True)
+    if receipt:
+        rec = path.with_suffix(".log")
+        if rec.is_file():
+            shutil.copy2(rec, dst.with_suffix(".log"))
+        else:
+            subprocess.run(["rsync", "-a", f"{REMOTE}:{rec}", str(dst.with_suffix(".log"))], check=True)
+    fetched.append(dst)
+    got = sha256(dst)
+    if got != want_sha:
+        raise SystemExit(f"{dst}: sha {got[:12]} differs from the scored sha {want_sha[:12]}")
+    if marker.is_file() and f"sha {want_sha[:12]}" not in marker.read_text():
+        raise SystemExit(f"{marker}: marker sha differs ({marker.read_text().strip()})")
+    return dst
+
+
+def drop_fetched(f: Path) -> None:
+    f.unlink(missing_ok=True)
+    f.with_suffix(".log").unlink(missing_ok=True)
+    log(f"removed fetched copy {f}")
+
+
+# =========================================================================== unit definition
+def unit_calls(design: str, ds: str, draw: int | None) -> tuple[list[tuple[Path, tuple | None]], dict]:
+    """[(call dir, arms or None = all)], notes."""
+    tree = SOURCE_TREE.get(ds, SCORES)
+    notes = {"source_tree": str(tree)}
+    if design == "fewshot":
+        base = tree / ds / "fewshot_n5"
+        calls = [(base / f"draw{draw}", None)]
+        sc = base / f"draw{draw}_scsemi5"
+        if (sc / "summary.json").is_file():
+            calls.append((sc, None))
+        else:
+            notes["missing_calls"] = [str(sc)]
+        return calls, notes
+    if design == "pooled":
+        name = POOLED_CALL.get(ds, "pooled")
+        if name != "pooled":
+            notes["contrast_also_checked_against"] = str(tree / ds / "pooled")
+        return [(tree / ds / name, None)], notes
+    if design == "scored":
+        return [(SCORED["dir"], SCORED["arms"])], notes
+    raise ValueError(design)
+
+
+def unit_dir(design: str, ds: str, draw: int | None) -> Path:
+    if design == "scored":
+        return OUT_ROOT / ds / SCORED["unit"]
+    return OUT_ROOT / ds / (f"fewshot_n5/draw{draw}" if design == "fewshot" else "pooled")
+
+
+def light_view(ref: dict, deg: dict, donors: list[str]) -> dict:
+    """score_ft.make_view's observed side without the embedding: the scored samples' groups and donor x type
+    aggregates with exactly the scorer's dtype casts."""
+    pos = {d: i for i, d in enumerate(ref["donors"].astype(str))}
+    miss = [d for d in donors if d not in pos]
+    if miss:
+        raise SystemExit(f"donors not in the reference: {miss[:5]}")
+    sel = np.asarray([pos[d] for d in donors], dtype=np.int64)
+    v = {"donors": np.asarray(donors, dtype=str), "sel": sel, "groups": ref["groups"][sel].astype(str),
+         "score_ids": [str(g) for g in ref["score_ids"]]}
+    for k in ("n", "sum", "cp10k", "det"):
+        v[f"agg_{k}"] = ref[f"agg_{k}"][sel].astype(np.float64 if k != "n" else np.int64)
+    v["deg_types"] = tuple(deg["types"])
+    v["deg_n"], v["deg_sum"] = deg["n"][sel], deg["sum"][sel]
+    return v
+
+
+def contrast_from_summary(s: dict, v: dict) -> dict:
+    cd = s["contrast_definition"]
+    if not cd.get("enabled"):
+        return {"enabled": False, "reason": cd.get("reason")}
+    case, ctrl = np.asarray(cd["case"], bool), np.asarray(cd["ctrl"], bool)
+    groups = np.asarray(cd["groups"], dtype=str)
+    if case.size != v["donors"].size or ctrl.size != v["donors"].size:
+        raise SystemExit("contrast_definition length differs from the scored donors")
+    if not (np.array_equal(case, np.isin(groups, cd["case_groups"])) and
+            np.array_equal(ctrl, np.isin(groups, cd["control_groups"]))):
+        raise SystemExit("contrast_definition case/ctrl differ from its groups and group lists")
+    if cd["group_source"] == "features groups" and not np.array_equal(groups, v["groups"]):
+        raise SystemExit("contrast groups differ from the reference groups")
+    return {"enabled": True, "case": case, "ctrl": ctrl, "groups": groups, "case_groups": cd["case_groups"],
+            "control_groups": cd["control_groups"], "n_case_donors": int(case.sum()), "n_control_donors": int(ctrl.sum())}
+
+
+# =========================================================================== observed cells (split half)
+def observed_cells(spec, ref: dict, man: dict, cache: Path, v: dict) -> dict:
+    """All observed QC cells of the scored samples on the scoring genes, in the reference's canonical order
+    (F.build_reference: lexsort by (cell key, sample row)), with the reference's frozen observed labels; every input
+    sha-checked against reference_manifest.json."""
+    feat = F.load_features(spec.features)
+    if feat["sha256"] != man["features"]["sha256"]:
+        raise SystemExit("features sha differs from the reference's")
+    gs = F.gene_sets(feat)
+    if not np.array_equal(gs["score_ids"], ref["score_ids"].astype(str)):
+        raise SystemExit("scoring genes differ from the reference")
+    cells = F.load_cells_datadir(spec, gs)
+    if cells is None or cells["inputs_sha256"] != man["cells"]["inputs_sha256"]:
+        raise SystemExit("observed cell files differ from the ones the reference was built from")
+    table = cells["table"].reset_index(drop=True)
+    lab_path = cache / "observed_labels" / "labels" / "labels.parquet"
+    if sha256(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()
+    keys, _ = F.cell_keys(table)
+    srow = np.asarray(cells["sample_row"], np.int64)
+    order = np.lexsort((keys, srow))
+    srow, labels = srow[order], labels[order]
+    sid = feat["sample_ids"]
+    want = {d: i for i, d in enumerate(v["donors"])}
+    didx = np.asarray([want.get(str(sid[r]), -1) for r in range(sid.size)], np.int64)[srow]
+    keep_rows = np.flatnonzero((didx >= 0) & np.isin(labels, F.CONTRAST_TYPES))
+    X = cells["X"].tocsr()[order]
+    del cells
+    X = X[keep_rows][:, gs["score_idx"]].tocsr()
+    return {"X": X, "d": didx[keep_rows], "labels": labels[keep_rows],
+            "n_cells_scored_all_types": int((didx >= 0).sum()), "inputs_sha256": man["cells"]["inputs_sha256"],
+            "labels_sha256": man["labels"]["sha256"]}
+
+
+def split_half(spec, ref: dict, man: dict, cache: Path, v: dict, contrast: dict, genes: dict) -> dict:
+    """Observed mean_cp10k logFC on random halves A / B of every scored sample's cells of each contrast type."""
+    t0 = time.monotonic()
+    oc = observed_cells(spec, ref, man, cache, v)
+    S_ = v["donors"].size
+    X, d, lab = oc["X"], oc["d"], oc["labels"]
+    # the full-data aggregates rebuilt from these cells must equal the reference cache (the scorer's observed side)
+    agg = F.type_aggregates(X, d, lab, S_)
+    chk = {"n_equal": bool(np.array_equal(agg["n"], v["agg_n"])),
+           "det_equal": bool(np.array_equal(agg["det"], v["agg_det"])),
+           "sum_equal_float32": bool(np.array_equal(agg["sum"].astype(np.float32), ref["agg_sum"][v["sel"]])),
+           "cp10k_max_abs_diff_float32": float(np.abs(agg["cp10k"].astype(np.float32).astype(np.float64)
+                                                      - v["agg_cp10k"]).max())}
+    chk["cp10k_equal_float32"] = chk["cp10k_max_abs_diff_float32"] == 0.0
+    if not (chk["n_equal"] and chk["det_equal"] and chk["sum_equal_float32"]):
+        raise SystemExit(f"observed cells do not rebuild the reference aggregates: {chk}")
+    del agg
+    Xf = X.astype(np.float64)
+    lib = np.asarray(Xf.sum(axis=1)).ravel()
+    cp = (sp.diags(np.divide(F.CP10K, lib, out=np.zeros_like(lib), where=lib > 0)) @ Xf).tocsr()
+    del Xf, X
+    T = len(F.CONTRAST_TYPES)
+    tix = np.asarray([F.CONTRAST_TYPES.index(x) for x in lab], np.int64)
+    blocks = {}
+    for s in range(S_):
+        for ti in range(T):
+            blocks[(s, ti)] = np.flatnonzero((d == s) & (tix == ti))   # canonical order within the sample
+    case, ctrl = contrast["case"], contrast["ctrl"]
+    out = {"seeds": list(SPLIT_SEEDS), "check_full_aggregates": chk, "per_seed": [], "halfB": {}}
+    G = cp.shape[1]
+    for seed in SPLIT_SEEDS:
+        inA = np.zeros(d.size, bool)
+        for (s, ti), idx in blocks.items():
+            n = idx.size
+            if n == 0:
+                continue
+            perm = F.donor_rng(seed, f"{v['donors'][s]}|{F.CONTRAST_TYPES[ti]}").permutation(n)
+            inA[idx[np.sort(perm[:n // 2])]] = True
+        gid = np.where(inA, 0, 1) * (S_ * T) + d * T + tix
+        ind = sp.csr_matrix((np.ones(d.size), (gid, np.arange(d.size))), shape=(2 * S_ * T, d.size))
+        sums = (ind @ cp).toarray().reshape(2, S_, T, G)
+        nn = np.bincount(gid, minlength=2 * S_ * T).reshape(2, S_, T)
+        for ti, t in enumerate(F.CONTRAST_TYPES):
+            gm = genes[t]
+            la = F.lfc_mean_cp10k(nn[0, :, ti], sums[0, :, ti], case, ctrl)
+            lb = F.lfc_mean_cp10k(nn[1, :, ti], sums[1, :, ti], case, ctrl)
+            ok = la is not None and lb is not None and gm.sum() >= 3
+            out["per_seed"].append({
+                "seed": seed, "celltype": t, "n_genes": int(gm.sum()),
+                "pearson": EV.pearson(la[gm], lb[gm]) if ok else float("nan"),
+                "spearman": spearman(la[gm], lb[gm]) if ok else float("nan"),
+                "n_case_donors_A": int((case & (nn[0, :, ti] > 0)).sum()),
+                "n_control_donors_A": int((ctrl & (nn[0, :, ti] > 0)).sum()),
+                "n_case_donors_B": int((case & (nn[1, :, ti] > 0)).sum()),
+                "n_control_donors_B": int((ctrl & (nn[1, :, ti] > 0)).sum()),
+                "n_cells_A": int(nn[0, case | ctrl, ti].sum()), "n_cells_B": int(nn[1, case | ctrl, ti].sum())})
+            out["halfB"][(seed, t)] = lb
+    out["seconds"] = round(time.monotonic() - t0, 1)
+    out["n_cells_used"] = int(d.size)
+    log(f"split half: {d.size} observed cells of the 4 types, {len(SPLIT_SEEDS)} seeds; mean r(A,B) "
+        + ", ".join(f"{F.SHORT_TYPE[t]} {np.nanmean([r['pearson'] for r in out['per_seed'] if r['celltype'] == t]):.3f}"
+                    for t in F.CONTRAST_TYPES) + f" ({out['seconds']} s; full aggregates rebuilt = cache)")
+    return out
+
+
+# =========================================================================== DEG helpers
+def welch_side(n: np.ndarray, sums: np.ndarray, case: np.ndarray, ctrl: np.ndarray, genes: list) -> dict:
+    """F.deg_top's computation (rows with >= 1 cell of the type among case | control; EV.welch_bh_deg;
+    EV.top_deg_genes), also returning the tested mask (the BH family)."""
+    rows = (np.asarray(n) > 0) & (case | ctrl)
+    deg = EV.welch_bh_deg(np.asarray(sums, np.float64)[rows], case[rows]) if rows.any() else None
+    top = EV.top_deg_genes(deg, genes, top_n=F.DEG_TOP_N, fdr=F.DEG_FDR)
+    return {"top": top, "defined": deg is not None, "tested": deg.tested if deg is not None else np.zeros(len(genes), bool),
+            "n_significant": int(deg.significant(F.DEG_FDR).size) if deg is not None else 0}
+
+
+class LimmaBatch:
+    """Collects donor x type count matrices (kept genes) for one Rscript call."""
+
+    def __init__(self, workdir: Path, n_genes: int):
+        self.dir = workdir
+        self.dir.mkdir(parents=True, exist_ok=True)
+        self.G = n_genes
+        self.fh = open(self.dir / "counts.bin", "wb")
+        self.offset = 0
+        self.jobs, self.meta = [], {}
+
+    def add(self, key: str, counts: np.ndarray, is_case: np.ndarray) -> dict:
+        """counts: samples x genes (the rows the Welch test uses). Samples with zero library are dropped (recorded)."""
+        counts = np.asarray(counts, np.float64)
+        is_case = np.asarray(is_case, bool)
+        lib = counts.sum(1)
+        zero = lib <= 0
+        counts, is_case = counts[~zero], is_case[~zero]
+        info = {"key": key, "n_samples": int(counts.shape[0]), "n_case": int(is_case.sum()),
+                "n_control": int((~is_case).sum()), "n_zero_library_dropped": int(zero.sum()),
+                "defined": bool(is_case.sum() >= 2 and (~is_case).sum() >= 2)}
+        self.meta[key] = info
+        if not info["defined"]:
+            return info
+        assert counts.shape[1] == self.G
+        self.fh.write(np.ascontiguousarray(counts, dtype="<f8").tobytes())
+        for flt in LIMMA_FILTERS:
+            self.jobs.append({"job": f"{key}|{flt}", "offset": self.offset, "n_samples": counts.shape[0],
+                              "is_case": "".join("1" if c else "0" for c in is_case), "filter": flt})
+        self.offset += counts.size
+        return info
+
+    def run(self, threads: int, log_path: Path) -> dict:
+        self.fh.close()
+        pd.DataFrame(self.jobs, columns=["job", "offset", "n_samples", "is_case", "filter"]).to_csv(
+            self.dir / "jobs.csv", index=False)
+        (self.dir / "n_genes.txt").write_text(f"{self.G}\n")
+        env = dict(os.environ, CUDA_VISIBLE_DEVICES="", OMP_NUM_THREADS=str(threads),
+                   OPENBLAS_NUM_THREADS=str(threads), MKL_NUM_THREADS=str(threads))
+        t0 = time.monotonic()
+        res = subprocess.run([str(RSCRIPT), "--vanilla", str(R_SCRIPT), str(self.dir)], env=env, capture_output=True,
+                             text=True)
+        log_path.write_text(res.stdout + "\n--- stderr ---\n" + res.stderr)
+        if res.returncode != 0:
+            raise SystemExit(f"limma Rscript failed (see {log_path})")
+        status = pd.read_csv(self.dir / "limma_status.csv")
+        raw = np.fromfile(self.dir / "limma.bin", dtype="<f8")
+        if raw.size != len(self.jobs) * self.G * 6:
+            raise SystemExit("limma.bin size differs from the job list")
+        out = {}
+        for i, j in enumerate(self.jobs):
+            m = raw[i * self.G * 6:(i + 1) * self.G * 6].reshape(6, self.G)
+            out[j["job"]] = {"logFC": m[0], "AveExpr": m[1], "t": m[2], "P": m[3], "q": m[4], "B": m[5],
+                             "status": str(status.status.iloc[i])}
+        bad = status[~status.status.isin(["ok"])]
+        log(f"limma: {len(self.jobs)} jobs in {time.monotonic() - t0:.0f} s ({len(bad)} not ok)")
+        return {"results": out, "status": status, "seconds": round(time.monotonic() - t0, 1),
+                "versions": (self.dir / "versions.txt").read_text().strip().splitlines()}
+
+
+def limma_top(res: dict | None, genes: list) -> dict:
+    """EV.top_deg_genes on a limma result (FDR = adj.P.Val < 0.05 over the tested genes, descending |logFC|, 50)."""
+    if res is None or res["status"] != "ok":
+        return {"top": [], "defined": False, "tested": np.zeros(len(genes), bool), "n_significant": 0}
+    tested = np.isfinite(res["P"])
+    deg = EV.DegResult(logfc=np.nan_to_num(res["logFC"], nan=0.0), pvalues=res["P"], qvalues=res["q"], tested=tested,
+                       backend="limma_voom")
+    return {"top": EV.top_deg_genes(deg, genes, top_n=F.DEG_TOP_N, fdr=F.DEG_FDR), "defined": True, "tested": tested,
+            "n_significant": int(deg.significant(F.DEG_FDR).size)}
+
+
+# =========================================================================== one unit
+def run_unit(design: str, ds: str, draw: int | None, a) -> None:
+    out = unit_dir(design, ds, draw)
+    if (out / "manifest.json").is_file() and not a.force:
+        log(f"{out} done already")
+        return
+    out.mkdir(parents=True, exist_ok=True)
+    lock = out / ".in_progress"
+    if lock.is_file():
+        pid = int(lock.read_text().split()[0])
+        if Path(f"/proc/{pid}").exists():
+            log(f"{out} is being computed by pid {pid}; skipped")
+            return
+    lock.write_text(f"{os.getpid()} {F.now()}\n")
+    try:
+        _run_unit(design, ds, draw, a, out)
+    finally:
+        lock.unlink(missing_ok=True)
+
+
+def _isclose(x, y) -> tuple[bool, float]:
+    x = float("nan") if x is None or (isinstance(x, float) and np.isnan(x)) else float(x)
+    y = float("nan") if y is None or pd.isna(y) else float(y)
+    if np.isnan(x) and np.isnan(y):
+        return True, 0.0
+    if np.isnan(x) or np.isnan(y):
+        return False, float("inf")
+    return abs(x - y) <= REPRO_TOL, abs(x - y)
+
+
+def _run_unit(design: str, ds: str, draw: int | None, a, out: Path) -> None:
+    t_unit = time.monotonic()
+    spec = F.DATASETS[ds]
+    calls, notes = unit_calls(design, ds, draw)
+    summ, arms_of = {}, {}
+    for cdir, arms in calls:
+        s = json.loads((cdir / "summary.json").read_text())
+        use = tuple(s["arms"]) if arms is None else tuple(arms)
+        miss = [x for x in use if x not in s["arms"]]
+        if miss:
+            raise SystemExit(f"{cdir}: arms {miss} not scored there")
+        summ[cdir], arms_of[cdir] = s, use
+    first = summ[calls[0][0]]
+    donors = [str(x) for x in first["donors"]]
+    for cdir, s in summ.items():
+        if [str(x) for x in s["donors"]] != donors:
+            raise SystemExit(f"{cdir}: scored donors differ from {calls[0][0]}")
+        if s["reference"]["reference_sha256"] != first["reference"]["reference_sha256"]:
+            raise SystemExit(f"{cdir}: reference sha differs")
+        if s["contrast_definition"].get("case") != first["contrast_definition"].get("case") or \
+                s["contrast_definition"].get("ctrl") != first["contrast_definition"].get("ctrl"):
+            raise SystemExit(f"{cdir}: contrast differs from {calls[0][0]}")
+    meta = {"dataset": ds, "design": design, "unit": str(out.relative_to(OUT_ROOT / ds))}
+    cache = F.CACHE_ROOT / ds
+    ref, man = F.load_reference(cache)
+    if man["reference_sha256"] != first["reference"]["reference_sha256"]:
+        raise SystemExit(f"{cache}: reference sha differs from the scored one")
+    deg_ref = F.load_deg_reference(cache, man, ref)
+    v = light_view(ref, deg_ref, donors)
+    # ---------------- gene exclusion (Giroux: the scored call's --exclude-genes)
+    ex_calls = {json.dumps(s.get("gene_exclusion", {}).get("sha256")) for s in summ.values()}
+    if len(ex_calls) != 1:
+        raise SystemExit("calls of one unit differ in their gene exclusion")
+    gex = first.get("gene_exclusion")
+    repro_comparable = True
+    excl_path = None
+    if gex is not None:
+        excl_path = Path(gex["file"])
+        if a.exclude_genes is not None and sha256(Path(a.exclude_genes)) != gex["sha256"]:
+            raise SystemExit("--exclude-genes differs from the scored call's exclusion")
+    elif a.exclude_genes is not None:
+        excl_path = Path(a.exclude_genes)
+        repro_comparable = False   # the scorer's numbers were made without this exclusion
+    elif ds == "giroux2022" and not a.allow_sex_genes:
+        raise SystemExit("giroux2022: the call has no sex-linked-gene exclusion; pass --exclude-genes "
+                         f"{SEX_EXCL} (or --allow-sex-genes)")
+    gene_excl = None
+    if excl_path is not None:
+        v["keep"], gene_excl = S.gene_exclusion(excl_path, v["score_ids"])
+        if gex is not None and gene_excl["sha256"] != gex["sha256"]:
+            raise SystemExit("exclusion file sha differs from the scored call's")
+        gene_excl.pop("dropped", None)
+    genes_kept = S.keep_genes(v)
+    Gk = len(genes_kept)
+    contrast = contrast_from_summary(first, v)
+    if not contrast["enabled"]:
+        manifest = {"schema": "paired_ft_contrast_extra.v1", **meta, "written_utc": F.now(), "skipped": True,
+                    "reason": f"no case-control contrast ({contrast.get('reason')})", "calls": [str(c) for c, _ in calls]}
+        (out / "manifest.json").write_text(json.dumps(manifest, indent=1) + "\n")
+        log(f"{out}: no contrast, skipped")
+        return
+    case, ctrl = contrast["case"], contrast["ctrl"]
+    S_ = v["donors"].size
+    log(f"{ds} {meta['unit']}: {S_} scored samples ({contrast['n_case_donors']} case / {contrast['n_control_donors']} "
+        f"control), {Gk} genes for the disease scores" + (f" ({gene_excl['n_dropped_from_scoring_genes']} excluded)"
+                                                        if gene_excl else ""))
+    # ---------------- observed side
+    genes, obs_lfc = {}, {}
+    for ti, t in enumerate(F.CONTRAST_TYPES):
+        n_o = v["agg_n"][:, ti]
+        det = v["agg_det"][:, ti].sum(0) / max(int(n_o.sum()), 1)
+        gm = det >= F.MIN_DETECT_FRAC
+        if "keep" in v:
+            gm &= v["keep"]
+        genes[t] = gm
+        obs_lfc[(t, "mean_cp10k")] = F.lfc_mean_cp10k(n_o, v["agg_cp10k"][:, ti], case, ctrl)
+        obs_lfc[(t, "pseudobulk_log1p_cpm")] = F.lfc_pseudobulk(n_o, v["agg_sum"][:, ti], case, ctrl)
+    obs_deg = S.observed_deg(v, contrast)          # the scorer's observed Welch lists
+    obs_welch = {t: welch_side(v["deg_n"][:, k], S.keep_cols(v, v["deg_sum"][:, k]), case, ctrl, genes_kept)
+                 for k, t in enumerate(v["deg_types"])}
+    for t in v["deg_types"]:
+        if obs_welch[t]["top"] != obs_deg[t]["top"]:
+            raise SystemExit(f"{t}: observed Welch list differs between welch_side and score_ft.observed_deg")
+    work = OUT_ROOT / "_work" / ds / meta["unit"]
+    if work.exists():
+        shutil.rmtree(work)
+    lb = LimmaBatch(work, Gk)
+    for k, t in enumerate(v["deg_types"]):
+        rows = (v["deg_n"][:, k] > 0) & (case | ctrl)
+        lb.add(f"obs|{t}", S.keep_cols(v, v["deg_sum"][:, k])[rows], case[rows])
+    # ---------------- split half (observed only)
+    sh = split_half(spec, ref, man, cache, v, contrast, genes)
+    # ---------------- arms
+    fetched: list[Path] = []
+    fetched_all: set = set()
+    fetch_root = Path(a.fetch_dir)
+    panel_ids = ref["panel_ids"].astype(str)
+    score_idx = ref["score_idx"]
+    cond_cache: dict = {}
+    contrast_rows, half_rows, welch_rows, repro, arm_info = [], [], [], {"arms": {}}, {}
+    gen_lfc_store, bcast_store = {}, {}
+    pcache = a.pcache
+    for cdir, arms in ((c, arms_of[c]) for c, _ in calls):
+        s = summ[cdir]
+        ccsv = pd.read_csv(cdir / "contrast.csv")
+        for name in arms:
+            t0 = time.monotonic()
+            pa = s["per_arm"][name]
+            path = resolve_file(Path(pa["npz"]), pa["npz_sha256"], fetch_root, fetched, receipt=True)
+            if str(path).startswith(str(fetch_root)):
+                fetched_all.add(str(path))
+            arm = S.open_arm(name, path, panel_ids, allow_no_receipt=False)
+            if arm["sha256"] != pa["npz_sha256"] or not arm["receipt_verified"]:
+                raise SystemExit(f"{name}: NPZ sha / receipt check failed for {path}")
+            npos = {n_: i for i, n_ in enumerate(arm["sample_ids"])}
+            rws = [np.flatnonzero(arm["bulk_index"] == npos[x]) for x in v["donors"]]
+            sel = np.concatenate(rws)
+            gen_d = np.repeat(np.arange(S_), [x.size for x in rws])
+            if arm["sha256"] not in pcache:
+                rates = np.ascontiguousarray(arm["d"]["generated_counts"], dtype=np.float32)
+                full = F.PR.poisson_integerise(rates, seed=F.POISSON_SEED, chunk_rows=4096)  # whole NPZ, row order
+                del rates
+                pcache[arm["sha256"]] = full[:, score_idx].tocsr()
+                del full
+            arm["d"].close()
+            Xg = pcache[arm["sha256"]][sel].tocsr()
+            gc = pd.read_parquet(cdir / "arms" / name / "generated_cells.parquet", columns=["npz_row", "donor", "label"])
+            if not (np.array_equal(gc.npz_row.to_numpy(), sel) and
+                    np.array_equal(gc.donor.astype(str).to_numpy(), v["donors"][gen_d])):
+                raise SystemExit(f"{name}: scored rows differ from {cdir}/arms/{name}/generated_cells.parquet")
+            gen_lab = gc.label.astype(str).to_numpy()
+            labp = pd.read_parquet(cdir / "arms" / name / "labels" / "labels.parquet", columns=["celltype_l1_pred"])
+            if not np.array_equal(labp.celltype_l1_pred.astype(str).to_numpy(), gen_lab):
+                raise SystemExit(f"{name}: labels.parquet differs from generated_cells.parquet")
+            # condition bulk (broadcast)
+            cfb = pa["condition_for_broadcast"]
+            cpath = resolve_file(Path(cfb["path"]), cfb["sha256"], fetch_root, fetched, receipt=False)
+            if str(cpath).startswith(str(fetch_root)):
+                fetched_all.add(str(cpath))
+            if cfb["sha256"] not in cond_cache:
+                cond = S.load_condition_bulk(str(cpath), cfb["sha256"], v["donors"], ref["score_ids"].astype(str))
+                cond_cache[cfb["sha256"]] = {"bulk": cond["bulk"], "path": cfb["path"], "lfc": F.bulk_lfc(cond["bulk"], case, ctrl),
+                                             "label": f"{Path(cfb['path']).name}@{cfb['sha256'][:8]}"}
+            cond = cond_cache[cfb["sha256"]]
+            bulk, blk = cond["bulk"], cond["lfc"]
+            # ---- 1. contrast (Pearson = scorer, Spearman new)
+            ga = F.type_aggregates(Xg, gen_d, gen_lab, S_)
+            rep = {"contrast_max_abs_diff": 0.0, "contrast_all_equal": True, "n_genes_equal": True}
+            for ti, t in enumerate(F.CONTRAST_TYPES):
+                gm = genes[t]
+                for variant, fn, key in (("mean_cp10k", F.lfc_mean_cp10k, "cp10k"),
+                                         ("pseudobulk_log1p_cpm", F.lfc_pseudobulk, "sum")):
+                    o = obs_lfc[(t, variant)]
+                    g = fn(ga["n"][:, ti], ga[key][:, ti], case, ctrl)
+                    sc = F.contrast_scores(o, g, blk[variant], gm)
+                    ok = o is not None and gm.sum() >= 3
+                    row = {"arm": name, "celltype": t, "statistic": variant, "n_genes": sc["n_genes"],
+                           "pearson_r_generated": sc["r_generated"],
+                           "spearman_r_generated": spearman(g[gm], o[gm]) if ok and g is not None else float("nan"),
+                           "pearson_r_broadcast": sc["r_broadcast"],
+                           "spearman_r_broadcast": spearman(blk[variant][gm], o[gm]) if ok and blk[variant] is not None
+                           else float("nan"),
+                           "partial_r_generated_given_broadcast": sc["partial_r_generated_given_broadcast"],
+                           "r_generated_vs_broadcast": sc["r_generated_vs_broadcast"],
+                           "condition": cond["label"], "condition_sha256": cfb["sha256"]}
+                    sr = ccsv[(ccsv.arm == name) & (ccsv.celltype == t) & (ccsv.statistic == variant)]
+                    if len(sr) != 1:
+                        raise SystemExit(f"{cdir}/contrast.csv: no unique row for {name} {t} {variant}")
+                    sr = sr.iloc[0]
+                    for ours, theirs in (("pearson_r_generated", "r_generated"), ("pearson_r_broadcast", "r_broadcast"),
+                                         ("partial_r_generated_given_broadcast", "partial_r_generated_given_broadcast"),
+                                         ("r_generated_vs_broadcast", "r_generated_vs_broadcast")):
+                        row[f"{ours}_scorer"] = sr[theirs]
+                        eq, dif = _isclose(row[ours], sr[theirs])
+                        rep["contrast_all_equal"] &= eq
+                        rep["contrast_max_abs_diff"] = max(rep["contrast_max_abs_diff"], dif)
+                    rep["n_genes_equal"] &= int(sr.n_genes) == row["n_genes"]
+                    contrast_rows.append(row)
+                    if variant == "mean_cp10k":
+                        gen_lfc_store[(name, t)] = g
+            # ---- 2. split half: generated and broadcast vs half B
+            for t in F.CONTRAST_TYPES:
+                gm, g = genes[t], gen_lfc_store[(name, t)]
+                for seed in SPLIT_SEEDS:
+                    hb = sh["halfB"][(seed, t)]
+                    ok = hb is not None and gm.sum() >= 3
+                    half_rows.append({"predictor": f"generated:{name}", "arm": name, "celltype": t, "seed": seed,
+                                      "pearson": EV.pearson(g[gm], hb[gm]) if ok and g is not None else float("nan"),
+                                      "spearman": spearman(g[gm], hb[gm]) if ok and g is not None else float("nan")})
+                    key = (cfb["sha256"], t, seed)
+                    if key not in bcast_store:
+                        b = blk["mean_cp10k"]
+                        bcast_store[key] = {"predictor": f"broadcast:{cond['label']}", "arm": "", "celltype": t,
+                                            "seed": seed, "condition_sha256": cfb["sha256"],
+                                            "pearson": EV.pearson(b[gm], hb[gm]) if ok and b is not None else float("nan"),
+                                            "spearman": spearman(b[gm], hb[gm]) if ok and b is not None else float("nan")}
+            # ---- 3. Welch top-50 reproduction (score_ft.deg_block) + tested masks + limma jobs
+            drows, block = S.deg_block(v, obs_deg, ga, Xg, gen_d, gen_lab, bulk, contrast)
+            extra = tuple(t for t in v["deg_types"] if t not in F.CONTRAST_TYPES)
+            gx = F.type_aggregates(Xg, gen_d, gen_lab, S_, types=extra) if extra else None
+            lcols = ["celltype", "source", "rank", "gene_id"]
+            sl = pd.read_csv(cdir / "arms" / name / "deg_top50_lists.csv", dtype=str)
+            ours_l = pd.DataFrame(block["_lists"], columns=lcols)
+            rep["welch_lists_equal"] = [tuple(x) for x in ours_l.astype(str).to_numpy()] == \
+                [tuple(x) for x in sl[lcols].astype(str).to_numpy()]
+            rep["welch_counts_equal"] = True
+            dsc = ccsv[(ccsv.arm == name) & (ccsv.statistic == F.DEG_STATISTIC)].set_index("celltype")
+            bw = welch_side(np.ones(S_, np.int64), S.keep_cols(v, bulk), case, ctrl, genes_kept)
+            for r in drows:
+                t = r["celltype"]
+                for c in ("top50_overlap", "n_sig_obs", "n_sig_gen", "obs_top_list_size", "gen_top_list_size",
+                          "top50_overlap_broadcast", "n_sig_broadcast"):
+                    if int(dsc.loc[t, c]) != int(r[c]):
+                        rep["welch_counts_equal"] = False
+                k = v["deg_types"].index(t)
+                if t in F.CONTRAST_TYPES:
+                    n_g, s_g = ga["n"][:, F.CONTRAST_TYPES.index(t)], ga["sum"][:, F.CONTRAST_TYPES.index(t)]
+                else:
+                    n_g, s_g = gx["n"][:, extra.index(t)], gx["sum"][:, extra.index(t)]
+                gw = welch_side(n_g, S.keep_cols(v, s_g), case, ctrl, genes_kept)
+                if gw["top"] != [x for x in ours_l[(ours_l.celltype == t) & (ours_l.source == "generated")].gene_id]:
+                    raise SystemExit(f"{name} {t}: welch_side list differs from score_ft.deg_block")
+                ow = obs_welch[t]
+                Gg = int((ow["tested"] & gw["tested"]).sum())
+                Gb = int((ow["tested"] & bw["tested"]).sum())
+                welch_rows.append({"arm": name, "celltype": t, "method": "welch", "deg_scored": ow["defined"],
+                                   "pred_defined": gw["defined"], "overlap": len(set(ow["top"]) & set(gw["top"])),
+                                   "overlap_scorer": int(dsc.loc[t, "top50_overlap"]),
+                                   "obs_list_size": len(ow["top"]), "gen_list_size": len(gw["top"]),
+                                   "n_sig_obs": ow["n_significant"], "n_sig_gen": gw["n_significant"],
+                                   "n_tested_obs": int(ow["tested"].sum()), "n_tested_gen": int(gw["tested"].sum()),
+                                   "G_both": Gg, "chance_overlap": expected_overlap(len(ow["top"]), len(gw["top"]), Gg),
+                                   "broadcast_overlap": len(set(ow["top"]) & set(bw["top"])),
+                                   "broadcast_overlap_scorer": int(dsc.loc[t, "top50_overlap_broadcast"]),
+                                   "broadcast_list_size": len(bw["top"]), "n_sig_broadcast": bw["n_significant"],
+                                   "n_tested_broadcast": int(bw["tested"].sum()), "G_both_broadcast": Gb,
+                                   "broadcast_chance_overlap": expected_overlap(len(ow["top"]), len(bw["top"]), Gb),
+                                   "condition": cond["label"]})
+                wr = welch_rows[-1]
+                if wr["overlap"] != wr["overlap_scorer"] or wr["broadcast_overlap"] != wr["broadcast_overlap_scorer"]:
+                    rep["welch_counts_equal"] = False
+                rows_ = (n_g > 0) & (case | ctrl)
+                lb.add(f"gen:{name}|{t}", S.keep_cols(v, s_g)[rows_], case[rows_])
+            ckey = f"bcast:{cfb['sha256'][:16]}"
+            if ckey not in lb.meta:
+                lb.add(ckey, S.keep_cols(v, bulk)[case | ctrl], case[case | ctrl])
+            arm_info[name] = {"call": str(cdir), "npz": pa["npz"], "npz_read_from": str(path), "npz_sha256": arm["sha256"],
+                              "receipt_verified": arm["receipt_verified"], "condition": cfb["path"],
+                              "condition_sha256": cfb["sha256"], "condition_label": cond["label"],
+                              "condition_read_from": str(cpath),
+                              "condition_key": ckey, "n_generated_cells": int(sel.size),
+                              "label": ARM_LABEL.get(name, name), "seconds": round(time.monotonic() - t0, 1)}
+            rep["pass"] = bool(rep["contrast_all_equal"] and rep["n_genes_equal"] and rep["welch_lists_equal"]
+                               and rep["welch_counts_equal"])
+            repro["arms"][name] = rep
+            log(f"{name}: {sel.size} cells; r mean_cp10k "
+                + ", ".join(f"{F.SHORT_TYPE[r['celltype']]} {r['pearson_r_generated']:.3f}/{r['spearman_r_generated']:.3f}"
+                            for r in contrast_rows if r["arm"] == name and r["statistic"] == "mean_cp10k")
+                + f" (Pearson/Spearman); repro {'PASS' if rep['pass'] else 'FAIL'} "
+                f"(max |d| {rep['contrast_max_abs_diff']:.1e}) ({time.monotonic() - t0:.0f} s)")
+            del Xg, ga, gx
+            if not (design == "fewshot" and arm["sha256"] in a.shared_shas):
+                pcache.pop(arm["sha256"], None)
+            if path in fetched and not (design == "fewshot" and path.name.endswith("_all.npz")):
+                drop_fetched(path)
+                fetched.remove(path)
+    for f in [f for f in fetched if f.name.startswith("conditions_")]:
+        drop_fetched(f)
+        fetched.remove(f)
+    # ---------------- extra reproduction: sepsis pooled_deg contrast vs pooled
+    if "contrast_also_checked_against" in notes:
+        other = pd.read_csv(Path(notes["contrast_also_checked_against"]) / "contrast.csv")
+        other = other[other.statistic.isin(STATS)].set_index(["arm", "celltype", "statistic"])
+        mx = 0.0
+        for r in contrast_rows:
+            k = (r["arm"], r["celltype"], r["statistic"])
+            if k in other.index:
+                for ours, theirs in (("pearson_r_generated", "r_generated"), ("pearson_r_broadcast", "r_broadcast"),
+                                     ("partial_r_generated_given_broadcast", "partial_r_generated_given_broadcast")):
+                    eq, dif = _isclose(r[ours], other.loc[k, theirs])
+                    mx = max(mx, dif)
+        repro["contrast_vs_other_call"] = {"call": notes["contrast_also_checked_against"], "max_abs_diff": mx,
+                                           "pass": mx <= REPRO_TOL}
+    # ---------------- limma
+    lim = lb.run(a.threads, out / "limma_R.log")
+    (out / "limma").mkdir(exist_ok=True)
+    for f in ("jobs.csv", "limma_status.csv", "versions.txt"):
+        shutil.copy2(work / f, out / "limma" / f)
+    shutil.move(str(out / "limma_R.log"), str(out / "limma" / "R.log"))
+    R = lim["results"]
+    deg_rows, cat_rows, rbo_rows = list(welch_rows), [], []
+    lim_obs = {flt: {t: limma_top(R.get(f"obs|{t}|{flt}"), genes_kept) for t in v["deg_types"]} for flt in LIMMA_FILTERS}
+    obs_rank = {t: rank_orders(R[f"obs|{t}|{PRIMARY_FILTER}"]["t"]) if f"obs|{t}|{PRIMARY_FILTER}" in R else None
+                for t in v["deg_types"]}
+    bc_rank_cache = {}
+    for name, info in arm_info.items():
+        ck = info["condition_key"]
+        for flt in LIMMA_FILTERS:
+            bres = limma_top(R.get(f"{ck}|{flt}"), genes_kept)
+            for t in v["deg_types"]:
+                ol = lim_obs[flt][t]
+                gl = limma_top(R.get(f"gen:{name}|{t}|{flt}"), genes_kept)
+                Gg = int((ol["tested"] & gl["tested"]).sum())
+                Gb = int((ol["tested"] & bres["tested"]).sum())
+                deg_rows.append({"arm": name, "celltype": t, "method": f"limma_voom_{flt}", "deg_scored": ol["defined"],
+                                 "pred_defined": gl["defined"], "overlap": len(set(ol["top"]) & set(gl["top"])),
+                                 "overlap_scorer": None, "obs_list_size": len(ol["top"]), "gen_list_size": len(gl["top"]),
+                                 "n_sig_obs": ol["n_significant"], "n_sig_gen": gl["n_significant"],
+                                 "n_tested_obs": int(ol["tested"].sum()), "n_tested_gen": int(gl["tested"].sum()),
+                                 "G_both": Gg, "chance_overlap": expected_overlap(len(ol["top"]), len(gl["top"]), Gg),
+                                 "broadcast_overlap": len(set(ol["top"]) & set(bres["top"])),
+                                 "broadcast_overlap_scorer": None, "broadcast_list_size": len(bres["top"]),
+                                 "n_sig_broadcast": bres["n_significant"], "n_tested_broadcast": int(bres["tested"].sum()),
+                                 "G_both_broadcast": Gb,
+                                 "broadcast_chance_overlap": expected_overlap(len(ol["top"]), len(bres["top"]), Gb),
+                                 "condition": info["condition_label"]})
+        # CAT / RBO on the primary limma ranking
+        bkey = f"{ck}|{PRIMARY_FILTER}"
+        if ck not in bc_rank_cache:
+            bc_rank_cache[ck] = rank_orders(R[bkey]["t"]) if bkey in R and R[bkey]["status"] == "ok" else None
+        for t in v["deg_types"]:
+            orank = obs_rank[t]
+            if orank is None or R[f"obs|{t}|{PRIMARY_FILTER}"]["status"] != "ok":
+                continue
+            gkey = f"gen:{name}|{t}|{PRIMARY_FILTER}"
+            grank = rank_orders(R[gkey]["t"]) if gkey in R and R[gkey]["status"] == "ok" else None
+            for pname, prank in ((f"generated:{name}", grank), (f"broadcast:{info['condition_label']}",
+                                                                bc_rank_cache[ck])):
+                G_both = int((orank["tested"] & prank["tested"]).sum()) if prank is not None else 0
+                for c in cat_curve(orank["abs"], orank["sign"], None if prank is None else prank["abs"],
+                                   None if prank is None else prank["sign"]):
+                    cs, ca = cat_chance(c["k"], G_both if prank is not None else int(orank["tested"].sum()))
+                    cat_rows.append({"arm": name, "predictor": pname, "celltype": t, **c, "chance_same_sign": cs,
+                                     "chance_any_sign": ca, "G_both": G_both, "pred_defined": prank is not None,
+                                     "n_tested_obs": int(orank["tested"].sum()),
+                                     "n_tested_pred": int(prank["tested"].sum()) if prank is not None else 0})
+                up = rbo_ext(list(orank["up"]), list(prank["up"]), RBO_P) if prank is not None else 0.0
+                dn = rbo_ext(list(orank["down"]), list(prank["down"]), RBO_P) if prank is not None else 0.0
+                rbo_rows.append({"arm": name, "predictor": pname, "celltype": t, "p": RBO_P, "rbo_ext_t_desc": up,
+                                 "rbo_ext_t_asc": dn, "rbo_ext_mean_up_down": (up + dn) / 2, "pred_defined": prank is not None,
+                                 "len_obs": int(orank["tested"].sum()),
+                                 "len_pred": int(prank["tested"].sum()) if prank is not None else 0})
+    # ---------------- assemble tables
+    def prefixed(df: pd.DataFrame) -> pd.DataFrame:
+        for k, x in reversed(list(meta.items())):
+            df.insert(0, k, x)
+        return df
+
+    cdf = pd.DataFrame(contrast_rows)
+    m4 = (cdf.groupby(["arm", "statistic"], sort=False)[[c for c in cdf.columns if c.startswith(("pearson", "spearman",
+                                                                                                   "partial", "r_gen"))]]
+          .agg(lambda x: float(np.nanmean(x)) if pd.notna(x).any() else float("nan")).reset_index())
+    m4["celltype"] = "mean4"
+    cdf = pd.concat([cdf, m4], ignore_index=True)
+    cdf.insert(3, "label", cdf.arm.map(lambda x: ARM_LABEL.get(x, x)))
+    prefixed(cdf).to_csv(out / "contrast.csv", index=False)
+    # ceiling.csv: split-half (ceiling) + generated / broadcast vs half B
+    ps = pd.DataFrame(sh["per_seed"])
+    ps["predictor"], ps["arm"] = "split_half_A_vs_B", ""
+    hr = pd.concat([ps, pd.DataFrame(half_rows), pd.DataFrame(list(bcast_store.values()))], ignore_index=True)
+    ceil_rows = []
+    for (pred, arm_, t), sub in hr.groupby(["predictor", "arm", "celltype"], sort=False):
+        sub = sub.set_index("seed").reindex(list(SPLIT_SEEDS))
+        r = {"predictor": pred, "arm": arm_, "celltype": t, "n_genes": int(genes[t].sum()),
+             "pearson_mean": float(sub.pearson.mean()), "pearson_sd": float(sub.pearson.std(ddof=1)),
+             "spearman_mean": float(sub.spearman.mean()), "spearman_sd": float(sub.spearman.std(ddof=1))}
+        for sd_ in SPLIT_SEEDS:
+            r[f"pearson_s{sd_}"], r[f"spearman_s{sd_}"] = sub.loc[sd_, "pearson"], sub.loc[sd_, "spearman"]
+        if pred == "split_half_A_vs_B":
+            r.update({"sb_reliability_pearson": spearman_brown(r["pearson_mean"]),
+                      "noise_free_ceiling_pearson": noise_free_ceiling(r["pearson_mean"]),
+                      "sb_reliability_spearman": spearman_brown(r["spearman_mean"]),
+                      "noise_free_ceiling_spearman": noise_free_ceiling(r["spearman_mean"])})
+            for c in ("n_case_donors_A", "n_control_donors_A", "n_case_donors_B", "n_control_donors_B"):
+                r[f"min_{c}"] = int(sub[c].min())
+            r["mean_n_cells_A"], r["mean_n_cells_B"] = float(sub.n_cells_A.mean()), float(sub.n_cells_B.mean())
+        if "condition_sha256" in sub.columns and sub.condition_sha256.notna().any():
+            r["condition_sha256"] = sub.condition_sha256.dropna().iloc[0]
+        ceil_rows.append(r)
+    for (pred, arm_), sub in hr.groupby(["predictor", "arm"], sort=False):   # mean over the 4 types, per seed
+        per_seed = sub.groupby("seed")[["pearson", "spearman"]].mean().reindex(list(SPLIT_SEEDS))
+        r = {"predictor": pred, "arm": arm_, "celltype": "mean4",
+             "pearson_mean": float(per_seed.pearson.mean()), "pearson_sd": float(per_seed.pearson.std(ddof=1)),
+             "spearman_mean": float(per_seed.spearman.mean()), "spearman_sd": float(per_seed.spearman.std(ddof=1))}
+        for sd_ in SPLIT_SEEDS:
+            r[f"pearson_s{sd_}"], r[f"spearman_s{sd_}"] = per_seed.loc[sd_, "pearson"], per_seed.loc[sd_, "spearman"]
+        if pred == "split_half_A_vs_B":
+            tt = [x for x in ceil_rows if x["predictor"] == pred]
+            for c in ("sb_reliability_pearson", "noise_free_ceiling_pearson", "sb_reliability_spearman",
+                      "noise_free_ceiling_spearman"):
+                vals = [x[c] for x in tt]
+                r[c] = float(np.nanmean(vals)) if np.isfinite(vals).any() else float("nan")
+        if "condition_sha256" in sub.columns and sub.condition_sha256.notna().any():
+            r["condition_sha256"] = sub.condition_sha256.dropna().iloc[0]
+        ceil_rows.append(r)
+    prefixed(pd.DataFrame(ceil_rows)).to_csv(out / "ceiling.csv", index=False)
+    ddf = pd.DataFrame(deg_rows)
+    prefixed(ddf).to_csv(out / "deg_limma.csv", index=False)
+    cat_df = pd.DataFrame(cat_rows)
+    prefixed(cat_df).to_csv(out / "cat.csv", index=False)
+    rbo_df = pd.DataFrame(rbo_rows)
+    prefixed(rbo_df).to_csv(out / "rbo.csv", index=False)
+    # ---------------- headline (one row per arm)
+    ceil = pd.DataFrame(ceil_rows)
+    sh4 = ceil[(ceil.predictor == "split_half_A_vs_B") & (ceil.celltype == "mean4")].iloc[0]
+    heads = []
+    for name, info in arm_info.items():
+        c4 = cdf[(cdf.arm == name) & (cdf.statistic == "mean_cp10k") & (cdf.celltype == "mean4")].iloc[0]
+        gB = ceil[(ceil.predictor == f"generated:{name}") & (ceil.celltype == "mean4")].iloc[0]
+        bB = ceil[(ceil.predictor == f"broadcast:{info['condition_label']}") & (ceil.celltype == "mean4")]
+        h = {"arm": name, "label": info["label"], "role": ROLE.get(name, "other"), "condition": info["condition_label"],
+             "pearson_r": c4.pearson_r_generated, "spearman_r": c4.spearman_r_generated,
+             "partial_r": c4.partial_r_generated_given_broadcast,
+             "broadcast_pearson_r": c4.pearson_r_broadcast, "broadcast_spearman_r": c4.spearman_r_broadcast,
+             "splithalf_r_AB": sh4.pearson_mean, "splithalf_r_AB_sd": sh4.pearson_sd,
+             "splithalf_spearman_AB": sh4.spearman_mean,
+             "sb_reliability": sh4.sb_reliability_pearson, "noise_free_ceiling": sh4.noise_free_ceiling_pearson,
+             "r_generated_vs_halfB": gB.pearson_mean, "r_broadcast_vs_halfB": bB.pearson_mean.iloc[0] if len(bB) else np.nan}
+        for meth in ("welch", f"limma_voom_{PRIMARY_FILTER}", "limma_voom_filterByExpr"):
+            sub = ddf[(ddf.arm == name) & (ddf.method == meth) & ddf.deg_scored.astype(bool)]
+            tag = {"welch": "welch", f"limma_voom_{PRIMARY_FILTER}": "limma", "limma_voom_filterByExpr": "limma_fbe"}[meth]
+            h[f"{tag}_top50"] = int(sub.overlap.sum())
+            h[f"{tag}_top50_max"] = int(sub.obs_list_size.sum())
+            h[f"{tag}_top50_chance"] = float(sub.chance_overlap.fillna(0).sum())
+            h[f"{tag}_top50_broadcast"] = int(sub.broadcast_overlap.sum())
+            h[f"{tag}_top50_broadcast_chance"] = float(sub.broadcast_chance_overlap.fillna(0).sum())
+            h[f"{tag}_n_sig_obs"] = int(sub.n_sig_obs.sum())
+            h[f"{tag}_n_sig_gen"] = int(sub.n_sig_gen.sum())
+            h[f"{tag}_n_sig_broadcast_per_type"] = int(sub.n_sig_broadcast.iloc[0]) if len(sub) else 0
+            h[f"{tag}_types_scored"] = int(len(sub))
+        for pred, tag in ((f"generated:{name}", ""), (f"broadcast:{info['condition_label']}", "broadcast_")):
+            cs = cat_df[(cat_df.arm == name) & (cat_df.predictor == pred)] if len(cat_df) else cat_df
+            for k in (50, 100):
+                sk = cs[cs.k == k] if len(cs) else cs
+                h[f"{tag}cat{k}"] = float(sk.cat_same_sign.mean()) if len(sk) else np.nan
+                h[f"{tag}cat{k}_chance"] = float(sk.chance_same_sign.mean()) if len(sk) else np.nan
+            rs = rbo_df[(rbo_df.arm == name) & (rbo_df.predictor == pred)] if len(rbo_df) else rbo_df
+            h[f"{tag}rbo"] = float(rs.rbo_ext_t_desc.mean()) if len(rs) else np.nan
+            h[f"{tag}rbo_up_down"] = float(rs.rbo_ext_mean_up_down.mean()) if len(rs) else np.nan
+            h[f"{tag}cat_types"] = int(rs.celltype.nunique()) if len(rs) else 0
+        h["repro_pass"] = repro["arms"][name]["pass"] if repro_comparable else None
+        heads.append(h)
+    hdf = pd.DataFrame(heads)
+    prefixed(hdf).to_csv(out / "headline.csv", index=False)
+    # ---------------- repro + manifest
+    repro["observed_split_half_full_aggregates"] = sh["check_full_aggregates"]
+    repro["comparable_with_scorer"] = repro_comparable
+    repro["all_pass"] = bool(all(r["pass"] for r in repro["arms"].values())
+                             and repro.get("contrast_vs_other_call", {}).get("pass", True)) if repro_comparable else None
+    (out / "repro.json").write_text(json.dumps(repro, indent=1, default=float) + "\n")
+    code = a.code_sha
+    manifest = {"schema": "paired_ft_contrast_extra.v1", **meta, "written_utc": F.now(), "command": sys.argv,
+                "threads": a.threads, "donors": list(map(str, v["donors"])), "n_samples": int(S_),
+                "contrast": {k: contrast[k] for k in ("case_groups", "control_groups", "n_case_donors",
+                                                       "n_control_donors")},
+                "calls": {str(c): {"arms": list(arms_of[c]), "summary_sha256": sha256(c / "summary.json"),
+                                   "contrast_csv_sha256": sha256(c / "contrast.csv")} for c, _ in calls},
+                "notes": notes, "reference_sha256": man["reference_sha256"],
+                "deg_reference": {"source": deg_ref["source"], "sha256": deg_ref["sha256"]},
+                "gene_exclusion": gene_excl, "n_genes_disease_scores": Gk,
+                "genes_per_type": {t: int(genes[t].sum()) for t in F.CONTRAST_TYPES},
+                "arms": arm_info, "observed_cells": {"inputs_sha256": man["cells"]["inputs_sha256"],
+                                                    "labels_sha256": man["labels"]["sha256"],
+                                                    "n_cells_4types_scored": sh["n_cells_used"]},
+                "params": {"split_seeds": list(SPLIT_SEEDS),
+                           "split_rule": "per scored sample x contrast type: permutation from default_rng([seed, "
+                                         "uint64 LE of sha256('<sample>|<type>')[:8]]) of its cells in canonical order; "
+                                         "half A = first floor(n/2) positions, half B = the rest",
+                           "cat_ks": list(CAT_KS), "rbo_p": RBO_P, "limma_filters": list(LIMMA_FILTERS),
+                           "primary_filter": PRIMARY_FILTER, "fdr": F.DEG_FDR, "top_n": F.DEG_TOP_N,
+                           "min_detect_frac": F.MIN_DETECT_FRAC, "poisson_seed": F.POISSON_SEED,
+                           "repro_tol": REPRO_TOL},
+                "limma": {"rscript": str(RSCRIPT), "versions": lim["versions"], "n_jobs": len(lb.jobs),
+                          "n_not_ok": int((lim["status"].status != "ok").sum()), "seconds": lim["seconds"],
+                          "job_matrices": lb.meta},
+                "repro_all_pass": repro["all_pass"], "split_half_seconds": sh["seconds"],
+                "fetched_from_server2": sorted(fetched_all), "code_sha256": code,
+                "seconds": round(time.monotonic() - t_unit, 1)}
+    (out / "manifest.json").write_text(json.dumps(manifest, indent=1, default=float) + "\n")
+    shutil.rmtree(work, ignore_errors=True)
+    log(f"unit {meta['unit']} of {ds} -> {out} in {manifest['seconds']} s; reproduction "
+        f"{'PASS' if repro['all_pass'] else ('n/a' if repro['all_pass'] is None else 'FAIL')}")
+
+
+# =========================================================================== collect
+LC_LORA = {"zs__raw": 0, "zs__cal": 0, "lora_n5__raw": 5, "lora_n10__raw": 10, "lora_n20__raw": 20,
+           "lora_n40__raw": 40, "real_lora__raw": "all"}
+LC_CAL = {"zs__cal_n5": 5, "zs__cal_n10": 10, "zs__cal_n20": 20, "zs__cal_n40": 40}
+
+
+def collect() -> None:
+    """Concatenate every unit into scores_contrast/<design>_<table>.csv, fewshot_summary.csv (mean +- SD over draws),
+    learning_curve_*.csv (sepsis pooled LoRA subsets + equal-budget calibration) and reproduction_check.csv."""
+    units = sorted(p.parent for p in OUT_ROOT.glob("*/**/manifest.json")
+                   if not any(x.startswith("_") for x in p.relative_to(OUT_ROOT).parts))
+    tabs = {k: [] for k in ("contrast", "ceiling", "deg_limma", "cat", "rbo", "headline")}
+    rep, skipped, runtime = [], [], []
+    for u in units:
+        m = json.loads((u / "manifest.json").read_text())
+        if m.get("skipped"):
+            skipped.append({"dataset": m["dataset"], "unit": m["unit"], "reason": m["reason"]})
+            continue
+        runtime.append({"dataset": m["dataset"], "design": m["design"], "unit": m["unit"], "seconds": m["seconds"],
+                        "split_half_seconds": m["split_half_seconds"], "limma_seconds": m["limma"]["seconds"],
+                        "n_samples": m["n_samples"], "n_arms": len(m["arms"])})
+        for k in tabs:
+            tabs[k].append(pd.read_csv(u / f"{k}.csv"))
+        r = json.loads((u / "repro.json").read_text())
+        for arm, x in r["arms"].items():
+            rep.append({"dataset": m["dataset"], "design": m["design"], "unit": m["unit"], "arm": arm,
+                        "contrast_max_abs_diff": x["contrast_max_abs_diff"], "contrast_all_equal": x["contrast_all_equal"],
+                        "n_genes_equal": x["n_genes_equal"], "welch_lists_equal": x["welch_lists_equal"],
+                        "welch_counts_equal": x["welch_counts_equal"], "pass": x["pass"],
+                        "observed_aggregates_rebuilt": all(r["observed_split_half_full_aggregates"][c] for c in
+                                                          ("n_equal", "det_equal", "sum_equal_float32")),
+                        "observed_cp10k_max_abs_diff_float32":
+                            r["observed_split_half_full_aggregates"]["cp10k_max_abs_diff_float32"],
+                        "other_call_max_abs_diff": r.get("contrast_vs_other_call", {}).get("max_abs_diff")})
+    if not runtime:
+        log("nothing to collect")
+        return
+    cat = {k: pd.concat(v_, ignore_index=True) for k, v_ in tabs.items()}
+
+    def design_of(df):
+        return np.where(df.unit.str.startswith("fewshot_n5"), "fewshot",
+                        np.where(df.unit == "pooled", "pooled", "scored"))
+    for k, df in cat.items():
+        df["_d"] = design_of(df)
+        for d, sub in df.groupby("_d"):
+            sub.drop(columns="_d").to_csv(OUT_ROOT / f"{d}_{k}.csv", index=False)
+    pd.DataFrame(rep).to_csv(OUT_ROOT / "reproduction_check.csv", index=False)
+    pd.DataFrame(runtime).to_csv(OUT_ROOT / "run_time.csv", index=False)
+    if skipped:
+        pd.DataFrame(skipped).to_csv(OUT_ROOT / "skipped_units.csv", index=False)
+    h = cat["headline"]
+    few = h[h._d == "fewshot"].drop(columns="_d")
+    if len(few):
+        num = [c for c in few.columns if c not in ("dataset", "design", "unit", "arm", "label", "role", "condition")
+               and pd.api.types.is_numeric_dtype(few[c])]
+        g = few.groupby(["dataset", "arm", "label", "role"], sort=False)
+        summ = g[num].mean().add_suffix("_mean").join(g[num].std(ddof=1).add_suffix("_sd")).join(
+            g.size().rename("n_draws")).reset_index()
+        summ.to_csv(OUT_ROOT / "fewshot_summary.csv", index=False)
+    lc = []
+    for _, r in h[(h.dataset == "ye2026_sepsis") & (h.unit == "pooled") & h.arm.isin(list(LC_LORA))].iterrows():
+        lc.append({**r.drop("_d").to_dict(), "series": "lora" if r.arm not in ("zs__raw", "zs__cal") else r.arm,
+                   "pairs": LC_LORA[r.arm]})
+    for _, r in h[(h.dataset == "ye2026_sepsis") & (h.unit == "cal_budget_20261001/pooled")].iterrows():
+        lc.append({**r.drop("_d").to_dict(), "series": "zs_cal_budget", "pairs": LC_CAL.get(r.arm, r.arm)})
+    if lc:
+        pd.DataFrame(lc).to_csv(OUT_ROOT / "learning_curve_headline.csv", index=False)
+        keys = {(x["unit"], x["arm"]) for x in lc}
+        for k in ("contrast", "ceiling", "deg_limma", "cat", "rbo"):
+            df = cat[k]
+            m_ = [(u, a_) in keys for u, a_ in zip(df.unit, df.arm)] if "arm" in df.columns else []
+            sub = df[(df.dataset == "ye2026_sepsis") & np.asarray(m_, bool)].drop(columns="_d")
+            if k == "ceiling":   # arm-independent rows (split half, broadcast) of the two units too
+                extra = df[(df.dataset == "ye2026_sepsis") & df.unit.isin(["pooled", "cal_budget_20261001/pooled"])
+                           & (df.arm.isna() | (df.arm == ""))].drop(columns="_d")
+                sub = pd.concat([extra, sub], ignore_index=True)
+            sub.to_csv(OUT_ROOT / f"learning_curve_{k}.csv", index=False)
+    log(f"collected {len(runtime)} units; reproduction pass {sum(bool(r['pass']) for r in rep)}/{len(rep)} arms")
+
+
+# =========================================================================== main
+def parse(argv=None):
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--design", choices=["fewshot", "pooled", "scored"])
+    p.add_argument("--dataset", choices=DATASETS)
+    p.add_argument("--draws", default="0,1,2,3,4")
+    p.add_argument("--score-dir", default=None, help="--design scored: a score_ft.py output dir (summary.json)")
+    p.add_argument("--arms", default=None, help="--design scored: comma list of arms scored in --score-dir")
+    p.add_argument("--unit", default=None, help="--design scored: output sub-path under scores_contrast/<dataset>/")
+    p.add_argument("--exclude-genes", default=None, help="CSV with gene_id (score_ft --exclude-genes); only needed "
+                                                         "when the scored call has none (reproduction then n/a)")
+    p.add_argument("--allow-sex-genes", action="store_true", help="giroux2022 without any sex-linked-gene exclusion")
+    p.add_argument("--threads", type=int, default=4)
+    p.add_argument("--fetch-dir", default=None, help="server_2 NPZ copies (default scores_contrast/_fetch_tmp)")
+    p.add_argument("--force", action="store_true")
+    p.add_argument("--collect", action="store_true")
+    return p.parse_args(argv)
+
+
+def main(argv=None) -> int:
+    a = parse(argv)
+    if a.collect:
+        collect()
+        return 0
+    if not 1 <= a.threads <= MAX_THREADS:
+        raise SystemExit(f"--threads must be 1..{MAX_THREADS}")
+    try:
+        from threadpoolctl import threadpool_limits
+        threadpool_limits(a.threads)
+    except ImportError:
+        pass
+    if a.design is None or a.dataset is None:
+        raise SystemExit("--design and --dataset are required (or --collect)")
+    if a.dataset not in DISEASE and a.design != "scored":
+        raise SystemExit(f"{a.dataset} has no case-control contrast")
+    a.code_sha = {str(p_): sha256(p_) for p_ in CODE_FILES}
+    a.fetch_dir = a.fetch_dir or str(OUT_ROOT / "_fetch_tmp")
+    Path(a.fetch_dir).mkdir(parents=True, exist_ok=True)
+    a.pcache, a.shared_shas = {}, set()
+    code_dir = OUT_ROOT / "_code"
+    code_dir.mkdir(parents=True, exist_ok=True)
+    for p_ in (Path(__file__).resolve(), R_SCRIPT):
+        dst = code_dir / f"{p_.stem}.{a.code_sha[str(p_)][:12]}{p_.suffix}"
+        if not dst.exists():
+            shutil.copy2(p_, dst)
+    if a.design == "scored":
+        if not (a.score_dir and a.arms and a.unit):
+            raise SystemExit("--design scored needs --score-dir, --arms and --unit")
+        unit = Path(a.unit)
+        if unit.is_absolute() or ".." in unit.parts or unit.parts[0] in ("pooled", "fewshot_n5") or unit.name.startswith("_"):
+            raise SystemExit("--unit must be a new relative sub-path (not pooled/ or fewshot_n5/)")
+        SCORED.update({"dir": Path(a.score_dir).resolve(), "arms": tuple(x for x in a.arms.split(",") if x),
+                       "unit": str(unit)})
+        run_unit("scored", a.dataset, None, a)
+    elif a.design == "pooled":
+        run_unit("pooled", a.dataset, None, a)
+    else:
+        draws = [int(x) for x in a.draws.split(",") if x.strip()]
+        # shared zero-shot NPZs (zs__raw_all, zs__pseudo_all): one Poisson read-out reused by every draw
+        tree = SOURCE_TREE.get(a.dataset, SCORES)
+        shas = {}
+        for j in draws:
+            s = json.loads((tree / a.dataset / "fewshot_n5" / f"draw{j}" / "summary.json").read_text())
+            for pa in s["per_arm"].values():
+                shas.setdefault(pa["npz_sha256"], set()).add(j)
+        a.shared_shas = {k for k, js in shas.items() if len(js) > 1}
+        for j in draws:
+            run_unit("fewshot", a.dataset, j, a)
+        shared = Path(a.fetch_dir) / "generated" / a.dataset / "fewshot_n5"
+        for f in list(shared.glob("zs__*_all.npz")) if shared.is_dir() else []:
+            drop_fetched(f)
+    assert "torch" not in sys.modules, "torch was imported"
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261002T085943Z-deck-restructure-contrast-metrics-zeroshot-len/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/contrast_extra_tables.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""Compact tables of scores_contrast (CPU, pandas only; reads the collected CSVs written by contrast_extra.py --collect).
+
+Writes scores_contrast/TABLES.md and scores_contrast/compact_{fewshot,pooled,learning_curve}.csv: per cohort and design,
+for the arms LoRA, scSemiProfiler, zero-shot raw, zero-shot + calibration and the real-bulk broadcast: Pearson r,
+Spearman r (mean of T/B/Mono/NK, statistic mean_cp10k), split-half ceiling (r(A,B) and the noise-free ceiling
+sqrt(2r/(1+r))), r vs half B, Welch and limma-voom top-50 DEG overlap (sum over scored types) with their chance levels,
+CAT(50), CAT(100) (same sign, mean over scored types) and RBO_ext (t descending, p = 0.98). Few-pair rows are means over
+the 5 draws (SD in the CSV). Added 2026-10-02.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+OUT = Path(__file__).resolve().parents[1] / "scores_contrast"
+COHORT = {"ye2026_sepsis": "Sepsis", "imperial_eskd": "Imperial ESKD COVID", "giroux2022": "Giroux (sex-linked genes excluded)",
+          "ji2025_chili": "Ji ChILI (whole-blood bulk)"}
+ROLE_ORDER = ["lora", "scsemi", "zs_raw", "zs_cal", "broadcast"]
+ROLE_LABEL = {"lora": "LoRA", "scsemi": "scSemiProfiler", "zs_raw": "zero-shot raw", "zs_cal": "zero-shot + cal",
+              "broadcast": "broadcast (real bulk)"}
+GEN_COLS = {"pearson_r": "pearson", "spearman_r": "spearman", "r_generated_vs_halfB": "r_vs_halfB",
+            "welch_top50": "welch50", "welch_top50_chance": "welch50_chance", "limma_top50": "limma50",
+            "limma_top50_chance": "limma50_chance", "limma_fbe_top50": "limma50_fbe", "cat50": "cat50", "cat100": "cat100",
+            "cat50_chance": "cat50_chance", "rbo": "rbo", "limma_n_sig_gen": "limma_nsig_pred",
+            "welch_n_sig_gen": "welch_nsig_pred"}
+BC_COLS = {"broadcast_pearson_r": "pearson", "broadcast_spearman_r": "spearman", "r_broadcast_vs_halfB": "r_vs_halfB",
+           "welch_top50_broadcast": "welch50", "welch_top50_broadcast_chance": "welch50_chance",
+           "limma_top50_broadcast": "limma50", "limma_top50_broadcast_chance": "limma50_chance",
+           "limma_fbe_top50_broadcast": "limma50_fbe", "broadcast_cat50": "cat50", "broadcast_cat100": "cat100",
+           "broadcast_cat50_chance": "cat50_chance", "broadcast_rbo": "rbo",
+           "limma_n_sig_broadcast_per_type": "limma_nsig_pred", "welch_n_sig_broadcast_per_type": "welch_nsig_pred"}
+UNIT_COLS = {"splithalf_r_AB": "ceiling_rAB", "noise_free_ceiling": "ceiling_noise_free", "welch_top50_max": "welch50_max",
+             "limma_top50_max": "limma50_max", "limma_n_sig_obs": "limma_nsig_obs", "welch_n_sig_obs": "welch_nsig_obs"}
+
+
+def rows_for(h: pd.DataFrame) -> pd.DataFrame:
+    """One row per unit x role (LoRA / scSemi / zs raw / zs cal, plus the broadcast of the LoRA arm's raw-bulk condition)."""
+    out = []
+    for (ds, unit), sub in h.groupby(["dataset", "unit"], sort=False):
+        base = {"dataset": ds, "unit": unit}
+        for _, r in sub[sub.role.isin(ROLE_ORDER[:4])].iterrows():
+            out.append({**base, "role": r.role, "arm": r.arm, **{v: r[k] for k, v in GEN_COLS.items()},
+                        **{v: r[k] for k, v in UNIT_COLS.items()}})
+        lora = sub[sub.role == "lora"]
+        if len(lora):
+            r = lora.iloc[0]
+            out.append({**base, "role": "broadcast", "arm": f"broadcast[{r.condition}]",
+                        **{v: r[k] for k, v in BC_COLS.items()}, **{v: r[k] for k, v in UNIT_COLS.items()}})
+    return pd.DataFrame(out)
+
+
+def fmt(x, nd=2):
+    return "–" if x is None or (isinstance(x, float) and np.isnan(x)) else f"{x:.{nd}f}"
+
+
+def md_table(df: pd.DataFrame, few: bool) -> str:
+    hdr = ("| cohort | arm | Pearson r | Spearman r | split-half r(A,B) / noise-free ceiling | r vs half B | "
+           "Welch top-50 (chance) | limma top-50 (chance) | CAT50 / CAT100 (chance@50) | RBO |")
+    lines = [hdr, "|" + "---|" * 10]
+    for ds in COHORT:
+        sub = df[df.dataset == ds]
+        if not len(sub):
+            continue
+        for role in ROLE_ORDER:
+            s = sub[sub.role == role]
+            if not len(s):
+                why = ("not computed: no scSemiProfiler arm in this design (5-fold CV / equal-budget calls do not "
+                       "exist yet)" if role == "scsemi" else "not computed: no such arm")
+                lines.append(f"| {COHORT[ds]} | {ROLE_LABEL[role]} | {why} |||||||| |")
+                continue
+            m = s.mean(numeric_only=True)
+            sd = s.std(numeric_only=True, ddof=1) if few and len(s) > 1 else None
+
+            def pm(c, nd=2):
+                return fmt(m[c], nd) + (f" ± {fmt(sd[c], nd)}" if sd is not None else "")
+            lines.append(
+                f"| {COHORT[ds]} | {ROLE_LABEL[role]} | {pm('pearson')} | {pm('spearman')} | "
+                f"{fmt(m['ceiling_rAB'])} / {fmt(m['ceiling_noise_free'])} | {fmt(m['r_vs_halfB'])} | "
+                f"{fmt(m['welch50'], 1)} ({fmt(m['welch50_chance'], 2)}) of {fmt(m['welch50_max'], 0 if not few else 1)} | "
+                f"{fmt(m['limma50'], 1)} ({fmt(m['limma50_chance'], 2)}) of {fmt(m['limma50_max'], 0 if not few else 1)} | "
+                f"{fmt(m['cat50'], 3)} / {fmt(m['cat100'], 3)} ({fmt(m['cat50_chance'], 3)}) | {fmt(m['rbo'], 3)} |")
+    return "\n".join(lines)
+
+
+def main() -> int:
+    parts = ["# scores_contrast: compact tables\n",
+             "Generated by `tools/contrast_extra_tables.py` from the collected CSVs. Means over T/B/Mono/NK (r) or over "
+             "the scored DEG types T/B/Mono/NK/DC (CAT, RBO); top-50 = sum over the scored types, 'of N' = sum of the "
+             "observed list lengths; chance = hypergeometric mean. Broadcast = the raw real-bulk condition of the LoRA "
+             "arm. Few-pair: mean ± SD over 5 draws (other columns: means).\n"]
+    for design, fn, few in (("fewshot", "fewshot_headline.csv", True), ("pooled", "pooled_headline.csv", False)):
+        p = OUT / fn
+        if not p.is_file():
+            continue
+        df = rows_for(pd.read_csv(p))
+        df.to_csv(OUT / f"compact_{design}.csv", index=False)
+        parts.append(f"\n## {'Few-pair (5 donors, 5 draws)' if few else '5-fold pooled'}\n\n" + md_table(df, few) + "\n")
+    p = OUT / "learning_curve_headline.csv"
+    if p.is_file():
+        lc = pd.read_csv(p)
+        keep = ["series", "pairs", "arm", "pearson_r", "spearman_r", "partial_r", "broadcast_pearson_r",
+                "broadcast_spearman_r", "splithalf_r_AB", "noise_free_ceiling", "r_generated_vs_halfB",
+                "welch_top50", "welch_top50_chance", "welch_top50_max", "limma_top50", "limma_top50_chance",
+                "limma_top50_max", "cat50", "cat100", "cat50_chance", "rbo", "broadcast_cat50", "broadcast_rbo"]
+        lc = lc[keep]
+        order = {"zs__raw": 0, "zs__cal": 1, "lora": 2, "zs_cal_budget": 3}
+        lc = lc.assign(_s=lc.series.map(order), _n=pd.to_numeric(lc.pairs, errors="coerce").fillna(1e9)) \
+            .sort_values(["_s", "_n"]).drop(columns=["_s", "_n"])
+        lc.to_csv(OUT / "compact_learning_curve.csv", index=False)
+        lines = ["| series | pairs | arm | Pearson | Spearman | Welch top-50 (chance) | limma top-50 (chance) | "
+                 "CAT50 / CAT100 | RBO |", "|" + "---|" * 9]
+        for _, r in lc.iterrows():
+            lines.append(f"| {r.series} | {r.pairs} | {r.arm} | {fmt(r.pearson_r)} | {fmt(r.spearman_r)} | "
+                         f"{int(r.welch_top50)} ({fmt(r.welch_top50_chance)}) of {int(r.welch_top50_max)} | "
+                         f"{int(r.limma_top50)} ({fmt(r.limma_top50_chance)}) of {int(r.limma_top50_max)} | "
+                         f"{fmt(r.cat50, 3)} / {fmt(r.cat100, 3)} | {fmt(r.rbo, 3)} |")
+        r0 = lc.iloc[0]
+        lines.append(f"\nBroadcast (real bulk): Pearson {fmt(lc[lc.arm == 'real_lora__raw'].broadcast_pearson_r.iloc[0]) if (lc.arm == 'real_lora__raw').any() else '–'}, "
+                     f"CAT50 {fmt(lc[lc.arm == 'real_lora__raw'].broadcast_cat50.iloc[0], 3) if (lc.arm == 'real_lora__raw').any() else '–'}, "
+                     f"RBO {fmt(lc[lc.arm == 'real_lora__raw'].broadcast_rbo.iloc[0], 3) if (lc.arm == 'real_lora__raw').any() else '–'}; "
+                     f"split-half r(A,B) {fmt(r0.splithalf_r_AB)}, noise-free ceiling {fmt(r0.noise_free_ceiling)}.")
+        parts.append("\n## Sepsis learning curve (pooled, 82 samples)\n\n" + "\n".join(lines) + "\n")
+    (OUT / "TABLES.md").write_text("\n".join(parts))
+    print((OUT / "TABLES.md").read_text())
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261002T085943Z-deck-restructure-contrast-metrics-zeroshot-len/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/run_contrast_unit.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+# Run a list of tools/contrast_extra.py jobs (CPU only) in one transient systemd user unit on server_1 (added 2026-10-02).
+#   MemoryMax MEM, MemorySwapMax 0, CPUQuota THREADS x 100 %, Nice 10, CUDA hidden, no bytecode written, no restart.
+#   Refuses to start unless MemAvailable - 32 GiB > MEM (host rule: keep a 32 GiB floor above the job's peak).
+#   Does not wait. Log: scores_contrast/_logs/NAME_<stamp>.log; launches are appended to scores_contrast/_logs/units.tsv.
+#   Jobs run one after another; a failed job is logged ("JOB_EXIT <rc> ...") and the next job starts.
+# usage: run_contrast_unit.sh NAME THREADS MEM_GIB JOBFILE
+#   JOBFILE: one contrast_extra.py argument line per row, e.g. "--design fewshot --dataset ji2025_chili --draws 0,1,2,3,4"
+set -uo pipefail
+export XDG_RUNTIME_DIR="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
+export DBUS_SESSION_BUS_ADDRESS="${DBUS_SESSION_BUS_ADDRESS:-unix:path=$XDG_RUNTIME_DIR/bus}"
+TASK=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927
+PY=/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python
+name=$1; thr=$2; mem=$3; jobs=$4
+(( thr >= 1 && thr <= 14 )) || { echo "THREADS must be 1..14" >&2; exit 2; }
+[[ $mem =~ ^[0-9]+$ ]] || { echo "MEM_GIB must be an integer (GiB)" >&2; exit 2; }
+[[ -s $jobs ]] || { echo "no job file $jobs" >&2; exit 2; }
+avail=$(awk '/MemAvailable/ {print int($2/1048576)}' /proc/meminfo)
+(( avail - 32 > mem )) || { echo "MemAvailable ${avail} GiB - 32 <= ${mem} GiB; not starting $name" >&2; exit 3; }
+logs=$TASK/scores_contrast/_logs
+mkdir -p "$logs"
+stamp=$(date +%Y%m%dT%H%M%S)
+unit=contrast-${name}-${stamp}
+log=$logs/${name}_${stamp}.log
+cp "$jobs" "$logs/${name}_${stamp}.jobs"
+echo -e "$(date -Is)\tstart\t$unit\t$(hostname -s)\tMemAvailable=${avail}GiB\tthreads=$thr\tmem=${mem}G\t$jobs" >> "$logs/units.tsv"
+systemd-run --user --unit="$unit" --working-directory="$TASK" \
+  -p MemoryMax="${mem}G" -p MemorySwapMax=0 -p CPUQuota=$((thr * 100))% -p Nice=10 \
+  -p StandardOutput=append:"$log" -p StandardError=append:"$log" \
+  --setenv=CUDA_VISIBLE_DEVICES= --setenv=PYTHONNOUSERSITE=1 --setenv=PYTHONDONTWRITEBYTECODE=1 \
+  --setenv=PYTHONUNBUFFERED=1 --setenv=OMP_NUM_THREADS="$thr" --setenv=OPENBLAS_NUM_THREADS="$thr" \
+  --setenv=MKL_NUM_THREADS="$thr" --setenv=NUMBA_NUM_THREADS="$thr" \
+  /bin/bash -c 'while IFS= read -r line; do [[ -z $line || $line == \#* ]] && continue; t0=$(date +%s);
+      echo "JOB_START $(date -Is) $line"; [[ $line == *--threads* ]] || line="$line --threads '"$thr"'";
+      /usr/bin/time -v '"$PY"' tools/contrast_extra.py $line;
+      echo "JOB_EXIT $? $(( $(date +%s) - t0 ))s $line"; done < '"$logs/${name}_${stamp}.jobs"'; echo UNIT_EXIT 0' >/dev/null
+echo "unit=$unit log=$log"

paper-releases/pbisc-diffusion/updates/20261002T085943Z-deck-restructure-contrast-metrics-zeroshot-len/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/sample_lockwait.sh

@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+# Sample base-model zero-shot sets by queuing on the shared GPU lock (2026-10-02).
+#
+# Same sampler, checkpoint and flags as plans/utility_studies_final6k_20260925/tools/sample_queue.sh. The only
+# difference: it does not poll gpu_usable.sh every 120 s. When another queue runs GPU steps back to back (gaps of
+# ~4 s between its ml-run jobs), that poll almost never sees the lock free. Here ml-run blocks on
+# /run/user/1000/ml-gpu0.lock (flock --exclusive) and takes the GPU at the next release, so no two CUDA jobs ever
+# overlap and the other queue simply waits for this one. Before each step: memory guard active, MemAvailable >= 32 GiB,
+# thermal gate. Queue lines: "sample|TAG|base|CONDITION_NPZ|SEED|OUTPUT_NPZ" (run_queue.sh format; base model only).
+#   env: QUEUE (required)
+set -uo pipefail
+export XDG_RUNTIME_DIR="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
+M8=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion
+TASK=$M8/plans/paired_finetune_intradataset_20260927
+CKPT=$M8/runs/f01_6k_1x_seed20260627/checkpoint_epoch_016.pt
+CKPT_SHA=8c7cd0e83e2bc19fe03dfcbc084919a1e2f61be8cc8bc12f4caf543dfda91633
+PY=/home/sj_server_1/miniforge3/envs/b2sc-cu130/bin/python
+QUEUE="${QUEUE:?QUEUE}"
+LOG=$TASK/logs/sample_lockwait_$(basename "$QUEUE" .txt)_$(date +%Y%m%dT%H%M%S).log
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+got=$(sha256sum "$CKPT" | cut -d' ' -f1)
+[[ "$got" == "$CKPT_SHA" ]] || { log "ABORT: checkpoint sha ${got:0:12} != ${CKPT_SHA:0:12}"; exit 1; }
+n_fail=0
+while IFS='|' read -r kind tag ck cond seed out; do
+  [[ -z "${kind// }" || "$kind" == \#* ]] && continue
+  [[ "$kind" == sample && "$ck" == base ]] || { log "skip non-base line: $kind|$tag"; continue; }
+  rec=${out%.npz}.log; err=${out%.npz}.err
+  if [[ -s "$rec" && -s "$out" ]]; then log "$tag already sampled; skipped"; continue; fi
+  systemctl --user is-active --quiet ml-memory-guard.service || { log "ABORT: memory guard inactive"; exit 1; }
+  avail=$(awk '/MemAvailable/ {print int($2 / 1048576)}' /proc/meminfo)
+  (( avail >= 32 )) || { log "ABORT: MemAvailable ${avail} GiB < 32"; exit 1; }
+  until verdict=$(bash "$M8/plans/floor01_campaign_20260923/tools/thermal_guard.sh"); do sleep 60; done
+  mkdir -p "$(dirname "$out")"
+  log "--- $tag seed=$seed ($verdict; MemAvailable ${avail} GiB; waiting on the GPU lock)"
+  if "$HOME/.local/bin/ml-run" /usr/bin/env CUDA_VISIBLE_DEVICES=0 PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True \
+       PYTHONPATH="$M8/src" OMP_NUM_THREADS=4 "$PY" -u "$M8/scripts/sample_sdd_standalone.py" \
+       --checkpoint "$CKPT" --condition-npz "$cond" --output "$out" --weights ema --batch-size 256 \
+       --steps 50 --seed "$seed" --device cuda --conditioner-source embedded \
+       --active-logit-threshold 0.0 --support-readout bernoulli > "$rec" 2> "$err"; then
+    log "$tag done: $(python3 -c "import json;d=json.load(open('$rec'));print('rows', d.get('generated_counts_rows','?'), 'zero_frac %.4f' % d.get('generated_zero_fraction',-1), d.get('output_sha256','')[:12])" 2>/dev/null)"
+  else
+    n_fail=$((n_fail+1)); log "WARN: $tag failed (see $err)"; rm -f "$rec"
+  fi
+done < "$QUEUE"
+log "finished: failed=$n_fail"
+(( n_fail == 0 ))