Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261001T023742Z-deck-calibration-giroux-sexgenes/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/rescore_excluding_genes.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""Re-run earlier score_ft.py calls with --exclude-genes, reusing their frozen scANVI labels (--reuse-labels).
+
+CPU only. For every source score dir (e.g. scores/giroux2022/pooled, scores/giroux2022/fewshot_n5/draw0_scsemi5) the
+exact command recorded in its summary.json is replayed through tools/run_unit.sh with only three changes:
+  --out <OUT_ROOT>/<path of the source dir below scores/>   (new directory; the source is never written)
+  --exclude-genes CSV
+  --reuse-labels <source dir>
+Optional --arms keeps a subset of the recorded arms. Optional --npz-map OLD=NEW reads generated NPZs (and their
+receipts / condition NPZs) from a copy, e.g. after tools/move_generated.sh moved them to the other host; the condition
+NPZ is then passed with --condition and its sha256 is checked here against the generation metadata.
+An output dir that already has a summary.json is skipped.
+
+usage: rescore_excluding_genes.py --exclude CSV --out-root DIR [--arms a,b] [--npz-map OLD=NEW] [--dry-run] SRC_DIR ...
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import numpy as np
+
+T = Path("/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"
+
+
+def sha(p: Path) -> str:
+    h = hashlib.sha256()
+    with open(p, "rb") as fh:
+        for b in iter(lambda: fh.read(1 << 22), b""):
+            h.update(b)
+    return h.hexdigest()
+
+
+def remap(path: str, npz_map: tuple[str, str] | None) -> str:
+    if npz_map and path.startswith(npz_map[0]):
+        return npz_map[1] + path[len(npz_map[0]):]
+    return path
+
+
+def build(src: Path, a) -> tuple[list[str], Path, int]:
+    s = json.loads((src / "summary.json").read_text())
+    cmd = list(s["command"])
+    if Path(cmd[0]).resolve() != (T / "tools" / "score_ft.py").resolve():
+        raise SystemExit(f"{src}: recorded command is not tools/score_ft.py: {cmd[0]}")
+    out = a.out_root / src.resolve().relative_to((T / "scores").resolve())
+    keep_arms = set(a.arms.split(",")) if a.arms else None
+    args, i, threads, conds = [], 1, 8, []
+    while i < len(cmd):
+        k = cmd[i]
+        if k in ("--out", "--exclude-genes", "--reuse-labels"):
+            i += 2
+            continue
+        if k == "--threads":
+            threads = int(cmd[i + 1])
+        if k == "--arm":
+            name, _, path = cmd[i + 1].partition("=")
+            if keep_arms is not None and name not in keep_arms:
+                i += 2
+                continue
+            new = remap(path, a.npz_map)
+            if new != path:
+                meta = json.loads(str(np.load(new, allow_pickle=False)["metadata_json"]))
+                cpath, csha = meta["input_condition_path"], meta["input_condition_sha256"]
+                cnew = remap(cpath, a.npz_map)
+                if not Path(cnew).is_file() or sha(Path(cnew)) != csha:
+                    raise SystemExit(f"{name}: condition copy {cnew} missing or sha differs from the generation metadata")
+                conds += ["--condition", f"{name}={cnew}"]
+            args += ["--arm", f"{name}={new}"]
+            i += 2
+            continue
+        args.append(k)
+        i += 1
+    if keep_arms is not None and len([x for x in args if x == "--arm"]) != len(keep_arms):
+        raise SystemExit(f"{src}: not every requested arm is in the recorded command")
+    args += conds + ["--out", str(out), "--exclude-genes", str(a.exclude), "--reuse-labels", str(src)]
+    return args, out, threads
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--exclude", type=Path, required=True)
+    p.add_argument("--out-root", type=Path, required=True)
+    p.add_argument("--arms", default=None)
+    p.add_argument("--npz-map", default=None, help="OLD_PREFIX=NEW_PREFIX for generated NPZ paths")
+    p.add_argument("--dry-run", action="store_true")
+    p.add_argument("src", nargs="+", type=Path)
+    a = p.parse_args()
+    a.npz_map = tuple(a.npz_map.split("=", 1)) if a.npz_map else None
+    a.exclude = a.exclude.resolve()
+    a.out_root = a.out_root.resolve()
+    if a.out_root.resolve() == (T / "scores").resolve():
+        raise SystemExit("--out-root must not be scores/ (never overwrite the original scores)")
+    rc = 0
+    for src in a.src:
+        args, out, threads = build(src.resolve(), a)
+        if (out / "summary.json").exists():
+            print(f"skip (done): {out}")
+            continue
+        unit = (a.out_root.name + "-" + "-".join(out.relative_to(a.out_root).parts))[-70:]
+        line = ["bash", str(T / "tools" / "run_unit.sh"), unit, str(threads), PY, str(T / "tools" / "score_ft.py")] + args
+        print(" ".join(line), flush=True)
+        if a.dry_run:
+            continue
+        out.mkdir(parents=True, exist_ok=True)
+        r = subprocess.run(line)
+        if r.returncode != 0:
+            print(f"FAILED rc={r.returncode}: {src}", flush=True)
+            rc = 1
+    return rc
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261001T023742Z-deck-calibration-giroux-sexgenes/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/run_chain.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+# Run several queues one after another with one runner (run_queue.sh on server_1, run_queue_s2.sh on server_2); each
+# runner takes one dataset, so a host with queues of two datasets chains them here.  A failed queue does not stop the
+# chain; finished steps are skipped by the runners, so a rerun resumes.  GPU steps go through ml-run inside the runner.
+# usage: run_chain.sh RUNNER DATASET:QUEUE_NAME [DATASET:QUEUE_NAME ...]     (RUNNER = run_queue.sh | run_queue_s2.sh)
+set -uo pipefail
+T=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927
+runner=$1; shift
+[[ -f $T/tools/$runner ]] || { echo "no runner $runner" >&2; exit 2; }
+rc=0
+for spec in "$@"; do
+  ds=${spec%%:*}; q=${spec#*:}
+  [[ -s $T/queues/$q.txt && -d $T/data/$ds ]] || { echo "bad spec $spec" >&2; rc=1; continue; }
+  echo "$(date +%FT%T) chain: $q ($ds) with $runner on $(hostname -s)"
+  QUEUE=$T/queues/$q.txt DATASET_DIR=$T/data/$ds bash "$T/tools/$runner" || rc=1
+done
+echo "$(date +%FT%T) chain finished rc=$rc"
+exit $rc

paper-releases/pbisc-diffusion/updates/20261001T023742Z-deck-calibration-giroux-sexgenes/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/score_arms.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+# Score a chosen set of finished arms of one dataset into a NEW output dir, leaving the existing
+# scores/<dataset>/{fold<k>,pooled,pooled_deg}/ untouched (score_ft.py rewrites summary.json/per_donor.csv of its --out).
+# Same scorer, same per-dataset contrast arguments (contrast_args.sh), same CPU unit (run_unit.sh, 8 threads) as
+# score_fold.sh / score_pooled.sh.  Every arm's metrics depend only on the scored donors (fixed per-donor seeds), so
+# arms scored here line up with the existing per-fold / pooled arms of the same donors.  With a contrast (sepsis) the
+# current scorer also writes the top-50 DEG score, i.e. the pooled_deg metrics.
+# Waits until MemAvailable >= 56 GiB (run_unit.sh refuses below).  An OUT_DIR that already has summary.json is skipped.
+# usage: score_arms.sh DATASET GEN_DIR OUT_DIR UNIT_NAME ARM [ARM ...]     (arm = NPZ basename without .npz)
+set -uo pipefail
+T=/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
+(( $# >= 5 )) || { echo "usage: score_arms.sh DATASET GEN_DIR OUT_DIR UNIT_NAME ARM [ARM ...]" >&2; exit 2; }
+ds=$1; gen=$2; out=$3; name=$4; shift 4
+[[ -s $out/summary.json ]] && { echo "$out already scored; not overwriting"; exit 0; }
+args=()
+for arm in "$@"; do
+  npz=$gen/$arm.npz; rec=$gen/$arm.log
+  if [[ ! -s $npz ]]; then
+    echo "missing $npz$([[ -f $gen/$arm.moved ]] && echo " ($(cat "$gen/$arm.moved"))")" >&2; exit 2
+  fi
+  grep -q '"output_sha256"' "$rec" 2>/dev/null || { echo "no finished receipt $rec" >&2; exit 2; }
+  args+=(--arm "$arm=$npz")
+done
+read -r -a cargs <<< "$(bash "$T/tools/contrast_args.sh" "$ds")"
+until (( $(awk '/MemAvailable/ {print int($2/1048576)}' /proc/meminfo) >= 56 )); do sleep 120; done
+mkdir -p "$out"
+echo "scoring ${#args[@]} arg(s) -> $out"
+bash "$T/tools/run_unit.sh" "$name" 8 "$PY" "$T/tools/score_ft.py" --dataset "$ds" --out "$out" --threads 8 \
+  "${args[@]}" "${cargs[@]}"

paper-releases/pbisc-diffusion/updates/20261001T023742Z-deck-calibration-giroux-sexgenes/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/score_ft.py

@@ -0,0 +1,827 @@
+#!/usr/bin/env python3
+"""Score generated cells of held-out donors against the same donors' observed cells (fine-tuning benchmark).
+
+CPU only.  Run through tools/run_unit.sh (systemd user unit, CUDA hidden, <= 8 threads).
+
+  # once per dataset (observed reference cache, ~tens of MB, independent of folds and arms)
+  score_ft.py --dataset immicro --build-reference [--cells-source auto|datadir|immicro_h5ad]
+
+  # score one or more arms on the same donors
+  score_ft.py --dataset immicro --out DIR --arm raw=GEN_raw.npz --arm ft_realbulk=GEN_ft.npz
+              [--donors HS1,HS2,... | --donors donors.txt] [--threads 8]
+              [--groups-csv FILE] [--case-groups A,B] [--control-groups C] [--no-contrast]
+              [--condition ARM=COND.npz] [--allow-no-receipt]
+
+Donors: default = the sample_ids of the NPZs; then every arm must have exactly the same sample_ids.  With --donors,
+every arm must contain all of them (it may hold more, e.g. a zero-shot NPZ over all donors).
+
+Per arm (definitions in the README.md written to DIR):
+  one Poisson read-out of generated_counts over the WHOLE NPZ (seed 20260916, poisson_integerise), then the scored
+  donors' cells; frozen f01common scANVI six-type labels from those integer counts (predict_scanvi.py, CPU);
+  composition + L1 + observed LOO null; pseudobulk r + closest-donor top-1 (evaluate_realbulk statistic, among the
+  scored donors); precision/coverage/density (PCA-50 + k = 10 balls fitted on the scored donors' observed R1 cells) and
+  the depth-matched version; monocyte %; median UMI per cell; per-cell-type group contrast logFC r with the bulk
+  broadcast baseline; the benchmark's top-50 DEG overlap per cell type (T, B, Monocyte, NK, DC) and its bulk-broadcast
+  analogue (on by default whenever the contrast is on; --no-deg skips it).
+Outputs in DIR: per_donor.csv, summary.json, contrast.csv (when a contrast is defined), README.md,
+                arms/<arm>/{labels/, predict_scanvi.log, generated_cells.parquet, deg_top50_lists.csv}.
+
+  # once per existing reference cache: donor x type aggregates incl. DC for the DEG score (new caches get it built in)
+  score_ft.py --dataset ye2026_sepsis --build-deg-reference
+
+Optional (added 2026-10-01; without them the scorer behaves exactly as before):
+  --exclude-genes CSV   genes (column gene_id) dropped from the disease-signal scores only: the group-contrast logFC r,
+                        its broadcast r and partial r (removed from each type's detected-gene set), and the top-50 DEG
+                        tests of the observed, generated and broadcast sides (columns removed before the Welch test, so
+                        log1p-CPM libraries and BH run on the kept genes). Composition, precision/coverage, pseudobulk r
+                        and depth are unchanged. Used for Giroux, whose severity is confounded with sex.
+  --reuse-labels DIR    take each arm's frozen scANVI labels from an earlier score_ft.py output DIR (arms/<arm>/labels)
+                        instead of running predict_scanvi.py; requires the same reference, NPZ sha256 and scored donors.
+"""
+from __future__ import annotations
+
+import os
+
+for _k in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS", "NUMBA_NUM_THREADS"):
+    os.environ.setdefault(_k, "8")
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+
+import argparse  # noqa: E402
+import json  # noqa: E402
+import shutil  # noqa: E402
+import sys  # 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
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import ft_common as F  # noqa: E402
+
+MAX_THREADS = 8
+
+
+# --------------------------------------------------------------------------- scored-donor view of the reference
+def make_view(ref: dict, donors: list[str]) -> dict:
+    """Observed side restricted to the scored donors; PCA-50 + k-NN radii fitted on their R1 cells only."""
+    from sklearn.decomposition import PCA
+    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 dataset reference: {miss[:5]}")
+    sel = np.asarray([pos[d] for d in donors], dtype=np.int64)
+    S = sel.size
+    remap = np.full(ref["donors"].size, -1, dtype=np.int64)
+    remap[sel] = np.arange(S)
+    v = {"donors": np.asarray(donors, dtype=str), "sel": sel, "groups": ref["groups"][sel].astype(str),
+         "n_cells": ref["n_cells"][sel], "n_ref": ref["n_ref"][sel], "comp": ref["composition"][sel],
+         "pb": ref["pseudobulk"][sel].astype(np.float64)}
+    for p in ("r1", "r2"):
+        m = remap[ref[f"{p}_donor"]] >= 0
+        v[p.upper()] = ref[p][np.flatnonzero(m)].tocsr()
+        v[f"{p}_d"] = remap[ref[f"{p}_donor"][m]]
+    cm = remap[ref["cell_donor"]] >= 0
+    v["cell_lib"], v["cell_d"] = ref["cell_lib"][cm].astype(np.float64), remap[ref["cell_donor"][cm]]
+    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["score_ids"] = [str(g) for g in ref["score_ids"]]
+    if "deg" in ref:  # DEG aggregates (F.load_deg_reference), attached by main
+        v["deg_types"] = tuple(ref["deg"]["types"])
+        v["deg_n"], v["deg_sum"] = ref["deg"]["n"][sel], ref["deg"]["sum"][sel]
+    X1 = F.SB.cp10k_log1p(v["R1"])
+    ncomp = int(min(F.PCA_DIM, X1.shape[0] - 1, X1.shape[1]))
+    pca = PCA(n_components=ncomp, svd_solver="randomized", random_state=F.SUB_SEED).fit(X1)
+    v["mean"], v["comps"] = pca.mean_.astype(np.float32), pca.components_.astype(np.float32)
+    v["z1"] = ((X1 - v["mean"]) @ v["comps"].T).astype(np.float32)
+    v["radius"] = F.SB.knn_radius(v["z1"], F.K_NN)
+    v["pca"] = {"n_components": ncomp, "explained_variance_ratio_sum": float(pca.explained_variance_ratio_.sum()),
+                "n_fit_cells": int(X1.shape[0])}
+    del X1
+    z2 = F.SB.project(v["R2"], v["mean"], v["comps"])
+    pc2 = F.SB.precision_coverage(v["z1"], v["radius"], z2)
+    dm2 = depth_matched(v, v["R2"], v["r2_d"])
+    v["r2_control"] = {"precision": pc2["precision"], "coverage": pc2["coverage"], "density": pc2["density"],
+                       "n_query": int(z2.shape[0]),
+                       "depth_matched": {k: dm2[k] for k in ("precision", "coverage", "density")}}
+    v["obs_lib_median_d"] = np.asarray([np.median(v["cell_lib"][v["cell_d"] == s]) for s in range(S)])
+    return v
+
+
+def depth_matched(v: dict, Q: sp.csr_matrix, q_d: np.ndarray) -> dict:
+    """stage_b_embed depth matching, pairwise (R1 vs one query set): per donor and within-donor rank of detected genes,
+    both cells are thinned (UMI sampling without replacement) to the smaller detected-gene count; the PCA is the one
+    fitted on the un-thinned R1; k = 10 radii are recomputed on the thinned R1.  Fresh rng(20260925 + 4) per call."""
+    names = v["donors"]
+    thinned, summ = F.SB.depth_match({"R1": v["R1"], "Q": Q}, {"R1": names[v["r1_d"]], "Q": names[q_d]}, list(names),
+                                     np.random.default_rng(F.DEPTH_SEED))
+    z1 = F.SB.project(thinned["R1"], v["mean"], v["comps"])
+    zq = F.SB.project(thinned["Q"], v["mean"], v["comps"])
+    radius = F.SB.knn_radius(z1, F.K_NN)
+    r = F.SB.precision_coverage(z1, radius, zq)
+    r["summary"] = summ
+    return r
+
+
+# --------------------------------------------------------------------------- --exclude-genes (disease-signal scores only)
+def gene_exclusion(path: Path, score_ids: list[str]) -> tuple[np.ndarray, dict]:
+    """keep mask over the scoring genes (False = listed in the CSV's gene_id column) and its summary block."""
+    g = pd.read_csv(path, dtype=str)
+    if "gene_id" not in g.columns:
+        raise SystemExit(f"{path}: needs a gene_id column")
+    listed = set(g.gene_id.str.strip())
+    keep = np.asarray([s not in listed for s in score_ids], dtype=bool)
+    sym = dict(zip(g.gene_id, g.symbol)) if "symbol" in g.columns else {}
+    dropped = [s for s, k in zip(score_ids, keep) if not k]
+    return keep, {"file": str(path), "sha256": F.sha(path), "n_listed": len(listed),
+                  "n_scoring_genes": len(score_ids), "n_dropped_from_scoring_genes": len(dropped),
+                  "n_scoring_genes_kept": int(keep.sum()),
+                  "dropped": [{"gene_id": s, "symbol": sym.get(s, "")} for s in dropped],
+                  "applies_to": "group contrast (logFC r generated / broadcast / partial: dropped from each type's "
+                                "detected-gene set) and top-50 DEG (observed, generated and broadcast tests: columns "
+                                "dropped before log1p CPM, Welch and BH); all other metrics use every scoring gene"}
+
+
+def keep_cols(v: dict, M: np.ndarray) -> np.ndarray:
+    """The scoring-gene columns (last axis) kept by --exclude-genes; M itself when no genes are excluded."""
+    return M if "keep" not in v else M[..., v["keep"]]
+
+
+def keep_genes(v: dict) -> list:
+    return v["score_ids"] if "keep" not in v else [g for g, k in zip(v["score_ids"], v["keep"]) if k]
+
+
+# --------------------------------------------------------------------------- --reuse-labels
+def reused_labels(prev: Path, name: str, arm: dict, ref_sha: str, donors: np.ndarray, sel: np.ndarray,
+                  gen_d: np.ndarray, work: Path) -> tuple[pd.DataFrame, dict]:
+    """Frozen labels of an earlier score_ft.py call on the same NPZ and scored donors (no predict_scanvi.py run).
+    The Poisson read-out and the row order depend only on the NPZ and the donor list, so that call labelled exactly
+    these cells. Checked: reference sha, NPZ sha256, donor list and order, NPZ rows and donors of its
+    generated_cells.parquet, labels row-aligned and equal to the parquet's, annotator model sha."""
+    s = json.loads((prev / "summary.json").read_text())
+    pa = s.get("per_arm", {}).get(name)
+    if pa is None:
+        raise SystemExit(f"--reuse-labels {prev}: no arm {name}")
+    if s["reference"]["reference_sha256"] != ref_sha:
+        raise SystemExit(f"--reuse-labels {prev}: reference sha differs")
+    if pa["npz_sha256"] != arm["sha256"]:
+        raise SystemExit(f"--reuse-labels {prev}: {name} NPZ sha differs from {arm['path']}")
+    if [str(x) for x in s["donors"]] != [str(x) for x in donors]:
+        raise SystemExit(f"--reuse-labels {prev}: scored donors differ")
+    gc = pd.read_parquet(prev / "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(), donors[gen_d])):
+        raise SystemExit(f"--reuse-labels {prev}: {name} generated cells differ (NPZ rows / donors)")
+    ldir = prev / "arms" / name / "labels"
+    lab = pd.read_parquet(ldir / "labels.parquet")
+    if len(lab) != sel.size or not np.array_equal(lab.cell_index.to_numpy(), np.arange(sel.size)) \
+            or not np.array_equal(lab.celltype_l1_pred.astype(str).to_numpy(), gc.label.astype(str).to_numpy()):
+        raise SystemExit(f"--reuse-labels {prev}: {name} labels are not row-aligned with its generated cells")
+    man = json.loads((ldir / "labels.manifest.json").read_text())
+    if man["model"]["model_pt_sha256"] != F.ANNOT_MODEL_SHA or pa["annotation"]["model_pt_sha256"] != F.ANNOT_MODEL_SHA:
+        raise SystemExit(f"--reuse-labels {prev}: annotator model sha differs from the f01common model")
+    (work / "labels").mkdir(parents=True, exist_ok=True)
+    for f in ("labels.parquet", "labels.manifest.json"):
+        shutil.copy2(ldir / f, work / "labels" / f)
+    info = {**pa["annotation"], "reused_from": str(ldir), "reused_labels_sha256": F.sha(ldir / "labels.parquet")}
+    F.log(f"{name}: labels reused from {ldir} (no predict_scanvi.py run)")
+    return lab, info
+
+
+# --------------------------------------------------------------------------- contrast definition
+def resolve_contrast(spec: F.DatasetSpec, v: dict, a) -> dict:
+    groups = v["groups"].copy()
+    source = "features groups"
+    if a.groups_csv:
+        g = pd.read_csv(a.groups_csv, dtype=str)
+        if not {"sample_id", "group"} <= set(g.columns):
+            raise SystemExit(f"{a.groups_csv}: needs columns sample_id, group")
+        m = g.set_index("sample_id").group.reindex(v["donors"])
+        if m.isna().any():
+            raise SystemExit(f"{a.groups_csv}: no group for {list(v['donors'][m.isna().to_numpy()][:5])}")
+        groups, source = m.astype(str).to_numpy(), f"groups csv {a.groups_csv}"
+    if a.no_contrast:
+        return {"enabled": False, "reason": "--no-contrast"}
+    case = a.case_groups.split(",") if a.case_groups else None
+    ctrl = a.control_groups.split(",") if a.control_groups else None
+    uniq = sorted(set(groups.tolist()))
+    if case is None and ctrl is None:
+        if spec.contrast == "none" and not a.groups_csv:
+            return {"enabled": False, "reason": f"dataset {spec.name} has no group contrast (use --groups-csv / --case-groups)"}
+        ctrl = [g for g in uniq if F.CONTROL_RE.search(g)]
+        case = [g for g in uniq if g not in ctrl]
+        rule = f"auto: control = groups matching /{F.CONTROL_RE.pattern}/, case = all other groups"
+    else:
+        if case is None:
+            case = [g for g in uniq if g not in ctrl]
+        if ctrl is None:
+            ctrl = [g for g in uniq if g not in case]
+        rule = "explicit --case-groups / --control-groups"
+    cm, hm = np.isin(groups, case), np.isin(groups, ctrl)
+    if (cm & hm).any():
+        raise SystemExit("a group is both case and control")
+    out = {"enabled": bool(cm.any() and hm.any()), "rule": rule, "group_source": source, "case_groups": case,
+           "control_groups": ctrl, "n_case_donors": int(cm.sum()), "n_control_donors": int(hm.sum()),
+           "n_donors_in_neither": int((~cm & ~hm).sum()), "case": cm, "ctrl": hm, "groups": groups}
+    if not out["enabled"]:
+        out["reason"] = "scored donors do not include both groups"
+    return out
+
+
+# --------------------------------------------------------------------------- one arm
+def open_arm(name: str, path: Path, panel_ids: np.ndarray, allow_no_receipt: bool) -> dict:
+    if not path.is_file():
+        moved = path.with_suffix(".moved")
+        raise SystemExit(f"{name}: {path} missing" + (f" ({moved} says it was moved)" if moved.exists() else ""))
+    npz_sha = F.sha(path)
+    rec_path = path.with_suffix(".log")
+    receipt = None
+    if rec_path.is_file() and rec_path.stat().st_size:
+        try:
+            receipt = json.loads(rec_path.read_text())
+        except json.JSONDecodeError:
+            receipt = None
+    if receipt is None and not allow_no_receipt:
+        raise SystemExit(f"{name}: no JSON generation receipt at {rec_path}; --allow-no-receipt to override")
+    if receipt is not None and receipt.get("output_sha256") not in (None, npz_sha):
+        raise SystemExit(f"{name}: NPZ sha256 differs from its generation receipt (partial or replaced file)")
+    d = np.load(path, allow_pickle=False)
+    if not np.array_equal(d["gene_ids"].astype(str), panel_ids):
+        raise SystemExit(f"{name}: NPZ gene_ids differ from the 6k panel")
+    meta = json.loads(str(d["metadata_json"])) if "metadata_json" in d.files else {}
+    cond = meta.get("input_condition_path") or (receipt or {}).get("condition_npz")
+    return {"name": name, "path": path, "d": d, "sha256": npz_sha, "receipt": receipt,
+            "receipt_verified": bool(receipt and receipt.get("output_sha256") == npz_sha),
+            "sample_ids": d["sample_ids"].astype(str), "bulk_index": d["bulk_index"].astype(np.int64), "meta": meta,
+            "condition": cond, "condition_sha256": meta.get("input_condition_sha256") or (receipt or {}).get("condition_sha256")}
+
+
+def load_condition_bulk(path: str | None, expect_sha: str | None, donors: np.ndarray, score_ids: np.ndarray) -> dict:
+    if not path or not Path(path).is_file():
+        raise SystemExit(f"condition NPZ not found: {path} (pass --condition ARM=PATH or --no-contrast)")
+    s = F.sha(Path(path))
+    if expect_sha and s != expect_sha:
+        raise SystemExit(f"{path}: sha differs from the generation metadata")
+    z = np.load(path, allow_pickle=False)
+    ids = z["sample_ids"].astype(str)
+    pos = {x: i for i, x in enumerate(ids)}
+    miss = [x for x in donors if x not in pos]
+    if miss:
+        raise SystemExit(f"{path}: no bulk for {miss[:5]}")
+    gpos = {g: i for i, g in enumerate(z["gene_ids"].astype(str))}
+    gm = [g for g in score_ids if g not in gpos]
+    if gm:
+        raise SystemExit(f"{path}: {len(gm)} scoring genes absent")
+    bulk = np.asarray(z["bulk_counts"], np.float64)[[pos[x] for x in donors]][:, [gpos[g] for g in score_ids]]
+    return {"bulk": bulk, "path": str(path), "sha256": s}
+
+
+def observed_deg(v: dict, contrast: dict) -> dict:
+    """Observed top-50 lists per DEG type (independent of the arm): F.deg_top on the observed donor x type sums."""
+    case, ctrl = contrast["case"], contrast["ctrl"]
+    out = {}
+    for ti, t in enumerate(v["deg_types"]):
+        d = F.deg_top(v["deg_n"][:, ti], keep_cols(v, v["deg_sum"][:, ti]), case, ctrl, keep_genes(v))
+        d["n_cells"] = int(v["deg_n"][case | ctrl, ti].sum())
+        out[t] = d
+    return out
+
+
+def deg_block(v: dict, obs: dict, ga: dict, Xg, gen_d, gen_lab, bulk, contrast: dict) -> tuple[list, dict]:
+    """contrast.csv rows (statistic welch_top50_deg) and the summary block of the top-50 DEG overlap of one arm.
+    A type is scored when the observed Welch test is defined (>= 2 case and >= 2 control donors with a cell of the
+    type); an arm whose generated test is undefined there gets an empty list, i.e. overlap 0 (EV semantics)."""
+    t0 = time.monotonic()
+    S = v["donors"].size
+    case, ctrl = contrast["case"], contrast["ctrl"]
+    genes = keep_genes(v)
+    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
+    blk = F.deg_top(np.ones(S, np.int64), keep_cols(v, bulk), case, ctrl, genes) if bulk is not None else None
+    rows, per, lists = [], {}, []
+    for t in v["deg_types"]:
+        if t in F.CONTRAST_TYPES:
+            n_g, s_g = ga["n"][:, F.CONTRAST_TYPES.index(t)], keep_cols(v, ga["sum"][:, F.CONTRAST_TYPES.index(t)])
+        else:
+            n_g, s_g = gx["n"][:, extra.index(t)], keep_cols(v, gx["sum"][:, extra.index(t)])
+        od, gd = obs[t], F.deg_top(n_g, s_g, case, ctrl, genes)
+        ov = F.deg_overlap(od["top"], gd["top"])
+        bo = F.deg_overlap(od["top"], blk["top"]) if blk is not None else {"overlap": None, "jaccard": float("nan")}
+        row = {"celltype": t, "statistic": F.DEG_STATISTIC, "n_genes": len(genes), "deg_scored": od["defined"],
+               "top50_overlap": ov["overlap"], "top50_jaccard": ov["jaccard"],
+               "obs_top_list_size": len(od["top"]), "gen_top_list_size": len(gd["top"]),
+               "n_sig_obs": od["n_significant"], "n_sig_gen": gd["n_significant"],
+               "top50_overlap_broadcast": bo["overlap"], "top50_jaccard_broadcast": bo["jaccard"],
+               "broadcast_top_list_size": len(blk["top"]) if blk is not None else None,
+               "n_sig_broadcast": blk["n_significant"] if blk is not None else None,
+               "n_case_donors_obs": od["n_case_donors"], "n_control_donors_obs": od["n_control_donors"],
+               "n_case_donors_gen": gd["n_case_donors"], "n_control_donors_gen": gd["n_control_donors"],
+               "n_cells_obs": od["n_cells"], "n_cells_gen": int(n_g[case | ctrl].sum())}
+        rows.append(row)
+        per[t] = {k: (None if isinstance(row[k], float) and np.isnan(row[k]) else row[k])
+                  for k in ("deg_scored", "top50_overlap", "top50_jaccard", "obs_top_list_size", "gen_top_list_size",
+                            "top50_overlap_broadcast", "top50_jaccard_broadcast", "n_cells_obs", "n_cells_gen")}
+        for src, lst in (("observed", od["top"]), ("generated", gd["top"])):
+            lists += [{"celltype": t, "source": src, "rank": i + 1, "gene_id": g} for i, g in enumerate(lst)]
+    if blk is not None:
+        lists += [{"celltype": "all (input bulk)", "source": "broadcast", "rank": i + 1, "gene_id": g}
+                  for i, g in enumerate(blk["top"])]
+    scored = [t for t in v["deg_types"] if obs[t]["defined"]]
+    four = [t for t in scored if t in F.CONTRAST_TYPES]
+
+    def tot(key, ts):
+        return None if key == "top50_overlap_broadcast" and blk is None else int(sum(per[t][key] for t in ts))
+
+    block = {"types_scored": scored,
+             "types_not_scored": {t: "observed Welch test undefined (< 2 case or < 2 control donors with a cell)"
+                                  for t in v["deg_types"] if not obs[t]["defined"]},
+             "per_type": per, "sum": tot("top50_overlap", scored), "sum_4type": tot("top50_overlap", four),
+             "max": tot("obs_top_list_size", scored), "mean": float(np.mean([per[t]["top50_overlap"] for t in scored]))
+             if scored else None,
+             "sum_broadcast": tot("top50_overlap_broadcast", scored), "sum_broadcast_4type": tot("top50_overlap_broadcast", four),
+             "broadcast_n_significant": blk["n_significant"] if blk is not None else None,
+             "seconds": round(time.monotonic() - t0, 2), "_lists": lists}
+    return rows, block
+
+
+def arm_metrics(v: dict, Xg: sp.csr_matrix, gen_d: np.ndarray, gen_lab: np.ndarray, gen_pb: np.ndarray,
+                bulk: np.ndarray | None, contrast: dict, obs_deg: dict | None = None) -> tuple[pd.DataFrame, dict, list, np.ndarray]:
+    """All metrics of one arm from arrays: Xg = Poisson-read counts on the scoring genes (scored donors' cells),
+    gen_d = scored-donor index per cell, gen_lab = frozen six-type label per cell, gen_pb = summed generated_counts
+    per scored donor on the scoring genes, bulk = condition bulk_counts per scored donor on the scoring genes,
+    obs_deg = observed_deg(v, contrast) (None: no top-50 DEG score)."""
+    donors = v["donors"]
+    S = donors.size
+    counts_per = np.bincount(gen_d, minlength=S)
+    if (counts_per == 0).any():
+        raise SystemExit(f"scored donors without generated cells: {list(donors[counts_per == 0][:5])}")
+    # 1. composition
+    gc = F.IC.composition(pd.Series(gen_lab), pd.Series(donors[gen_d]), donors).to_numpy()
+    oc = v["comp"]
+    l1 = F.IC.l1(gc, oc)
+    null = F.IC.l1(oc, F.lodo_mean(oc, v["donor_of"])) if S > 1 else np.full(S, np.nan)
+    gen_loo = F.IC.l1(F.lodo_mean(gc, v["donor_of"]), oc) if S > 1 else np.full(S, np.nan)
+    pair = np.abs(gc[:, None, :] - oc[None, :, :]).sum(-1)
+    # 2. pseudobulk agreement + closest donor among the scored donors
+    obs = F.IC.ER.cpm_log1p(v["pb"])
+    gen = F.IC.ER.cpm_log1p(gen_pb)
+    rr = F.IC.retrieval(gen, obs, np.arange(S))
+    paired = F.IC.ER.paired_r(gen, obs)
+    # 3. precision / coverage (+ depth matched)
+    sub = []
+    for s in range(S):
+        rs = np.flatnonzero(gen_d == s)
+        sub.append(rs[F.generated_subsample(rs.size, int(v["n_ref"][s]), donors[s])])
+    sub = np.concatenate(sub)
+    Q, q_d = Xg[sub].tocsr(), gen_d[sub]
+    zq = F.SB.project(Q, v["mean"], v["comps"])
+    pc = F.SB.precision_coverage(v["z1"], v["radius"], zq)
+    dm = depth_matched(v, Q, q_d)
+    nq = np.bincount(q_d, minlength=S)
+    n1 = np.bincount(v["r1_d"], minlength=S)
+    per_prec = np.bincount(q_d, weights=pc["inside"], minlength=S) / nq
+    per_cov = np.bincount(v["r1_d"], weights=pc["covered"], minlength=S) / n1
+    per_prec_dm = np.bincount(q_d, weights=dm["inside"], minlength=S) / nq
+    per_cov_dm = np.bincount(v["r1_d"], weights=dm["covered"], minlength=S) / n1
+    # 4. monocyte %, median UMI per cell (scoring genes)
+    mj = F.GATE.index("Monocyte")
+    glib = np.asarray(Xg.sum(axis=1)).ravel()
+    med_gen = np.asarray([np.median(glib[gen_d == s]) for s in range(S)])
+    per = pd.DataFrame({"donor": donors, "group": v["groups"], "n_generated_cells": counts_per,
+                        "n_observed_cells": v["n_cells"], "n_reference_cells": v["n_ref"]})
+    for j, g in enumerate(F.GATE):
+        per[f"gen_{g}"] = gc[:, j]
+        per[f"obs_{g}"] = oc[:, j]
+    per["comp_l1"] = l1
+    per["comp_l1_obs_loo_null"] = null
+    per["pb_r"] = paired
+    per["pb_own_rank"] = rr["rank"]
+    per["pb_top1"] = rr["rank"] == 1
+    per["precision"] = per_prec
+    per["coverage"] = per_cov
+    per["precision_depth_matched"] = per_prec_dm
+    per["coverage_depth_matched"] = per_cov_dm
+    per["mono_pct_gen"] = 100 * gc[:, mj]
+    per["mono_pct_obs"] = 100 * oc[:, mj]
+    per["median_umi_gen"] = med_gen
+    per["median_umi_obs"] = v["obs_lib_median_d"]
+    summ = {
+        "n_donors": int(S), "n_generated_cells": int(gen_d.size),
+        "composition": {"l1_mean": float(l1.mean()), "l1_median": float(np.median(l1)),
+                        "l1_obs_loo_null_mean": float(np.nanmean(null)) if S > 1 else None,
+                        "l1_generated_loo_mean_vs_observed_mean": float(np.nanmean(gen_loo)) if S > 1 else None,
+                        "composition_top1": float((pair.argmin(1) == np.arange(S)).mean()),
+                        "mean_fraction_generated": dict(zip(F.GATE, gc.mean(0).round(6).tolist())),
+                        "mean_fraction_observed": dict(zip(F.GATE, oc.mean(0).round(6).tolist()))},
+        "pseudobulk": {"n_genes": int(gen.shape[1]), "r_median": float(np.median(paired)), "r_mean": float(paired.mean()),
+                       "top1": float(rr["top1"]), "n_top1": int((rr["rank"] == 1).sum()),
+                       "own_rank_median": float(np.median(rr["rank"])), "chance_top1": 1.0 / S},
+        "precision_coverage": {"precision": pc["precision"], "coverage": pc["coverage"], "density": pc["density"],
+                               "n_query": int(zq.shape[0]), "n_reference": int(v["z1"].shape[0])},
+        "precision_coverage_depth_matched": {"precision": dm["precision"], "coverage": dm["coverage"], "density": dm["density"],
+                                             "detected_median_before": dm["summary"]["detected_median_before"].to_dict(),
+                                             "detected_median_after": dm["summary"]["detected_median_after"].to_dict()},
+        "monocyte_pct": {"generated_mean_over_donors": float(100 * gc[:, mj].mean()),
+                         "observed_mean_over_donors": float(100 * oc[:, mj].mean()),
+                         "generated_pooled_cells": float(100 * (gen_lab == "Monocyte").mean())},
+        "median_umi_per_cell_scoring_genes": {"generated_pooled": float(np.median(glib)),
+                                              "observed_pooled": float(np.median(v["cell_lib"])),
+                                              "generated_mean_of_donor_medians": float(med_gen.mean()),
+                                              "observed_mean_of_donor_medians": float(v["obs_lib_median_d"].mean())},
+    }
+    # 5. group contrast
+    crow = []
+    if contrast.get("enabled"):
+        case, ctrl = contrast["case"], contrast["ctrl"]
+        ga = F.type_aggregates(Xg, gen_d, gen_lab, S)
+        blk = F.bulk_lfc(bulk, case, ctrl) if bulk is not None else {"mean_cp10k": None, "pseudobulk_log1p_cpm": None}
+        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)
+            genes = det >= F.MIN_DETECT_FRAC
+            if "keep" in v:  # --exclude-genes
+                genes &= v["keep"]
+            for variant, fn, key in (("mean_cp10k", F.lfc_mean_cp10k, "cp10k"),
+                                     ("pseudobulk_log1p_cpm", F.lfc_pseudobulk, "sum")):
+                o = fn(n_o, v[f"agg_{key}"][:, ti], case, ctrl)
+                g = fn(ga["n"][:, ti], ga[key][:, ti], case, ctrl)
+                row = {"celltype": t, "statistic": variant, **F.contrast_scores(o, g, blk[variant], genes),
+                       "n_case_donors_obs": int((case & (n_o > 0)).sum()), "n_control_donors_obs": int((ctrl & (n_o > 0)).sum()),
+                       "n_case_donors_gen": int((case & (ga["n"][:, ti] > 0)).sum()),
+                       "n_control_donors_gen": int((ctrl & (ga["n"][:, ti] > 0)).sum()),
+                       "n_cells_obs": int(n_o[case | ctrl].sum()), "n_cells_gen": int(ga["n"][case | ctrl, ti].sum())}
+                crow.append(row)
+        cdf = pd.DataFrame(crow)
+        summ["contrast"] = {}
+        for variant, sub_ in cdf.groupby("statistic", sort=False):
+            summ["contrast"][variant] = {
+                "per_type": {r.celltype: {k: (None if isinstance(r[k], float) and np.isnan(r[k]) else r[k])
+                                          for k in ("r_generated", "r_broadcast", "partial_r_generated_given_broadcast",
+                                                    "r_generated_vs_broadcast", "n_genes")} for _, r in sub_.iterrows()},
+                "mean_r_generated": float(np.nanmean(sub_.r_generated)) if sub_.r_generated.notna().any() else None,
+                "mean_r_broadcast": float(np.nanmean(sub_.r_broadcast)) if sub_.r_broadcast.notna().any() else None,
+                "mean_partial_r": float(np.nanmean(sub_.partial_r_generated_given_broadcast))
+                if sub_.partial_r_generated_given_broadcast.notna().any() else None}
+        if obs_deg is not None:
+            drows, summ["deg_top50"] = deg_block(v, obs_deg, ga, Xg, gen_d, gen_lab, bulk, contrast)
+            crow += drows
+    return per, summ, crow, sub
+
+
+def score_arm(arm: dict, v: dict, ref: dict, man: dict, spec: F.DatasetSpec, contrast: dict, out: Path, a,
+              obs_deg: dict | None = None) -> tuple:
+    t0 = time.monotonic()
+    name, d = arm["name"], arm["d"]
+    donors = v["donors"]
+    npos = {n: i for i, n in enumerate(arm["sample_ids"])}
+    rows = [np.flatnonzero(arm["bulk_index"] == npos[x]) for x in donors]
+    sel = np.concatenate(rows)
+    gen_d = np.repeat(np.arange(donors.size), [r.size for r in rows])
+    F.log(f"{name}: loading generated_counts ({arm['bulk_index'].size} cells in the NPZ, {sel.size} scored)")
+    rates = np.ascontiguousarray(d["generated_counts"], dtype=np.float32)
+    full = F.PR.poisson_integerise(rates, seed=F.POISSON_SEED, chunk_rows=4096)  # one read-out of the whole NPZ
+    nnz_full = int(full.nnz)
+    lib_full_median = float(np.median(np.asarray(full.sum(1)).ravel()))
+    score_idx = ref["score_idx"]
+    gen_pb = np.vstack([rates[r].sum(0) for r in rows]).astype(np.float64)[:, score_idx]  # score_generated.py arithmetic
+    del rates
+    counts = full[sel].tocsr()
+    del full
+    F.log(f"{name}: Poisson read-out nnz {nnz_full} (whole NPZ), median library {lib_full_median:.0f}; annotating")
+    work = out / "arms" / name
+    if a.reuse_labels is not None:
+        lab, linfo = reused_labels(a.reuse_labels, name, arm, man["reference_sha256"], donors, sel, gen_d, work)
+    else:
+        lab, linfo = F.run_annotator(counts[:, man["_query_panel_idx"]], list(ref["query_ids"].astype(str)),
+                                     np.asarray([f"{x}|generated" for x in donors[gen_d]], dtype=object), work=work,
+                                     method=name, spec=spec, split="generated", threads=a.threads, annot=a.annot,
+                                     expected_zero_pad=man["gene_sets"]["model_genes_missing_from_query"],
+                                     source_note={"kind": "generated_npz", "readout": "poisson", "seed": F.POISSON_SEED,
+                                                  "source_path": str(arm["path"]), "source_sha256": arm["sha256"],
+                                                  "poisson_note": "one draw over the whole NPZ, then the scored donors' rows"})
+    gen_lab = lab.celltype_l1_pred.astype(str).to_numpy()
+    Xg = counts[:, score_idx].tocsr()
+    del counts
+    bulk, cond = None, None
+    if contrast.get("enabled"):
+        cpath = a.condition_map.get(name, arm["condition"])
+        cond = load_condition_bulk(cpath, arm["condition_sha256"] if cpath == arm["condition"] else None, donors,
+                                   ref["score_ids"].astype(str))
+        bulk = cond["bulk"]
+    per, summ, crow, sub = arm_metrics(v, Xg, gen_d, gen_lab, gen_pb, bulk, contrast, obs_deg)
+    in_sub = np.zeros(sel.size, bool)
+    in_sub[sub] = True
+    pd.DataFrame({"npz_row": sel, "donor": donors[gen_d], "label": gen_lab,
+                  "umi_scoring_genes": np.asarray(Xg.sum(axis=1)).ravel().astype(np.float32),
+                  "in_pc_subsample": in_sub}).to_parquet(work / "generated_cells.parquet", index=False)
+    if "deg_top50" in summ:
+        pd.DataFrame(summ["deg_top50"].pop("_lists"), columns=["celltype", "source", "rank", "gene_id"]).to_csv(
+            work / "deg_top50_lists.csv", index=False)
+    per.insert(0, "arm", name)
+    for r in crow:
+        r["arm"] = name
+    summ = {"arm": name, "npz": str(arm["path"]), "npz_sha256": arm["sha256"], "receipt_verified": arm["receipt_verified"],
+            "generation": {k: arm["meta"].get(k) for k in ("checkpoint", "checkpoint_sha256", "input_condition_path",
+                                                            "input_condition_sha256", "seed", "steps", "support_readout", "weights")},
+            "condition_for_broadcast": {k: cond[k] for k in ("path", "sha256")} if cond else None,
+            "poisson": {"seed": F.POISSON_SEED, "rule": "whole NPZ, rows in NPZ order", "nnz_whole_npz": nnz_full,
+                        "median_library_whole_npz_panel": lib_full_median, "n_rows_whole_npz": int(arm["bulk_index"].size)},
+            "annotation": {k: linfo[k] for k in ("model_pt_sha256", "zero_padded_model_genes", "label_counts",
+                                                 "mean_l2_max_prob", "predict_seconds")}
+            | {k: linfo[k] for k in ("reused_from", "reused_labels_sha256") if k in linfo},
+            **summ, "seconds": round(time.monotonic() - t0, 1)}
+    F.log(f"{name}: L1 {summ['composition']['l1_mean']:.4f} (null {summ['composition']['l1_obs_loo_null_mean']}) "
+          f"P/C {summ['precision_coverage']['precision']:.4f}/{summ['precision_coverage']['coverage']:.4f} "
+          f"pb r {summ['pseudobulk']['r_median']:.4f} top1 {summ['pseudobulk']['top1']:.3f} "
+          f"mono {summ['monocyte_pct']['generated_mean_over_donors']:.1f}% ({summ['seconds']} s)")
+    if "deg_top50" in summ:
+        dg = summ["deg_top50"]
+        F.log(f"{name}: top-50 DEG {dg['sum']}/{dg['max']} ("
+              + ", ".join(f"{F.SHORT_TYPE.get(t, t)} {dg['per_type'][t]['top50_overlap']}" for t in dg["types_scored"])
+              + f"); broadcast {dg['sum_broadcast']} ({dg['seconds']} s)")
+    return per, summ, crow
+
+
+# --------------------------------------------------------------------------- README
+def readme(spec: F.DatasetSpec, man: dict, v: dict, contrast: dict, summary: dict) -> str:
+    c = contrast
+    ctext = (f"case groups {c['case_groups']} (n = {c['n_case_donors']}) vs control groups {c['control_groups']} "
+             f"(n = {c['n_control_donors']}); rule: {c['rule']}; groups from {c['group_source']}."
+             if c.get("enabled") else f"not computed ({c.get('reason')}).")
+    dd = summary.get("deg_definition") or {}
+    if dd.get("enabled"):
+        ns = dd["types_not_scored_observed"]
+        dtext = f"""the SLE benchmark's score (`total_top50_overlap` of
+   `bulk2sc-paper/scripts/evaluate_generated_vs_truth.py`, Welch backend: the "top-50 DEG 81 / 84" of the final model), run
+   with the evaluator's own functions on the same donor x type pseudobulks as the contrast. Per cell type, observed and
+   generated separately: donor x type summed counts on all {len(v['score_ids'])} scoring genes (donors of the two groups with
+   >= 1 cell of the type) -> `welch_bh_deg` (log1p CPM, two-sided Welch t-test case vs control, Benjamini-Hochberg over the
+   genes with a defined p-value; needs >= 2 donors per group) -> `top_deg_genes` (FDR < {F.DEG_FDR:g}, descending |logFC|,
+   first {F.DEG_TOP_N}; shorter when fewer genes pass). `top50_overlap` = |observed list & generated list|; `top50_jaccard`
+   the evaluator's Jaccard. Summary `sum` = total over the scored types (the quantity reported as 81), `max` = the sum of
+   the observed list lengths (the "of 262"), `sum_4type` = T + B + Monocyte + NK. A type is scored when its observed test
+   is defined; an arm whose generated test is undefined for a scored type gets overlap 0. Types: {', '.join(dd['types'])}
+   (aggregates: {dd['aggregates_source']}){'; not scored: ' + ', '.join(ns) if ns else ''}.
+   **Broadcast analogue** (`top50_overlap_broadcast`, as `sle_broadcast.py` `broadcast_input_bulk`; not part of the
+   published benchmark): the same test on the arm's condition bulk_counts (scoring genes, the {c.get('n_case_donors')} + {c.get('n_control_donors')}
+   donors), one whole-PBMC top-{F.DEG_TOP_N} list, compared with every type's observed list."""
+    else:
+        dtext = f"not computed ({dd.get('reason', 'contrast off')})."
+    return f"""# score_ft.py output: {spec.name}, {v['donors'].size} scored donors
+
+Arms: {', '.join(summary['arms'])}.  Every arm is scored on the same donors against the same observed reference.
+
+## Inputs and fixed contracts
+- Observed reference: `{man['reference_npz']}` (sha {man['reference_sha256'][:12]}), built from {man['cells']['source']};
+  observed cells sum exactly to the features pseudobulk of every donor. Observed labels: {man['labels'].get('source', man['labels'].get('labels_parquet'))}.
+- Generated cells: `generated_counts` read out once with Poisson(seed {F.POISSON_SEED}) over the **whole NPZ in row order**
+  (`poisson_readout.poisson_integerise`), then the scored donors' rows. These integer counts are used for labels, embedding,
+  depth and the contrast. Pseudobulk uses the summed `generated_counts` (rates), as `score_generated.py`.
+- Labels: frozen f01common scANVI (`predict_scanvi.py`, CPU, zero query epochs), six-type gate {list(F.GATE)}; query genes =
+  the 1,006-gene annotation list minus genes the dataset's sc assay did not measure in every sample ({man['gene_sets']['query']} genes).
+- Scoring genes: 6k panel genes measured by both assays in every sample of the dataset ({man['gene_sets']['scoring']} genes).
+
+## Definitions
+1. **Composition**: fraction of each donor's cells per six-type label (all generated cells; all observed QC cells).
+   `comp_l1` = sum over the six labels of |generated - observed| (immicro_common.l1). `comp_l1_obs_loo_null` = L1 of the
+   donor's observed composition to the mean of the *other scored donors'* observed compositions. `composition_top1` =
+   fraction of donors whose generated composition is closest (L1) to their own observed composition.
+2. **Pseudobulk**: `pb_r` = Pearson r of CPM-log1p(summed generated_counts) vs CPM-log1p(observed pseudobulk) on the scoring
+   genes (evaluate_realbulk.cpm_log1p / paired_r). `pb_top1` = the donor's generated pseudobulk is closest (Pearson) to its own
+   observed pseudobulk among the {v['donors'].size} scored donors (immicro_common.retrieval = evaluate_realbulk.top1 arithmetic).
+3. **Precision / coverage / density** (stage_b_embed.py functions): per-cell CP10K over the scoring genes + log1p; PCA-50
+   (randomized, random_state {F.SUB_SEED}) and k = {F.K_NN} real-real k-NN balls fitted on **R1 of the scored donors only**.
+   Reference rule (independent of fold and arm): per donor, cells in canonical order ({man['cells']['key_rule']}), one
+   permutation from `default_rng([{F.SUB_SEED}, uint64(sha256(donor)[:8])])`; R1 = first n, R2 = next n,
+   n = min({F.N_SUB}, n_cells // 2) ({v['n_ref'].sum()} R1 cells here). Generated query: per donor n cells (the donor's R1 size),
+   without replacement, `default_rng([{F.GEN_SUB_SEED}, same key])`. Precision = fraction of generated cells inside any R1 ball
+   (Kynkaanniemi 2019); coverage = fraction of R1 cells whose ball holds a generated cell; density = Naeem 2020.
+   Per-donor precision = that donor's generated cells; per-donor coverage = that donor's R1 cells (the pooled values are
+   their n-weighted means; plain means when every donor has {F.N_SUB} reference cells). R2 (held-out real cells of the same donors) is the
+   perfect-generator control: precision {v['r2_control']['precision']:.4f}, coverage {v['r2_control']['coverage']:.4f}.
+   **Depth matched**: stage_b_embed depth matching run pairwise (R1 vs this arm): per donor and within-donor rank of detected
+   genes, both cells are thinned by UMI sampling without replacement to the smaller detected-gene count; PCA kept from
+   un-thinned R1, radii recomputed on thinned R1; fresh rng({F.DEPTH_SEED}) per arm. R2 control: precision
+   {v['r2_control']['depth_matched']['precision']:.4f}, coverage {v['r2_control']['depth_matched']['coverage']:.4f}.
+4. **Monocyte %** = 100 x Monocyte fraction (all cells) per donor; **median UMI per cell** = median over cells of the
+   Poisson-read (generated) / observed counts summed over the scoring genes (per donor, and pooled).
+5. **Group contrast** (T, B, Monocyte, NK): {ctext}
+   Genes per type = scoring genes detected (count > 0) in >= {100 * F.MIN_DETECT_FRAC:g} % of the scored donors' observed
+   cells of that type. Primary statistic `mean_cp10k`: per-cell CP10K over the scoring genes; per donor the mean over its
+   cells of the type (donors with >= 1 such cell); group mean = mean over the group's donors (donor-balanced);
+   logFC = log2(case mean + 1) - log2(control mean + 1). Secondary `pseudobulk_log1p_cpm`: the SLE benchmark evaluator's
+   statistic (donor x type summed counts, log1p CPM over the scoring genes, mean case - mean control;
+   evaluate_generated_vs_truth.group_log_fold_change). Both are computed on the generated cells (their frozen labels) and on
+   the observed cells; `r_generated` = Pearson r of the two logFC vectors. Broadcast baseline `r_broadcast`: the same
+   observed vector against the logFC of the input bulk (condition NPZ `bulk_counts` of the arm, scoring genes, per-donor
+   CP10K resp. log1p CPM, group means). `partial_r_generated_given_broadcast`: r of the OLS residuals of observed and
+   generated logFC on the bulk logFC (residual_specificity.py).
+6. **Top-50 DEG overlap** (contrast.csv rows `statistic = {F.DEG_STATISTIC}`; summary `deg_top50`): {dtext}
+
+## Files
+- `per_donor.csv`: one row per arm x donor (all per-donor quantities above).
+- `summary.json`: per arm the donor means / pooled values, provenance (NPZ sha, receipt check, generation metadata,
+  Poisson nnz of the whole NPZ, annotation contract), and the reference block (PCA, R2 control).
+- `contrast.csv`: per arm x cell type x statistic (`mean_cp10k`, `pseudobulk_log1p_cpm`: logFC r; `{F.DEG_STATISTIC}`:
+  top-50 DEG overlap, T / B / Monocyte / NK / DC; columns of the other kind are empty).
+- `arms/<arm>/labels/` (predict_scanvi.py labels + manifest), `arms/<arm>/generated_cells.parquet` (NPZ row, donor, label,
+  UMI on the scoring genes, P/C subsample flag), `arms/<arm>/deg_top50_lists.csv` (observed, generated and broadcast
+  top-50 gene lists, Ensembl ids, rank order).
+"""
+
+
+def deg_headline(dg: dict) -> dict:
+    """Headline columns of the top-50 DEG score: per scored type, the sum (reported like the SLE 81), its maximum
+    (sum of the observed list lengths), the four-contrast-type sum and the broadcast sum."""
+    return {**{f"deg_top50_{F.SHORT_TYPE.get(t, t)}": dg["per_type"][t]["top50_overlap"] for t in dg["types_scored"]},
+            "deg_top50_sum": dg["sum"], "deg_top50_max": dg["max"], "deg_top50_sum_4type": dg["sum_4type"],
+            "deg_top50_sum_broadcast": dg["sum_broadcast"]}
+
+
+# --------------------------------------------------------------------------- main
+def parse(argv=None):
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--dataset", choices=sorted(F.DATASETS), required=True)
+    p.add_argument("--build-reference", action="store_true")
+    p.add_argument("--build-deg-reference", action="store_true",
+                   help="add deg_reference.npz (donor x type aggregates incl. DC) to an existing reference cache")
+    p.add_argument("--no-deg", action="store_true", help="skip the top-50 DEG overlap (default: on with the contrast)")
+    p.add_argument("--cells-source", choices=["auto", "datadir", "immicro_h5ad"], default="auto")
+    p.add_argument("--reference", type=Path, default=None, help="reference cache dir (default scoring_cache/<dataset>)")
+    p.add_argument("--arm", action="append", default=[], help="NAME=GENERATED_NPZ (repeatable)")
+    p.add_argument("--out", type=Path)
+    p.add_argument("--donors", default=None, help="comma list or a file with one sample id per line")
+    p.add_argument("--groups-csv", default=None)
+    p.add_argument("--case-groups", default=None)
+    p.add_argument("--control-groups", default=None)
+    p.add_argument("--no-contrast", action="store_true")
+    p.add_argument("--condition", action="append", default=[], help="ARM=CONDITION_NPZ override for the broadcast")
+    p.add_argument("--allow-no-receipt", action="store_true")
+    p.add_argument("--annot", type=Path, default=None, help="annotator run dir (default: server_1 run or server_2 mirror)")
+    p.add_argument("--threads", type=int, default=8)
+    p.add_argument("--exclude-genes", type=Path, default=None,
+                   help="CSV with a gene_id column: drop these genes from the contrast logFC r / broadcast / partial r "
+                        "and the top-50 DEG tests (other metrics unchanged)")
+    p.add_argument("--reuse-labels", type=Path, default=None,
+                   help="earlier score_ft.py output dir: reuse its arms/<arm>/labels instead of running predict_scanvi.py")
+    return p.parse_args(argv)
+
+
+def main(argv=None) -> int:
+    a = parse(argv)
+    t0 = time.monotonic()
+    if not 1 <= a.threads <= MAX_THREADS:
+        raise SystemExit(f"--threads must be 1..{MAX_THREADS} on the shared hosts")
+    try:
+        from threadpoolctl import threadpool_limits
+        threadpool_limits(a.threads)
+    except ImportError:
+        pass
+    spec = F.DATASETS[a.dataset]
+    cache = a.reference or (F.CACHE_ROOT / spec.name)
+    a.annot = F.annotator_run(a.annot)
+    if a.build_reference:
+        F.build_reference(spec, cache, source={"immicro_h5ad": "h5ad"}.get(a.cells_source, a.cells_source),
+                          threads=a.threads, annot=a.annot)
+        return 0
+    if a.build_deg_reference:
+        F.build_deg_reference(spec, cache)
+        return 0
+    if not a.arm or a.out is None:
+        raise SystemExit("--arm NAME=NPZ (at least one) and --out are required")
+    ref, man = F.load_reference(cache)
+    if not a.no_deg:
+        ref["deg"] = F.load_deg_reference(cache, man, ref)
+    panel_ids = ref["panel_ids"].astype(str)
+    ppos = {g: i for i, g in enumerate(panel_ids)}
+    man["_query_panel_idx"] = np.asarray([ppos[g] for g in ref["query_ids"].astype(str)], dtype=np.int64)
+    arms, seen = [], set()
+    for s in a.arm:
+        name, _, path = s.partition("=")
+        if not name or not path or name in seen or not name.replace("_", "").replace("-", "").isalnum():
+            raise SystemExit(f"bad or duplicate --arm {s!r} (NAME=PATH, NAME alphanumeric/_/-)")
+        seen.add(name)
+        arms.append(open_arm(name, Path(path), panel_ids, a.allow_no_receipt))
+    a.condition_map = dict(x.split("=", 1) for x in a.condition)
+    ref_order = {d: i for i, d in enumerate(ref["donors"].astype(str))}
+    if a.donors:
+        p = Path(a.donors)
+        want = [x.strip().split(",")[0] for x in p.read_text().splitlines() if x.strip()] if p.is_file() else a.donors.split(",")
+        for arm in arms:
+            miss = sorted(set(want) - set(arm["sample_ids"]))
+            if miss:
+                raise SystemExit(f"{arm['name']}: NPZ lacks scored donors {miss[:5]}")
+    else:
+        want = list(arms[0]["sample_ids"])
+        for arm in arms[1:]:
+            if set(arm["sample_ids"]) != set(want):
+                raise SystemExit(f"{arm['name']}: sample_ids differ from {arms[0]['name']}'s; every arm must cover the same donors")
+    if len(set(want)) != len(want):
+        raise SystemExit("duplicate donors")
+    miss = [d for d in want if d not in ref_order]
+    if miss:
+        raise SystemExit(f"donors not in the {spec.name} reference: {miss[:5]}")
+    donors = sorted(want, key=ref_order.get)
+    a.out.mkdir(parents=True, exist_ok=True)
+    F.log(f"{spec.name}: {len(donors)} scored donors, {len(arms)} arm(s); fitting the observed reference")
+    v = make_view(ref, donors)
+    gene_excl = None
+    if a.exclude_genes is not None:
+        v["keep"], gene_excl = gene_exclusion(a.exclude_genes, v["score_ids"])
+        F.log(f"--exclude-genes: {gene_excl['n_dropped_from_scoring_genes']} of {gene_excl['n_listed']} listed genes are "
+              f"scoring genes; contrast and DEG use {gene_excl['n_scoring_genes_kept']} of {gene_excl['n_scoring_genes']}")
+    feat = F.load_features(spec.features)   # sample -> donor, for the leave-donor-out composition null
+    d_of = dict(zip(feat["sample_ids"].astype(str), feat["donor_ids"].astype(str)))
+    v["donor_of"] = np.asarray([d_of[d] for d in v["donors"]], dtype=str)
+    contrast = resolve_contrast(spec, v, a)
+    F.log(f"reference: R1 {v['z1'].shape[0]} cells, PCA var {v['pca']['explained_variance_ratio_sum']:.3f}, "
+          f"R2 control P/C {v['r2_control']['precision']:.4f}/{v['r2_control']['coverage']:.4f}; contrast "
+          f"{'on' if contrast.get('enabled') else 'off'}")
+    obs_deg, deg_def = None, {"enabled": False}
+    if a.no_deg:
+        deg_def["reason"] = "--no-deg"
+    elif not contrast.get("enabled"):
+        deg_def["reason"] = "contrast off"
+    else:
+        obs_deg = observed_deg(v, contrast)
+        deg_def = {
+            "enabled": True, "score": "top-50 DEG overlap per cell type (benchmark total_top50_overlap, Welch backend)",
+            "source": str(F.EV_PATH), "functions": ["welch_bh_deg", "top_deg_genes", "jaccard"],
+            "reproduces": "utility_studies_final6k_20260925/sle top-50 DEG 81 (1,006 genes) / 84 (2,279 genes) = "
+                          "sum over the six gated types of top50_overlap_count",
+            "top_n": F.DEG_TOP_N, "fdr": F.DEG_FDR, "n_genes": len(v["score_ids"]), "types": list(v["deg_types"]),
+            "aggregates_source": ref["deg"]["source"], "aggregates_sha256": ref["deg"]["sha256"],
+            "aggregates_note": ref["deg"]["note"],
+            "types_not_scored_observed": [t for t, d in obs_deg.items() if not d["defined"]],
+            "observed": {t: {k: d[k] for k in ("n_significant", "n_tested", "n_case_donors", "n_control_donors", "n_cells")}
+                         | {"top_list_size": len(d["top"])} for t, d in obs_deg.items()},
+            "broadcast": "welch_bh_deg + top_deg_genes on the arm's condition bulk_counts (scoring genes, case|control "
+                         "donors), one list compared with every type's observed list (sle_broadcast.py broadcast_input_bulk); "
+                         "not part of the published benchmark"}
+        if gene_excl is not None:
+            deg_def["n_genes"] = gene_excl["n_scoring_genes_kept"]
+        F.log("observed top-50 DEG lists: " + ", ".join(
+            f"{F.SHORT_TYPE.get(t, t)} {len(d['top'])} (sig {d['n_significant']}, {d['n_case_donors']}+{d['n_control_donors']} donors, "
+            f"{d['n_cells']} cells)" for t, d in obs_deg.items()))
+    pers, summs, crows = [], {}, []
+    for arm in arms:
+        per, summ, crow = score_arm(arm, v, ref, man, spec, contrast, a.out, a, obs_deg)
+        pers.append(per)
+        summs[arm["name"]] = summ
+        crows += crow
+        arm["d"].close()
+    pd.concat(pers, ignore_index=True).to_csv(a.out / "per_donor.csv", index=False)
+    if crows:
+        cols = ["arm", "celltype", "statistic"]
+        cdf = pd.DataFrame(crows)
+        for c in ("top50_overlap", "obs_top_list_size", "gen_top_list_size", "n_sig_obs", "n_sig_gen",
+                  "top50_overlap_broadcast", "broadcast_top_list_size", "n_sig_broadcast"):
+            if c in cdf.columns:  # integer counts on the DEG rows, empty on the logFC rows
+                cdf[c] = cdf[c].astype("Int64")
+        if "deg_scored" in cdf.columns:
+            cdf["deg_scored"] = cdf["deg_scored"].astype("boolean")
+        cdf[cols + [c for c in cdf.columns if c not in cols]].to_csv(a.out / "contrast.csv", index=False)
+    headline = {n: {"comp_l1": s["composition"]["l1_mean"], "comp_l1_obs_loo_null": s["composition"]["l1_obs_loo_null_mean"],
+                    "precision": s["precision_coverage"]["precision"], "coverage": s["precision_coverage"]["coverage"],
+                    "precision_dm": s["precision_coverage_depth_matched"]["precision"],
+                    "coverage_dm": s["precision_coverage_depth_matched"]["coverage"],
+                    "pb_r_median": s["pseudobulk"]["r_median"], "pb_top1": s["pseudobulk"]["top1"],
+                    "mono_pct_gen": s["monocyte_pct"]["generated_mean_over_donors"],
+                    "mono_pct_obs": s["monocyte_pct"]["observed_mean_over_donors"],
+                    "median_umi_gen": s["median_umi_per_cell_scoring_genes"]["generated_pooled"],
+                    "median_umi_obs": s["median_umi_per_cell_scoring_genes"]["observed_pooled"],
+                    **({f"contrast_{k}_r_gen": s["contrast"][k]["mean_r_generated"] for k in s["contrast"]} if "contrast" in s else {}),
+                    **({f"contrast_{k}_r_broadcast": s["contrast"][k]["mean_r_broadcast"] for k in s["contrast"]} if "contrast" in s else {}),
+                    **(deg_headline(s["deg_top50"]) if "deg_top50" in s else {}),
+                    "seconds": s["seconds"]} for n, s in summs.items()}
+    code = {str(p): F.sha(p) for p in (Path(__file__).resolve(), Path(F.__file__).resolve(), F.SB_PATH, F.EV_PATH,
+                                       Path(F.IC.__file__).resolve(), F.IC.PREDICT, F.IC.REBUILD / "poisson_readout.py")}
+    summary = {"schema": "paired_ft_scores.v1", "dataset": spec.name, "written_utc": F.now(), "command": sys.argv,
+               "arms": list(summs), "donors": donors, "n_donors": len(donors),
+               "reference": {"cache": str(cache), "reference_sha256": man["reference_sha256"], "features_sha256": man["features"]["sha256"],
+                             "n_r1_cells": int(v["z1"].shape[0]), "pca": v["pca"], "r2_control": v["r2_control"],
+                             "observed_l1_loo_null_mean": float(np.mean(F.IC.l1(v["comp"], F.lodo_mean(v["comp"], v["donor_of"])))) if len(donors) > 1 else None},
+               "contrast_definition": {k: (x.tolist() if isinstance(x, np.ndarray) else x) for k, x in contrast.items()},
+               "deg_definition": deg_def, "headline": headline, "per_arm": summs, "code_sha256": code, "seconds": round(time.monotonic() - t0, 1)}
+    note = ""
+    if gene_excl is not None:
+        summary["gene_exclusion"] = gene_excl
+        note += (f"\n## Gene exclusion (--exclude-genes)\n`{gene_excl['file']}` (sha {gene_excl['sha256'][:12]}): "
+                 f"{gene_excl['n_listed']} genes listed, {gene_excl['n_dropped_from_scoring_genes']} of them scoring genes "
+                 f"({', '.join(d['symbol'] or d['gene_id'] for d in gene_excl['dropped'])}). Applies to: "
+                 f"{gene_excl['applies_to']}. Definitions 5 and 6 above therefore run on "
+                 f"{gene_excl['n_scoring_genes_kept']} of the {gene_excl['n_scoring_genes']} scoring genes.\n")
+    if a.reuse_labels is not None:
+        summary["labels_reused_from"] = str(a.reuse_labels)
+        note += (f"\n## Labels\nFrozen scANVI labels reused from `{a.reuse_labels}` (same reference, NPZ sha256 and scored "
+                 f"donors; checked per arm); predict_scanvi.py was not run.\n")
+    (a.out / "summary.json").write_text(json.dumps(summary, indent=1, default=float) + "\n")
+    (a.out / "README.md").write_text(readme(spec, man, v, contrast, summary) + note)
+    with pd.option_context("display.width", 250, "display.max_columns", 40):
+        print(pd.DataFrame(headline).T.round(4).to_string())
+    F.log(f"done in {summary['seconds']} s -> {a.out}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())