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/aggregate_rankcal.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+"""Line up the 2026-10-01 arms with their existing counterparts (CPU only; reads scores, writes one md + json).
+
+Rank sweep (alpha = r):  n = 5 / 20 / all  x  r = 4 (new) / 16 (lora_n5, lora_n20, real_lora) / 64 (new)
+Equal-budget calibration: n = 5 / 10 / 20 / 40 / all  x  zs__cal_n<n> (new; all = zs__cal) vs lora_n<n> (all = real_lora)
+Per arm: fold mean ± SD (scores/<ds>/fold<k> or scores/<ds>/<exp>/fold<k>), pooled values (scores/<ds>/pooled_deg, else
+pooled, or scores/<ds>/<exp>/pooled), with a contrast the pooled mean_cp10k logFC r / partial r over T, B, Monocyte, NK
+and the top-50 DEG sum, the training runs' selected step and inner-val loss (RUN.json, where present on this host),
+and a paired Wilcoxon over pooled per-donor composition L1 against the comparator.
+Writes scores/<ds>/rankcal_20261001.md and .json.   usage: aggregate_rankcal.py DATASET
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from scipy.stats import wilcoxon
+
+TASK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+RANK, CAL = "lora_rank_20261001", "cal_budget_20261001"
+TYPES = ["T cell", "B cell", "Monocyte", "NK cell"]
+
+
+def rank_arm(r: int, n: str) -> str:
+    if r == 16:
+        return "real_lora__raw" if n == "all" else f"lora_n{n}__raw"
+    return f"lora_r{r}__raw" if n == "all" else f"lora_r{r}_n{n}__raw"
+
+
+def main(ds: str) -> int:
+    S = TASK / "scores" / ds
+    old_pooled = S / "pooled_deg" if (S / "pooled_deg/summary.json").exists() else S / "pooled"
+    src = {}  # arm -> (fold dirs, pooled dir)
+    for r in (4, 16, 64):
+        for n in ("5", "20", "all"):
+            a = rank_arm(r, n)
+            src[a] = ([S / f"fold{k}" for k in range(5)], old_pooled) if r == 16 else \
+                     ([S / RANK / f"fold{k}" for k in range(5)], S / RANK / "pooled")
+    for n in ("5", "10", "20", "40"):
+        src[f"lora_n{n}__raw"] = ([S / f"fold{k}" for k in range(5)], old_pooled)
+        src[f"zs__cal_n{n}"] = ([S / CAL / f"fold{k}" for k in range(5)], S / CAL / "pooled")
+    src["zs__cal"] = ([S / f"fold{k}" for k in range(5)], old_pooled)
+    cache: dict[Path, tuple] = {}
+
+    def load(d: Path):
+        if d not in cache:
+            if not (d / "summary.json").exists():
+                cache[d] = None
+            else:
+                s = json.loads((d / "summary.json").read_text())
+                pdn = pd.read_csv(d / "per_donor.csv")
+                c = pd.read_csv(d / "contrast.csv") if (d / "contrast.csv").exists() else None
+                cache[d] = (s, pdn, c)
+        return cache[d]
+
+    stats = {}
+    for arm, (fdirs, pdir) in src.items():
+        rec = {"fold": {}, "pooled": None}
+        rows = [load(d)[0]["headline"][arm] for d in fdirs if load(d) and arm in load(d)[0]["headline"]]
+        if rows:
+            df = pd.DataFrame(rows)
+            for m in ("comp_l1", "precision", "coverage", "pb_r_median"):
+                rec["fold"][m] = (float(df[m].mean()), float(df[m].std(ddof=1)) if len(df) > 1 else float("nan"), len(df))
+        p = load(pdir)
+        if p and arm in p[0]["headline"]:
+            h = p[0]["headline"][arm]
+            rec["pooled"] = {m: h.get(m) for m in ("comp_l1", "precision", "coverage", "pb_r_median", "deg_top50_sum")}
+            if p[2] is not None:
+                c = p[2][(p[2]["arm"] == arm) & (p[2]["statistic"] == "mean_cp10k") & p[2]["celltype"].isin(TYPES)]
+                rec["pooled"]["logfc_r"] = float(c["r_generated"].mean())
+                rec["pooled"]["partial_r"] = float(c["partial_r_generated_given_broadcast"].mean())
+            rec["per_donor_l1"] = p[1][p[1]["arm"] == arm].set_index("donor")["comp_l1"]
+        run = arm.removesuffix("__raw")
+        rj = [TASK / "runs" / ds / f"fold{k}" / run / "RUN.json" for k in range(5)]
+        rj = [json.loads(x.read_text()) for x in rj if x.exists()]
+        if rj:
+            rec["train"] = {"selected_steps": [x["selected_step"] for x in rj],
+                            "inner_val": float(np.mean([x["selected_inner_val_loss"] for x in rj])),
+                            "pretrained_inner_val": float(np.mean([x["pretrained_inner_val_loss"] for x in rj])),
+                            "n_trainable": rj[0]["trainable"].get("n_trainable"), "n_runs": len(rj)}
+        stats[arm] = rec
+
+    def wil(a: str, b: str) -> str:
+        x, y = stats[a].get("per_donor_l1"), stats[b].get("per_donor_l1")
+        if x is None or y is None:
+            return "—"
+        j = x.to_frame("a").join(y.to_frame("b"), how="inner")
+        if len(j) < 5:
+            return "—"
+        d = j["a"] - j["b"]
+        return f"{d.mean():+.3f} ({(d < 0).mean():.0%} better, p {wilcoxon(j['a'], j['b']).pvalue:.2g})"
+
+    def cells(arm: str) -> list[str]:
+        s = stats[arm]
+        f, p = s["fold"], s["pooled"]
+        out = [f"{f['comp_l1'][0]:.3f} ± {f['comp_l1'][1]:.3f} ({f['comp_l1'][2]})" if f else "pending",
+               f"{f['coverage'][0]:.3f}" if f else "", f"{p['comp_l1']:.3f}" if p else "pending",
+               f"{p['precision']:.3f} / {p['coverage']:.3f}" if p else ""]
+        if p and "logfc_r" in p:
+            out += [f"{p['logfc_r']:.2f}", f"{p['partial_r']:.2f}", f"{p['deg_top50_sum']}" if p.get("deg_top50_sum") is not None else "—"]
+        elif p is None and any(stats[a]["pooled"] and "logfc_r" in stats[a]["pooled"] for a in stats):
+            out += ["", "", ""]
+        t = s.get("train")
+        out.append(f"{min(t['selected_steps'])}–{max(t['selected_steps'])}; {t['inner_val']:.5f}" if t else "")
+        return out
+
+    contrast = any(stats[a]["pooled"] and "logfc_r" in stats[a]["pooled"] for a in stats)
+    head = ["comp L1 fold mean ± SD (folds)", "coverage (fold mean)", "pooled comp L1", "pooled precision / coverage"]
+    head += ["pooled logFC r (T/B/Mono/NK)", "partial r", "top-50 DEG"] if contrast else []
+    head += ["selected step; inner-val loss", "pooled per-donor L1 vs comparator (Δ, better in, Wilcoxon p)"]
+    L = [f"# {ds}: LoRA rank sweep and equal-budget calibration (2026-10-01)", "",
+         f"Existing arms: scores/{ds}/fold<k>, {old_pooled.relative_to(TASK)}; new: scores/{ds}/{RANK}, scores/{ds}/{CAL}.", "",
+         "## LoRA rank (alpha = r; comparator = r 16 at the same n)", "",
+         "| n | r | " + " | ".join(head) + " |", "|" + "---|" * (len(head) + 2)]
+    for n in ("5", "20", "all"):
+        for r in (4, 16, 64):
+            a = rank_arm(r, n)
+            L.append(f"| {n} | {r} | " + " | ".join(cells(a)) + f" | {wil(a, rank_arm(16, n)) if r != 16 else '(comparator)'} |")
+    L += ["", "## Zero-shot paired calibration at the LoRA pair budget (comparator = zs__cal_n<n>)", "",
+          "| n | arm | " + " | ".join(head) + " |", "|" + "---|" * (len(head) + 2)]
+    for n in ("5", "10", "20", "40", "all"):
+        zs, lo = ("zs__cal", "real_lora__raw") if n == "all" else (f"zs__cal_n{n}", f"lora_n{n}__raw")
+        L.append(f"| {n} | {zs} | " + " | ".join(cells(zs)) + " | (comparator) |")
+        L.append(f"| {n} | {lo} | " + " | ".join(cells(lo)) + f" | {wil(lo, zs)} |")
+    L += ["", "Fold scores use each fold's test donors as reference; pooled scores use all donors (cross-fitted). "
+          "n = training pairs; every run also saw the fold's inner-validation pairs, which zs__cal_n<n> uses for alpha."]
+    (S / "rankcal_20261001.md").write_text("\n".join(L) + "\n")
+    js = {a: {k: v for k, v in s.items() if k != "per_donor_l1"} for a, s in stats.items()}
+    (S / "rankcal_20261001.json").write_text(json.dumps(js, indent=1, default=float))
+    print("\n".join(L))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1]))

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

@@ -0,0 +1,202 @@
+#!/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")
+    # 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/20261001T023742Z-deck-calibration-giroux-sexgenes/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/build_sex_gene_list.py

@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+"""Sex-chromosome-linked genes to drop from the disease-signal scores (user decision 2026-10-01, Giroux cohort).
+
+CPU only, no network. Every gene comes from a source file; nothing is typed in by hand.
+
+Definition (on the 20,097-gene protein-coding axis of data/<cohort>/features.npz):
+  1. chrY non-PAR: every axis gene that GENCODE v50 places on chrY and that does not lie entirely inside a chrY
+     pseudo-autosomal region (PAR1 / PAR2 of GRCh38, read from the NCBI GRCh38.p14 assembly-regions report).
+  2. chrX XCI escape: every X gene of Tukiainen et al. 2017 (Nature 550:244, Supplementary Table 13) whose
+     "Reported XCI status" is Escape or Variable (variable escape), plus the genes the paper flags as a possible new
+     escape call; mapped to the axis by Ensembl gene id (version stripped), else by a unique chrX symbol in GENCODE
+     v50. Genes lying entirely inside a chrX PAR are dropped (they are expressed from X and Y alike).
+  PAR = the gene's GENCODE v50 interval lies entirely inside a PAR interval of its chromosome. GENCODE v50 gives the
+  chrY PAR copies their own ids (ENSG00000292xxx) and no "PAR" tag, so coordinates are the only rule; Tukiainen's
+  own Region column is reported next to it as a cross-check.
+
+Outputs (data/sex_linked_genes/):
+  sex_linked_genes_exclude.csv   gene_id, symbol, chromosome, reason, start, end, tukiainen_* columns   (full list)
+  chrY_nonPAR_genes.csv          the chrY part only (chrY-only sensitivity run)
+  tukiainen2017_mapping.csv      every Tukiainen escape / variable / new-call row and what happened to it
+  par_genes_on_axis.csv          axis genes inside a PAR (kept in the scores)
+  BUILD.json                     input sha256s and counts
+
+usage: python3 tools/build_sex_gene_list.py
+"""
+from __future__ import annotations
+
+import gzip
+import hashlib
+import json
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+T = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+OUT = T / "data" / "sex_linked_genes"
+SRC = OUT / "sources"
+GTF = Path("/home/sj_server_1/gblee/ablations_data_repro_20260802/fixed_assets/gencode.v50.annotation.gtf.gz")
+TUK = SRC / "Tukiainen2017_Suppl.Table.13.xlsx"
+REGIONS = SRC / "GCF_000001405.40_GRCh38.p14_assembly_regions.txt"
+COHORTS = ["immicro", "ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili"]
+ESCAPE_STATUS = ("Escape", "Variable")     # Tukiainen "Reported XCI status" values counted as escape
+NEW_CALL_COL = "Possible new call for escape (support from several analyses)"
+
+
+def sha(p: Path) -> str:
+    h = hashlib.sha256()
+    with open(p, "rb") as fh:
+        for b in iter(lambda: fh.read(1 << 20), b""):
+            h.update(b)
+    return h.hexdigest()
+
+
+def axis() -> np.ndarray:
+    ids = None
+    for ds in COHORTS:
+        g = np.load(T / "data" / ds / "features.npz", allow_pickle=False)["gene_ids"].astype(str)
+        if ids is None:
+            ids = g
+        elif not np.array_equal(ids, g):
+            raise SystemExit(f"{ds}: gene axis differs from {COHORTS[0]}")
+    return ids
+
+
+def gtf_genes() -> pd.DataFrame:
+    rows = []
+    with gzip.open(GTF, "rt") as fh:
+        for line in fh:
+            if line.startswith("#"):
+                continue
+            p = line.split("\t", 9)
+            if p[2] != "gene":
+                continue
+            a = p[8]
+            rows.append((re.search(r'gene_id "([^"]+)"', a).group(1), re.search(r'gene_name "([^"]+)"', a).group(1),
+                         re.search(r'gene_type "([^"]+)"', a).group(1), p[0], int(p[3]), int(p[4])))
+    g = pd.DataFrame(rows, columns=["gene_id_versioned", "symbol", "gene_type", "chromosome", "start", "end"])
+    g["gene_id"] = g.gene_id_versioned.str.replace(r"\.\d+(_PAR_Y)?$", "", regex=True)
+    if g.gene_id.duplicated().any():
+        raise SystemExit(f"duplicate unversioned gene ids in {GTF}")
+    return g
+
+
+def par_regions() -> pd.DataFrame:
+    """PAR rows of the NCBI region report: region name, chromosome, start, stop (1-based, inclusive)."""
+    rows = []
+    for line in REGIONS.read_text().splitlines():
+        if line.startswith("#") or not line.strip():
+            continue
+        f = line.split("\t")
+        if f[4] == "PAR":
+            rows.append({"region": f[0], "chromosome": f"chr{f[1]}", "start": int(f[2]), "end": int(f[3])})
+    par = pd.DataFrame(rows)
+    if sorted(par.chromosome.value_counts().items()) != [("chrX", 2), ("chrY", 2)]:
+        raise SystemExit(f"expected PAR1 and PAR2 on chrX and chrY in {REGIONS}, got {rows}")
+    return par
+
+
+def inside_par(chrom: str, start: int, end: int, par: pd.DataFrame) -> str:
+    """'PAR#1' / 'PAR#2' when [start, end] lies entirely inside one; 'boundary' when it only overlaps one; ''."""
+    for r in par[par.chromosome == chrom].itertuples():
+        if start >= r.start and end <= r.end:
+            return r.region
+        if start <= r.end and end >= r.start:
+            return "boundary"
+    return ""
+
+
+def tukiainen() -> pd.DataFrame:
+    t = pd.read_excel(TUK, header=0)
+    t = t[t["Gene ID"].astype(str).str.startswith("ENSG")].copy()   # drops the footnote row
+    if set(t["Chr"].astype(str)) != {"X"}:
+        raise SystemExit("Tukiainen table: non-X rows")
+    t["gene_id"] = t["Gene ID"].astype(str).str.replace(r"\.\d+$", "", regex=True)
+    t["new_call"] = t[NEW_CALL_COL].astype(str).str.strip().str.lower().eq("x")
+    return t.rename(columns={"Gene ID": "tuk_id", "Gene name": "tuk_symbol", "Reported XCI status": "status"})
+
+
+def main() -> int:
+    ids = axis()
+    g = gtf_genes().set_index("gene_id")
+    miss = [x for x in ids if x not in g.index]
+    if miss:
+        raise SystemExit(f"{len(miss)} axis genes not in GENCODE v50 (e.g. {miss[:3]})")
+    ax = g.loc[ids].reset_index()
+    par = par_regions()
+    ax["par"] = [inside_par(c, s, e, par) if c in ("chrX", "chrY") else ""
+                 for c, s, e in zip(ax.chromosome, ax.start, ax.end)]
+
+    # 1. chrY non-PAR
+    y = ax[ax.chromosome == "chrY"]
+    if (y.par == "boundary").any():
+        raise SystemExit(f"chrY genes crossing a PAR boundary: {y[y.par == 'boundary'].symbol.tolist()}")
+    ynp = y[y.par == ""].assign(reason="chrY non-PAR")
+
+    # 2. chrX XCI escape (Tukiainen 2017)
+    t = tukiainen()
+    sel = t[t.status.isin(ESCAPE_STATUS) | t.new_call].copy()
+    pos = {x: i for i, x in enumerate(ax.gene_id)}
+    xsym = ax[ax.chromosome == "chrX"].symbol.value_counts()
+    xsym_row = {s: i for i, s in zip(ax.index, ax.symbol) if ax.at[i, "chromosome"] == "chrX" and xsym[s] == 1}
+    maps = []
+    for r in sel.itertuples():
+        if r.gene_id in pos:
+            i, how = pos[r.gene_id], "ensembl id"
+        elif r.tuk_symbol in xsym_row:
+            i, how = xsym_row[r.tuk_symbol], "unique chrX symbol (GENCODE v50)"
+        else:
+            maps.append({"tukiainen_id": r.tuk_id, "tukiainen_symbol": r.tuk_symbol, "tukiainen_region": r.Region,
+                         "tukiainen_status": r.status, "tukiainen_new_call": bool(r.new_call), "mapped_by": "",
+                         "gene_id": "", "symbol": "", "chromosome": "", "par": "", "outcome": "not on the axis"})
+            continue
+        a = ax.loc[i]
+        if a.chromosome != "chrX":
+            raise SystemExit(f"Tukiainen {r.tuk_symbol} maps to {a.gene_id} on {a.chromosome}")
+        status = r.status if r.status in ESCAPE_STATUS else "new call"
+        outcome = "PAR: kept" if a.par.startswith("PAR") else "excluded"
+        maps.append({"tukiainen_id": r.tuk_id, "tukiainen_symbol": r.tuk_symbol, "tukiainen_region": r.Region,
+                     "tukiainen_status": r.status, "tukiainen_new_call": bool(r.new_call), "mapped_by": how,
+                     "gene_id": a.gene_id, "symbol": a.symbol, "chromosome": a.chromosome, "par": a.par,
+                     "outcome": outcome, "reason": f"chrX XCI escape (Tukiainen 2017: {status})"})
+    mp = pd.DataFrame(maps)
+    disagree = mp[(mp.outcome != "not on the axis") & ((mp.par.str.startswith("PAR")) != (mp.tukiainen_region == "PAR"))]
+    xe = mp[mp.outcome == "excluded"]
+    if xe.gene_id.duplicated().any():
+        raise SystemExit(f"two Tukiainen rows map to one axis gene: {xe[xe.gene_id.duplicated()].gene_id.tolist()}")
+    xe = xe.merge(ax[["gene_id", "start", "end"]], on="gene_id")
+
+    cols = ["gene_id", "symbol", "chromosome", "reason", "start", "end"]
+    full = pd.concat([ynp[cols].assign(tukiainen_status="", tukiainen_region="", tukiainen_mapped_by=""),
+                      xe[cols + ["tukiainen_status", "tukiainen_region", "mapped_by"]]
+                      .rename(columns={"mapped_by": "tukiainen_mapped_by"})], ignore_index=True)
+    full = full.sort_values(["chromosome", "start"], kind="stable").reset_index(drop=True)
+    if full.gene_id.duplicated().any():
+        raise SystemExit("duplicate gene in the exclusion list")
+    OUT.mkdir(parents=True, exist_ok=True)
+    full.to_csv(OUT / "sex_linked_genes_exclude.csv", index=False)
+    full[full.reason == "chrY non-PAR"].to_csv(OUT / "chrY_nonPAR_genes.csv", index=False)
+    mp.to_csv(OUT / "tukiainen2017_mapping.csv", index=False)
+    pg = ax[ax.par.str.startswith("PAR") | (ax.par == "boundary")][["gene_id", "symbol", "chromosome", "start", "end", "par"]]
+    pg.to_csv(OUT / "par_genes_on_axis.csv", index=False)
+    build = {"written_utc": datetime.now(timezone.utc).isoformat(), "script": str(Path(__file__).resolve()),
+             "script_sha256": sha(Path(__file__).resolve()),
+             "inputs": {str(p): sha(p) for p in (GTF, TUK, REGIONS)},
+             "axis": {"source": f"{T}/data/<cohort>/features.npz gene_ids (identical in {len(COHORTS)} cohorts)",
+                      "n_genes": int(ids.size), "n_chrX": int((ax.chromosome == "chrX").sum()),
+                      "n_chrY": int((ax.chromosome == "chrY").sum())},
+             "par_regions": par.to_dict(orient="records"),
+             "counts": {"chrY_on_axis": int(len(y)), "chrY_PAR_kept": int((y.par != "").sum()),
+                        "chrY_nonPAR_excluded": int(len(ynp)),
+                        "tukiainen_rows_selected": int(len(sel)),
+                        "tukiainen_selected_by_status": sel.status.value_counts().to_dict(),
+                        "tukiainen_new_calls": int(sel.new_call.sum()),
+                        "tukiainen_not_on_axis": int((mp.outcome == "not on the axis").sum()),
+                        "tukiainen_PAR_kept": int((mp.outcome == "PAR: kept").sum()),
+                        "chrX_escape_excluded": int(len(xe)),
+                        "chrX_escape_by_reason": xe.reason.value_counts().to_dict(),
+                        "mapped_by_symbol": int((xe.mapped_by != "ensembl id").sum()),
+                        "par_status_disagrees_with_tukiainen_region": disagree[["symbol", "par", "tukiainen_region"]]
+                        .to_dict(orient="records"),
+                        "axis_genes_crossing_a_PAR_boundary": ax[ax.par == "boundary"].symbol.tolist(),
+                        "total_excluded": int(len(full))}}
+    (OUT / "BUILD.json").write_text(json.dumps(build, indent=1) + "\n")
+    print(json.dumps(build["counts"], indent=1))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,292 @@
+#!/usr/bin/env python3
+"""Dry-run check of the 2026-10-01 rank-sweep / equal-budget-calibration queues (CPU only; never imports torch).
+
+For every queue line (run_queue.sh format):
+  train   the reference r 16 run of the same dataset / fold / n (lora_n<n>, or real_lora for all pairs) is read; its
+          lr, warmup, batch, EMA, eval interval, patience, cap, seed, base checkpoint sha, condition NPZ (path + current
+          sha) and update scale alpha/r must equal what this line will use (ft_sdd.py defaults read with ast + the
+          line's flags); the line's --train-n / --subset-seed / --strata-regex must equal the reference's train_subset;
+          the training / inner-validation / test rows are recomputed from folds.csv with ft_sdd.py's selection code
+          and must equal the reference RUN.json lists.  The run dir must not hold RUN.json / checkpoint_ft.pt yet.
+  sample  checkpoint = base or a run trained earlier in the same queue; condition NPZ resolves with the sampler's keys
+          and the fold's test rows; seed / steps / weights equal the reference arm's generation receipt; for zs__cal_n<n>
+          the CAL_BUDGET.json fit rows equal lora_n<n>'s train + inner-val rows and exclude every test donor; the output
+          NPZ / receipt / .moved marker must not exist, and no arm name collides with an existing one.
+Also: base checkpoint sha, input shas (for comparing hosts), disk need vs free space, runner/env paths.
+--no-ref skips the reference comparisons (for server_2, whose runs/ holds no ImMicro/sepsis runs).
+usage: check_rankcal.py QUEUE [QUEUE ...] [--no-ref] [--json OUT]
+"""
+from __future__ import annotations
+
+import argparse
+import ast
+import hashlib
+import json
+import os
+import re
+import shutil
+import socket
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+TASK = M8 / "plans/paired_finetune_intradataset_20260927"
+BASE_CKPT = M8 / "runs/f01_6k_1x_seed20260627/checkpoint_epoch_016.pt"
+BASE_SHA = "8c7cd0e83e2bc19fe03dfcbc084919a1e2f61be8cc8bc12f4caf543dfda91633"
+SAMPLER_KEYS = {"bulk_counts", "bulk_measurement_fraction", "output_availability_mask", "recipe_k", "cells_per_bulk",
+                "sample_ids", "gene_ids"}
+CKPT_BYTES = 217_981_000          # merged FT checkpoint (existing runs: 217.98 MB)
+GENES, CELLS = 6000, 1500         # generated NPZ: float32 [donors x 1500, 6000]
+_sha_cache: dict[str, str] = {}
+
+
+def sha(p: Path) -> str:
+    k = str(Path(p).resolve())
+    if k not in _sha_cache:
+        h = hashlib.sha256()
+        with open(p, "rb") as f:
+            for b in iter(lambda: f.read(1 << 24), b""):
+                h.update(b)
+        _sha_cache[k] = h.hexdigest()
+    return _sha_cache[k]
+
+
+def ft_defaults() -> dict:
+    """argparse defaults of ft_sdd.py, read from its source (no torch import)."""
+    tree = ast.parse((TASK / "tools/ft_sdd.py").read_text())
+    out = {}
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Call) and getattr(node.func, "attr", "") == "add_argument" and node.args:
+            name = ast.literal_eval(node.args[0])
+            kw = {k.arg: k.value for k in node.keywords}
+            if "default" in kw:
+                out[name.lstrip("-").replace("-", "_")] = ast.literal_eval(kw["default"])
+    return out
+
+
+def parse_extra(tokens: list[str]) -> dict:
+    out, i = {}, 0
+    while i < len(tokens):
+        k = tokens[i]
+        if not k.startswith("--"):
+            raise ValueError(f"unexpected token {k!r}")
+        out[k[2:].replace("-", "_")] = tokens[i + 1]
+        i += 2
+    return out
+
+
+def select_rows(folds: pd.DataFrame, fold: int, train_n: int, subset_seed: int, strata_regex: str):
+    """ft_sdd.py's row selection (fold mode, optional --train-n learning-curve subset), verbatim logic."""
+    inner_col = f"inner_val_f{fold}"
+    test_rows = folds.index[folds["fold"] == fold].to_numpy()
+    inner_rows = folds.index[folds[inner_col]].to_numpy()
+    train_rows = folds.index[(folds["fold"] != fold) & (folds["fold"] >= 0) & ~folds[inner_col]].to_numpy()
+    if train_n:
+        grp = folds.loc[train_rows, "group"].astype(str)
+        strata = (grp.str.contains(strata_regex, regex=True) if strata_regex
+                  else pd.Series(True, index=grp.index)).to_numpy()
+        srng = np.random.default_rng(subset_seed)
+        labels = sorted(set(strata.tolist()))
+        perm = {s: train_rows[strata == s][srng.permutation(int((strata == s).sum()))] for s in labels}
+        n = min(int(train_n), len(train_rows))
+        sizes = {s: len(perm[s]) for s in labels}
+        alloc = {s: max(1, int(np.floor(n * sizes[s] / len(train_rows)))) for s in labels}
+        while sum(alloc.values()) < n:
+            s = max(labels, key=lambda s: n * sizes[s] / len(train_rows) - alloc[s])
+            alloc[s] += 1
+        while sum(alloc.values()) > n:
+            s = max((s for s in labels if alloc[s] > 1), key=lambda s: alloc[s])
+            alloc[s] -= 1
+        train_rows = np.sort(np.concatenate([perm[s][:alloc[s]] for s in labels]))
+    return train_rows, inner_rows, test_rows
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("queues", nargs="+", type=Path)
+    ap.add_argument("--no-ref", action="store_true")
+    ap.add_argument("--json", type=Path, default=None)
+    a = ap.parse_args(argv)
+    errors, notes = [], []
+    err = errors.append
+    defaults = ft_defaults()
+    host = socket.gethostname().split(".")[0]
+    inputs: dict[str, str] = {}
+
+    def need(p: Path, what: str) -> bool:
+        if not Path(p).exists():
+            err(f"missing {what}: {p}")
+            return False
+        return True
+
+    if need(BASE_CKPT, "base checkpoint"):
+        inputs[str(BASE_CKPT)] = sha(BASE_CKPT)
+        if inputs[str(BASE_CKPT)] != BASE_SHA:
+            err(f"base checkpoint sha {inputs[str(BASE_CKPT)][:12]} != {BASE_SHA[:12]}")
+    trained, tags, outputs = set(), set(), set()
+    n_train = n_sample = 0
+    need_bytes = 0
+    per_queue = {}
+    folds_cache: dict[str, pd.DataFrame] = {}
+    for q in a.queues:
+        nq = {"train": 0, "sample": 0}
+        for ln, line in enumerate(q.read_text().splitlines(), 1):
+            if not line.strip() or line.startswith("#"):
+                continue
+            parts = line.split("|")
+            where = f"{q.name}:{ln}"
+            if parts[0] == "train":
+                n_train += 1; nq["train"] += 1
+                run, cond, fold, mode, lr = Path(parts[1]), Path(parts[2]), int(parts[3]), parts[4], parts[5]
+                extra = parse_extra(parts[6:])
+                ds = run.parent.parent.name
+                dsdir = TASK / "data" / ds
+                if mode != "lora":
+                    err(f"{where}: mode {mode}")
+                rank, alpha = int(extra.get("lora_rank", defaults["lora_rank"])), float(extra.get("lora_alpha", defaults["lora_alpha"]))
+                if alpha / rank != 1.0:
+                    err(f"{where}: alpha/r = {alpha / rank}")
+                unknown = set(extra) - {"lora_rank", "lora_alpha", "train_n", "subset_seed", "strata_regex"}
+                if unknown:
+                    err(f"{where}: unexpected flags {sorted(unknown)} (would differ from the r 16 arms)")
+                if (run / "RUN.json").exists() or (run / "checkpoint_ft.pt").exists():
+                    err(f"{where}: {run} already holds RUN.json/checkpoint_ft.pt (would be skipped / clash)")
+                if run.name in {"real_lora", "real_full", "real_condenc", "pseudo_full", "lora_multik", "lora_recipe"} \
+                        or re.fullmatch(r"lora_n\d+", run.name):
+                    err(f"{where}: run dir name {run.name} is an existing arm")
+                for p, w in ((cond, "condition"), (dsdir / "cells_panel6k.npz", "cells"), (dsdir / "folds.csv", "folds")):
+                    if need(p, w):
+                        inputs[str(p)] = sha(p)
+                trained.add(str(run / "checkpoint_ft.pt"))
+                need_bytes += CKPT_BYTES
+                if a.no_ref:
+                    continue
+                n = int(extra.get("train_n", 0))
+                ref_dir = run.parent / (f"lora_n{n}" if n else "real_lora")
+                rj = ref_dir / "RUN.json"
+                if not need(rj, "reference RUN.json"):
+                    continue
+                ref = json.loads(rj.read_text())
+                checks = {
+                    "fold": (ref["fold"], fold), "mode": (ref["mode"], mode), "lr": (ref["lr"], float(lr)),
+                    "warmup": (ref["warmup"], defaults["warmup"]), "batch_size": (ref["batch_size"], defaults["batch_size"]),
+                    "ema_decay": (ref["ema_decay"], defaults["ema_decay"]), "max_steps": (ref["max_steps"], defaults["max_steps"]),
+                    "eval_every": (ref["eval_every"], defaults["eval_every"]), "patience": (ref["patience"], defaults["patience"]),
+                    "seed": (ref["seed"], defaults["seed"]), "source_checkpoint_sha256": (ref["source_checkpoint_sha256"], BASE_SHA),
+                    "condition_npz": (ref["condition_npz"], str(cond)), "condition_npz_sha256": (ref["condition_npz_sha256"], inputs.get(str(cond))),
+                    "scale alpha/r": (ref["trainable"]["lora_alpha"] / ref["trainable"]["lora_rank"], alpha / rank),
+                    "fixed_steps": (ref.get("fixed_steps"), None), "train_donors_file": (ref.get("train_donors_file"), None),
+                }
+                ts = ref.get("train_subset") or {}
+                if n:
+                    checks.update({"train_n": (ts.get("train_n"), n), "subset_seed": (ts.get("subset_seed"), int(extra["subset_seed"])),
+                                   "strata_regex": (ts.get("strata_regex"), extra.get("strata_regex", ""))})
+                elif ts:
+                    err(f"{where}: reference {rj} is a subset run")
+                for k, (want, got) in checks.items():
+                    if want != got:
+                        err(f"{where}: {k}: reference {want!r} vs this line {got!r}")
+                if ds not in folds_cache:
+                    folds_cache[ds] = pd.read_csv(dsdir / "folds.csv")
+                folds = folds_cache[ds]
+                tr, iv, te = select_rows(folds, fold, n, int(extra.get("subset_seed", 0)), extra.get("strata_regex", ""))
+                sid = folds["sample_id"].astype(str).to_numpy()
+                for name, mine, theirs in (("train_rows", sid[tr], ref["train_rows"]), ("inner_val_rows", sid[iv], ref["inner_val_rows"]),
+                                           ("test_rows", sid[te], ref["test_rows_never_loaded_for_training"])):
+                    if list(mine) != list(theirs):
+                        err(f"{where}: {name} differ from {rj} ({len(mine)} vs {len(theirs)})")
+            elif parts[0] == "sample":
+                n_sample += 1; nq["sample"] += 1
+                tag, ckpt, cond, seed, out = parts[1], parts[2], Path(parts[3]), int(parts[4]), Path(parts[5])
+                if tag in tags:
+                    err(f"{where}: duplicate tag {tag}")
+                tags.add(tag)
+                if str(out) in outputs:
+                    err(f"{where}: duplicate output {out}")
+                outputs.add(str(out))
+                if ckpt != "base" and ckpt not in trained:
+                    err(f"{where}: checkpoint {ckpt} is not trained earlier in the queues")
+                for suffix in (".npz", ".log", ".moved", ".err"):
+                    if out.with_suffix(suffix).exists():
+                        err(f"{where}: {out.with_suffix(suffix)} already exists")
+                arm = out.stem
+                fold = int(out.parent.name.removeprefix("fold"))
+                ds = out.parent.parent.name
+                if not need(cond, "condition"):
+                    continue
+                inputs[str(cond)] = sha(cond)
+                z = np.load(cond, allow_pickle=True)
+                if not SAMPLER_KEYS <= set(z.files):
+                    err(f"{where}: {cond.name} lacks {sorted(SAMPLER_KEYS - set(z.files))}")
+                test_raw = np.load(TASK / "data" / ds / f"fold{fold}" / "test_raw.npz", allow_pickle=True)
+                if not np.array_equal(z["sample_ids"].astype(str), test_raw["sample_ids"].astype(str)):
+                    err(f"{where}: {cond.name} rows differ from fold{fold}/test_raw.npz")
+                need_bytes += int(z["sample_ids"].size) * CELLS * GENES * 4 * 2   # fold NPZ + its pooled copy
+                if a.no_ref:
+                    continue
+                # generation settings of the reference arm (receipt is kept even after the NPZ moved to server_2)
+                if arm.startswith("zs__cal_n"):
+                    ref_arm, n = "zs__cal", int(arm.removeprefix("zs__cal_n"))
+                    cb = json.loads((TASK / "data" / ds / "CAL_BUDGET.json").read_text())["folds"][str(fold)]["n"][str(n)]
+                    if cb["sha256"] != inputs[str(cond)] or Path(cb["file"]) != cond:
+                        err(f"{where}: CAL_BUDGET.json entry does not describe {cond}")
+                    lr_ = json.loads((TASK / "runs" / ds / f"fold{fold}" / f"lora_n{n}" / "RUN.json").read_text())
+                    if sorted(cb["fit_sample_ids"]) != sorted(lr_["train_rows"] + lr_["inner_val_rows"]):
+                        err(f"{where}: calibration rows differ from lora_n{n} train + inner-val rows")
+                    if set(cb["fit_sample_ids"]) & set(z["sample_ids"].astype(str)):
+                        err(f"{where}: a test row is among the calibration rows")
+                else:
+                    m = re.fullmatch(r"lora_r(\d+)(?:_n(\d+))?__raw", arm)
+                    if not m:
+                        err(f"{where}: unexpected arm name {arm}")
+                        continue
+                    ref_arm = f"lora_n{m.group(2)}__raw" if m.group(2) else "real_lora__raw"
+                rec_p = out.parent / f"{ref_arm}.log"
+                if not need(rec_p, "reference generation receipt"):
+                    continue
+                rec = json.loads(rec_p.read_text())
+                if rec["seed"] != seed or rec["steps"] != 50 or rec["weights"] != "ema":
+                    err(f"{where}: seed/steps/weights differ from {rec_p.name}")
+                if not ref_arm.startswith("zs__") and (rec["condition_npz"] != str(cond) or rec["condition_sha256"] != inputs[str(cond)]):
+                    err(f"{where}: condition differs from {rec_p.name}'s ({rec['condition_npz']})")
+            else:
+                err(f"{where}: unknown line kind {parts[0]}")
+        per_queue[q.name] = nq
+    # arm-name collisions with anything already in generated/<ds>/fold*/ on this host
+    for o in outputs:
+        p = Path(o)
+        same = [x for x in p.parent.glob(p.stem + ".*")]
+        if same:
+            err(f"existing files for new arm {p.stem} in {p.parent}: {[x.name for x in same]}")
+    for py in ("/home/sj_server_1/miniforge3/envs/b2sc-cu130/bin/python", "/home/sj_server_2/miniforge3/envs/b2sc-infer/bin/python",
+               "/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python"):
+        notes.append(f"{py}: {'present' if Path(py).exists() else 'absent'}")
+    for p in (Path.home() / ".local/bin/ml-run", M8 / "plans/arch_ablation_6k_20260913/tools/gpu_usable.sh",
+              M8 / "plans/floor01_campaign_20260923/tools/thermal_guard.sh", M8 / "plans/utility_studies_final6k_20260925/tools/sample_queue.sh",
+              M8 / "scripts/sample_sdd_standalone.py"):
+        if not p.exists():
+            err(f"missing runner piece {p}")
+    free = shutil.disk_usage(TASK).free
+    rep = {"host": host, "queues": per_queue, "train_steps": n_train, "sample_steps": n_sample, "errors": errors,
+           "notes": notes, "disk_need_gib": round(need_bytes / 2**30, 1), "disk_free_gib": round(free / 2**30, 1),
+           "inputs_sha256": inputs, "reference_checks": not a.no_ref}
+    if need_bytes > free:
+        errors.append(f"disk: need ~{need_bytes / 2**30:.0f} GiB, free {free / 2**30:.0f} GiB")
+    if a.json:
+        a.json.write_text(json.dumps(rep, indent=1))
+    print(json.dumps({k: rep[k] for k in ("host", "queues", "train_steps", "sample_steps", "disk_need_gib", "disk_free_gib",
+                                          "reference_checks")}, indent=1))
+    print("\n".join(notes))
+    print(f"{len(inputs)} input files hashed; {len(errors)} error(s)")
+    for e in errors:
+        print("ERROR", e)
+    return 1 if errors else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())