Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261001T200638Z-extra-realism-metrics/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tests/test_extra_metrics.py

@@ -0,0 +1,215 @@
+"""Synthetic checks of tools/extra_metrics.py (CPU; ~1-2 min, the get_error comparison imports scSemiProfiler).
+
+Run:  CUDA_VISIBLE_DEVICES= OMP_NUM_THREADS=4 <cxg_corpus python> -m pytest -q tests/test_extra_metrics.py
+
+1. Same distribution: C2ST AUC (kNN, RF) ~ 0.5, 1-NN accuracy ~ 0.5, MMD^2 ~ 0, coverage at k = 3 / 5 / 10 near
+   Naeem et al.'s E[coverage] (eq. 9), precision high.
+2. Shifted distribution: AUC -> 1, 1-NN -> 1, MMD^2 >> 0, coverage -> 0.
+3. Building blocks equal their definitions (brute-force NN, unbiased MMD^2 by explicit sums, sparse log1p CP10K =
+   stage_b_embed.cp10k_log1p, Gram-eigh PCA = sklearn PCA up to signs).
+4. E_N: extra_metrics.get_error_legacy and the production path (Gram PCA + dif_sc) equal scSemiProfiler's own
+   utils.get_error on a toy project (run in the frozen scSemiProfiler runtime_env, CPU, same np.random seed).
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+import numpy as np  # noqa: E402
+import pytest  # noqa: E402
+import scipy.sparse as sp  # noqa: E402
+
+TASK = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(TASK / "tools"))
+import extra_metrics as X  # noqa: E402
+
+SCSEMI_PY = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/"
+                 "immicro_scsemi_comparison_20260927/runtime_env/bin/python")
+SCSEMI_VENDOR = TASK / "scsemi/vendor/scSemiProfiler"
+
+
+@pytest.fixture(scope="module")
+def same():
+    rng = np.random.default_rng(0)
+    n, d = 2000, 50
+    return rng.normal(size=(n, d)).astype(np.float32), rng.normal(size=(n, d)).astype(np.float32)
+
+
+def test_same_distribution(same):
+    zr, zg = same
+    knn = X.c2st_auc(zr, zg, kind="knn", n_jobs=2)["c2st_knn_auc"]
+    rf = X.c2st_auc(zr, zg, kind="rf", n_jobs=2)["c2st_rf_auc"]
+    nn1 = X.one_nn_loo(zr, zg)
+    m = X.median_bandwidth(zr)
+    mmd = X.mmd2_unbiased(zr, zg, [0.5 * m, m, 2 * m])
+    assert abs(knn - 0.5) < 0.04 and abs(rf - 0.5) < 0.04, (knn, rf)
+    assert abs(nn1["nn1_acc"] - 0.5) < 0.04, nn1
+    assert np.all(np.abs(mmd) < 2e-3), mmd
+    prec = []
+    for k in (3, 5, 10):
+        r = X.pc_at_k(zr, zg, k)
+        exp = X.expected_coverage(len(zr), len(zg), k)
+        assert abs(r["coverage"] - exp) < 0.03, (k, r["coverage"], exp)
+        assert abs(r["density"] - 1.0) < 0.15     # Naeem lemma 1: E[density] = 1
+        prec.append(r["precision"])
+    # Kynkaanniemi precision has no closed form; in 50-D it is well below 1 at small k even for identical sets
+    assert prec[0] < prec[1] < prec[2] and prec[2] > 0.8, prec
+    # Naeem eq. 9 limits: 1 - 1/2^k for M = N -> inf
+    assert abs(X.expected_coverage(10**6, 10**6, 3) - (1 - 1 / 8)) < 1e-4
+
+
+def test_shifted_distribution(same):
+    zr, zg = same
+    zs = zg + 3.0
+    assert X.c2st_auc(zr, zs, kind="knn", n_jobs=2)["c2st_knn_auc"] > 0.99
+    assert X.c2st_auc(zr, zs, kind="rf", n_jobs=2)["c2st_rf_auc"] > 0.99
+    assert X.one_nn_loo(zr, zs)["nn1_acc"] > 0.97
+    m = X.median_bandwidth(zr)
+    assert X.mmd2_unbiased(zr, zs, [m])[0] > 0.1
+    assert X.pc_at_k(zr, zs, 10)["coverage"] < 0.05
+
+
+def test_building_blocks():
+    from scipy.spatial.distance import cdist
+    rng = np.random.default_rng(1)
+    a, b = rng.normal(size=(300, 7)), rng.normal(size=(250, 7)) + 0.3
+    D = cdist(a, b, "sqeuclidean")
+    d, i = X.sqdist_min(a, b, max_block=5e3)
+    assert np.allclose(d, D.min(1)) and np.array_equal(i, D.argmin(1))
+    Daa = cdist(a, a, "sqeuclidean")
+    np.fill_diagonal(Daa, np.inf)
+    d2, i2 = X.sqdist_min(a, a, exclude_self=True, max_block=5e3)
+    assert np.allclose(d2, Daa.min(1)) and np.array_equal(i2, Daa.argmin(1))
+    # unbiased MMD^2 by explicit sums
+    s = 1.7
+    k = lambda u, v: np.exp(-cdist(u, v, "sqeuclidean") / (2 * s * s))  # noqa: E731
+    Kxx, Kyy, Kxy = k(a, a), k(b, b), k(a, b)
+    n, m = len(a), len(b)
+    want = (Kxx.sum() - np.trace(Kxx)) / (n * (n - 1)) + (Kyy.sum() - np.trace(Kyy)) / (m * (m - 1)) - 2 * Kxy.mean()
+    assert np.isclose(X.mmd2_unbiased(a, b, [s])[0], want, rtol=1e-9, atol=1e-12)
+    # sparse log1p CP10K = stage_b_embed.cp10k_log1p (dense float32), incl. an empty cell
+    C = sp.csr_matrix(rng.poisson(0.7, size=(40, 30)).astype(np.float32))
+    C[3] = 0
+    C.eliminate_zeros()
+    assert np.array_equal(X.log1p_cp10k_sparse(C).toarray(), X.F.SB.cp10k_log1p(C))
+    # Gram-eigh PCA = sklearn PCA (distances in the embedding equal; components equal up to sign)
+    from sklearn.decomposition import PCA
+    # well-separated spectrum (low rank + small noise), so the components are identifiable up to sign
+    W = rng.normal(size=(3000, 12)) * np.linspace(6, 1, 12)
+    Z = sp.csr_matrix(np.maximum(W @ rng.normal(size=(12, 120)) + 0.05 * rng.normal(size=(3000, 120)) + 8, 0)
+                      .astype(np.float32))
+    g = X.Gram(120).add(Z, chunk=700)
+    mu, comps = g.pca(12)
+    e1 = X.embed(Z, mu, comps, chunk=500)
+    e2 = PCA(n_components=12, svd_solver="full").fit_transform(Z.toarray().astype(np.float64))
+    assert np.allclose(np.abs(e1), np.abs(e2), rtol=1e-4, atol=1e-3)
+    assert np.allclose(cdist(e1[:200], e1[200:400]), cdist(e2[:200], e2[200:400]), rtol=1e-5, atol=1e-3)
+
+
+# ------------------------------------------------------------------ E_N vs scSemiProfiler's own get_error
+def _toy(rng, P=6, genes=150):
+    """P samples from three 'conditions'; representatives 0 and 3; semis of targets = their rep's cells shifted
+    towards the target (what scSemiProfiler outputs, one cell per representative cell)."""
+    prof = rng.gamma(0.5, 1.0, size=(3, genes)) + 0.02
+    gts, sids = [], []
+    for i in range(P):
+        n = int(rng.integers(300, 420))
+        p = prof[i % 3] * rng.uniform(0.8, 1.2, size=genes)
+        lib = rng.integers(800, 2000, size=n)
+        c = rng.poisson(p / p.sum() * lib[:, None])
+        gts.append(np.log1p(c / c.sum(1, keepdims=True) * 1e4).astype(np.float32))
+        sids.append(f"S{i}")
+    reps, labels = [0, 3], [0, 0, 0, 1, 1, 1]
+    semis = []
+    for i in range(P):
+        if i in reps:
+            semis.append(gts[i])
+        else:
+            r = gts[reps[labels[i]]]
+            semis.append((0.6 * r + 0.4 * gts[i].mean(0)).astype(np.float32))
+    return gts, semis, sids, reps, labels
+
+
+@pytest.mark.skipif(not SCSEMI_PY.is_file(), reason="scSemiProfiler runtime_env not on this host")
+def test_en_matches_get_error(tmp_path):
+    rng = np.random.default_rng(7)
+    gts, semis, sids, reps, labels = _toy(rng)
+    name = tmp_path / "proj"
+    (name / "status").mkdir(parents=True)
+    (name / "inferreddata").mkdir()
+    (name / "sids.txt").write_text("\n".join(sids) + "\n")
+    (name / "status/init_representatives.txt").write_text("\n".join(map(str, reps)) + "\n")
+    (name / "status/init_cluster_labels.txt").write_text("\n".join(map(str, labels)) + "\n")
+    for i in range(len(sids)):
+        if i not in reps:
+            np.save(name / "inferreddata" / f"{sids[reps[labels[i]]]}_to_{sids[i]}.npy", semis[i])
+    np.save(tmp_path / "X.npy", np.concatenate(gts))
+    np.save(tmp_path / "sid.npy", np.repeat(np.asarray(sids), [len(g) for g in gts]))
+    seed = 20261001
+    script = f"""
+import os, sys, json, numpy as np
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+sys.path.insert(0, {str(SCSEMI_VENDOR)!r})
+import anndata, pandas as pd
+from scSemiProfiler.utils import get_error
+X = np.load({str(tmp_path / 'X.npy')!r}); sid = np.load({str(tmp_path / 'sid.npy')!r})
+anndata.AnnData(X=X, obs=pd.DataFrame({{"sample_ids": sid}}, index=[str(i) for i in range(len(sid))])).write_h5ad({str(tmp_path / 'sc.h5ad')!r})
+np.random.seed({seed})
+ub, lb, se, ne = get_error({str(name)!r}, scpath={str(tmp_path / 'sc.h5ad')!r})
+print("RESULT " + json.dumps({{"ub": float(ub[0]), "lb": float(lb[0]), "semi": float(se[0]), "naive": float(ne[0])}}))
+"""
+    env = dict(os.environ, CUDA_VISIBLE_DEVICES="", OMP_NUM_THREADS="2", OPENBLAS_NUM_THREADS="2")
+    res = subprocess.run([str(SCSEMI_PY), "-c", script], capture_output=True, text=True, env=env, timeout=900)
+    line = [x for x in res.stdout.splitlines() if x.startswith("RESULT ")]
+    assert line, res.stdout[-2000:] + res.stderr[-3000:]
+    theirs = json.loads(line[0][7:])
+    # 1) line-by-line restatement, same global np.random stream
+    np.random.seed(seed)
+    ours = X.get_error_legacy(gts, semis, reps, labels)
+    for k_o, k_t in (("upperbound", "ub"), ("lowerbound", "lb"), ("semierror", "semi"), ("naiveerror", "naive")):
+        assert np.isclose(ours[k_o], theirs[k_t], rtol=2e-5), (k_o, ours[k_o], theirs[k_t])
+    en_theirs = (theirs["semi"] - theirs["lb"]) / (theirs["ub"] - theirs["lb"])
+    assert np.isclose(ours["en_semi"], en_theirs, rtol=1e-4)
+    # 2) production path: Gram-eigh PCA-100 on real + generated, dif_sc per sample, same LB split and UB partners
+    #    as the legacy stream (fed explicitly), representatives at LB -> the same E_N as get_error
+    L_g = [sp.csr_matrix(g) for g in gts]
+    L_s = [sp.csr_matrix(s) for s in semis]
+    gram = X.Gram(gts[0].shape[1])
+    for L in L_g + L_s:
+        gram.add(L)
+    mu, comps = gram.pca(100)
+    eg, es = [X.embed(L, mu, comps) for L in L_g], [X.embed(L, mu, comps) for L in L_s]
+    np.random.seed(seed)
+    Z = np.vstack(eg + es)
+    perm = np.arange(len(Z))
+    np.random.shuffle(perm)                       # same draws as np.random.shuffle on the matrix rows
+    h = len(Z) // 2
+    a, b = Z[perm[:h]], Z[perm[h:]]
+    lb = float(np.r_[X.sqdist_min(a, b)[0], X.sqdist_min(b, a)[0]].mean())
+    ub = float(np.mean([X.dif_sc(eg[i], eg[np.random.randint(0, len(eg))])["sq"] for i in range(len(eg))]))
+    semi = np.mean([lb if i in reps else X.dif_sc(eg[i], es[i])["sq"] for i in range(len(eg))])
+    assert np.isclose(lb, theirs["lb"], rtol=2e-5) and np.isclose(ub, theirs["ub"], rtol=2e-5)
+    assert np.isclose((semi - lb) / (ub - lb), en_theirs, rtol=1e-4)
+    # 3) the production en_from_embeddings arithmetic (no representatives, own rng) on the same embedding
+    t = [i for i in range(len(eg)) if i not in reps]
+    r = X.en_from_embeddings([eg[i] for i in t], [es[i] for i in t], np.random.default_rng(0), lb_max_queries=None,
+                             Z_all=Z)
+    d = np.asarray([X.dif_sc(eg[i], es[i])["sq"] for i in t])
+    assert np.allclose(r["sq"]["dif_i"], d)
+    assert np.isclose(r["sq"]["en"], (d.mean() - r["sq"]["lb"]) / (r["sq"]["ub"] - r["sq"]["lb"]))
+    # scSemiProfiler's convention (representatives at LB) = ours x n_targets / P, with the same LB / UB
+    conv = ((d.sum() + len(reps) * r["sq"]["lb"]) / len(eg) - r["sq"]["lb"]) / (r["sq"]["ub"] - r["sq"]["lb"])
+    assert np.isclose(conv, r["sq"]["en"] * len(t) / len(eg))
+
+
+def test_lower_bound_estimate_unbiased():
+    rng = np.random.default_rng(3)
+    Z = rng.normal(size=(6000, 10))
+    exact = X.lower_bound(Z, np.random.default_rng(5), None)
+    est = X.lower_bound(Z, np.random.default_rng(5), 1500)
+    assert exact["exact"] and not est["exact"]
+    assert abs(est["sq"] / exact["sq"] - 1) < 0.03

paper-releases/pbisc-diffusion/updates/20261001T200638Z-extra-realism-metrics/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/build_archive_request.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""Archive-maintenance request for the paired fine-tuning benchmark (PBISC-Diffusion paper, pbisc-diffusion).
+
+Follows paper-release-20260928/maintenance/POLICY.md: every payload is listed explicitly (host, exact path, kind,
+state); generated arrays are not payloads but inference locations with their receipts; work that is still running
+(the scSemiProfiler baseline) is registered as running/planned locations only.
+
+Payloads (completed): code, documents, figures and their source CSVs, score tables, paired-data manifests and
+small data (features, pairs, folds, splits, cell metadata), the condition NPZs every sampler read, run receipts
+(RUN.json / history.json, which carry every fine-tuned checkpoint's sha256), queues, and the recommended-protocol
+LoRA checkpoints (all-training-donor LoRA per fold, and the 5-pair LoRA per draw) on both hosts.
+Not uploaded (location/provenance only): other fine-tuned checkpoints (sha256 in their RUN.json), the per-cell
+count arrays cells_panel6k.npz / cells_full.npz (sha256 in BUILD.json / MANIFEST.json; rebuilt from the datalake
+processing outputs), generated NPZs.
+usage: build_archive_request.py OUT.json
+"""
+from __future__ import annotations
+
+import glob
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+T = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+DATASETS = ("immicro", "ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili")
+
+
+def files(patterns, root=T):
+    out = []
+    for p in patterns:
+        for f in sorted(glob.glob(str(root / p), recursive=True)):
+            q = Path(f)
+            if q.is_file() and not q.is_symlink() and "__pycache__" not in q.parts and not q.name.endswith((".bak", ".pyc")) \
+                    and ".bak_" not in q.name:
+                out.append(str(q))
+    return sorted(set(out))
+
+
+def remote_files(patterns):
+    cmd = "cd %s && for p in %s; do ls -1d $p 2>/dev/null; done; true" % (T, " ".join(patterns))
+    res = subprocess.run(["ssh", "-n", "spark-0110", cmd], capture_output=True, text=True, check=True)
+    return sorted({str(T / l.strip()) for l in res.stdout.splitlines() if l.strip()})
+
+
+def remote_json(path):
+    res = subprocess.run(["ssh", "-n", "spark-0110", f"cat '{path}'"], capture_output=True, text=True)
+    return json.loads(res.stdout) if res.returncode == 0 and res.stdout.strip() else None
+
+
+def main(out: str) -> int:
+    assets = []
+
+    def add(paths, kind, host="server_1", state="completed"):
+        for p in paths:
+            assets.append({"host": host, "source": p, "kind": kind, "state": state})
+
+    add(files(["tools/*.py", "tools/*.sh", "tests/*.py", "figures/make_figures.py",
+               "scsemi/tools/*.py", "scsemi/tools/*.sh", "scsemi/tests/*.py"]), "code")
+    add(files(["README.md", "FEASIBILITY.md", "figures/FIGURES.md", "scsemi/README.md",
+               "data/*/QC_REPORT.md"]), "document")
+    add(files(["figures/*.png", "figures/*.pdf"]), "figure")
+    add(files(["figures/source_data/**/*.csv"]), "table")
+    add(files(["scores/*/*/summary.json", "scores/*/*/per_donor.csv", "scores/*/*/contrast.csv", "scores/*/*/README.md",
+               "scores/*/fewshot_n5/*/summary.json", "scores/*/fewshot_n5/*/per_donor.csv",
+               "scores/*/fewshot_n5/*/contrast.csv", "scores/*/fewshot_n5/*/README.md",
+               "scores/*/AGGREGATE.md", "scores/*/aggregate.json",
+               "scores/*/fewshot_n5/AGGREGATE.md", "scores/*/fewshot_n5/aggregate.json"]), "table")
+    # 2026-10-01: Giroux sex-linked-gene rescoring (scores_nosex, chrY-only sensitivity scores_nochrY) and its gene list
+    add(files([f"{d}/{p}" for d in ("scores_nosex", "scores_nochrY")
+               for p in ("README.md", "**/summary.json", "**/per_donor.csv", "**/contrast.csv", "**/README.md")]), "table")
+    add(files(["data/sex_linked_genes/*.csv", "data/sex_linked_genes/*.md",  # BUILD.json is caught by data/*/BUILD.json
+               "data/sex_linked_genes/sources/*.txt", "data/sex_linked_genes/sources/README*"]), "metadata")
+    # 2026-10-01 LoRA rank sweep (r4/r64) and equal-pair-budget calibration: per-fold and pooled scores + comparison tables
+    add(files([f"scores/*/{d}/*/{p}" for d in ("lora_rank_20261001", "cal_budget_20261001")
+               for p in ("summary.json", "per_donor.csv", "contrast.csv", "README.md")]), "table")
+    add(files(["scores/*/rankcal_20261001.md", "scores/*/rankcal_20261001.json"]), "table")
+    # 2026-10-02 extra realism/diversity metrics (classifier AUC, 1-NN, MMD2, scSemiProfiler E_N, k = 3/5/10 P/C)
+    add(files(["scores_extra/**/*.csv", "scores_extra/**/*.json", "scores_extra/**/*.md"]), "table")
+    add(files(["scores_extra/_code/*.py"]), "code")
+    add(files(["logs/extraA_*.log", "logs/extraA_*.jobs", "logs/extraB_*.log", "logs/extraB_*.jobs"]), "log")
+    # equal-pair-budget calibration (alpha fitted on each lora_n<n> run's own pairs)
+    add(files(["data/*/fold*/alpha_n*.npy"]), "data")
+    add(files(["data/*/CAL_BUDGET.json"]), "metadata")
+    add(files(["data/*/features.npz", "data/*/cells_obs.parquet", "data/*/fold*/alpha.npy",
+               "data/*/fewshot_n5/draw*/alpha.npy"]), "data")
+    add(files(["data/*/pairs.csv", "data/*/folds.csv", "data/*/samples.csv", "data/*/identity_*.csv",
+               "data/*/pairs_sensitivity_offday.csv", "data/*/MANIFEST.json", "data/*/PREPARE.json",
+               "data/*/BUILD.json", "data/*/cells_full.BUILD.json", "data/*/fewshot_n5/DRAWS.json",
+               "data/*/fewshot_n5/draw*/*.txt"]), "metadata")
+    add(files(["data/*/conditions_*.npz", "data/*/fold*/*.npz", "data/*/fewshot_n5/*.npz",
+               "data/*/fewshot_n5/draw*/*.npz"]), "condition")
+    add(files(["runs/**/RUN.json", "runs/**/history.json"]), "log")
+    # server_2 ran its own copies of the scSemiProfiler queues (some exist only there): keep them as the as-run record
+    subprocess.run(["rsync", "-a", f"spark-0110:{T}/scsemi/queues/", f"{T}/scsemi/queues/as_run_server2/",
+                    "--include=server2_*.txt", "--exclude=*"], check=True)
+    add(files(["queues/*.txt", "scsemi/queues/*.txt", "scsemi/queues/as_run_server2/*.txt",
+               "scsemi/vendor/compatibility.patch",
+               "scsemi/vendor/source_manifest.json"]), "config")
+    # recommended protocol weights (LoRA merged into the base weights): server_1 datasets here, Imperial on server_2
+    add(files(["runs/*/fold*/real_lora/checkpoint_ft.pt", "runs/*/fewshot_n5/draw*/lora/checkpoint_ft.pt"]), "checkpoint")
+    add(remote_files(["runs/imperial_eskd/fold*/real_lora/checkpoint_ft.pt",
+                      "runs/imperial_eskd/fewshot_n5/draw*/lora/checkpoint_ft.pt"]), "checkpoint", host="server_2")
+    add(remote_files(["runs/imperial_eskd/*/*/RUN.json", "runs/imperial_eskd/*/*/history.json",
+                      "runs/imperial_eskd/fewshot_n5/*/*/RUN.json", "runs/imperial_eskd/fewshot_n5/*/*/history.json"]),
+        "log", host="server_2")
+
+    # ---- inference locations (not payloads) ------------------------------------------------------------------------
+    locs = []
+
+    def receipt_fields(rec: dict | None) -> dict:
+        if not rec:
+            return {}
+        keep = {}
+        for k in ("output_sha256", "checkpoint", "checkpoint_sha256", "input_condition_path", "input_condition_sha256",
+                  "condition_npz", "condition_sha256", "seed", "steps", "generated_counts_rows"):
+            if k in rec and not isinstance(rec[k], (dict, list)):
+                keep[k] = rec[k]
+        if "output_sha256" in keep:
+            keep["sha256"] = keep["output_sha256"]
+        return keep
+
+    def loc(host, npz, experiment, cohort, rec=None, state="completed"):
+        rpath = npz[:-4] + ".log"
+        item = {"host": host, "path": npz, "state": state, "experiment": experiment, "cohort": cohort,
+                "artifact_role": "inference_output"}
+        if state in ("completed", "final"):
+            item["receipt"] = rpath
+        item.update(receipt_fields(rec))
+        locs.append(item)
+
+    for ds in DATASETS:
+        # present on server_1
+        for npz in files([f"generated/{ds}/**/*.npz"]):
+            rel = Path(npz).relative_to(T / "generated" / ds)
+            rp = Path(npz[:-4] + ".log")
+            rec = json.loads(rp.read_text()) if rp.is_file() and rp.stat().st_size else None
+            if rec is None:
+                continue
+            loc("server_1", npz, f"paired_finetune_{rel.parts[0]}", ds, rec)
+        # moved to server_2 (sha-verified move; .moved marker kept on server_1)
+        for mk in files([f"generated/{ds}/**/*.moved"]):
+            npz = mk[:-6] + ".npz"
+            rp = Path(mk[:-6] + ".log")
+            rec = json.loads(rp.read_text()) if rp.is_file() and rp.stat().st_size else None
+            rel = Path(npz).relative_to(T / "generated" / ds)
+            item_state = "completed" if rec else "presence_only"
+            loc("server_2", npz, f"paired_finetune_{rel.parts[0]}", ds, rec, state=item_state)
+            locs[-1]["move_marker_server_1"] = mk
+    # Imperial outputs live on server_2
+    for npz in remote_files(["generated/imperial_eskd/*/*.npz", "generated/imperial_eskd/fewshot_n5/*/*.npz",
+                             "generated/imperial_eskd/pooled/*.npz"]):
+        rec = remote_json(npz[:-4] + ".log")
+        if rec is None:
+            continue
+        rel = Path(npz).relative_to(T / "generated" / "imperial_eskd")
+        loc("server_2", npz, f"paired_finetune_{rel.parts[0]}", "imperial_eskd", rec)
+    # scSemiProfiler draws of the other datasets that ran on server_2 (queues server2_*.txt)
+    for npz in remote_files([f"generated/{ds}/fewshot_n5/draw*/scsemi5__raw.npz" for ds in DATASETS
+                             if ds != "imperial_eskd"]):
+        rec = remote_json(npz[:-4] + ".log")
+        if rec is None:
+            continue
+        rel = Path(npz).relative_to(T / "generated")
+        loc("server_2", npz, "paired_finetune_fewshot_n5", rel.parts[0], rec)
+    # scSemiProfiler baseline still running: register in-progress / planned draws by their future output path
+    done = {l["path"] for l in locs}
+    run_queues = [T / "scsemi" / "queues" / "server1_fewshot_d0first.txt"] + \
+        sorted((T / "scsemi" / "queues" / "as_run_server2").glob("server2_*.txt"))
+    for qf in run_queues:
+        host = "server_1" if qf.name.startswith("server1_") else "server_2"
+        for line in qf.read_text().splitlines():
+            if not line.startswith("fewshot|"):
+                continue
+            _, ds, j = line.split("|")[:3]
+            npz = str(T / "generated" / ds / "fewshot_n5" / f"draw{j}" / "scsemi5__raw.npz")
+            if npz in done:
+                continue
+            state = "planned"
+            locs.append({"host": host, "path": npz, "state": state, "experiment": "paired_finetune_fewshot_n5_scsemiprofiler",
+                         "cohort": ds, "artifact_role": "inference_output",
+                         "note": "scSemiProfiler 5-pair baseline queued or running on this host at request time"})
+            done.add(npz)
+    req = {
+        "project_id": "pbisc-diffusion",
+        "summary": (
+            "Within-dataset paired fine-tuning benchmark of the final 6k 1x E16 model (plans/paired_finetune_intradataset_20260927): "
+            "LoRA (recommended protocol), full and condition-encoder fine-tuning, sc-only control, LoRA learning curve, "
+            "K-augmentation null, 5-pair deployment scenario, on ImMicro, Ye 2026 sepsis, Imperial ESKD COVID, Giroux 2022 and "
+            "Ji 2025 (whole-blood bulk); scores (scANVI composition, precision/coverage, contrast logFC r, top-50 DEG), figures, "
+            "paired-data manifests, conditions, run receipts and the recommended-protocol LoRA checkpoints. The scSemiProfiler "
+            "5-pair baseline: every finished draw is included as score tables and a completed location; draws not yet "
+            "finished at request time (none on 2026-09-30: 25/25 done) are planned locations. Not uploaded: per-cell count "
+            "arrays and non-recommended fine-tuned checkpoints (sha256 recorded in BUILD/MANIFEST and RUN.json)."),
+        "assets": assets,
+        "inference_locations": locs,
+    }
+    Path(out).write_text(json.dumps(req, indent=1))
+    kinds = {}
+    for a in assets:
+        kinds[(a["host"], a["kind"])] = kinds.get((a["host"], a["kind"]), 0) + 1
+    print(json.dumps({"assets": len(assets), "by_host_kind": {f"{h}/{k}": v for (h, k), v in sorted(kinds.items())},
+                      "locations": len(locs), "location_states": {s: sum(l["state"] == s for l in locs) for s in {l["state"] for l in locs}}},
+                     indent=1))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1]))

