Archive 4 checkpoints (1-4)

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

@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+"""Folds and condition NPZs for the within-dataset fine-tuning benchmark (CPU only).
+
+For one dataset directory (features.npz + samples.csv, see build_immicro_cells.py) this writes
+
+  folds.csv                      row, sample_id, donor_id, group, fold (0..K-1), inner_val (bool, per fold column)
+  conditions_raw_fixed.npz       every row: the separately measured bulk
+  conditions_pseudo_fixed.npz    every row: the pseudobulk of that row's own cells
+  fold{k}/conditions_cal_fixed.npz   every row: bulk x gene multiplier alpha fitted on fold k's training rows only
+  fold{k}/test_{raw,cal,pseudo}.npz  the test rows of fold k, same keys (the sampler input)
+
+Folds are donor-level (all rows of one donor share a fold) and stratified by group.  Inside each fold's
+training donors, a fixed ~10 % (at least one per group where possible) is marked inner_val: fine-tuning uses
+them only for early stopping; the test donors are never read during training.
+
+Condition arithmetic is imported from plans/realbulk_generation_20260922/build_realbulk_conditions.py (cpm,
+gene_multiplier, to_condition_counts, RECIPE_K, DEPTH_ANCHOR), i.e. the fixed-depth policy of the published
+ImMicro arms: K = 1000 and one depth anchor for every sample, so no test donor's single-cell depth or cell count
+enters its own condition.  For ImMicro the raw and pseudo NPZs are checked against the published
+conditions_ImMicro_{raw,pseudo}.npz.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.util
+import json
+import os
+import sys
+from datetime import datetime, timezone
+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"
+BUILDER = M8 / "plans/realbulk_generation_20260922/build_realbulk_conditions.py"
+PUBLISHED_IMMICRO = M8 / "plans/realbulk_generation_20260922/conditions"
+SCHEMA = "pbisc_sdd.ft_intradataset.conditions.v1"
+MIN_CELLS = 200
+
+spec = importlib.util.spec_from_file_location("build_realbulk_conditions", BUILDER)
+RB = importlib.util.module_from_spec(spec)
+sys.modules[spec.name] = RB
+spec.loader.exec_module(RB)
+
+
+def sha256_file(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(1 << 24), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def load(ds_dir: Path) -> dict:
+    f = np.load(ds_dir / "features.npz", allow_pickle=False)
+    if not (ds_dir / "samples.csv").exists():
+        # datasets built by the pairing agent carry sample_ids / donor_ids / groups in features.npz
+        pd.DataFrame({"row": np.arange(len(f["donor_ids"])), "sample_id": f["sample_ids"].astype(str),
+                      "donor_id": f["donor_ids"].astype(str), "group": f["groups"].astype(str),
+                      "n_cells": f["qc_cell_counts"].astype(np.int64)}).to_csv(ds_dir / "samples.csv", index=False)
+    s = pd.read_csv(ds_dir / "samples.csv")
+    n = len(s)
+    sample_ids = (f["sample_ids"] if "sample_ids" in f.files else f["donor_ids"]).astype(str)
+    if not np.array_equal(sample_ids, s["sample_id"].astype(str).to_numpy()):
+        raise SystemExit("samples.csv sample_id order differs from features.npz")
+    d = {
+        "gene_ids": f["gene_ids"].astype(str), "sample_ids": sample_ids,
+        "donor_ids": s["donor_id"].astype(str).to_numpy(), "groups": s["group"].astype(str).to_numpy(),
+        "bulk_valid": f["bulk_valid"].astype(bool), "sc_valid": f["sc_valid"].astype(bool),
+        "n_cells": s["n_cells"].to_numpy(np.int64),
+        # rows whose bulk and single cells failed the pairing identity checks are never trained on or tested
+        "use": (f["identity_pass"].astype(bool) if "identity_pass" in f.files else np.ones(n, dtype=bool)),
+    }
+    # the strict-QC protocol's minimum usable cells per sample (PROTOCOL.json qc.minimum_usable_cells_per_sample);
+    # every earlier dataset has >= 759 cells per row, so this only affects Imperial's tiny sc samples
+    d["use"] = d["use"] & (d["n_cells"] >= MIN_CELLS)
+    d["bulk"] = RB.drop_unmeasured_nan(f["bulk_raw"], d["bulk_valid"], "bulk")
+    d["pseudo"] = RB.drop_unmeasured_nan(f["pseudo_raw_sum"], d["sc_valid"], "pseudobulk")
+    for k in ("bulk", "pseudo", "bulk_valid", "sc_valid"):
+        if d[k].shape != (n, 20097):
+            raise SystemExit(f"{k} shape {d[k].shape}")
+    return d
+
+
+def make_folds(d: dict, k: int, seed: int, inner_frac: float) -> pd.DataFrame:
+    """Donor-level, group-stratified folds; inner-validation donors inside each fold's training part."""
+    rng = np.random.default_rng(seed)
+    use = d["use"]
+    donors = pd.DataFrame({"donor_id": d["donor_ids"][use], "group": d["groups"][use]}).drop_duplicates("donor_id")
+    if donors["donor_id"].duplicated().any():
+        raise SystemExit("a donor carries two groups")
+    fold_of = {}
+    offset = 0
+    for _, g in donors.groupby("group", sort=True):
+        ids = g["donor_id"].to_numpy()
+        ids = ids[rng.permutation(len(ids))]
+        for i, did in enumerate(ids):
+            fold_of[did] = (offset + i) % k       # round-robin across groups keeps folds balanced in size
+        offset += len(ids)
+    out = pd.DataFrame({"row": np.arange(len(d["sample_ids"])), "sample_id": d["sample_ids"],
+                        "donor_id": d["donor_ids"], "group": d["groups"]})
+    out["fold"] = out["donor_id"].map(fold_of).fillna(-1).astype(int)
+    out.loc[~use, "fold"] = -1                  # excluded rows: fold -1, never training, inner-val or test
+    for f in range(k):
+        train_donors = donors[donors["donor_id"].map(fold_of) != f]
+        inner = []
+        for _, g in train_donors.groupby("group", sort=True):
+            n_take = int(round(inner_frac * len(g)))
+            if n_take == 0 and len(g) >= 4:
+                n_take = 1
+            ids = g["donor_id"].to_numpy()
+            inner.extend(ids[rng.permutation(len(ids))[:n_take]].tolist())
+        out[f"inner_val_f{f}"] = out["donor_id"].isin(inner) & (out["fold"] != f) & (out["fold"] >= 0)
+    return out
+
+
+def write_npz(path: Path, d: dict, rows: np.ndarray, counts: np.ndarray, frac: np.ndarray,
+              cells_per_bulk: int, arm: str) -> str:
+    rows = np.asarray(rows, dtype=np.int64)
+    c = counts[rows]
+    fr = frac[rows].astype(np.float32)
+    if bool((c[fr == 0] != 0).any()):
+        raise SystemExit(f"{path.name}: unmeasured coordinate with a non-zero count")
+    np.savez(path, schema_version=np.array(SCHEMA), bulk_counts=c, bulk_measurement_fraction=fr,
+             output_availability_mask=d["sc_valid"][rows], recipe_k=np.full(len(rows), RB.RECIPE_K, dtype=np.int64),
+             cells_per_bulk=np.full(len(rows), int(cells_per_bulk), dtype=np.int64),
+             sample_ids=d["sample_ids"][rows], donor_ids=d["donor_ids"][rows], groups=d["groups"][rows],
+             gene_ids=d["gene_ids"], donor_n_cells=d["n_cells"][rows], dataset_rows=rows, arm=np.array(arm))
+    return sha256_file(path)
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--dataset", required=True)
+    ap.add_argument("--folds", type=int, default=5)
+    ap.add_argument("--seed", type=int, default=20260927)
+    ap.add_argument("--inner-frac", type=float, default=0.10)
+    ap.add_argument("--cells-per-bulk", type=int, default=1500)
+    a = ap.parse_args(argv)
+    ds = TASK / "data" / a.dataset
+    d = load(ds)
+    n = len(d["sample_ids"])
+    folds = make_folds(d, a.folds, a.seed, a.inner_frac)
+    folds.to_csv(ds / "folds.csv", index=False)
+    all_rows = np.arange(n)
+    man = {"schema": SCHEMA, "dataset": a.dataset, "written_utc": datetime.now(timezone.utc).isoformat(),
+           "features_sha256": sha256_file((ds / "features.npz").resolve()), "seed": a.seed, "folds": a.folds,
+           "inner_frac": a.inner_frac, "cells_per_bulk": a.cells_per_bulk, "recipe_k": RB.RECIPE_K,
+           "depth_anchor": RB.DEPTH_ANCHOR, "builder": str(BUILDER), "builder_sha256": sha256_file(BUILDER),
+           "files": {}, "fold_sizes": {}, "checks": {}}
+
+    raw = RB.to_condition_counts(d["bulk"], d["bulk_valid"])
+    pseudo = RB.to_condition_counts(d["pseudo"], d["sc_valid"])
+    man["files"]["conditions_raw_fixed.npz"] = write_npz(ds / "conditions_raw_fixed.npz", d, all_rows, raw,
+                                                         d["bulk_valid"], a.cells_per_bulk, "raw")
+    man["files"]["conditions_pseudo_fixed.npz"] = write_npz(ds / "conditions_pseudo_fixed.npz", d, all_rows, pseudo,
+                                                            d["sc_valid"], a.cells_per_bulk, "pseudo")
+    if a.dataset == "immicro":
+        for arm, arr in (("raw", raw), ("pseudo", pseudo)):
+            pub = np.load(PUBLISHED_IMMICRO / f"conditions_ImMicro_{arm}.npz")
+            same = bool(np.array_equal(pub["bulk_counts"], arr)) and bool(
+                np.array_equal(pub["sample_ids"].astype(str), d["sample_ids"]))
+            man["checks"][f"{arm}_equals_published_fixed"] = same
+            if not same:
+                raise SystemExit(f"{arm}: differs from the published fixed ImMicro condition")
+
+    for f in range(a.folds):
+        fd = ds / f"fold{f}"
+        fd.mkdir(exist_ok=True)
+        test = folds.index[folds["fold"] == f].to_numpy()
+        inner = folds.index[folds[f"inner_val_f{f}"]].to_numpy()
+        train = folds.index[(folds["fold"] != f) & (folds["fold"] >= 0) & ~folds[f"inner_val_f{f}"]].to_numpy()
+        # alpha uses all training donors (train + inner-val), never excluded rows
+        fit = folds.index[(folds["fold"] != f) & (folds["fold"] >= 0)].to_numpy()
+        valid = d["bulk_valid"][fit].all(axis=0) & d["sc_valid"][fit].all(axis=0)
+        alpha = RB.gene_multiplier(d["bulk"][fit], d["pseudo"][fit], valid)
+        cal = RB.to_condition_counts(RB.cpm(d["bulk"]) * alpha[None, :], d["bulk_valid"])
+        man["files"][f"fold{f}/conditions_cal_fixed.npz"] = write_npz(fd / "conditions_cal_fixed.npz", d, all_rows,
+                                                                      cal, d["bulk_valid"], a.cells_per_bulk, "cal")
+        np.save(fd / "alpha.npy", alpha)
+        for arm, arr, frac in (("raw", raw, d["bulk_valid"]), ("cal", cal, d["bulk_valid"]),
+                               ("pseudo", pseudo, d["sc_valid"])):
+            man["files"][f"fold{f}/test_{arm}.npz"] = write_npz(fd / f"test_{arm}.npz", d, test, arr, frac,
+                                                                a.cells_per_bulk, arm)
+        man["fold_sizes"][f] = {"test": int(len(test)), "train": int(len(train)), "inner_val": int(len(inner)),
+                                "test_groups": folds.loc[test, "group"].value_counts().to_dict(),
+                                "alpha_genes_estimated": int((alpha != 1.0).sum())}
+    (ds / "PREPARE.json").write_text(json.dumps(man, indent=1, default=str))
+    print(json.dumps(man["fold_sizes"], indent=1), json.dumps(man["checks"]))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+"""Few-pair deployment scenario: n paired donors for fine-tuning, every other donor of the cohort for testing (CPU only).
+
+Per draw j (seed = --seed + j), n donors are drawn among the usable rows of data/<dataset>/folds.csv (fold >= 0,
+i.e. identity-passed), stratified by a donor-level stratum (a donor is in the stratum if any of its rows' group
+matches --strata-regex; allocation proportional, at least one donor per stratum).  All rows of the chosen donors are
+training pairs; all rows of every other usable donor are test rows.  No inner validation: the LoRA is trained for a
+fixed number of steps (the learning curve's early-stopping range for n = 5).
+
+Writes data/<dataset>/fewshot_n<n>/
+  all_usable_{raw,pseudo}.npz        every usable row (zero-shot raw and pseudobulk arms are sampled once and subset)
+  draw<j>/train_donors.txt           the n training donors
+  draw<j>/test_samples.txt           test sample_ids (the scorer's --donors list)
+  draw<j>/test_cal.npz               test rows, bulk x alpha fitted on the n training donors only
+  draw<j>/test_raw.npz               test rows, raw bulk (the fine-tuned model's input)
+  DRAWS.json
+usage: prepare_fewshot.py DATASET --n 5 --draws 5 [--strata-regex REGEX]
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+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=''")
+TASK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+sys.path.insert(0, str(TASK / "tools"))
+import prepare_dataset as PD  # noqa: E402  (same loader, condition arithmetic and NPZ writer as the fold benchmark)
+
+DEFAULT_STRATA = {"ye2026_sepsis": "sepsis", "imperial_eskd": "positive", "giroux2022": "severe",
+                  "ji2025_chili": "TOL|FU1"}
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("dataset")
+    ap.add_argument("--n", type=int, default=5)
+    ap.add_argument("--draws", type=int, default=5)
+    ap.add_argument("--seed", type=int, default=20260928)
+    ap.add_argument("--strata-regex", default=None)
+    ap.add_argument("--cells-per-bulk", type=int, default=1500)
+    a = ap.parse_args(argv)
+    ds = TASK / "data" / a.dataset
+    d = PD.load(ds)
+    folds = pd.read_csv(ds / "folds.csv")
+    if not np.array_equal(folds["sample_id"].astype(str).to_numpy(), d["sample_ids"]):
+        raise SystemExit("folds.csv rows differ from features.npz")
+    usable = folds.index[folds["fold"] >= 0].to_numpy()
+    regex = DEFAULT_STRATA.get(a.dataset, "") if a.strata_regex is None else a.strata_regex
+    donor_groups = folds.loc[usable].groupby("donor_id")["group"].apply(lambda g: " ".join(map(str, g)))
+    stratum = donor_groups.str.contains(regex, regex=True) if regex else pd.Series(True, index=donor_groups.index)
+    out = ds / f"fewshot_n{a.n}"
+    out.mkdir(exist_ok=True)
+    raw = PD.RB.to_condition_counts(d["bulk"], d["bulk_valid"])
+    pseudo = PD.RB.to_condition_counts(d["pseudo"], d["sc_valid"])
+    man = {"dataset": a.dataset, "n": a.n, "draws": a.draws, "seed": a.seed, "strata_regex": regex,
+           "n_usable_rows": int(usable.size), "n_usable_donors": int(donor_groups.size),
+           "stratum_sizes": {str(k): int(v) for k, v in stratum.value_counts().items()}, "files": {}, "draw": {}}
+    man["files"]["all_usable_raw.npz"] = PD.write_npz(out / "all_usable_raw.npz", d, usable, raw, d["bulk_valid"],
+                                                      a.cells_per_bulk, "raw")
+    man["files"]["all_usable_pseudo.npz"] = PD.write_npz(out / "all_usable_pseudo.npz", d, usable, pseudo, d["sc_valid"],
+                                                         a.cells_per_bulk, "pseudo")
+    labels = sorted(set(stratum.tolist()))
+    sizes = {s: int((stratum == s).sum()) for s in labels}
+    total = sum(sizes.values())
+    for j in range(a.draws):
+        rng = np.random.default_rng(a.seed + j)
+        alloc = {s: max(1, int(np.floor(a.n * sizes[s] / total))) for s in labels}
+        while sum(alloc.values()) < a.n:
+            s = max(labels, key=lambda s: a.n * sizes[s] / total - alloc[s]); alloc[s] += 1
+        while sum(alloc.values()) > a.n:
+            s = max((s for s in labels if alloc[s] > 1), key=lambda s: alloc[s]); alloc[s] -= 1
+        chosen = []
+        for s in labels:
+            pool = np.asarray(sorted(stratum.index[stratum == s]))
+            chosen += pool[rng.permutation(pool.size)[:alloc[s]]].tolist()
+        train = folds.index[folds["donor_id"].astype(str).isin(chosen) & (folds["fold"] >= 0)].to_numpy()
+        test = np.setdiff1d(usable, train)
+        dd = out / f"draw{j}"
+        dd.mkdir(exist_ok=True)
+        (dd / "train_donors.txt").write_text("\n".join(chosen) + "\n")
+        (dd / "test_samples.txt").write_text("\n".join(d["sample_ids"][test]) + "\n")
+        # paired calibration with the same n pairs the LoRA sees: the zero-parameter comparator at equal data budget
+        valid = d["bulk_valid"][train].all(axis=0) & d["sc_valid"][train].all(axis=0)
+        alpha = PD.RB.gene_multiplier(d["bulk"][train], d["pseudo"][train], valid)
+        cal = PD.RB.to_condition_counts(PD.RB.cpm(d["bulk"]) * alpha[None, :], d["bulk_valid"])
+        np.save(dd / "alpha.npy", alpha)
+        for arm, arr, frac in (("raw", raw, d["bulk_valid"]), ("cal", cal, d["bulk_valid"])):
+            man["files"][f"draw{j}/test_{arm}.npz"] = PD.write_npz(dd / f"test_{arm}.npz", d, test, arr, frac,
+                                                                   a.cells_per_bulk, arm)
+        man["draw"][j] = {"train_donors": chosen, "n_train_rows": int(train.size), "n_test_rows": int(test.size),
+                          "allocation": {str(k): int(v) for k, v in alloc.items()},
+                          "test_groups": folds.loc[test, "group"].value_counts().to_dict(),
+                          "alpha_genes_estimated": int((alpha != 1.0).sum())}
+    (out / "DRAWS.json").write_text(json.dumps(man, indent=1, default=str))
+    print(json.dumps({k: man[k] for k in ("dataset", "n", "n_usable_rows", "n_usable_donors", "stratum_sizes")}))
+    for j, v in man["draw"].items():
+        print(j, v["train_donors"], v["n_train_rows"], v["n_test_rows"], v["allocation"])
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/20260928/diffusion/data/source_prep/giroux2022/code/giroux2022_assemble.py

@@ -0,0 +1,661 @@
+#!/usr/bin/env python3
+"""Assemble the Giroux 2022 COVID-19 paired bulk <-> scRNA fine-tuning files (CPU only).
+
+Adapted from the Ye 2026 build (processing/ye2026_sepsis_v1_20260927/code/ye2026_assemble.py); same output
+files, keys and semantics.  Study-specific differences:
+  * one row = one subject-day (a subject has 2-3 rows); donor_ids = GEO subject, timepoints = GEO day;
+  * bulk genes are hg19 annotation symbols (no Ensembl IDs); RPS4Y1 is absent from the bulk table, so the bulk
+    Y score uses DDX3Y + UTY + KDM5D (sc keeps the 4-gene Ye score; a 3-gene sc score is reported alongside);
+  * the donor-sensitive expression test ranks SUBJECTS (a subject's other visit is the same person), removes
+    k = 5 sample PCs per modality (41 sc libraries / 49 bulks; k = 3 and 10 are sensitivity), and leaves chrY
+    genes out so that it is independent of the sex check.
+
+Inputs (processing run, produced by giroux2022_pipeline.py):
+  pairing/sc_libraries_with_bulk_match.csv, pairing/bulk_count_columns.csv,
+  bulk/GSE206263_featureCounts/harmonized.h5ad, bulk/bulk_source_counts.npz,
+  singlecell/<GSM>/{canonical.h5ad, pseudobulk_per_published_sample.h5, source_axis_pseudobulk.npz,
+  cell_sex_gene_counts.npz, summary.json}
+Outputs (OUT):
+  features.npz, cells_panel6k.npz, cells_obs.parquet, samples.csv, pairs.csv, identity_sex_bulk_all.csv,
+  identity_sex_sc_all.csv, identity_expression.csv, MANIFEST.json (QC_REPORT.md is written by hand)
+Processing-run extras: identity/ (full residual correlation matrices, unpaired-healthy leads).
+
+Rows = accepted pairs ordered by bulk GSM.  Retained cells = flag_conservative_review_pass (qc_core: >= 200 genes,
+>= 500 UMIs, <= 20 % mito), the ImMicro definition.  Identity checks are reported, never used to drop rows.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import shutil
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import h5py
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+from scipy.stats import rankdata
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+
+DATALAKE = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc")
+RUN = DATALAKE / "processing/giroux2022_v1_20260928"
+REFERENCE = DATALAKE / "processing/strict_qc_v1_20260913/reference"
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+OUT = M8 / "plans/paired_finetune_intradataset_20260927/data/giroux2022"
+POSITIONS = M8 / "artifacts/panel_ladder_floor01_1m_20260923/tiers/6k/gene_positions.npy"
+POSITIONS_SHA = "653ffa45ac519000baa41086c52408009391d6e68cfb218bc6a50d34163fcb24"
+SELECTED = POSITIONS.parent / "selected_genes.csv"
+TMP = RUN / "assemble_tmp"
+IDENT = RUN / "identity"
+SEX_GENES = ["XIST", "RPS4Y1", "DDX3Y", "UTY", "KDM5D"]
+SEX_IDS = {"XIST": "ENSG00000229807", "RPS4Y1": "ENSG00000129824", "DDX3Y": "ENSG00000067048",
+           "UTY": "ENSG00000183878", "KDM5D": "ENSG00000012817"}
+Y_GENES = ["RPS4Y1", "DDX3Y", "UTY", "KDM5D"]
+Y_GENES_BULK = ["DDX3Y", "UTY", "KDM5D"]  # RPS4Y1 is not a row of the author bulk table
+TOP_N = 2000
+RESID_K = (5, 3, 10)      # k = 5 primary; 3 and 10 sensitivity
+K_PRIMARY = 5
+SUBJ_TOP = 3              # verdict: own subject 1st in one direction and within the top 3 subjects in the other
+ISG_GENES = ["IFI27", "IFI44L", "ISG15", "RSAD2", "IFIT1", "IFIT3", "MX1", "OAS1", "OAS3", "SIGLEC1", "IFI6", "HERC5"]
+
+
+def sha256_file(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(1 << 24), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def text(values) -> np.ndarray:
+    return np.asarray([v.decode() if isinstance(v, bytes) else str(v) for v in values])
+
+
+def require(ok: bool, msg: str) -> None:
+    if not ok:
+        raise SystemExit(msg)
+
+
+def sex_call(xist_cpm: float, y_cpm: float) -> tuple[str, float]:
+    """female if log2(XIST+1)-log2(Ysum+1) > 2, male if < -2, else ambiguous (the Ye 2026 rule)."""
+    score = float(np.log2(xist_cpm + 1) - np.log2(y_cpm + 1))
+    return ("female" if score > 2 else "male" if score < -2 else "ambiguous"), score
+
+
+def spearman_matrix(a: np.ndarray, b: np.ndarray) -> np.ndarray:
+    ra = rankdata(a, axis=1)
+    rb = rankdata(b, axis=1)
+    ra = (ra - ra.mean(1, keepdims=True)) / ra.std(1, keepdims=True)
+    rb = (rb - rb.mean(1, keepdims=True)) / rb.std(1, keepdims=True)
+    return ra @ rb.T / a.shape[1]
+
+
+def pearson_matrix(a: np.ndarray, b: np.ndarray) -> np.ndarray:
+    a = (a - a.mean(1, keepdims=True)) / a.std(1, keepdims=True)
+    b = (b - b.mean(1, keepdims=True)) / b.std(1, keepdims=True)
+    return a @ b.T / a.shape[1]
+
+
+def subject_rank(scores: np.ndarray, subjects: np.ndarray, own: str) -> tuple[int, str, float]:
+    """Rank of subject `own` when every subject is scored by its best-matching sample (1 = best)."""
+    best = pd.Series(scores).groupby(subjects).max().sort_values(ascending=False, kind="mergesort")
+    return int(np.flatnonzero(best.index.to_numpy() == own)[0]) + 1, str(best.index[0]), float(best.iloc[0])
+
+
+def main() -> int:
+    t0 = datetime.now(timezone.utc)
+    require(sha256_file(POSITIONS) == POSITIONS_SHA, "gene_positions.npy sha differs from the final run's")
+    positions = np.load(POSITIONS).astype(np.int64)
+    canonical = pd.read_csv(REFERENCE / "canonical_genes.tsv", sep="\t", dtype=str)
+    gene_ids = canonical.gene_id.to_numpy().astype("U15")
+    require(gene_ids.dtype.kind == "U" and all(len(x) == 15 for x in gene_ids), "gene id dtype")
+    require(len(gene_ids) == 20097 and canonical.panel_index.astype(int).tolist() == list(range(20097)), "axis")
+    chr_y = canonical.chromosome.astype(str).isin(["Y", "chrY"]).to_numpy()
+    selected = pd.read_csv(SELECTED)
+    require(np.array_equal(selected.gene_id.to_numpy(), gene_ids[positions]), "panel ids differ from positions")
+
+    table = pd.read_csv(RUN / "pairing/sc_libraries_with_bulk_match.csv", dtype=str, keep_default_na=False)
+    cols = pd.read_csv(RUN / "pairing/bulk_count_columns.csv", dtype=str, keep_default_na=False)
+    summaries = {g: json.loads((RUN / "singlecell" / g / "summary.json").read_text()) for g in table.sc_gsm}
+    bad = [g for g, s in summaries.items() if s["status"] != "PASS"]
+    pairs = table[table.paired == "True"].copy()
+    quarantined_pairs = sorted(set(bad) & set(pairs.sc_gsm))
+    pairs = pairs[~pairs.sc_gsm.isin(bad)].sort_values("bulk_gsm").reset_index(drop=True)
+    n = len(pairs)
+
+    # ---------------- bulk (canonical, harmonized by qc_bulk.harmonize)
+    import anndata as ad
+    bad_ = ad.read_h5ad(RUN / "bulk/GSE206263_featureCounts/harmonized.h5ad")
+    bX = np.asarray(bad_.X, dtype=np.float64)
+    b_valid = np.asarray(bad_.layers["harmonization_valid"]).astype(bool)
+    b_index = bad_.obs_names.to_numpy().astype(str)            # author column names
+    b_gsm = bad_.obs["source_GSM"].astype(str).to_numpy()      # '' for the 6 columns without a GEO GSM
+    require(np.array_equal(bad_.var_names.to_numpy().astype(str), gene_ids), "bulk gene order")
+    require(str(bad_.uns["units"]) == "featureCounts_raw_gene_counts", "bulk units")
+    require(bool(bad_.uns["raw_count_eligible"]), "bulk not raw-count eligible")
+    del bad_
+    bcol = {c: i for i, c in enumerate(b_index)}
+    require(len(bcol) == len(b_index), "duplicate bulk column")
+    inside = bX[b_valid]
+    require(np.isfinite(inside).all() and (inside >= 0).all() and np.array_equal(inside, np.rint(inside)),
+            "bulk values inside the measured mask must be nonnegative integers")
+    require(np.isnan(bX[~b_valid]).all(), "bulk values outside the mask must be NaN in the harmonized file")
+    bulk_all = np.where(b_valid, bX, 0.0)
+    b_subject = cols.set_index("bulk_column").loc[b_index, "subject"].to_numpy()
+    b_label = np.asarray([c for c in b_index])
+
+    # ---------------- sc per library: pseudobulk sums and masks for every PASS library
+    sc_gsms = [g for g in table.sc_gsm if summaries[g]["status"] == "PASS"]
+    sc_meta = table.set_index("sc_gsm")
+    s_subject = sc_meta.loc[sc_gsms, "subject"].to_numpy()
+    s_label = sc_meta.loc[sc_gsms, "sample_id"].to_numpy()
+    sc_sum = np.zeros((len(sc_gsms), 20097))
+    sc_valid_all = np.zeros((len(sc_gsms), 20097), dtype=bool)
+    sc_n = np.zeros(len(sc_gsms), dtype=np.int64)
+    for i, g in enumerate(sc_gsms):
+        with h5py.File(RUN / "singlecell" / g / "pseudobulk_per_published_sample.h5", "r") as f:
+            require(np.array_equal(text(f["gene_id"][:]), gene_ids), f"{g}: gene order")
+            require(len(f["sample_id"]) == 1, f"{g}: exactly one sample per library")
+            require(text(f["sample_id"][:])[0] == s_label[i], f"{g}: sample id")
+            require(f.attrs["units"] == "UMI_counts", f"{g}: units")
+            sc_sum[i] = f["qc_review_pass_cells_sum"][0]
+            sc_valid_all[i] = f["harmonization_valid"][:].astype(bool)
+            sc_n[i] = int(f["n_cells"][1, 0])
+        require(np.array_equal(sc_sum[i], np.rint(sc_sum[i])) and (sc_sum[i] >= 0).all(), f"{g}: noninteger sum")
+        require((sc_sum[i][~sc_valid_all[i]] == 0).all(), f"{g}: mass outside the measured mask")
+    srow = {g: i for i, g in enumerate(sc_gsms)}
+
+    # ---------------- per-pair feature rows
+    bi = np.asarray([bcol[c] for c in pairs.bulk_count_column])
+    si = np.asarray([srow[g] for g in pairs.sc_gsm])
+    require(np.array_equal(b_gsm[bi], pairs.bulk_gsm.to_numpy()), "bulk column -> GSM join")
+    require(np.array_equal(b_subject[bi], pairs.subject.to_numpy()), "bulk subject join")
+    bulk_raw = bulk_all[bi]
+    bulk_valid = b_valid[bi]
+    pseudo_raw_sum = sc_sum[si]
+    sc_valid = sc_valid_all[si]
+    qc_cell_counts = sc_n[si]
+
+    # ---------------- sex check (source axis; XIST is not protein-coding)
+    bsrc = np.load(RUN / "bulk/bulk_source_counts.npz")
+    bids = list(bsrc["gene_ids"])
+    bcounts = bsrc["counts"]
+    require(list(bsrc["sample_ids"]) == list(b_index), "bulk source-axis sample order")
+    bcpm = bcounts / bcounts.sum(1, keepdims=True) * 1e6
+    sex_rows = []
+    for g in sc_gsms:
+        z = np.load(RUN / "singlecell" / g / "source_axis_pseudobulk.npz")
+        fid = list(z["feature_ids"])
+        tot = z["qc_pass_sum"][z["rna"]].sum()
+        rec = {"sc_gsm": g}
+        for gene in SEX_GENES:
+            rec["sc_" + gene + "_cpm"] = float(z["qc_pass_sum"][fid.index(SEX_IDS[gene])] / tot * 1e6)
+        rec["sc_Ysum_cpm"] = sum(rec["sc_" + x + "_cpm"] for x in Y_GENES)
+        rec["sc_Ysum3_cpm"] = sum(rec["sc_" + x + "_cpm"] for x in Y_GENES_BULK)
+        rec["sc_sex_call"], rec["sc_sex_score"] = sex_call(rec["sc_XIST_cpm"], rec["sc_Ysum_cpm"])
+        rec["sc_sex_call_3gene"], rec["sc_sex_score_3gene"] = sex_call(rec["sc_XIST_cpm"], rec["sc_Ysum3_cpm"])
+        sex_rows.append(rec)
+    sc_sex = pd.DataFrame(sex_rows).set_index("sc_gsm")
+    bulk_sex_rows = []
+    for j, c in enumerate(b_index):
+        rec = {"bulk_column": c, "bulk_gsm": b_gsm[j]}
+        for gene in SEX_GENES:
+            rec["bulk_" + gene + "_cpm"] = float(bcpm[j, bids.index(gene)]) if gene in bids else np.nan
+        rec["bulk_Ysum_cpm"] = sum(rec["bulk_" + x + "_cpm"] for x in Y_GENES_BULK)
+        rec["bulk_sex_call"], rec["bulk_sex_score"] = sex_call(rec["bulk_XIST_cpm"], rec["bulk_Ysum_cpm"])
+        bulk_sex_rows.append(rec)
+    bulk_sex = pd.DataFrame(bulk_sex_rows).set_index("bulk_column")
+
+    # ---------------- expression identity: every bulk column vs every sc pseudobulk (retained cells)
+    common = b_valid.all(0) & sc_valid_all.all(0) & ~chr_y
+
+    def logcpm(m: np.ndarray) -> np.ndarray:
+        x = m[:, common]
+        return np.log2(x / x.sum(1, keepdims=True) * 1e6 + 1)
+
+    lb_all, ls_all = logcpm(bulk_all), logcpm(sc_sum)
+    mean_score = 0.5 * (lb_all.mean(0) + ls_all.mean(0))
+    top = np.argsort(-mean_score, kind="mergesort")[:TOP_N]
+    rho = spearman_matrix(lb_all[bi][:, top], ls_all[:, top])                 # paired bulks x all sc
+    rho_rev = spearman_matrix(ls_all[si][:, top], lb_all[:, top])             # paired sc x all bulks
+    cb = lb_all - lb_all.mean(0)
+    cs = ls_all - ls_all.mean(0)
+    rho_c = spearman_matrix(cb[bi][:, top], cs[:, top])                       # modality-centred sensitivity
+    rho_c_rev = spearman_matrix(cs[si][:, top], cb[:, top])
+    expr = []
+    for r in range(n):
+        own = si[r]
+        order = np.argsort(-rho[r]); order_c = np.argsort(-rho_c[r])
+        rev = np.argsort(-rho_rev[r]); rev_c = np.argsort(-rho_c_rev[r])
+        expr.append({"sample_id": pairs.sample_id[r], "bulk_gsm": pairs.bulk_gsm[r], "sc_gsm": pairs.sc_gsm[r],
+                     "rho_own": rho[r, own], "best_sc_gsm": sc_gsms[order[0]], "rho_best": rho[r, order[0]],
+                     "own_rank_among_sc": int(np.flatnonzero(order == own)[0]) + 1,
+                     "best_is_own": bool(order[0] == own),
+                     "rho_second": rho[r, order[1]],
+                     "centred_rho_own": rho_c[r, own], "centred_best_sc_gsm": sc_gsms[order_c[0]],
+                     "centred_own_rank_among_sc": int(np.flatnonzero(order_c == own)[0]) + 1,
+                     "centred_best_is_own": bool(order_c[0] == own),
+                     "reverse_best_bulk": b_label[rev[0]], "reverse_own_rank_among_bulk": int(np.flatnonzero(rev == bi[r])[0]) + 1,
+                     "reverse_best_is_own": bool(rev[0] == bi[r]),
+                     "centred_reverse_best_bulk": b_label[rev_c[0]],
+                     "centred_reverse_own_rank_among_bulk": int(np.flatnonzero(rev_c == bi[r])[0]) + 1,
+                     "centred_reverse_best_is_own": bool(rev_c[0] == bi[r])})
+    expr = pd.DataFrame(expr)
+
+    # Residualised donor-identity test (unsupervised w.r.t. pairing): within each modality centre log CPM, remove
+    # the top-k sample PCs (computed on expressed genes), keep the 2,000 genes with the highest residual variance
+    # in both modalities, Pearson.  Ranks are reported per library and per subject (best library of a subject).
+    expressed = (lb_all.mean(0) > 3) & (ls_all.mean(0) > 1)
+    ex = np.flatnonzero(expressed)
+
+    def resid(x: np.ndarray, k: int) -> np.ndarray:
+        xc = x - x.mean(0)
+        u = np.linalg.svd(xc[:, ex], full_matrices=False)[0][:, :k]
+        return xc - u @ (u.T @ xc)
+
+    IDENT.mkdir(exist_ok=True)
+    full_fw = {}
+    for k in RESID_K:
+        rb_, rs_ = resid(lb_all, k), resid(ls_all, k)
+        vb = np.where(expressed, rb_.var(0), -1.0); vs = np.where(expressed, rs_.var(0), -1.0)
+        sel = np.argsort(rankdata(-vb) + rankdata(-vs), kind="mergesort")[:TOP_N]
+        fw_all = pearson_matrix(rb_[:, sel], rs_[:, sel])                     # all 49 bulks x all 41 sc
+        full_fw[k] = fw_all
+        pd.DataFrame(fw_all, index=b_label, columns=[f"{g}|{s}" for g, s in zip(sc_gsms, s_label)]).to_csv(
+            IDENT / f"residual_k{k}_pearson_bulk_x_sc.csv")
+        fw = fw_all[bi]; bw = fw_all[:, si].T
+        c = {x: [] for x in ("lib_b2s", "lib_s2b", "subj_b2s", "subj_s2b", "best_sc", "best_subj_b2s",
+                             "best_subj_s2b", "r_own", "r_best", "day_b2s", "day_s2b", "n_days")}
+        for r in range(n):
+            o = np.argsort(-fw[r]); o2 = np.argsort(-bw[r])
+            subj = pairs.subject[r]
+            c["lib_b2s"].append(int(np.flatnonzero(o == si[r])[0]) + 1)
+            c["lib_s2b"].append(int(np.flatnonzero(o2 == bi[r])[0]) + 1)
+            rk, best, _ = subject_rank(fw[r], s_subject, subj); c["subj_b2s"].append(rk); c["best_subj_b2s"].append(best)
+            rk, best, _ = subject_rank(bw[r], b_subject, subj); c["subj_s2b"].append(rk); c["best_subj_s2b"].append(best)
+            c["best_sc"].append(sc_gsms[o[0]]); c["r_own"].append(float(fw[r, si[r]])); c["r_best"].append(float(fw[r, o[0]]))
+            # within-subject day check: among this subject's paired libraries / bulks, is the own day the best?
+            own_s = np.flatnonzero((s_subject == subj) & np.isin(np.arange(len(sc_gsms)), si))
+            own_b = np.flatnonzero((b_subject == subj) & np.isin(np.arange(len(b_index)), bi))
+            c["day_b2s"].append(int((fw[r, own_s] > fw[r, si[r]]).sum()) + 1)
+            c["day_s2b"].append(int((bw[r, own_b] > bw[r, bi[r]]).sum()) + 1)
+            c["n_days"].append(len(own_s))
+        for key, name in (("lib_b2s", "own_rank_bulk_to_sc"), ("lib_s2b", "own_rank_sc_to_bulk"),
+                          ("subj_b2s", "own_subject_rank_bulk_to_sc"), ("subj_s2b", "own_subject_rank_sc_to_bulk"),
+                          ("best_sc", "best_sc_gsm"), ("best_subj_b2s", "best_subject_bulk_to_sc"),
+                          ("best_subj_s2b", "best_subject_sc_to_bulk"), ("r_own", "r_own"), ("r_best", "r_best"),
+                          ("day_b2s", "own_day_rank_within_subject_bulk_to_sc"),
+                          ("day_s2b", "own_day_rank_within_subject_sc_to_bulk"), ("n_days", "subject_paired_days")):
+            expr[f"resid_k{k}_{name}"] = c[key]
+
+    # Day check on disease-state signal (centred, NOT residualised): within the subject's paired rows only.
+    vb = cb.var(0); vs = cs.var(0)
+    selc = np.argsort(rankdata(-np.where(expressed, vb, -1)) + rankdata(-np.where(expressed, vs, -1)), kind="mergesort")[:TOP_N]
+    cfw = pearson_matrix(cb[:, selc], cs[:, selc])
+    dd1, dd2 = [], []
+    for r in range(n):
+        subj = pairs.subject[r]
+        rows_subj = np.flatnonzero(pairs.subject.to_numpy() == subj)
+        dd1.append(int((cfw[bi[r], si[rows_subj]] > cfw[bi[r], si[r]]).sum()) + 1)
+        dd2.append(int((cfw[bi[rows_subj], si[r]] > cfw[bi[r], si[r]]).sum()) + 1)
+    expr["centred_own_day_rank_within_subject_bulk_to_sc"] = dd1
+    expr["centred_own_day_rank_within_subject_sc_to_bulk"] = dd2
+
+    # Interferon-stimulated-gene score (informational day evidence): mean log2(CPM+1) of a fixed ISG set on the
+    # canonical axis, per bulk column and per sc library.  Early COVID-19 should peak at day 0 in both assays.
+    sym = canonical.gene_symbol.astype(str).to_numpy()
+    isg_idx = np.flatnonzero(np.isin(sym, ISG_GENES))
+    require(len(isg_idx) == len(ISG_GENES), "ISG genes missing from the canonical axis")
+    require(bool(b_valid[:, isg_idx].all() and sc_valid_all[:, isg_idx].all()), "ISG genes not measured everywhere")
+    isg_b = np.log2(bulk_all[:, isg_idx] / bulk_all.sum(1, keepdims=True) * 1e6 + 1).mean(1)
+    isg_s = np.log2(sc_sum[:, isg_idx] / sc_sum.sum(1, keepdims=True) * 1e6 + 1).mean(1)
+    expr["isg_score_bulk"] = isg_b[bi]
+    expr["isg_score_sc"] = isg_s[si]
+    peak_b, peak_s = {}, {}
+    for subj in pairs.subject.unique():
+        rows_subj = np.flatnonzero(pairs.subject.to_numpy() == subj)
+        peak_b[subj] = pairs.day[rows_subj[np.argmax(isg_b[bi[rows_subj]])]]
+        peak_s[subj] = pairs.day[rows_subj[np.argmax(isg_s[si[rows_subj]])]]
+    expr["isg_peak_day_bulk"] = [peak_b[s] for s in pairs.subject]
+    expr["isg_peak_day_sc"] = [peak_s[s] for s in pairs.subject]
+
+    # Leads only (no pairing): unpaired bulk columns without a GEO GSM vs unpaired sc libraries, primary k.
+    fw_all = full_fw[K_PRIMARY]
+    unpaired_sc = [i for i in range(len(sc_gsms)) if i not in set(si)]
+    no_gsm_cols = [j for j in range(len(b_index)) if b_gsm[j] == ""]
+    # positional counterpart: healthy rows of the author sample sheet vs healthy bulk GSMs in GEO order
+    sheet = pd.read_csv(RUN / "extracted/GSE206263/bulk_RNA-seq_sample_metadata.tsv", sep="\t", dtype=str, keep_default_na=False)
+    sheet_healthy = sheet[sheet.Cohort == "Healthy"].SampleID.tolist()
+    geo_b = pd.read_csv(RUN / "pairing/GSE206263_samples.csv", dtype=str, keep_default_na=False).sort_values("gsm")
+    geo_healthy = geo_b[geo_b.ch_exposure == "Healthy"].subject.tolist()
+    require(len(sheet_healthy) == len(geo_healthy), "healthy counts differ between author sheet and GEO")
+    same_position = dict(zip(sheet_healthy, geo_healthy))
+    leads = []
+    for j in no_gsm_cols:
+        o = np.argsort(-fw_all[j])
+        best = o[0]
+        rev = np.argsort(-fw_all[:, best])
+        leads.append({"bulk_column": b_label[j], "bulk_sex_call": bulk_sex.loc[b_label[j], "bulk_sex_call"],
+                      "best_sc_gsm": sc_gsms[best], "best_sc_sample": s_label[best],
+                      "best_sc_sex_call": sc_sex.loc[sc_gsms[best], "sc_sex_call"],
+                      "best_sc_geo_sex": sc_meta.loc[sc_gsms[best], "sc_sex"],
+                      "best_sc_is_unpaired": bool(best in unpaired_sc), "r_best": float(fw_all[j, best]),
+                      "r_second": float(fw_all[j, o[1]]), "second_sc_sample": s_label[o[1]],
+                      "reverse_rank_of_this_bulk_for_best_sc": int(np.flatnonzero(rev == j)[0]) + 1,
+                      "reverse_best_bulk_for_best_sc": b_label[rev[0]],
+                      "geo_healthy_subject_at_same_position_in_author_sheet": same_position.get(b_label[j], ""),
+                      "position_agrees_with_best_sc_subject": same_position.get(b_label[j], "") == s_subject[best]})
+    leads = pd.DataFrame(leads)
+    leads.to_csv(IDENT / f"leads_bulk_columns_without_gsm_k{K_PRIMARY}.csv", index=False)
+
+    # ---------------- cells on the 6k panel (two passes: per-library temp files, then one CSR)
+    TMP.mkdir(exist_ok=True)
+    nnz_per, obs_blocks = [], []
+    for r in range(n):
+        g = pairs.sc_gsm[r]
+        h5 = RUN / "singlecell" / g / "canonical.h5ad"
+        with h5py.File(h5, "r") as f:
+            X = f["X"]
+            ncell = len(X["indptr"]) - 1
+            full = sp.csr_matrix((X["data"][:], X["indices"][:], X["indptr"][:]), shape=(ncell, 20097))
+            o = f["obs"]
+            keep = o["flag_conservative_review_pass"][:].astype(bool)
+            obs = pd.DataFrame({"cell_index": np.arange(ncell), "barcode": text(o["_index"][:]),
+                                "raw_gex_total": o["cell_total"][:], "n_genes": o["cell_detected"][:],
+                                "mito_pct": o["cell_mito_percent"][:],
+                                "flag_low_total_mad": o["flag_low_total_mad"][:].astype(bool),
+                                "flag_low_genes_mad": o["flag_low_genes_mad"][:].astype(bool),
+                                "flag_high_mito_mad": o["flag_high_mito_mad"][:].astype(bool),
+                                "flag_high_total_review_only": o["flag_high_total_review_only"][:].astype(bool)})
+            require(np.array_equal(text(o["sample_id"][:]), np.full(ncell, pairs.sample_id[r])), f"{g}: sample id")
+        require(int(keep.sum()) == qc_cell_counts[r], f"{g}: retained-cell count differs from pseudobulk file")
+        kept = full[np.flatnonzero(keep)]
+        require(np.array_equal(np.asarray(kept.sum(0)).ravel(), pseudo_raw_sum[r]), f"{g}: canonical sum differs")
+        sub = kept[:, positions].tocsr()
+        sub.sort_indices()
+        require(np.array_equal(sub.data, np.rint(sub.data)) and (sub.data >= 0).all() and
+                (sub.data.max(initial=0) < 2**31), f"{g}: non-integer or overflowing counts")
+        require(np.array_equal(np.asarray(sub.sum(0)).ravel(), pseudo_raw_sum[r, positions]), f"{g}: panel sum")
+        np.save(TMP / f"{r:03d}_data.npy", sub.data.astype(np.int32))
+        np.save(TMP / f"{r:03d}_indices.npy", sub.indices.astype(np.int32))
+        np.save(TMP / f"{r:03d}_indptr.npy", sub.indptr.astype(np.int64))
+        sx = np.load(RUN / "singlecell" / g / "cell_sex_gene_counts.npz")
+        require(list(sx["genes"]) == SEX_GENES and sx["found"].all(), f"{g}: sex genes")
+        obs = obs[keep].reset_index(drop=True)
+        obs["cell_total_canonical"] = np.asarray(kept.sum(1)).ravel()
+        obs["lib_panel"] = np.asarray(sub.sum(1)).ravel()
+        for k, gene in enumerate(SEX_GENES):
+            obs[("xist" if gene == "XIST" else "y_" + gene)] = sx["counts"][k][keep]
+        obs["y_sum"] = obs[["y_" + x for x in Y_GENES]].sum(1)
+        obs.insert(2, "library_id", g)
+        obs.insert(3, "sample_id", pairs.sample_id[r])
+        obs.insert(4, "donor_id", pairs.subject[r])
+        obs.insert(5, "group", pairs.group[r])
+        obs["author_cell_type"] = ""
+        obs["row_sample"] = np.int32(r)
+        obs_blocks.append(obs)
+        nnz_per.append(sub.nnz)
+        print(f"{g} {pairs.sample_id[r]}: {sub.shape[0]} cells, nnz {sub.nnz}", flush=True)
+        del full, kept, sub
+    total_nnz = int(sum(nnz_per))
+    total_cells = int(qc_cell_counts.sum())
+    data = np.lib.format.open_memmap(TMP / "all_data.npy", mode="w+", dtype=np.int32, shape=(total_nnz,))
+    indices = np.lib.format.open_memmap(TMP / "all_indices.npy", mode="w+", dtype=np.int32, shape=(total_nnz,))
+    indptr = np.empty(total_cells + 1, dtype=np.int64)
+    indptr[0] = 0
+    at, cell_at = 0, 0
+    for r in range(n):
+        d = np.load(TMP / f"{r:03d}_data.npy"); ix = np.load(TMP / f"{r:03d}_indices.npy")
+        ip = np.load(TMP / f"{r:03d}_indptr.npy")
+        data[at:at + len(d)] = d
+        indices[at:at + len(d)] = ix
+        indptr[cell_at + 1:cell_at + len(ip)] = ip[1:] + at
+        at += len(d); cell_at += len(ip) - 1
+    require(at == total_nnz and cell_at == total_cells, "assembly size")
+    cobs = pd.concat(obs_blocks, ignore_index=True)
+    row_sample = cobs.row_sample.to_numpy(np.int32)
+    # Fail-closed re-check on the assembled matrix.
+    require(np.all(np.diff(row_sample) >= 0), "cells must be grouped by row")
+    require(np.array_equal(np.bincount(row_sample, minlength=n), qc_cell_counts), "assembled cell counts")
+    starts = np.concatenate([[0], np.cumsum(qc_cell_counts)])
+    for r in range(n):
+        a, b = indptr[starts[r]], indptr[starts[r + 1]]
+        s_r = np.bincount(indices[a:b], weights=data[a:b].astype(np.float64), minlength=len(positions))
+        require(np.array_equal(s_r, pseudo_raw_sum[r, positions]), f"row {r}: assembled panel sum differs")
+    require(np.all(np.diff(indptr) >= 0) and indptr[-1] == total_nnz, "indptr")
+
+    # ---------------- write
+    OUT.mkdir(parents=True, exist_ok=True)
+    bmeta = pd.read_csv(RUN / "pairing/GSE206263_samples.csv", dtype=str, keep_default_na=False).set_index("gsm")
+    meta_arrays = {
+        "gene_ids": gene_ids, "sample_ids": pairs.sample_id.to_numpy().astype(str),
+        "donor_ids": pairs.subject.to_numpy().astype(str), "groups": pairs.group.to_numpy().astype(str),
+        "timepoints": pairs.day.astype(np.int64).to_numpy(),
+        "bulk_raw": bulk_raw.astype(np.float64), "pseudo_raw_sum": pseudo_raw_sum.astype(np.float64),
+        "bulk_valid": bulk_valid, "sc_valid": sc_valid, "pair_valid": bulk_valid & sc_valid,
+        "qc_cell_counts": qc_cell_counts.astype(np.int64),
+        "bulk_gsm": pairs.bulk_gsm.to_numpy().astype(str), "sc_gsm": pairs.sc_gsm.to_numpy().astype(str),
+        "sc_title_sample_id": pairs.sc_title.to_numpy().astype(str),
+        "id_match": np.full(n, "exact_subject_day").astype(str),
+        "bulk_count_column": pairs.bulk_count_column.to_numpy().astype(str),
+        "sc_author_library": pairs.author_library.to_numpy().astype(str),
+        "sex_geo": pairs.sc_sex.to_numpy().astype(str), "age_geo": pairs.sc_age.to_numpy().astype(str),
+        "serostatus_geo": pairs.sc_serostatus.to_numpy().astype(str),
+        "author_cohort": cols.set_index("bulk_column").loc[pairs.bulk_count_column, "author_cohort"].to_numpy().astype(str),
+    }
+    require(np.array_equal(bmeta.loc[pairs.bulk_gsm, "ch_serostatus"].to_numpy(), pairs.sc_serostatus.to_numpy()),
+            "serostatus differs between bulk and sc GSM")
+    panel_gene_ids = gene_ids[positions]
+    tmp = OUT / "cells_panel6k.npz.tmp"
+    with open(tmp, "wb") as h:
+        np.savez_compressed(h, data=data, indices=indices, indptr=indptr,
+                            shape=np.array([total_cells, len(positions)], dtype=np.int64), row_sample=row_sample,
+                            panel_gene_ids=panel_gene_ids, panel_measured=sc_valid[:, positions])
+    os.replace(tmp, OUT / "cells_panel6k.npz")
+    cobs.to_parquet(OUT / "cells_obs.parquet", index=False)
+    pd.DataFrame({"row": np.arange(n), "sample_id": meta_arrays["sample_ids"], "donor_id": meta_arrays["donor_ids"],
+                  "group": meta_arrays["groups"], "n_cells": qc_cell_counts}).to_csv(OUT / "samples.csv", index=False)
+
+    # pairs.csv with identity results
+    p = pairs[["sample_id", "bulk_gsm", "sc_gsm", "subject", "bulk_title", "sc_title", "bulk_count_column",
+               "author_library", "group", "day", "sc_sex", "sc_age", "sc_serostatus"]].copy()
+    p = p.rename(columns={"subject": "donor_id", "author_library": "sc_author_library", "day": "timepoint",
+                          "sc_sex": "sex_geo", "sc_age": "age_geo", "sc_serostatus": "serostatus_geo"})
+    p.insert(4, "row", np.arange(n))
+    p.insert(7, "id_match", "exact_subject_day")
+    p["author_cohort"] = meta_arrays["author_cohort"]
+    p["n_cells_library"] = [summaries[g]["n_cells"] for g in p.sc_gsm]
+    p["n_cells_retained"] = qc_cell_counts
+    p["bulk_assigned_counts"] = bcounts[bi].sum(1)
+    p["bulk_canonical_counts"] = bulk_raw.sum(1)
+    p["sc_retained_umis_canonical"] = pseudo_raw_sum.sum(1)
+    for c in ("bulk_XIST_cpm", "bulk_Ysum_cpm", "bulk_sex_score", "bulk_sex_call"):
+        p[c] = bulk_sex.loc[p.bulk_count_column, c].to_numpy()
+    for c in ("sc_XIST_cpm", "sc_Ysum_cpm", "sc_sex_score", "sc_sex_call", "sc_Ysum3_cpm", "sc_sex_call_3gene"):
+        p[c] = sc_sex.loc[p.sc_gsm, c].to_numpy()
+    geo = p.sex_geo.str.lower()
+    p["sex_concordant"] = (p.bulk_sex_call == p.sc_sex_call) & (p.sc_sex_call == geo)
+    p["bulk_possible_mixture"] = ((p.bulk_sex_call == "female") & (p.bulk_Ysum_cpm > 20)) | \
+                                 ((p.bulk_sex_call == "male") & (p.bulk_XIST_cpm > 50))
+    e = expr.set_index("bulk_gsm")
+    for c in ("rho_own", "rho_best", "own_rank_among_sc", "best_is_own", "best_sc_gsm", "centred_own_rank_among_sc",
+              "centred_best_is_own", "reverse_own_rank_among_bulk", "reverse_best_is_own",
+              "centred_own_day_rank_within_subject_bulk_to_sc", "centred_own_day_rank_within_subject_sc_to_bulk",
+              "isg_score_bulk", "isg_score_sc", "isg_peak_day_bulk", "isg_peak_day_sc"):
+        p["expr_" + c] = e.loc[p.bulk_gsm, c].to_numpy()
+    for k in RESID_K:
+        for c in ("own_rank_bulk_to_sc", "own_rank_sc_to_bulk", "own_subject_rank_bulk_to_sc",
+                  "own_subject_rank_sc_to_bulk", "best_subject_bulk_to_sc", "best_subject_sc_to_bulk",
+                  "best_sc_gsm", "r_own", "r_best", "own_day_rank_within_subject_bulk_to_sc",
+                  "own_day_rank_within_subject_sc_to_bulk", "subject_paired_days"):
+            p[f"expr_resid_k{k}_{c}"] = e.loc[p.bulk_gsm, f"resid_k{k}_{c}"].to_numpy()
+    kp = K_PRIMARY
+
+    def day_ranks(row) -> tuple[int, int, int, int]:
+        return (row[f"expr_resid_k{kp}_own_day_rank_within_subject_bulk_to_sc"],
+                row[f"expr_resid_k{kp}_own_day_rank_within_subject_sc_to_bulk"],
+                row.expr_centred_own_day_rank_within_subject_bulk_to_sc,
+                row.expr_centred_own_day_rank_within_subject_sc_to_bulk)
+
+    def verdict(row) -> str:
+        """pass: sex concordant AND (residualised, k=5) own SUBJECT ranked 1st in one direction and within the top 3
+        subjects in the other AND no day failure.  fail: sex discordant, or own subject ranked below 3rd in both
+        directions, or a day failure = within the subject's paired rows another day beats the own day in BOTH
+        directions on BOTH the residualised (k=5) and the centred expression test.  Otherwise borderline.
+        (A subject's other visit is the same person, so subjects are ranked for the donor test and days are
+        checked separately within the subject.)"""
+        r1 = row[f"expr_resid_k{kp}_own_subject_rank_bulk_to_sc"]
+        r2 = row[f"expr_resid_k{kp}_own_subject_rank_sc_to_bulk"]
+        d1, d2, c1, c2 = day_ranks(row)
+        issues = []
+        if not row.sex_concordant:
+            issues.append(f"sex bulk={row.bulk_sex_call} sc={row.sc_sex_call} geo={row.sex_geo.lower()}")
+        if min(r1, r2) > SUBJ_TOP:
+            issues.append(f"expression: own subject rank {r1} (bulk->{len(set(s_subject))} sc subjects) and {r2} "
+                          f"(sc->{len(set(b_subject))} bulk subjects); bulk best subject = "
+                          f"{row[f'expr_resid_k{kp}_best_subject_bulk_to_sc']}")
+        if min(d1, d2, c1, c2) > 1:
+            issues.append(f"day: within subject {row.donor_id}, own day {row.timepoint} ranks {d1}/{d2} (residualised "
+                          f"k={kp}, bulk->sc/sc->bulk) and {c1}/{c2} (centred) among {row[f'expr_resid_k{kp}_subject_paired_days']} "
+                          f"paired days; ISG peak day bulk={row.expr_isg_peak_day_bulk} sc={row.expr_isg_peak_day_sc}")
+        if issues:
+            return "fail: " + "; ".join(issues)
+        if min(r1, r2) == 1 and max(r1, r2) <= SUBJ_TOP:
+            return "pass"
+        return f"borderline: own subject rank {r1} (bulk->sc) and {r2} (sc->bulk)"
+    p["identity_check"] = p.apply(verdict, axis=1)
+    p["identity_pass"] = p.identity_check == "pass"
+    notes = []
+    for _, row in p.iterrows():
+        nt = []
+        if row.bulk_possible_mixture:
+            nt.append("bulk has opposite-sex signal (possible minor admixture)")
+        d1, d2, c1, c2 = day_ranks(row)
+        if max(d1, d2, c1, c2) > 1 and min(d1, d2, c1, c2) == 1:
+            nt.append(f"within subject, another day beats the own day in some day tests (residualised {d1}/{d2}, "
+                      f"centred {c1}/{c2}); not a day failure")
+        if row.expr_isg_peak_day_bulk != row.expr_isg_peak_day_sc:
+            nt.append(f"subject ISG peak day differs between assays (bulk day {row.expr_isg_peak_day_bulk}, "
+                      f"sc day {row.expr_isg_peak_day_sc})")
+        if row.bulk_assigned_counts < 2e6:
+            nt.append(f"low-depth bulk ({int(row.bulk_assigned_counts):,} assigned reads)")
+        notes.append("; ".join(nt))
+    p["identity_notes"] = notes
+    p.to_csv(OUT / "pairs.csv", index=False)
+    require(np.array_equal(p.bulk_gsm.to_numpy(), meta_arrays["bulk_gsm"]), "pairs/features row order")
+    meta_arrays["identity_pass"] = p.identity_pass.to_numpy().astype(bool)
+    meta_arrays["identity_check"] = p.identity_check.to_numpy().astype(str)
+    meta_arrays["sex_bulk_expr"] = p.bulk_sex_call.to_numpy().astype(str)
+    meta_arrays["sex_sc_expr"] = p.sc_sex_call.to_numpy().astype(str)
+    tmp = OUT / "features.npz.tmp"
+    with open(tmp, "wb") as h:
+        np.savez_compressed(h, **meta_arrays)
+    os.replace(tmp, OUT / "features.npz")
+    bsex_out = bulk_sex.copy()
+    bsex_out["subject"] = b_subject
+    bsex_out["geo_sex"] = [bmeta.loc[g, "ch_Sex"] if g else "" for g in bsex_out.bulk_gsm]
+    bsex_out["paired"] = bsex_out.index.isin(set(p.bulk_count_column))
+    bsex_out.to_csv(OUT / "identity_sex_bulk_all.csv")
+    sc_sex.join(table.set_index("sc_gsm")[["sample_id", "subject", "sc_sex", "paired"]]).to_csv(OUT / "identity_sex_sc_all.csv")
+    expr.to_csv(OUT / "identity_expression.csv", index=False)
+
+    # unmatched lists
+    unmatched_sc = table[table.paired != "True"][["sc_gsm", "sample_id", "group", "pair_status"]]
+    unmatched_cols = cols[cols.paired != "True"][["bulk_column", "bulk_gsm", "unpaired_reason"]]
+    bulk_no_col = pd.read_csv(RUN / "pairing/bulk_GSM_without_count_column.csv", dtype=str, keep_default_na=False)
+    rk = f"expr_resid_k{kp}"
+    checks = {
+        "gene_positions_sha256_ok": True,
+        "panel_gene_ids_match_selected_genes_csv": True,
+        "bulk_integer_nonnegative_inside_mask": True,
+        "pseudo_raw_sum_equals_sum_of_retained_cells_full_axis": True,
+        "cells_panel_sums_equal_pseudo_raw_sum_positions_exactly": True,
+        "cells_per_row_equal_qc_cell_counts": True,
+        "no_sc_mass_outside_sc_valid": True,
+        "one_sample_id_per_library": True,
+        "bulk_and_sc_GSM_agree_on_age_sex_group_serostatus": True,
+        "sex_concordant_pairs": f"{int(p.sex_concordant.sum())}/{n}",
+        "sc_sex_call_4gene_equals_3gene_all_41_libraries": bool((sc_sex.sc_sex_call == sc_sex.sc_sex_call_3gene).all()),
+        "expression_best_match_is_own_pair": f"{int(p.expr_best_is_own.sum())}/{n}",
+        "expression_best_match_is_own_pair_centred": f"{int(p.expr_centred_best_is_own.sum())}/{n}",
+        "expression_reverse_best_match_is_own_pair": f"{int(p.expr_reverse_best_is_own.sum())}/{n}",
+        **{f"expression_residualised_k{k}_own_subject_top1_bulk_to_sc": f"{int((p[f'expr_resid_k{k}_own_subject_rank_bulk_to_sc'] == 1).sum())}/{n}" for k in RESID_K},
+        **{f"expression_residualised_k{k}_own_subject_top1_sc_to_bulk": f"{int((p[f'expr_resid_k{k}_own_subject_rank_sc_to_bulk'] == 1).sum())}/{n}" for k in RESID_K},
+        **{f"expression_residualised_k{k}_own_library_top1_bulk_to_sc": f"{int((p[f'expr_resid_k{k}_own_rank_bulk_to_sc'] == 1).sum())}/{n}" for k in RESID_K},
+        f"expression_residualised_k{kp}_own_day_best_within_subject_bulk_to_sc": f"{int((p[f'{rk}_own_day_rank_within_subject_bulk_to_sc'] == 1).sum())}/{n}",
+        f"expression_residualised_k{kp}_own_day_best_within_subject_sc_to_bulk": f"{int((p[f'{rk}_own_day_rank_within_subject_sc_to_bulk'] == 1).sum())}/{n}",
+        "expression_centred_own_day_best_within_subject_bulk_to_sc": f"{int((p.expr_centred_own_day_rank_within_subject_bulk_to_sc == 1).sum())}/{n}",
+        "expression_centred_own_day_best_within_subject_sc_to_bulk": f"{int((p.expr_centred_own_day_rank_within_subject_sc_to_bulk == 1).sum())}/{n}",
+        "isg_peak_day_same_in_both_assays_subjects": f"{int((p.drop_duplicates('donor_id').expr_isg_peak_day_bulk == p.drop_duplicates('donor_id').expr_isg_peak_day_sc).sum())}/{p.donor_id.nunique()}",
+        "identity_check_pass": f"{int((p.identity_check == 'pass').sum())}/{n}",
+        "identity_check_fail": p[p.identity_check.str.startswith('fail')].sample_id.tolist(),
+        "identity_check_borderline": p[p.identity_check.str.startswith('borderline')].sample_id.tolist(),
+    }
+    manifest = {
+        "schema": "giroux2022_paired_ft_v1",
+        "written_utc": datetime.now(timezone.utc).isoformat(), "started_utc": t0.isoformat(),
+        "study": "Giroux NS et al., Sci Rep 2022 (doi 10.1038/s41598-022-15668-8; PMID 35810186); SuperSeries GSE206284; bulk GSE206263, scRNA GSE206283",
+        "rows": n, "subjects": int(pairs.subject.nunique()), "row_order": "bulk GSM ascending (subject blocks, day ascending)",
+        "pairs_by_group": p.group.value_counts().to_dict(),
+        "pairs_by_timepoint": p.timepoint.value_counts().to_dict(),
+        "pairs_by_subject": p.groupby("donor_id").timepoint.apply(lambda s: ",".join(s)).to_dict(),
+        "pairs_by_id_match": p.id_match.value_counts().to_dict(),
+        "cells": {"n_cells": total_cells, "nnz": total_nnz, "per_row_min": int(qc_cell_counts.min()),
+                  "per_row_median": float(np.median(qc_cell_counts)), "per_row_max": int(qc_cell_counts.max())},
+        "retained_cells_rule": "flag_conservative_review_pass = genes>=200 & UMIs>=500 & mito<=20% (qc_core, ImMicro definition); MAD flags are review-only columns",
+        "features_semantics": {
+            "bulk_raw": "author featureCounts raw gene counts (STAR/hg19) mapped by gene symbol to the canonical axis; 0 where bulk_valid is False (ImMicro file uses NaN there); 3 many-to-one symbol groups summed (bundle policy for verified integer counts)",
+            "pseudo_raw_sum": "sum of retained cells' UMI counts on the canonical axis; storage 0 where sc_valid is False",
+            "bulk_valid": "harmonization_valid from qc_bulk.harmonize (symbol in the author table maps uniquely to the canonical gene)",
+            "sc_valid": "harmonization_valid from qc_singlecell.canonical_export (gene in the 10x features table)",
+            "pair_valid": "bulk_valid & sc_valid",
+            "sample_ids": "<subject>_d<day>, e.g. 450905_d0",
+            "donor_ids": "GEO subject ID (6-hex); a subject has 2-3 rows (days)",
+            "timepoints": "GEO sampling day (int64: 0, 7 or 14 among pairs)",
+            "groups": "GEO 'exposure' field lower-cased: mild, severe (the paper and the author sample sheet call this group 'moderate'; kept in author_cohort), exposed, healthy; only mild and severe have pairs",
+            "extra_keys": "bulk_gsm, sc_gsm, sc_title_sample_id (GEO sc title), id_match, bulk_count_column (author table column), sc_author_library (author library name), sex_geo, age_geo, serostatus_geo (IgG), author_cohort, identity_pass, identity_check, sex_bulk_expr, sex_sc_expr",
+            "not_applicable": "Ye 2026 keys infection_source and collection_site have no counterpart here"},
+        "identity": {"sex_rule": "CPM on the source axis (bulk: all 26,045 author-table genes; sc: retained cells, all RNA features); score=log2(XIST+1)-log2(Ysum+1); female>2, male<-2, else ambiguous. Bulk Ysum = DDX3Y+UTY+KDM5D (RPS4Y1 is not in the author table); sc Ysum = RPS4Y1+DDX3Y+UTY+KDM5D (3-gene sc call also reported); opposite-sex signal flag: female call with Y CPM>20 or male call with XIST CPM>50 (bulk)",
+                     "expression_rule": f"log2(CPM+1) over the {int(common.sum())} non-chrY canonical genes measured in all 49 bulk columns and all {len(sc_gsms)} sc libraries; top {TOP_N} by the mean of the bulk-mean and sc-mean log CPM; Spearman of each paired bulk vs all sc pseudobulks; centred sensitivity; reverse vs all 49 bulks",
+                     "expression_residualised_rule": f"within each modality: centre log2(CPM+1) (same genes), remove the top k sample PCs computed on expressed genes (bulk mean >3 and sc mean >1 log2 CPM), keep the 2000 genes with the highest residual variance in both modalities (rank sum), Pearson over all 49 bulks x all {len(sc_gsms)} sc libraries. k={K_PRIMARY} primary (41 sc libraries and 49 bulks, vs 133/207 with k=10 for Ye 2026), k=3 and k=10 sensitivity. Ranks are reported per library and per subject (each subject scored by its best sample). chrY genes are excluded so the test is independent of the sex check. Uses no pairing information.",
+                     "verdict_rule": f"pass = sex concordant (bulk, sc, GEO) and residualised k={K_PRIMARY} own subject ranked 1st in one direction and within the top {SUBJ_TOP} subjects in the other and no day failure; fail = sex discordant, or own subject below {SUBJ_TOP} in both directions, or day failure; else borderline",
+                     "day_check": f"within the subject's paired rows, rank of the own day on the residualised (k={K_PRIMARY}) and on the centred (not residualised; top {TOP_N} genes by centred variance in both modalities) expression correlation, both directions. Day failure = another day of the same subject beats the own day in all four. Added after the subject-level test was seen to be blind to within-subject day swaps (the task requires the same sampling day).",
+                     "isg_rule": f"informational: mean log2(CPM+1) of {len(ISG_GENES)} ISGs ({', '.join(ISG_GENES)}) per sample; per subject the ISG-peak day in bulk and in sc is reported",
+                     "policy": "reported only; no row dropped on identity results; features.npz carries identity_pass / identity_check"},
+        "checks": checks,
+        "excluded": {"quarantined_sc_libraries_among_pairs": quarantined_pairs,
+                     "sc_libraries_without_pair": unmatched_sc.to_dict("records"),
+                     "bulk_count_columns_without_pair": unmatched_cols.to_dict("records"),
+                     "bulk_GSMs_without_author_count_column": bulk_no_col[["gsm", "sample_id", "group"]].to_dict("records")},
+        "leads_not_pairs": {"note": f"unpaired author bulk columns that have no GEO GSM vs all sc libraries (residualised k={K_PRIMARY}); a lead is NOT a pair: no published ID links these columns to GEO subjects",
+                            "rows": leads.to_dict("records")},
+        "inputs": {"gene_positions": {"path": str(POSITIONS), "sha256": POSITIONS_SHA},
+                   "selected_genes": {"path": str(SELECTED), "sha256": sha256_file(SELECTED)},
+                   "canonical_genes": {"path": str(REFERENCE / "canonical_genes.tsv"), "sha256": sha256_file(REFERENCE / "canonical_genes.tsv")},
+                   "bulk_harmonized": {"path": str(RUN / "bulk/GSE206263_featureCounts/harmonized.h5ad"),
+                                       "sha256": sha256_file(RUN / "bulk/GSE206263_featureCounts/harmonized.h5ad")},
+                   "sources": json.loads((RUN / "SOURCES.json").read_text())["files"],
+                   "external_metadata": json.loads((RUN / "SOURCES.json").read_text())["external_metadata_fetched_20260928"]},
+        "code": {name: {"path": str(path), "sha256": sha256_file(path)} for name, path in [
+            ("assemble", Path(__file__).resolve()), ("pipeline", RUN / "code/giroux2022_pipeline.py"),
+            ("run_step", RUN / "code/run_step.sh")] + [
+            ("bundle/" + q.name, q) for q in sorted((RUN / "code/strict_qc_v1_code_bundle_v5").glob("*.py"))]},
+        "processing_dir": str(RUN),
+    }
+    manifest["outputs"] = {q.name: {"bytes": q.stat().st_size, "sha256": sha256_file(q)}
+                           for q in sorted(OUT.iterdir()) if q.is_file() and q.name in (
+                               "features.npz", "cells_panel6k.npz", "cells_obs.parquet", "samples.csv", "pairs.csv",
+                               "identity_sex_bulk_all.csv", "identity_sex_sc_all.csv", "identity_expression.csv")}
+    (OUT / "MANIFEST.json").write_text(json.dumps(manifest, indent=1, default=str) + "\n")
+    shutil.rmtree(TMP)
+    print(json.dumps({"rows": n, "cells": manifest["cells"], "checks": checks}, indent=1, default=str))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/20260928/diffusion/data/source_prep/giroux2022/code/giroux2022_full_cells.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""cells_full.npz for giroux2022: tools/build_full_cells.py semantics with bounded memory (CPU only).
+
+Uses build_full_cells.read_library (the tool's own reader) for every library and applies the tool's fail-closed
+checks: cells_obs rows == cells_panel6k rows; cells sorted by dataset row; on every row the panel columns equal
+cells_panel6k exactly and the full-axis sums equal features.npz pseudo_raw_sum.  Rows are streamed through disk
+memmaps (one library = one row here), so peak memory is one library instead of three copies of the whole matrix.
+Output keys, dtypes and cells_full.BUILD.json fields are those of build_full_cells.py.
+"""
+from __future__ import annotations
+
+import importlib.util
+import json
+import os
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+TOOL = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/tools/build_full_cells.py")
+RUN = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/giroux2022_v1_20260928")
+DS = "giroux2022"
+spec = importlib.util.spec_from_file_location("build_full_cells", TOOL)
+BF = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(BF)
+BF.LIBRARY_ROOT[DS] = RUN / "singlecell"
+
+
+def main() -> int:
+    d = BF.TASK / "data" / DS
+    obs = pd.read_parquet(d / "cells_obs.parquet")
+    panel = np.load(d / "cells_panel6k.npz", allow_pickle=False)
+    feat = np.load(d / "features.npz", allow_pickle=False)
+    positions = np.load(BF.POSITIONS).astype(np.int64)
+    if len(obs) != int(panel["shape"][0]):
+        raise SystemExit("cells_obs rows differ from cells_panel6k rows")
+    rs = panel["row_sample"].astype(np.int64)
+    if bool((np.diff(rs) < 0).any()):
+        raise SystemExit("cells are not sorted by dataset row")
+    if not np.array_equal(rs, obs.row_sample.to_numpy(np.int64)):
+        raise SystemExit("cells_obs row_sample differs from cells_panel6k row_sample")
+    P = sp.csr_matrix((panel["data"], panel["indices"], panel["indptr"]), shape=tuple(panel["shape"]))
+    want = np.nan_to_num(feat["pseudo_raw_sum"].astype(np.float64), nan=0.0)
+    n_rows = int(rs.max()) + 1
+    bounds = np.searchsorted(rs, np.arange(n_rows + 1))
+    root = BF.LIBRARY_ROOT[DS]
+    parts, total_nnz = [], 0
+    tmp = RUN / "full_cells_tmp"
+    tmp.mkdir(exist_ok=True)
+    bad_panel = bad_sum = 0
+    for r in range(n_rows):
+        a, b = int(bounds[r]), int(bounds[r + 1])
+        sub = obs.iloc[a:b]
+        libs = sub.library_id.unique()
+        if len(libs) != 1:
+            raise SystemExit(f"row {r}: expected one library, found {list(libs)}")
+        Xr = BF.read_library(root / str(libs[0]) / "canonical.h5ad", sub["barcode"].astype(str).to_numpy())
+        bad_panel += int((Xr[:, positions] != P[a:b]).nnz)
+        bad_sum += int(not np.array_equal(np.asarray(Xr.sum(axis=0, dtype=np.float64)).ravel(), want[r]))
+        np.save(tmp / f"{r:03d}_data.npy", Xr.data.astype(np.int32))
+        np.save(tmp / f"{r:03d}_indices.npy", Xr.indices.astype(np.int32))
+        np.save(tmp / f"{r:03d}_indptr.npy", Xr.indptr.astype(np.int64))
+        parts.append((Xr.shape[0], Xr.nnz))
+        total_nnz += Xr.nnz
+        print(f"{libs[0]}: {Xr.shape[0]} cells", flush=True)
+        del Xr
+    if bad_panel:
+        raise SystemExit(f"full-axis cells differ from cells_panel6k on the panel columns ({bad_panel} entries)")
+    if bad_sum:
+        raise SystemExit(f"per-row full-axis sums differ from pseudo_raw_sum for {bad_sum} rows")
+    n_cells = sum(c for c, _ in parts)
+    if n_cells != len(obs):
+        raise SystemExit("assembled cell count differs")
+    data = np.lib.format.open_memmap(tmp / "all_data.npy", mode="w+", dtype=np.int32, shape=(total_nnz,))
+    indices = np.lib.format.open_memmap(tmp / "all_indices.npy", mode="w+", dtype=np.int32, shape=(total_nnz,))
+    indptr = np.empty(n_cells + 1, dtype=np.int64)
+    indptr[0] = 0
+    at = cell_at = 0
+    for r in range(n_rows):
+        dd = np.load(tmp / f"{r:03d}_data.npy"); ix = np.load(tmp / f"{r:03d}_indices.npy")
+        ip = np.load(tmp / f"{r:03d}_indptr.npy")
+        data[at:at + len(dd)] = dd
+        indices[at:at + len(dd)] = ix
+        indptr[cell_at + 1:cell_at + len(ip)] = ip[1:] + at
+        at += len(dd); cell_at += len(ip) - 1
+    if at != total_nnz or cell_at != n_cells or indptr[-1] != total_nnz or bool((np.diff(indptr) < 0).any()):
+        raise SystemExit("assembly size / indptr")
+    data.flush(); indices.flush()
+    out = d / "cells_full.npz"
+    part = d / "cells_full.npz.partial"
+    with open(part, "wb") as h:
+        np.savez(h, data=data, indices=indices, indptr=indptr, shape=np.array([n_cells, 20097], dtype=np.int64),
+                 row_sample=rs.astype(np.int32))
+    os.replace(part, out)
+    del data, indices
+    # re-open the written file and re-run the row checks on it (fail-closed on the artifact itself)
+    z = np.load(out, allow_pickle=False, mmap_mode=None)
+    for k, dt in (("data", np.int32), ("indices", np.int32), ("indptr", np.int64), ("shape", np.int64), ("row_sample", np.int32)):
+        if z[k].dtype != dt:
+            raise SystemExit(f"{k} dtype {z[k].dtype}")
+    X = sp.csr_matrix((z["data"], z["indices"], z["indptr"]), shape=tuple(z["shape"]))
+    for r in range(n_rows):
+        a, b = int(bounds[r]), int(bounds[r + 1])
+        Xr = X[a:b]
+        if (Xr[:, positions] != P[a:b]).nnz or not np.array_equal(np.asarray(Xr.sum(axis=0, dtype=np.float64)).ravel(), want[r]):
+            raise SystemExit(f"row {r}: written cells_full.npz fails the checks")
+    del X, z
+    for q in tmp.iterdir():
+        q.unlink()
+    tmp.rmdir()
+    info = {"dataset": DS, "n_cells": int(n_cells), "nnz": int(total_nnz), "sha256": BF.sha(out),
+            "checks": {"panel_columns_equal_cells_panel6k": True, "row_sums_equal_pseudo_raw_sum": True},
+            "builder": "processing/giroux2022_v1_20260928/code/giroux2022_full_cells.py (build_full_cells.read_library, same checks, streamed; re-verified on the written file)"}
+    (d / "cells_full.BUILD.json").write_text(json.dumps(info, indent=1))
+    print(json.dumps(info))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())