paper-releases/pbisc-diffusion/updates/20261001T200638Z-extra-realism-metrics/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/collect_extra_metrics.py

@@ -0,0 +1,290 @@
+#!/usr/bin/env python3
+"""Collect the per-unit outputs of tools/extra_metrics.py into scores_extra/*.csv and scores_extra/TABLES.md.
+
+CPU, pandas only (no torch, no CUDA, no heavy imports). usage: collect_extra_metrics.py
+
+Files written (scores_extra/):
+  {fewshot,pooled}_{metrics,per_donor,en,en_per_sample}.csv   every unit's CSV, concatenated
+  {fewshot,pooled}_wide.csv                one row per unit x set x real_side x mode, with the E_N headline columns
+  {fewshot,pooled}_headline.csv            per cohort x arm (few-pair: mean, SD, n over draws) of the headline metrics
+  {fewshot,pooled}_reproduction_check.csv  k = 10 precision / coverage recomputed vs score_ft.py, per unit and set
+  run_time.csv                              seconds per unit (manifest.json)
+  TABLES.md                                 headline tables, all-variant tables, LoRA win counts, Kendall tau
+
+Headline metric spaces (README.md): classifier AUCs, 1-NN accuracy and MMD^2 from the out-of-sample real side (R2;
+control row = R2 vs R3); precision / coverage at k = 3 / 5 / 10 from the scorer's space (R1; control = R1 vs R2);
+E_N = scSemiProfiler's metric on all cells, squared L2 (control = within-sample half split). E_N is undefined when
+the arm's own upper bound does not exceed its lower bound (UB <= LB): such units are left out of the means (count
+shown as "†n") and rank last in the win counts.
+"""
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from scipy.stats import kendalltau
+
+TASK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+OUT = TASK / "scores_extra"
+DATASETS = ("immicro", "ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili")
+COHORT = {"immicro": "ImMicro", "ye2026_sepsis": "Sepsis", "imperial_eskd": "Imperial", "giroux2022": "Giroux",
+          "ji2025_chili": "Ji (whole blood)"}
+CONTROL, CONTROL_OOS = "real_R2", "real_R3"
+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", "pseudo_full__cal": "sc-only fine-tune (+ calibration)",
+         "zs_pseudo": "Zero-shot, sc pseudobulk input (ref.)", "zs__pseudo": "Zero-shot, sc pseudobulk input (ref.)",
+         CONTROL: "Real vs real control (R1 vs R2)", CONTROL_OOS: "Real vs real control (R2 vs R3)", "control": "Real vs real control"}
+ARMS = {"fewshot": ("zs_raw", "zs_cal", "scsemi5", "lora5", "zs_pseudo"),
+        "pooled": ("zs__raw", "zs__cal", "pseudo_full__cal", "real_lora__raw", "zs__pseudo")}
+LORA = {"fewshot": "lora5", "pooled": "real_lora__raw"}
+COMPARE = {"fewshot": ("scsemi5", "zs_raw", "zs_cal"), "pooled": ("zs__raw", "zs__cal", "pseudo_full__cal")}
+# (column, short name, direction: +1 higher better, -1 lower better, 0 closer to 0.5 better, space)
+TWO = [("c2st_knn_auc", "AUC kNN", 0), ("c2st_rf_auc", "AUC RF", 0), ("nn1_acc", "1-NN acc", 0),
+       ("mmd2_bw1", "MMD² (σ=m)", -1), ("mmd2_sum", "MMD² (σ sum)", -1)]
+ENC = [("en_all_sq", "E_N (all cells)", -1), ("en_pc_sq", "E_N (P/C cells)", -1)]
+PC = [(f"{q}_k{k}", f"{q[0].upper()} k{k}", 1) for k in (3, 5, 10) for q in ("precision", "coverage")]
+HEADLINE = [(c, n, s, "R2") for c, n, s in TWO] + [(ENC[0][0], ENC[0][1], -1, "EN")] + [(c, n, s, "R1") for c, n, s in PC]
+
+
+def now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def units(design: str) -> list[Path]:
+    glob = "*/fewshot_n5/draw*" if design == "fewshot" else "*/pooled"
+    return [d for d in sorted(OUT.glob(glob)) if (d / "manifest.json").is_file()]
+
+
+def wide(design: str) -> pd.DataFrame:
+    us = units(design)
+    if not us:
+        return pd.DataFrame()
+    met = pd.concat([pd.read_csv(d / "metrics.csv") for d in us], ignore_index=True)
+    en = pd.concat([pd.read_csv(d / "en.csv") for d in us], ignore_index=True)
+    en["bounds_ok"] = en.ub > en.lb
+    key = ["dataset", "design", "unit", "set"]
+    parts = []
+    for val, name in (("en", "en"), ("bounds_ok", "en_ok"), ("dif_mean", "dif"), ("lb", "lb"), ("ub", "ub"),
+                      ("en_reps_at_lb", "en_reps_at_lb")):
+        x = en.pivot_table(index=key, columns=["cellset", "distance"], values=val, aggfunc="first")
+        x.columns = [f"{name}_{c}_{d}" for c, d in x.columns]
+        parts.append(x)
+    e = pd.concat(parts, axis=1).reset_index()
+    w = met.merge(e, on=key, how="left")
+    w.loc[w.real_side == "R2", [c for c in e.columns if c not in key]] = np.nan   # E_N: one value per set (R1 rows)
+    return w
+
+
+def en_rank_value(row, col: str) -> float:
+    """E_N for ranking: +inf when undefined (UB <= LB), the value otherwise."""
+    ok = row.get(col.replace("en_", "en_ok_"), True)
+    return float(row[col]) if (ok is True or ok == 1.0) else np.inf
+
+
+def cell_stats(x: pd.DataFrame, col: str) -> tuple:
+    v = x[col].astype(float)
+    bad = 0
+    if col.startswith("en_") and col.replace("en_", "en_ok_") in x.columns:
+        ok = x[col.replace("en_", "en_ok_")].astype(bool)
+        bad = int((~ok).sum())
+        v = v[ok]
+    return (v.mean() if len(v) else np.nan, v.std(ddof=1) if len(v) > 1 else np.nan, len(v), bad)
+
+
+def fmt(m, sd=np.nan, bad=0, nd=3, show_sd=True) -> str:
+    if m is None or (isinstance(m, float) and np.isnan(m)):
+        s = "—"
+    else:
+        s = f"{m:.{nd}f}" if (abs(m) >= 10 ** -nd or m == 0) else f"{m:.1e}"
+        if show_sd and not np.isnan(sd):
+            s += f" ± {sd:.{nd}f}"
+    return s + (f" †{bad}" if bad else "")
+
+
+def better(a: float, b: float, sign: int) -> bool:
+    return (abs(a - 0.5) < abs(b - 0.5)) if sign == 0 else (a > b if sign > 0 else a < b)
+
+
+def pick(w: pd.DataFrame, ds: str, s: str, space: str) -> pd.DataFrame:
+    """Rows of one cohort x set in the metric's headline space (no depth matching)."""
+    side = "R2" if space == "R2" else "R1"
+    if s == "control":
+        s = CONTROL_OOS if space == "R2" else CONTROL
+    return w[(w.dataset == ds) & (w.set == s) & (w["mode"] == "raw") & (w.real_side == side)]
+
+
+def headline(w: pd.DataFrame, design: str) -> tuple[pd.DataFrame, list]:
+    rows, lines = [], []
+    sd = design == "fewshot"
+    lines.append("| cohort | arm | " + " | ".join(n for _, n, _, _ in HEADLINE) + " |")
+    lines.append("|---|---|" + "---:|" * len(HEADLINE))
+    for ds in DATASETS:
+        if not (w.dataset == ds).any():
+            continue
+        for s in ("control",) + ARMS[design]:
+            cells, rec = [], {"dataset": ds, "set": s, "label": LABEL[s]}
+            for c, n, _, space in HEADLINE:
+                x = pick(w, ds, s, space)
+                if x.empty or c not in x.columns:
+                    cells.append("—")
+                    continue
+                m, v, k, bad = cell_stats(x, c)
+                rec.update({c: m, f"{c}_sd": v, f"{c}_n": k, f"{c}_undefined": bad})
+                cells.append(fmt(m, v, bad, 4 if c.startswith("mmd") else 3, sd))
+            rows.append(rec)
+            name = f"**{LABEL[s]}**" if s == LORA[design] else LABEL[s]
+            lines.append(f"| {COHORT[ds]} | {name} | " + " | ".join(cells) + " |")
+    return pd.DataFrame(rows), lines
+
+
+def wins(w: pd.DataFrame, design: str) -> tuple[list, list]:
+    cols = HEADLINE + [(ENC[1][0], ENC[1][1], -1, "EN")]
+    lines = ["| cohort | LoRA vs | " + " | ".join(n for _, n, _, _ in cols) + " |", "|---|---|" + "---:|" * len(cols)]
+    exc = []
+    for ds in DATASETS:
+        for comp in COMPARE[design]:
+            cells, any_ = [], False
+            for c, n, sgn, space in cols:
+                L = pick(w, ds, LORA[design], space).set_index("unit")
+                C = pick(w, ds, comp, space).set_index("unit")
+                us = sorted(set(L.index) & set(C.index))
+                if not us or c not in L.columns:
+                    cells.append("—")
+                    continue
+                any_ = True
+                if c.startswith("en_"):
+                    pairs = [(en_rank_value(L.loc[u], c), en_rank_value(C.loc[u], c)) for u in us]
+                    k = sum(a < b for a, b in pairs)
+                    tie = sum(a == b for a, b in pairs)
+                else:
+                    pairs = [(float(L.at[u, c]), float(C.at[u, c])) for u in us]
+                    k = sum(better(a, b, sgn) for a, b in pairs)
+                    tie = sum(a == b for a, b in pairs)
+                tt = f" ({tie} tie)" if tie else ""
+                cells.append(f"{k}/{len(us)}{tt}" if design == "fewshot" else ("✓" if k else ("tie" if tie else "✗")))
+                if k + tie < len(us):
+                    exc.append(f"{COHORT[ds]}: LoRA worse than {LABEL[comp]} on {n} in {len(us) - k - tie}/{len(us)} "
+                               f"{'draws' if design == 'fewshot' else 'pooled call'}{tt}")
+            if any_:
+                lines.append(f"| {COHORT[ds]} | {LABEL[comp]} | " + " | ".join(cells) + " |")
+    return lines, exc
+
+
+def taus(w: pd.DataFrame, design: str) -> list:
+    """Kendall tau over the arms (control excluded) of each metric's cohort-mean ranking vs coverage / precision k10."""
+    cols = HEADLINE + [(ENC[1][0], ENC[1][1], -1, "EN")]
+    lines = ["| cohort | vs | " + " | ".join(n for _, n, _, _ in cols) + " |", "|---|---|" + "---:|" * len(cols)]
+    for ds in DATASETS:
+        if not (w.dataset == ds).any():
+            continue
+        score = {}
+        for s in ARMS[design]:
+            score[s] = {}
+            for c, _, sgn, space in cols:
+                x = pick(w, ds, s, space)
+                if x.empty:
+                    continue
+                if c.startswith("en_"):
+                    vals = [en_rank_value(r, c) for _, r in x.iterrows()]
+                    score[s][c] = -np.median(vals)              # median: robust to an undefined unit (+inf)
+                else:
+                    m = x[c].astype(float).mean()
+                    score[s][c] = -abs(m - 0.5) if sgn == 0 else sgn * m
+        S = pd.DataFrame(score).T
+        for ref in ("coverage_k10", "precision_k10"):
+            t = [kendalltau(S[c], S[ref]).statistic if c in S else np.nan for c, _, _, _ in cols]
+            lines.append(f"| {COHORT[ds]} | {ref.split('_')[0]} k10 | " + " | ".join(fmt(x, nd=2) for x in t) + " |")
+    return lines
+
+
+def variant_tables(w: pd.DataFrame, design: str) -> list:
+    lines = []
+    sd = design == "fewshot"
+    for side, mode in (("R1", "raw"), ("R1", "dm"), ("R2", "raw"), ("R2", "dm")):
+        sub = w[(w.real_side == side) & (w["mode"] == mode)]
+        cols = TWO + ([] if side == "R2" else PC) + (ENC if (side == "R1" and mode == "raw") else [])
+        lines += [f"#### real side {side}, {'no depth matching' if mode == 'raw' else 'depth matched'}", "",
+                  "| cohort | set | " + " | ".join(n for _, n, _ in cols) + " |", "|---|---|" + "---:|" * len(cols)]
+        for ds in DATASETS:
+            for s in ((CONTROL,) if side == "R1" else (CONTROL_OOS,)) + ARMS[design]:
+                x = sub[(sub.dataset == ds) & (sub.set == s)]
+                if x.empty:
+                    continue
+                cells = []
+                for c, _, _ in cols:
+                    m, v, _, bad = cell_stats(x, c)
+                    cells.append(fmt(m, v, bad, 4 if c.startswith("mmd") else 3, sd))
+                lines.append(f"| {COHORT[ds]} | {LABEL[s]} | " + " | ".join(cells) + " |")
+        lines.append("")
+    return lines
+
+
+def main() -> int:
+    md = ["# Extra realism / diversity metrics: tables", "",
+          f"Written by `tools/collect_extra_metrics.py` ({now()}). Definitions, parameters and citations: `README.md`.", "",
+          "Headline spaces: AUC (5-fold CV), 1-NN accuracy and MMD² use the **out-of-sample real side R2** (same PCA-50, "
+          "generated cells, subsample as the scorer; control row = R2 vs R3); precision (P) / coverage (C) are the "
+          "scorer's own (real side R1; control row = R1 vs R2); E_N = scSemiProfiler's normalized error on all cells, "
+          "squared L2 (control row = within-sample half split). AUC / 1-NN: 0.5 is ideal. † n = units where E_N is "
+          "undefined (the arm's UB ≤ LB), left out of the mean. No depth matching in the headline tables.", ""]
+    times = []
+    for design in ("fewshot", "pooled"):
+        us = units(design)
+        if not us:
+            continue
+        for name in ("metrics", "per_donor", "en", "en_per_sample"):
+            pd.concat([pd.read_csv(d / f"{name}.csv") for d in us], ignore_index=True).to_csv(
+                OUT / f"{design}_{name}.csv", index=False)
+        rep = []
+        for d in us:
+            r = json.loads((d / "repro.json").read_text())
+            m = json.loads((d / "manifest.json").read_text())
+            times.append({"dataset": m["dataset"], "design": design, "unit": m["unit"], "n_samples": m["n_samples"],
+                          "seconds": m["seconds"], "threads": m["threads"]})
+            for arm, c in r["arms"].items():
+                rep.append({"dataset": m["dataset"], "unit": m["unit"], "set": arm,
+                            **{k: (x["abs_diff"] if isinstance(x, dict) and "abs_diff" in x else x)
+                               for k, x in c.items() if k != "npz"}})
+        rp = pd.DataFrame(rep)
+        rp.to_csv(OUT / f"{design}_reproduction_check.csv", index=False)
+        w = wide(design)
+        w.to_csv(OUT / f"{design}_wide.csv", index=False)
+        title = ("(a) 5-donor few-pair design: mean ± SD over the 5 draws" if design == "fewshot"
+                 else "(b) 5-fold pooled design: one scoring call over all cross-fitted pairs")
+        hl, lines = headline(w, design)
+        hl.to_csv(OUT / f"{design}_headline.csv", index=False)
+        num = [c for c in rp.columns if c not in ("dataset", "unit", "set", "rows_and_subsample_equal_scorer")]
+        same = rp["rows_and_subsample_equal_scorer"].dropna().astype(bool).all() \
+            if "rows_and_subsample_equal_scorer" in rp else True
+        md += [f"## {title}", "", f"Units: {len(us)}. k = 10 reproduction: max |diff| vs score_ft.py = "
+               f"{np.nanmax(rp[num].to_numpy(dtype=float)):.1e} over {len(rp)} unit × set rows (pooled and per donor, "
+               f"raw and depth matched); scored rows and P/C subsample identical in every arm: {bool(same)}.", ""]
+        md += lines + [""]
+        wl, exc = wins(w, design)
+        md += [f"### {title}: is LoRA better than each comparator? "
+               + ("(draws where LoRA is better / draws)" if design == "fewshot" else "(✓ better / ✗ not)"), ""] + wl
+        md += ["", "Exceptions (LoRA worse; ties are not counted as worse):", ""] + ([f"- {e}" for e in exc] or ["- none"]) + [""]
+        md += [f"### {title}: Kendall τ of each metric's arm ranking with the coverage / precision (k = 10) ranking "
+               "(arms only; few-pair: means over draws, E_N medians)", ""] + taus(w, design) + [""]
+        md += [f"### {title}: every variant (real side R1 / R2, raw / depth matched)", ""] + variant_tables(w, design)
+    pd.DataFrame(times).to_csv(OUT / "run_time.csv", index=False)
+    if times:
+        t = pd.DataFrame(times)
+        md += ["## Run time per unit (seconds; server_1 CPU, few-pair 6 threads, pooled 8 threads)", "",
+               "| design | cohort | units | samples per unit | mean s | min s | max s |", "|---|---|---:|---:|---:|---:|---:|"]
+        for (dz, ds), x in t.groupby(["design", "dataset"], sort=False):
+            md.append(f"| {dz} | {COHORT[ds]} | {len(x)} | {int(x.n_samples.median())} | {x.seconds.mean():.0f} | "
+                      f"{x.seconds.min():.0f} | {x.seconds.max():.0f} |")
+        md.append("")
+    (OUT / "TABLES.md").write_text("\n".join(md) + "\n")
+    print(f"collected -> {OUT / 'TABLES.md'}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261001T200638Z-extra-realism-metrics/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/extra_metrics.py

@@ -0,0 +1,849 @@
+#!/usr/bin/env python3
+"""Reviewer-expected realism / diversity metrics for the paired fine-tuning benchmark (CPU only; never imports torch).
+
+Added 2026-10-01. Every scored unit (one few-pair draw, or one pooled 5-fold call) is re-read exactly as tools/score_ft.py
+scored it, and four metric families are added next to the existing precision/coverage:
+
+  1. classifier two-sample tests (real vs generated): kNN (k = 5) and random-forest 5-fold cross-validated ROC AUC
+     (scGAN / scDiffusion style) and the leave-one-out 1-NN accuracy (scLDM; Lopez-Paz & Oquab 2017);
+  2. MMD^2 (unbiased, Gaussian RBF; median-heuristic bandwidth and the fixed multiples 0.5 / 1 / 2, plus their sum);
+  3. scSemiProfiler's normalized error E_N (Wang et al. 2024, Methods eq. 17-18; get_error in vendor utils.py);
+  4. precision / coverage at k = 3 and 5 next to k = 10 (k = 10 re-computed first and checked against score_ft.py).
+
+Families 1, 2 and 4 use exactly the scorer's embedding and cells: score_ft.make_view (PCA-50 fitted on the scored
+donors' R1 cells), the scorer's whole-NPZ Poisson read-out (seed 20260916), its donor-keyed generated subsample
+(F.generated_subsample) and its pairwise depth matching (F.SB.depth_match with a fresh rng(20260929)). They are
+reported both without ("raw", the deck's headline precision/coverage) and with depth matching ("dm"). The
+real-vs-real control is the scorer's own: held-out real cells R2 of the same donors, same n per donor.
+
+E_N follows scSemiProfiler's own space instead: per arm, log1p CP10K -> PCA-100 fitted on real and generated cells
+together; Dif_sc = symmetric 1-NN distance (eq. 17); lower bound = random half split of the whole PCA matrix; upper
+bound = random pairs of different real samples. Distances: squared L2 as their code computes them (faiss
+IndexFlatL2), and plain L2 as the paper's text writes them. Two cell sets:
+  "all": every observed QC cell of each scored sample vs all of its generated cells (their setting);
+         control = a random within-sample half split of the observed cells (half A as 'real', half B as 'generated').
+  "pc":  the precision/coverage cells (R1 vs the generated subsample, n per donor equal); control = R1 vs R2.
+Representatives: scSemiProfiler sets a representative's error to the lower bound. Our scored samples never include a
+representative (the 5 training donors of a few-pair draw are not scored in any arm), so no sample is set to LB; for
+scsemi5 the table also gives the value that convention would produce (E_N x n_test / (n_test + n_representative_rows)).
+
+usage (CPU; run through tools/run_extra_unit.sh):
+  extra_metrics.py --design fewshot --dataset giroux2022 --draws 0,1,2,3,4 [--threads 7] [--no-en-all]
+  extra_metrics.py --design pooled  --dataset giroux2022
+  extra_metrics.py --collect                     # scores_extra/*.csv + TABLES.md from every unit written so far
+Outputs: scores_extra/<dataset>/<fewshot_n5/draw<j> | pooled>/{metrics.csv, per_donor.csv, en.csv, en_per_sample.csv,
+         repro.json, manifest.json}.
+"""
+from __future__ import annotations
+
+import os
+import sys
+
+
+def _threads_from_argv(default: int = 7) -> 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 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
+
+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)
+
+TASK = F.TASK
+SCORES = TASK / "scores"
+CODE_FILES = (Path(__file__).resolve(), TOOLS / "ft_common.py", TOOLS / "score_ft.py", F.SB_PATH)
+OUT_ROOT = TASK / "scores_extra"
+REMOTE = "spark-0110"
+MIN_FREE_GIB = 40.0
+
+SEED = 20261001                      # every new random stream of this file (CV folds, RF, bandwidth subsample, E_N)
+KS = (3, 5, 10)
+KNN_C2ST_K = 5                       # sklearn default, scDiffusion's kNN classifier
+RF_TREES = 300                       # scGAN: fully grown trees, max_features = sqrt; 300 instead of 1000 trees (cost)
+CV_FOLDS = 5                         # scGAN: five-fold cross-validation, equal real / generated counts
+BW_MULTIPLES = (0.5, 1.0, 2.0)       # scGAN: sigma in {m/2, m, 2m}
+BW_MAX_CELLS = 4000                  # R1 cells used for the median pairwise distance
+EN_PCS = 100                         # scSemiProfiler: PCA to 100 dimensions
+EN_LB_MAX_QUERIES = 20000            # all-cells E_N: LB estimated from this many query cells per direction (index = full half)
+EN_CHUNK = 8192
+
+FEW_ARMS = ("zs_raw", "zs_cal", "scsemi5", "lora5", "zs_pseudo")
+POOLED_ARMS = ("zs__raw", "zs__cal", "pseudo_full__cal", "real_lora__raw", "zs__pseudo")
+CONTROL = "real_R2"                  # R1 vs R2 (P/C cells) / within-sample half split (all cells)
+CONTROL_OOS = "real_R3"              # out-of-sample real side: R2' vs R3 (families 1-2)
+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", "pseudo_full__cal": "sc-only fine-tune (+ calibration)",
+             "zs_pseudo": "Zero-shot, sc pseudobulk input (reference)",
+             "zs__pseudo": "Zero-shot, sc pseudobulk input (reference)",
+             CONTROL: "Real vs real control (held-out real cells)",
+             CONTROL_OOS: "Real vs real control (out-of-sample: R2 vs R3)"}
+DATASETS = ("immicro", "ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili")
+
+
+def log(msg: str) -> None:
+    F.log(msg)
+
+
+# =========================================================================== pure metric functions
+def sqdist_min(Q: np.ndarray, X: np.ndarray, *, exclude_self: bool = False, max_block: float = 1.5e8) -> tuple:
+    """For every row of Q: the minimum squared L2 distance to the rows of X and its index (brute force, float64,
+    chunked BLAS). exclude_self: Q is X and the diagonal is skipped (leave-one-out)."""
+    Q = np.ascontiguousarray(Q, dtype=np.float64)
+    X = np.ascontiguousarray(X, dtype=np.float64)
+    xx = np.einsum("ij,ij->i", X, X)
+    qq = np.einsum("ij,ij->i", Q, Q)
+    out = np.empty(Q.shape[0])
+    arg = np.empty(Q.shape[0], dtype=np.int64)
+    chunk = max(16, int(max_block // max(X.shape[0], 1)))
+    for s in range(0, Q.shape[0], chunk):
+        e = min(s + chunk, Q.shape[0])
+        D = qq[s:e, None] + xx[None, :] - 2.0 * (Q[s:e] @ X.T)
+        if exclude_self:
+            D[np.arange(e - s), np.arange(s, e)] = np.inf
+        a = np.argmin(D, axis=1)
+        arg[s:e] = a
+        out[s:e] = np.maximum(D[np.arange(e - s), a], 0.0)
+    return out, arg
+
+
+def one_nn_loo(zr: np.ndarray, zg: np.ndarray) -> dict:
+    """Leave-one-out 1-NN two-sample accuracy (Lopez-Paz & Oquab 2017; scLDM eq. 32): pool both sets, predict each
+    point's label by its nearest other point; 0.5 = indistinguishable, 1 = separable."""
+    Z = np.vstack([zr, zg])
+    y = np.r_[np.ones(len(zr), bool), np.zeros(len(zg), bool)]
+    _, a = sqdist_min(Z, Z, exclude_self=True)
+    ok = y[a] == y
+    return {"nn1_acc": float(ok.mean()), "nn1_acc_real": float(ok[y].mean()), "nn1_acc_gen": float(ok[~y].mean())}
+
+
+def c2st_auc(zr: np.ndarray, zg: np.ndarray, *, kind: str, seed: int = SEED, n_jobs: int = 1) -> dict:
+    """Classifier two-sample test: stratified 5-fold CV ROC AUC of real (1) vs generated (0); mean and SD over folds."""
+    from sklearn.ensemble import RandomForestClassifier
+    from sklearn.metrics import roc_auc_score
+    from sklearn.model_selection import StratifiedKFold
+    from sklearn.neighbors import KNeighborsClassifier
+    Z = np.vstack([zr, zg]).astype(np.float32)
+    y = np.r_[np.ones(len(zr), np.int8), np.zeros(len(zg), np.int8)]
+    aucs = []
+    for tr, te in StratifiedKFold(CV_FOLDS, shuffle=True, random_state=seed).split(Z, y):
+        if kind == "knn":
+            clf = KNeighborsClassifier(n_neighbors=KNN_C2ST_K, n_jobs=n_jobs)
+        elif kind == "rf":
+            clf = RandomForestClassifier(n_estimators=RF_TREES, max_features="sqrt", n_jobs=n_jobs, random_state=seed)
+        else:
+            raise ValueError(kind)
+        clf.fit(Z[tr], y[tr])
+        p = clf.predict_proba(Z[te])[:, list(clf.classes_).index(1)]
+        aucs.append(roc_auc_score(y[te], p))
+    return {f"c2st_{kind}_auc": float(np.mean(aucs)), f"c2st_{kind}_auc_sd": float(np.std(aucs, ddof=1))}
+
+
+def median_bandwidth(z: np.ndarray, *, seed: int = SEED, max_cells: int = BW_MAX_CELLS) -> float:
+    """Median heuristic (Gretton et al. 2012): median pairwise Euclidean distance among (<= max_cells) real cells."""
+    rng = np.random.default_rng(seed)
+    idx = np.sort(rng.choice(len(z), size=min(max_cells, len(z)), replace=False))
+    x = np.asarray(z[idx], np.float64)
+    sq = np.einsum("ij,ij->i", x, x)
+    D = np.maximum(sq[:, None] + sq[None, :] - 2 * x @ x.T, 0.0)
+    iu = np.triu_indices(len(x), 1)
+    return float(np.sqrt(np.median(D[iu])))
+
+
+def _kernel_sums(A: np.ndarray, B: np.ndarray, sigmas, same: bool, max_block: float = 6e7) -> np.ndarray:
+    """sum over pairs of exp(-||a - b||^2 / (2 sigma^2)) for every sigma (diagonal excluded when same)."""
+    A = np.ascontiguousarray(A, np.float64)
+    B = np.ascontiguousarray(B, np.float64)
+    aa, bb = np.einsum("ij,ij->i", A, A), np.einsum("ij,ij->i", B, B)
+    g = np.asarray([1.0 / (2.0 * s * s) for s in sigmas])
+    tot = np.zeros(len(sigmas))
+    chunk = max(16, int(max_block // max(len(B), 1)))
+    for s in range(0, len(A), chunk):
+        e = min(s + chunk, len(A))
+        D = np.maximum(aa[s:e, None] + bb[None, :] - 2.0 * (A[s:e] @ B.T), 0.0)
+        for i, gi in enumerate(g):
+            K = np.exp(-gi * D)
+            if same:
+                K[np.arange(e - s), np.arange(s, e)] = 0.0
+            tot[i] += K.sum()
+    return tot
+
+
+def mmd2_unbiased(zr: np.ndarray, zg: np.ndarray, sigmas) -> np.ndarray:
+    """Unbiased MMD^2 (Gretton et al. 2012, eq. 3) with Gaussian RBF k(x, y) = exp(-||x - y||^2 / (2 sigma^2)), one value
+    per sigma; the kernel sum over the sigmas (scGAN's multi-scale kernel) is the sum of the per-sigma values."""
+    n, m = len(zr), len(zg)
+    kxx = _kernel_sums(zr, zr, sigmas, True) / (n * (n - 1))
+    kyy = _kernel_sums(zg, zg, sigmas, True) / (m * (m - 1))
+    kxy = _kernel_sums(zr, zg, sigmas, False) / (n * m)
+    return kxx + kyy - 2.0 * kxy
+
+
+def pc_at_k(zr: np.ndarray, zg: np.ndarray, k: int) -> dict:
+    """Kynkaanniemi precision and Naeem coverage / density with k-NN balls of the real set: the scorer's own
+    stage_b_embed functions (knn_radius, precision_coverage). density is rescaled from SB's fixed k = 10 to k."""
+    radius = F.SB.knn_radius(zr, k)
+    r = F.SB.precision_coverage(zr, radius, zg)
+    r["density"] = r["density"] * F.K_NN / k
+    return r
+
+
+def expected_coverage(n_real: int, n_gen: int, k: int) -> float:
+    """Naeem et al. 2020, eq. 9: E[coverage] for identical real and fake distributions."""
+    num = np.prod([(n_real - i) for i in range(1, k + 1)], dtype=np.float64)
+    den = np.prod([(n_gen + n_real - i) for i in range(1, k + 1)], dtype=np.float64)
+    return float(1.0 - num / den)
+
+
+def two_sample_block(zr: np.ndarray, zg: np.ndarray, sigma_m: float, *, n_jobs: int, rf: bool = True) -> dict:
+    out = {}
+    out.update(c2st_auc(zr, zg, kind="knn", n_jobs=n_jobs))
+    if rf:
+        out.update(c2st_auc(zr, zg, kind="rf", n_jobs=n_jobs))
+    out.update(one_nn_loo(zr, zg))
+    sig = [m * sigma_m for m in BW_MULTIPLES]
+    mm = mmd2_unbiased(zr, zg, sig)
+    for mult, val in zip(BW_MULTIPLES, mm):
+        out[f"mmd2_bw{mult:g}"] = float(val)
+    out["mmd2_sum"] = float(mm.sum())
+    out["mmd_bandwidth_m"] = float(sigma_m)
+    return out
+
+
+# =========================================================================== scSemiProfiler E_N
+def log1p_cp10k_sparse(X: sp.csr_matrix) -> sp.csr_matrix:
+    """SB.cp10k_log1p (per-cell CP10K over the columns, log1p; empty cells stay zero) kept sparse, float32."""
+    X = X.tocsr().astype(np.float64)
+    lib = np.asarray(X.sum(axis=1)).ravel()
+    D = (sp.diags(np.divide(F.CP10K, lib, out=np.zeros_like(lib), where=lib > 0)) @ X).tocsr()
+    D.data = np.log1p(D.data)
+    return D.astype(np.float32)
+
+
+class Gram:
+    """Running X^T X, column sums and row count of log1p-CP10K features (float64), for an exact PCA by eigh of the
+    covariance (the solver sklearn's PCA calls covariance_eigh; equal to the full-SVD PCA up to component signs)."""
+
+    def __init__(self, p: int):
+        self.G = np.zeros((p, p))
+        self.s = np.zeros(p)
+        self.n = 0
+
+    def add(self, L: sp.csr_matrix, chunk: int = EN_CHUNK) -> "Gram":
+        for a in range(0, L.shape[0], chunk):
+            B = L[a:a + chunk].toarray()                       # float32 (log1p CP10K)
+            self.G += (B.T @ B).astype(np.float64)              # sgemm within a chunk, float64 across chunks
+            self.s += B.sum(0, dtype=np.float64)
+            self.n += B.shape[0]
+        return self
+
+    def __add__(self, other: "Gram") -> "Gram":
+        g = Gram(len(self.s))
+        g.G, g.s, g.n = self.G + other.G, self.s + other.s, self.n + other.n
+        return g
+
+    def pca(self, n_comp: int = EN_PCS) -> tuple[np.ndarray, np.ndarray]:
+        from scipy.linalg import eigh
+        p = len(self.s)
+        n_comp = int(min(n_comp, p, self.n - 1))
+        mu = self.s / self.n
+        C = (self.G - self.n * np.outer(mu, mu)) / (self.n - 1)
+        w, V = eigh(C, subset_by_index=[p - n_comp, p - 1])
+        return mu, np.ascontiguousarray(V[:, ::-1].T)          # components x genes, descending variance
+
+
+def embed(L: sp.csr_matrix, mu: np.ndarray, comps: np.ndarray, chunk: int = EN_CHUNK) -> np.ndarray:
+    """(x - mu) @ comps.T for sparse features x (dense row chunks, float64 BLAS)."""
+    out = np.empty((L.shape[0], comps.shape[0]))
+    for a in range(0, L.shape[0], chunk):
+        out[a:a + chunk] = (L[a:a + chunk].toarray().astype(np.float64) - mu) @ comps.T
+    return out
+
+
+def dif_sc(a: np.ndarray, b: np.ndarray) -> dict:
+    """scSemiProfiler eq. 17 with K = 1: mean over the cells of both samples of the distance to the nearest cell of the
+    other sample. 'sq' = squared L2 (their code: faiss IndexFlatL2), 'l2' = L2 (their text)."""
+    da, _ = sqdist_min(a, b)
+    db, _ = sqdist_min(b, a)
+    n = len(a) + len(b)
+    return {"sq": float((da.sum() + db.sum()) / n), "l2": float((np.sqrt(da).sum() + np.sqrt(db).sum()) / n)}
+
+
+def lower_bound(Z: np.ndarray, rng: np.random.Generator, max_queries: int | None) -> dict:
+    """LB: random half split of the whole PCA matrix (real + generated), symmetric 1-NN (their code: shuffle, first
+    n//2 rows vs the rest). With max_queries, each direction averages max_queries random query cells of one half
+    against the complete other half (an unbiased estimate of the same mean)."""
+    perm = rng.permutation(len(Z))
+    h = len(Z) // 2
+    A, B = Z[perm[:h]], Z[perm[h:]]
+    qa = A if (max_queries is None or len(A) <= max_queries) else A[np.sort(rng.choice(len(A), max_queries, replace=False))]
+    qb = B if (max_queries is None or len(B) <= max_queries) else B[np.sort(rng.choice(len(B), max_queries, replace=False))]
+    da, _ = sqdist_min(qa, B)
+    db, _ = sqdist_min(qb, A)
+    exact = len(qa) == len(A) and len(qb) == len(B)
+    if exact:   # their arithmetic: mean over the concatenated distances of both directions
+        sq = float((da.sum() + db.sum()) / (len(da) + len(db)))
+        l2 = float((np.sqrt(da).sum() + np.sqrt(db).sum()) / (len(da) + len(db)))
+    else:       # same weights as the exact concatenation (|A| and |B| cells), each direction estimated
+        wa, wb = len(A) / (len(A) + len(B)), len(B) / (len(A) + len(B))
+        sq = float(wa * da.mean() + wb * db.mean())
+        l2 = float(wa * np.sqrt(da).mean() + wb * np.sqrt(db).mean())
+    return {"sq": sq, "l2": l2, "exact": exact, "n_queries": [int(len(qa)), int(len(qb))], "n_half": [int(len(A)), int(len(B))]}
+
+
+def en_from_embeddings(gts: list, semis: list, rng: np.random.Generator, *, lb_max_queries: int | None,
+                       Z_all: np.ndarray) -> dict:
+    """E_N for one arm from per-sample embeddings (PCA already fitted on real + generated together).
+    UB: per sample i a uniformly random partner j != i (real cells of both), Dif averaged over samples.
+    Dif_i: real vs generated of sample i. E_N = (mean_i Dif_i - LB) / (UB - LB) (eq. 18); per sample (Dif_i - LB) / (UB - LB)."""
+    P = len(gts)
+    lb = lower_bound(Z_all, rng, lb_max_queries)
+    partner = (np.arange(P) + rng.integers(1, P, size=P)) % P if P > 1 else np.zeros(P, int)
+    ub_i = [dif_sc(gts[i], gts[partner[i]]) for i in range(P)]
+    dif_i = [dif_sc(gts[i], semis[i]) for i in range(P)]
+    out = {"lb": lb, "partner": partner.tolist(), "per_sample": []}
+    for d in ("sq", "l2"):
+        ub = float(np.mean([u[d] for u in ub_i]))
+        dif = np.asarray([x[d] for x in dif_i])
+        out[d] = {"lb": lb[d], "ub": ub, "dif_mean": float(dif.mean()), "en": float((dif.mean() - lb[d]) / (ub - lb[d])),
+                  "en_i": ((dif - lb[d]) / (ub - lb[d])).tolist(), "dif_i": dif.tolist()}
+    return out
+
+
+def get_error_legacy(gts: list, semis: list, representatives: list, cluster_labels: list, n_comp: int = EN_PCS) -> dict:
+    """Line-by-line re-statement of scSemiProfiler utils.get_error for one round (global np.random state, sklearn PCA,
+    self-pairing allowed in the UB, representatives at LB, squared L2). Only for the equivalence test."""
+    from sklearn.decomposition import PCA
+    P = len(gts)
+    X = np.concatenate([np.concatenate(gts, 0), np.concatenate(semis, 0)], 0)
+    Xr = PCA(n_components=n_comp).fit_transform(X)
+    xg, xs, off = [], [], 0
+    for g in gts:
+        xg.append(Xr[off:off + len(g)])
+        off += len(g)
+    for s in semis:
+        xs.append(Xr[off:off + len(s)])
+        off += len(s)
+    lbgt = Xr.copy()
+    np.random.shuffle(lbgt)
+    h = lbgt.shape[0] // 2
+    a, b = lbgt[:h], lbgt[h:]
+    da, _ = sqdist_min(a, b)
+    db, _ = sqdist_min(b, a)
+    lb = float(np.r_[da, db].mean())
+    ubs = []
+    for i in range(P):
+        r = np.random.randint(0, P)
+        ubs.append(dif_sc(xg[i], xg[r])["sq"])
+    ub = float(np.mean(ubs))
+    semi = [lb if i in representatives else dif_sc(xg[i], xs[i])["sq"] for i in range(P)]
+    naive = [lb if i in representatives else dif_sc(xg[i], xg[representatives[cluster_labels[i]]])["sq"] for i in range(P)]
+    return {"upperbound": ub, "lowerbound": lb, "semierror": float(np.mean(semi)), "naiveerror": float(np.mean(naive)),
+            "en_semi": (float(np.mean(semi)) - lb) / (ub - lb)}
+
+
+# =========================================================================== unit inputs
+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_npz(path: Path, want_sha: str, fetch_root: Path, fetched: list) -> Path:
+    """The scored NPZ: the local file if present, else a sha-checked copy from server_2 (same path) under fetch_root,
+    with its receipt (.log) next to it 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 dst.with_suffix(".log").is_file():
+        if sha256(dst) == want_sha:
+            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
+    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)
+    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 NPZ sha {want_sha[:12]}")
+    if marker.is_file():
+        txt = marker.read_text()
+        if f"sha {want_sha[:12]}" not in txt:
+            raise SystemExit(f"{marker}: marker sha differs ({txt.strip()})")
+    return dst
+
+
+def unit_calls(design: str, ds: str, draw: int | None) -> list[tuple[Path, tuple]]:
+    if design == "fewshot":
+        base = SCORES / ds / "fewshot_n5"
+        return [(base / f"draw{draw}", ("zs_raw", "zs_cal", "lora5", "zs_pseudo")), (base / f"draw{draw}_scsemi5", ("scsemi5",))]
+    if design == "pooled":
+        return [(SCORES / ds / "pooled", POOLED_ARMS)]
+    raise ValueError(design)
+
+
+def unit_dir(design: str, ds: str, draw: int | None) -> Path:
+    return OUT_ROOT / ds / (f"fewshot_n5/draw{draw}" if design == "fewshot" else "pooled")
+
+
+def observed_cells(spec, ref: dict, man: dict, donors: np.ndarray, cache: dict) -> tuple[list, dict]:
+    """All observed QC cells of the scored samples on the scoring genes (counts), per sample in the reference's
+    canonical cell order, from the same files the reference was built from (inputs sha-checked against
+    reference_manifest.json). cache: per dataset, reused by the draws of one process."""
+    if spec.name not in cache:
+        cache.clear()
+        cache[spec.name] = _observed_all(spec, ref, man)
+    X, srow, sid, inputs = cache[spec.name]
+    out = []
+    for d in donors:
+        out.append(X[np.flatnonzero(srow == int(np.flatnonzero(sid == d)[0]))].tocsr())
+    n = np.asarray([o.shape[0] for o in out])
+    ref_n = ref["n_cells"][[int(np.flatnonzero(ref["donors"].astype(str) == d)[0]) for d in donors]]
+    if not np.array_equal(n, ref_n):
+        raise SystemExit("observed cell counts per sample differ from the reference")
+    return out, {"inputs_sha256": inputs, "n_cells_total": int(n.sum())}
+
+
+def _observed_all(spec, ref: dict, man: dict):
+    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")
+    keys, _ = F.cell_keys(cells["table"].reset_index(drop=True))
+    srow = np.asarray(cells["sample_row"])
+    order = np.lexsort((keys, srow))          # the reference's canonical order (F.build_reference)
+    X = cells["X"].tocsr()[order][:, gs["score_idx"]].tocsr().astype(np.float32)
+    return X, srow[order], feat["sample_ids"], cells["inputs_sha256"]
+
+
+CODE_SHA256 = {str(p): sha256(p) for p in CODE_FILES}   # at import = the code this process runs
+
+
+# =========================================================================== one unit
+def pair_embeddings(v: dict, R: sp.csr_matrix, r_d: np.ndarray, Q: sp.csr_matrix, q_d: np.ndarray,
+                    zr_raw: np.ndarray | None = None) -> dict:
+    """Real set R and query set Q in the scorer's PCA-50: 'raw' = SB.project; 'dm' = score_ft.depth_matched's own
+    steps (SB.depth_match of the pair with a fresh rng(DEPTH_SEED), real set in the 'R1' slot, then SB.project),
+    returning the embeddings instead of only their precision/coverage. zr_raw: the view's fitted z1 for R = R1."""
+    names = v["donors"]
+    thinned, _ = F.SB.depth_match({"R1": R, "Q": Q}, {"R1": names[r_d], "Q": names[q_d]}, list(names),
+                                  np.random.default_rng(F.DEPTH_SEED))
+    return {"raw": (zr_raw if zr_raw is not None else F.SB.project(R, v["mean"], v["comps"]),
+                    F.SB.project(Q, v["mean"], v["comps"])),
+            "dm": (F.SB.project(thinned["R1"], v["mean"], v["comps"]), F.SB.project(thinned["Q"], v["mean"], v["comps"]))}
+
+
+def per_donor_pc(r1_d, q_d, S_, res) -> tuple:
+    nq, n1 = np.bincount(q_d, minlength=S_), np.bincount(r1_d, minlength=S_)
+    return (np.bincount(q_d, weights=res["inside"], minlength=S_) / nq,
+            np.bincount(r1_d, weights=res["covered"], minlength=S_) / n1)
+
+
+def score_set(name: str, v: dict, Q: sp.csr_matrix, q_d: np.ndarray, sigma_m: float, n_jobs: int,
+              expect: dict | None, oos: tuple | None) -> tuple[list, pd.DataFrame, dict]:
+    """Families 1, 2, 4 for one query set (an arm's P/C subsample, or R2), raw and depth matched, real side = R1
+    (the scorer's space). oos = (R2 counts, R2 donor index, set name): families 1-2 again with R2 as the real side."""
+    S_ = v["donors"].size
+    E = pair_embeddings(v, v["R1"], v["r1_d"], Q, q_d, zr_raw=v["z1"])
+    rows, per, chk = [], {"donor": v["donors"], "set": name}, {}
+    for mode, (zr, zg) in E.items():
+        t0 = time.monotonic()
+        m = {"set": name, "real_side": "R1", "mode": mode, "n_real": int(len(zr)), "n_gen": int(len(zg))}
+        for k in KS:
+            # k = 10 raw: the view's own radii (score_ft.arm_metrics); every other k / mode: radii recomputed on zr
+            res = F.SB.precision_coverage(zr, v["radius"], zg) if (k == F.K_NN and mode == "raw") else pc_at_k(zr, zg, k)
+            m[f"precision_k{k}"], m[f"coverage_k{k}"], m[f"density_k{k}"] = res["precision"], res["coverage"], res["density"]
+            m[f"expected_coverage_identical_k{k}"] = expected_coverage(len(zr), len(zg), k)
+            pp, pc = per_donor_pc(v["r1_d"], q_d, S_, res)
+            per[f"precision_k{k}_{mode}"], per[f"coverage_k{k}_{mode}"] = pp, pc
+        m.update(two_sample_block(zr, zg, sigma_m, n_jobs=n_jobs))
+        m["seconds"] = round(time.monotonic() - t0, 1)
+        rows.append(m)
+        log(f"  {name} [R1 {mode}] P/C k10 {m['precision_k10']:.4f}/{m['coverage_k10']:.4f} k5 {m['precision_k5']:.4f}/"
+            f"{m['coverage_k5']:.4f} k3 {m['precision_k3']:.4f}/{m['coverage_k3']:.4f} | AUC knn {m['c2st_knn_auc']:.3f} "
+            f"rf {m['c2st_rf_auc']:.3f} | 1-NN {m['nn1_acc']:.3f} | MMD2 {m['mmd2_bw1']:.4f} ({m['seconds']} s)")
+    if oos is not None:
+        R2, r2_d, oname = oos
+        for mode, (zr, zg) in pair_embeddings(v, R2, r2_d, Q, q_d).items():
+            t0 = time.monotonic()
+            m = {"set": oname, "real_side": "R2", "mode": mode, "n_real": int(len(zr)), "n_gen": int(len(zg))}
+            m.update(two_sample_block(zr, zg, sigma_m, n_jobs=n_jobs))
+            m["seconds"] = round(time.monotonic() - t0, 1)
+            rows.append(m)
+            log(f"  {oname} [R2 {mode}] AUC knn {m['c2st_knn_auc']:.3f} rf {m['c2st_rf_auc']:.3f} | 1-NN {m['nn1_acc']:.3f} "
+                f"| MMD2 {m['mmd2_bw1']:.4f} ({m['seconds']} s)")
+    if expect is not None:   # reproduction of the scorer's k = 10 values
+        for mode, key in (("raw", ""), ("dm", "_depth_matched")):
+            mm = next(r for r in rows if r["mode"] == mode)
+            for q in ("precision", "coverage"):
+                chk[f"{q}{key}"] = {"ours": mm[f"{q}_k10"], "scorer": expect[f"{q}{key}"],
+                                    "abs_diff": abs(mm[f"{q}_k10"] - expect[f"{q}{key}"])}
+                if "per_donor" in expect:
+                    d = np.abs(per[f"{q}_k10_{mode}"] - expect["per_donor"][f"{q}{key}"])
+                    chk[f"{q}{key}_per_donor_max_abs_diff"] = float(d.max())
+    return rows, pd.DataFrame(per), chk
+
+
+def run_unit(design: str, ds: str, draw: int | None, a) -> None:
+    t_unit = time.monotonic()
+    spec = F.DATASETS[ds]
+    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():   # another process (other stream) is computing this unit: skip unless its pid is gone
+        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, t_unit, spec, out)
+    finally:
+        lock.unlink(missing_ok=True)
+
+
+def _run_unit(design: str, ds: str, draw: int | None, a, t_unit: float, spec, out: Path) -> None:
+    calls = unit_calls(design, ds, draw)
+    summ = {}
+    for cdir, arms in calls:
+        s = json.loads((cdir / "summary.json").read_text())
+        miss = [x for x in arms if x not in s["arms"]]
+        if miss:
+            raise SystemExit(f"{cdir}: arms {miss} not scored there")
+        summ[cdir] = s
+    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")
+    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")
+    log(f"{ds} {design} {'' if draw is None else f'draw{draw} '}: {len(donors)} scored samples; fitting the scorer's view")
+    v = S.make_view(ref, donors)
+    repro = {"unit": str(out), "pca": {"ours": v["pca"], "scorer": first["reference"]["pca"]},
+             "r2_control": {"ours": v["r2_control"], "scorer": first["reference"]["r2_control"]}, "arms": {}}
+    S_ = v["donors"].size
+    sigma_m = median_bandwidth(v["z1"])
+    log(f"bandwidth m (median pairwise distance of R1, PCA-50) = {sigma_m:.4f}")
+    rows, per_frames, en_rows, en_ps = [], [], [], []
+    fetched: list[Path] = []
+    fetch_root = Path(a.fetch_dir)
+
+    # ---------------- E_N inputs shared by all arms
+    rng_c = F.donor_rng
+    R1L = log1p_cp10k_sparse(v["R1"])
+    gram_r1 = Gram(R1L.shape[1]).add(R1L)
+    r1_split = [np.flatnonzero(v["r1_d"] == s) for s in range(S_)]
+    obs, obs_info = observed_cells(spec, ref, man, v["donors"], a.obs_cache)
+    # out-of-sample real sets from the scorer's donor-keyed permutation (F.reference_split): R1 = perm[:n],
+    # R2 = perm[n:2n] (both checked equal to reference.npz), R3 = perm[2n:3n] (fewer cells when the sample is small);
+    # the R2-vs-R3 control uses R2' = perm[n:n+m], m = min(n, |R3|), so both sides have the same size per sample.
+    r3_blocks, r2b_blocks, r3_d, r2b_d, oos_info = [], [], [], [], {"n_r3": [], "short_samples": []}
+    for k in range(S_):
+        nk, d = obs[k].shape[0], str(v["donors"][k])
+        a1, a2 = F.reference_split(nk, d)
+        if (obs[k][a1] != v["R1"][np.flatnonzero(v["r1_d"] == k)]).nnz or \
+                (obs[k][a2] != v["R2"][np.flatnonzero(v["r2_d"] == k)]).nnz:
+            raise SystemExit(f"{d}: R1 / R2 rebuilt from the observed cells differ from reference.npz")
+        perm = F.donor_rng(F.SUB_SEED, d).permutation(nk)
+        n = a1.size
+        r3 = np.sort(perm[2 * n:3 * n])
+        m_ = r3.size
+        if m_ < n:
+            oos_info["short_samples"].append({"sample": d, "n": int(n), "n_r3": int(m_)})
+        r3_blocks.append(obs[k][r3])
+        r2b_blocks.append(obs[k][np.sort(perm[n:n + m_])])
+        r3_d.append(np.full(m_, k))
+        r2b_d.append(np.full(m_, k))
+        oos_info["n_r3"].append(int(m_))
+    R3, R2b = sp.vstack(r3_blocks, format="csr"), sp.vstack(r2b_blocks, format="csr")
+    r3_d, r2b_d = np.concatenate(r3_d), np.concatenate(r2b_d)
+    log(f"observed cells: {obs_info['n_cells_total']} in {S_} samples; R1/R2 rebuilt = reference.npz; R3 {R3.shape[0]} "
+        f"cells ({len(oos_info['short_samples'])} samples with fewer than n)")
+    oos_r2 = (v["R2"], v["r2_d"])
+    if not a.no_en_all:
+        obsL = [log1p_cp10k_sparse(o) for o in obs]
+        gram_obs = Gram(R1L.shape[1])
+        for L in obsL:
+            gram_obs.add(L)
+    del obs
+
+    def en_unit(set_name: str, cellset: str, gts_L: list, semis_L: list, gram_real: Gram, n_rep_rows: int | None):
+        t0 = time.monotonic()
+        g = Gram(gts_L[0].shape[1])
+        for L in semis_L:
+            g.add(L)
+        mu, comps = (gram_real + g).pca(EN_PCS)
+        gts = [embed(L, mu, comps) for L in gts_L]
+        semis = [embed(L, mu, comps) for L in semis_L]
+        Z_all = np.vstack(gts + semis)
+        rng = np.random.default_rng([SEED, 17 if cellset == "pc" else 29])
+        res = en_from_embeddings(gts, semis, rng, Z_all=Z_all,
+                                 lb_max_queries=None if cellset == "pc" else EN_LB_MAX_QUERIES)
+        n_test = len(gts)
+        for d in ("sq", "l2"):
+            r = res[d]
+            en_rows.append({"set": set_name, "cellset": cellset, "distance": d, "n_samples": n_test,
+                            "n_cells_real": int(sum(len(x) for x in gts)), "n_cells_gen": int(sum(len(x) for x in semis)),
+                            "n_pcs": int(comps.shape[0]), "lb": r["lb"], "ub": r["ub"], "dif_mean": r["dif_mean"],
+                            "en": r["en"], "lb_exact": res["lb"]["exact"], "lb_queries": res["lb"]["n_queries"],
+                            "n_representative_rows": n_rep_rows,
+                            "en_reps_at_lb": (r["en"] * n_test / (n_test + n_rep_rows)) if n_rep_rows else None,
+                            "seconds": round(time.monotonic() - t0, 1)})
+            en_ps.append(pd.DataFrame({"set": set_name, "cellset": cellset, "distance": d, "donor": v["donors"],
+                                       "n_real": [len(x) for x in gts], "n_gen": [len(x) for x in semis],
+                                       "partner": v["donors"][res["partner"]], "dif": r["dif_i"], "en_i": r["en_i"]}))
+        log(f"  {set_name} E_N[{cellset}] sq {res['sq']['en']:.4f} (LB {res['sq']['lb']:.3f} UB {res['sq']['ub']:.3f} "
+            f"Dif {res['sq']['dif_mean']:.3f}) l2 {res['l2']['en']:.4f} ({round(time.monotonic() - t0, 1)} s)")
+
+    # ---------------- control: R1 vs R2 (the scorer's own)
+    expect_r2 = {"precision": first["reference"]["r2_control"]["precision"],
+                 "coverage": first["reference"]["r2_control"]["coverage"],
+                 "precision_depth_matched": first["reference"]["r2_control"]["depth_matched"]["precision"],
+                 "coverage_depth_matched": first["reference"]["r2_control"]["depth_matched"]["coverage"]}
+    r, p, chk = score_set(CONTROL, v, v["R2"], v["r2_d"], sigma_m, a.threads, expect_r2, oos=None)
+    rows += r
+    # out-of-sample control: R2' (real side) vs R3, families 1-2 only
+    for mode, (zr, zg) in pair_embeddings(v, R2b, r2b_d, R3, r3_d).items():
+        t0 = time.monotonic()
+        m = {"set": CONTROL_OOS, "real_side": "R2", "mode": mode, "n_real": int(len(zr)), "n_gen": int(len(zg))}
+        m.update(two_sample_block(zr, zg, sigma_m, n_jobs=a.threads))
+        m["seconds"] = round(time.monotonic() - t0, 1)
+        rows.append(m)
+        log(f"  {CONTROL_OOS} [R2 {mode}] AUC knn {m['c2st_knn_auc']:.3f} rf {m['c2st_rf_auc']:.3f} | 1-NN "
+            f"{m['nn1_acc']:.3f} | MMD2 {m['mmd2_bw1']:.4f} ({m['seconds']} s)")
+    per_frames.append(p)
+    repro["arms"][CONTROL] = chk
+    R2L = log1p_cp10k_sparse(v["R2"])
+    en_unit(CONTROL, "pc", [R1L[i] for i in r1_split], [R2L[np.flatnonzero(v["r2_d"] == s)] for s in range(S_)],
+            gram_r1, None)
+    if not a.no_en_all:
+        A_, B_ = [], []
+        for s in range(S_):
+            perm = rng_c(SEED, v["donors"][s]).permutation(obsL[s].shape[0])
+            h = obsL[s].shape[0] // 2
+            A_.append(obsL[s][np.sort(perm[:h])])
+            B_.append(obsL[s][np.sort(perm[h:])])
+        # the PCA basis is the one of all observed cells (A and B together): gram_real = A-part, semis add the B-part
+        gA = Gram(R1L.shape[1])
+        for L in A_:
+            gA.add(L)
+        en_unit(CONTROL, "all", A_, B_, gA, None)
+        del A_, B_
+
+    # ---------------- arms
+    pcache = a.pcache            # Poisson read-outs (scoring genes) by NPZ sha; zs_*_all are reused by later draws
+    n_rep_rows = None
+    if design == "fewshot":
+        dj = json.loads((TASK / "data" / ds / "fewshot_n5" / "DRAWS.json").read_text())["draw"][str(draw)]
+        n_rep_rows = int(dj["n_train_rows"])
+    panel_ids = ref["panel_ids"].astype(str)
+    for cdir, arms in calls:
+        s = summ[cdir]
+        per_csv = pd.read_csv(cdir / "per_donor.csv")
+        for name in arms:
+            t0 = time.monotonic()
+            pa = s["per_arm"][name]
+            path = resolve_npz(Path(pa["npz"]), pa["npz_sha256"], fetch_root, fetched)
+            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)
+                del rates
+                pcache[arm["sha256"]] = full[:, ref["score_idx"]].tocsr()
+                del full
+            arm["d"].close()
+            Xg = pcache[arm["sha256"]][sel].tocsr()
+            sub = np.concatenate([np.flatnonzero(gen_d == k)[F.generated_subsample(int((gen_d == k).sum()),
+                                                                                    int(v["n_ref"][k]), v["donors"][k])]
+                                  for k in range(S_)])
+            Q, q_d = Xg[sub].tocsr(), gen_d[sub]
+            gc = pd.read_parquet(cdir / "arms" / name / "generated_cells.parquet", columns=["npz_row", "in_pc_subsample"])
+            same_rows = bool(np.array_equal(gc.npz_row.to_numpy(), sel)
+                             and np.array_equal(np.flatnonzero(gc.in_pc_subsample.to_numpy()), np.sort(sub)))
+            if not same_rows:
+                raise SystemExit(f"{name}: scored rows / P/C subsample differ from {cdir}/arms/{name}/generated_cells.parquet")
+            pdn = per_csv[per_csv.arm == name].set_index("donor").loc[v["donors"]]
+            h = s["headline"][name]
+            expect = {"precision": h["precision"], "coverage": h["coverage"], "precision_depth_matched": h["precision_dm"],
+                      "coverage_depth_matched": h["coverage_dm"],
+                      "per_donor": {k: pdn[k].to_numpy() for k in ("precision", "coverage", "precision_depth_matched",
+                                                                   "coverage_depth_matched")}}
+            log(f"{name}: {path.name} sha {arm['sha256'][:12]} (receipt verified), {sel.size} scored cells, "
+                f"{sub.size} in the P/C subsample (same rows as the scorer)")
+            r, p, chk = score_set(name, v, Q, q_d, sigma_m, a.threads, expect, oos=(oos_r2[0], oos_r2[1], name))
+            chk["rows_and_subsample_equal_scorer"] = same_rows
+            chk["npz"] = {"path": str(path), "scored_path": pa["npz"], "sha256": arm["sha256"]}
+            rows += r
+            per_frames.append(p)
+            repro["arms"][name] = chk
+            QL = log1p_cp10k_sparse(Q)
+            en_unit(name, "pc", [R1L[i] for i in r1_split], [QL[np.flatnonzero(q_d == k)] for k in range(S_)], gram_r1,
+                    n_rep_rows if name == "scsemi5" else None)
+            if not a.no_en_all:
+                XgL = log1p_cp10k_sparse(Xg)
+                en_unit(name, "all", obsL, [XgL[np.flatnonzero(gen_d == k)] for k in range(S_)], gram_obs,
+                        n_rep_rows if name == "scsemi5" else None)
+                del XgL
+            log(f"{name} done in {time.monotonic() - t0:.0f} s")
+            if not (design == "fewshot" and name in ("zs_raw", "zs_pseudo")):
+                pcache.pop(arm["sha256"], None)  # not reused by another unit
+    # ---------------- write
+    meta = {"dataset": ds, "design": design, "unit": "pooled" if draw is None else f"draw{draw}"}
+    met = pd.DataFrame(rows)
+    for k, x in reversed(list(meta.items())):
+        met.insert(0, k, x)
+    met.insert(3, "label", met["set"].map(ARM_LABEL))
+    met.to_csv(out / "metrics.csv", index=False)
+    perd = pd.concat(per_frames, ignore_index=True)
+    for k, x in reversed(list(meta.items())):
+        perd.insert(0, k, x)
+    perd.to_csv(out / "per_donor.csv", index=False)
+    en = pd.DataFrame(en_rows)
+    for k, x in reversed(list(meta.items())):
+        en.insert(0, k, x)
+    en.to_csv(out / "en.csv", index=False)
+    ep = pd.concat(en_ps, ignore_index=True)
+    for k, x in reversed(list(meta.items())):
+        ep.insert(0, k, x)
+    ep.to_csv(out / "en_per_sample.csv", index=False)
+    worst = max([c.get("abs_diff", 0.0) for arm in repro["arms"].values() for c in arm.values() if isinstance(c, dict)]
+                + [0.0])
+    repro["max_abs_diff_k10_pooled"] = worst
+    repro["oos_r3"] = oos_info
+    repro["pca_equal"] = repro["pca"]["ours"] == repro["pca"]["scorer"]
+    (out / "repro.json").write_text(json.dumps(repro, indent=1, default=float) + "\n")
+    code = CODE_SHA256   # hashed when the process started
+    manifest = {"schema": "paired_ft_extra_metrics.v1", **meta, "written_utc": F.now(), "command": sys.argv,
+                "threads": a.threads, "donors": list(map(str, v["donors"])), "n_samples": int(S_),
+                "calls": {str(c): {"arms": list(arms), "summary_sha256": sha256(c / "summary.json")} for c, arms in calls},
+                "reference_sha256": man["reference_sha256"], "bandwidth_m": sigma_m,
+                "params": {"seed": SEED, "ks": KS, "knn_c2st_k": KNN_C2ST_K, "rf_trees": RF_TREES, "cv_folds": CV_FOLDS,
+                           "bw_multiples": BW_MULTIPLES, "bw_max_cells": BW_MAX_CELLS, "en_pcs": EN_PCS,
+                           "en_lb_max_queries_all_cells": EN_LB_MAX_QUERIES, "en_all_cells": not a.no_en_all},
+                "n_representative_rows": n_rep_rows, "fetched_from_server2": [str(f) for f in fetched],
+                "code_sha256": code, "seconds": round(time.monotonic() - t_unit, 1),
+                "max_abs_diff_k10_pooled": worst}
+    (out / "manifest.json").write_text(json.dumps(manifest, indent=1, default=float) + "\n")
+    log(f"unit {meta['unit']} of {ds} written to {out} in {manifest['seconds']} s (k=10 max |diff| vs scorer {worst:.2e})")
+    for f in fetched:
+        if f.name.startswith("zs__raw_all") or f.name.startswith("zs__pseudo_all"):
+            continue  # shared by the draws of the cohort; removed by main after the last draw
+        f.unlink(missing_ok=True)
+        f.with_suffix(".log").unlink(missing_ok=True)
+        log(f"removed fetched copy {f}")
+
+
+# =========================================================================== collect
+def collect() -> None:
+    """Tables and concatenated CSVs: tools/collect_extra_metrics.py (pandas only)."""
+    import collect_extra_metrics as C
+    C.main()
+
+
+def parse(argv=None):
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--design", choices=["fewshot", "pooled"])
+    p.add_argument("--dataset", choices=DATASETS)
+    p.add_argument("--draws", default="0,1,2,3,4")
+    p.add_argument("--threads", type=int, default=7)
+    p.add_argument("--fetch-dir", default=None, help="where server_2 NPZ copies go (default: scratch under scores_extra)")
+    p.add_argument("--no-en-all", action="store_true", help="skip the all-cells E_N (P/C-cell E_N is always computed)")
+    p.add_argument("--force", action="store_true", help="recompute units that already have a manifest")
+    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 <= 8):
+        raise SystemExit("--threads must be 1..8")
+    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)")
+    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.obs_cache = {}, {}
+    if a.design == "pooled":
+        run_unit("pooled", a.dataset, None, a)
+    else:
+        for j in [int(x) for x in a.draws.split(",") if x.strip()]:
+            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 []:
+            f.unlink(missing_ok=True)
+            f.with_suffix(".log").unlink(missing_ok=True)
+            log(f"removed fetched copy {f}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())