Archive 4 checkpoints (1-4)

paper-releases/20260928/diffusion/data/source_prep/ji2025_chili/code/export_seurat_counts.R

@@ -0,0 +1,126 @@
+# Export the raw RNA counts (Assay "RNA", slot "counts"; NOT data / scale.data) of the GSE287541
+# author-filtered Seurat object into one 10x-style MatrixMarket library per sequencing library
+# (round x PID_visit, = one GEO GPEX GSM), plus the cell metadata and the feature table.
+# CPU only. Reads the outer-gunzipped copy extracted/GSE287541_seurat.rds (byte-identical inner stream
+# of the acquired .RDS.gz; sha256 of both recorded by the Python 'sources' step).
+#
+# Feature identity: the object carries gene symbols only (36,601 rows). The CellRanger GRCh38-2020-A
+# features.tsv (36,601 Ensembl IDs) is taken from 13 byte-identical GEO copies already extracted in
+# strict_qc_v1 (GSE201534, GSE247707). IDs are assigned only if make.unique(gsub("_","-",symbol)),
+# i.e. exactly what Read10X + CreateSeuratObject do, reproduces the object's rownames in order.
+suppressPackageStartupMessages({library(Seurat); library(SeuratObject); library(Matrix); library(data.table); library(jsonlite)})
+RUN <- "/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/ji2025_chili_v1_20260928"
+FEATURES_2020A <- "/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/strict_qc_v1_20260913/extracted/GSE201534/GSE201534_RAW_tar/GSM6066350_ChAd_ChAd_2_Day7_features.tsv.gz"
+OUT <- file.path(RUN, "r_export")
+dir.create(OUT, showWarnings = FALSE)
+stopifnot(!file.exists(file.path(OUT, "EXPORT_SUMMARY.json")))
+data.table::setDTthreads(2)
+
+obj <- readRDS(file.path(RUN, "extracted/GSE287541_seurat.rds"))
+stopifnot(identical(Assays(obj), "RNA"))
+counts <- GetAssayData(obj, assay = "RNA", layer = "counts")
+stopifnot(inherits(counts, "dgCMatrix"))
+md <- obj@meta.data
+umap <- Embeddings(obj, "ref.umap")
+obj_version <- as.character(obj@version); obj_reductions <- Reductions(obj)
+rm(obj); invisible(gc())  # drop the log-normalised 'data' slot from memory
+cells <- colnames(counts)
+stopifnot(identical(cells, rownames(md)), !anyDuplicated(cells))
+
+# ---- values: finite, positive, integer-valued
+x <- counts@x
+stopifnot(all(is.finite(x)), all(x > 0), all(x == round(x)), max(x) < 2^31)
+
+# ---- feature identity
+f <- fread(FEATURES_2020A, header = FALSE, col.names = c("id", "symbol", "type"))
+stopifnot(nrow(f) == nrow(counts), all(f$type == "Gene Expression"), !anyDuplicated(f$id))
+seurat_names <- make.unique(gsub("_", "-", f$symbol))
+feature_order_identical <- identical(seurat_names, rownames(counts))
+stopifnot(feature_order_identical)
+n_underscore <- sum(grepl("_", f$symbol))
+n_dup_symbol <- sum(duplicated(f$symbol))
+
+# ---- author per-cell metrics reproduce from the counts slot
+tot <- Matrix::colSums(counts)
+det <- Matrix::colSums(counts > 0)
+mt <- grepl("^MT-", f$symbol)
+pmt <- Matrix::colSums(counts[mt, , drop = FALSE]) / tot * 100
+chk <- list(
+  nCount_equals_colsum = isTRUE(all.equal(unname(tot), md$nCount_RNA, tolerance = 0)),
+  nFeature_equals_detected = identical(as.integer(unname(det)), as.integer(md$nFeature_RNA)),
+  percent_mt_max_abs_diff = max(abs(unname(pmt) - md$percent.mt)),
+  nCount_refAssay_equals_nCount = isTRUE(all.equal(md$nCount_refAssay, md$nCount_RNA, tolerance = 0))
+)
+author <- list(n_cells = ncol(counts), min_nFeature = min(det), max_nFeature = max(det), min_nCount = min(tot),
+               max_nCount = max(tot), max_percent_mt = max(pmt), cells_lt_200_genes = sum(det < 200),
+               cells_lt_500_umi = sum(tot < 500), cells_gt_20pct_mt = sum(pmt > 20), cells_gt_10pct_mt = sum(pmt > 10),
+               cells_gt_15pct_mt = sum(pmt > 15))
+
+# ---- library key from the cell-name prefix "<round>_<PID_visit>_<barcode>"
+# The middle token embeds patient initials and is not always the PID (e.g. Rd4a_N1131ACV01 = N131V01,
+# Rd4a_N127131ACV00 = N127V00); the library key therefore uses round + meta.data PID_visit, and the
+# name token is kept as provenance. Each (round, name token) must map to exactly one PID_visit and back.
+m <- regmatches(cells, regexec("^(Rd[0-9]+[ab]?)_([A-Za-z0-9]+)_([ACGT]+-1)$", cells))
+ok <- lengths(m) == 4
+stopifnot(all(ok))
+round_ <- vapply(m, `[`, "", 2); name_token <- vapply(m, `[`, "", 3); bc <- vapply(m, `[`, "", 4)
+stopifnot(identical(round_, md$round))
+pidv <- md$PID_visit
+key_name <- paste(round_, name_token); key_meta <- paste(round_, pidv)
+stopifnot(all(tapply(key_meta, key_name, function(v) length(unique(v))) == 1),
+          all(tapply(key_name, key_meta, function(v) length(unique(v))) == 1))
+lib <- paste0(round_, "_", pidv)
+libs <- unique(lib)
+
+# ---- write features and cell metadata
+fwrite(data.table(f$id, f$symbol, f$type, seurat_names), file.path(OUT, "features.tsv.gz"), sep = "\t", col.names = FALSE)
+meta <- data.table(cell = cells, library_key = lib, round = round_, cell_name_token = name_token, raw_barcode = bc,
+                   counts_total = unname(tot), counts_detected = as.integer(unname(det)), counts_percent_mt = unname(pmt))
+meta <- cbind(meta, as.data.table(md))
+stopifnot(identical(rownames(umap), cells))
+meta[, `:=`(refUMAP_1 = umap[, 1], refUMAP_2 = umap[, 2])]
+fwrite(meta, file.path(OUT, "cell_metadata.csv.gz"))
+
+# ---- per-library MatrixMarket (features x cells, integer, cell-column ordered)
+lib_rows <- list()
+for (L in libs) {
+  idx <- which(lib == L)
+  sub <- counts[, idx, drop = FALSE]
+  d <- file.path(OUT, L); dir.create(d, showWarnings = FALSE)
+  mtx <- file.path(d, "matrix.mtx")
+  s <- summary(sub)  # i, j, x in column-major order
+  stopifnot(nrow(s) == length(sub@x), !is.unsorted(s$j))
+  writeLines(c("%%MatrixMarket matrix coordinate integer general",
+               sprintf("%%metadata_json: {\"source\": \"GSE287541 Seurat RNA@counts\", \"library_key\": \"%s\"}", L),
+               sprintf("%d %d %d", nrow(sub), ncol(sub), nrow(s))), mtx)
+  fwrite(data.table(i = as.integer(s$i), j = as.integer(s$j), x = as.integer(s$x)), mtx, sep = " ",
+         col.names = FALSE, append = TRUE)
+  stopifnot(system2("gzip", c("-1", "-f", mtx)) == 0)
+  fwrite(data.table(cells[idx]), file.path(d, "barcodes.tsv.gz"), col.names = FALSE)
+  lib_rows[[L]] <- data.table(library_key = L, n_cells = length(idx), nnz = nrow(s), total_counts = sum(s$x),
+                              PID_visit = unique(md$PID_visit[idx]), round = unique(md$round[idx]),
+                              orig_ident = paste(unique(md$orig.ident[idx]), collapse = "|"),
+                              cell_name_token = paste(unique(name_token[idx]), collapse = "|"),
+                              Time = paste(unique(md$Time[idx]), collapse = "|"),
+                              Person = paste(unique(md$Person.CHILI.ID[idx]), collapse = "|"),
+                              Group = paste(unique(md$Group[idx]), collapse = "|"),
+                              Gender = paste(unique(md$Gender[idx]), collapse = "|"),
+                              Age = paste(unique(md$Age[idx]), collapse = "|"),
+                              Steroid = paste(unique(md$Steroid_yn[idx]), collapse = "|"),
+                              Cancer = paste(unique(md$Type.of.cancer[idx]), collapse = "|"),
+                              min_genes = min(det[idx]), min_umi = min(tot[idx]), max_pct_mt = max(pmt[idx]))
+  cat(L, length(idx), nrow(s), "\n")
+}
+libtab <- rbindlist(lib_rows)
+fwrite(libtab, file.path(OUT, "libraries.csv"))
+summ <- list(source_object = file.path(RUN, "extracted/GSE287541_seurat.rds"), seurat_object_version = obj_version,
+             assay = "RNA", exported_slot = "counts (raw UMI counts; data and scale.data not exported)",
+             n_features = nrow(counts), n_cells = ncol(counts), nnz = length(counts@x), total_counts = sum(counts@x),
+             n_libraries = length(libs), feature_reference = FEATURES_2020A,
+             feature_identity_rule = "make.unique(gsub('_','-',symbol)) of CellRanger GRCh38-2020-A features.tsv equals Seurat rownames in order",
+             feature_order_identical = feature_order_identical, n_symbols_with_underscore = n_underscore,
+             n_duplicated_symbols = n_dup_symbol, counts_checks = chk, author_filter_evidence = author,
+             meta_columns = colnames(md), reductions = obj_reductions)
+write_json(summ, file.path(OUT, "EXPORT_SUMMARY.json"), auto_unbox = TRUE, pretty = TRUE, digits = NA)
+cat(toJSON(summ[c("n_cells", "nnz", "n_libraries", "feature_order_identical", "counts_checks", "author_filter_evidence")],
+           auto_unbox = TRUE, pretty = TRUE), "\n")

paper-releases/20260928/diffusion/data/source_prep/ji2025_chili/code/ji2025_assemble.py

@@ -0,0 +1,638 @@
+#!/usr/bin/env python3
+"""Assemble the Ji 2025 ChILI paired bulk <-> scRNA fine-tuning files (CPU only).
+
+Mirrors plans/.../data/ye2026_sepsis (same file names, keys and semantics; see ye2026_assemble.py). Differences:
+  * rows are patient x timepoint pairs; donor_ids = patient, groups = timepoints = GEO time label,
+    outcome = ChILI / control;
+  * bulk is Salmon estimated read counts (float64, stored unchanged; the deposited table is integer-valued);
+  * identity checks are made patient-aware (the same patient's other time points are the natural near-ties),
+    use a PC-removal depth adapted to 46 sc libraries, and exclude chrY genes so that they are independent
+    of the sex check.
+
+Inputs (processing run, produced by ji2025_pipeline.py): pairing/, bulk/GSE287540_salmon_counts/harmonized.h5ad,
+  bulk/bulk_source_counts.npz, singlecell/<GSM>/..., r_export/cell_metadata.csv.gz
+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
+Retained cells = flag_conservative_review_pass (>=200 genes, >=500 UMIs, <=20 % mito). 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/ji2025_chili_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/ji2025_chili"
+POSITIONS = M8 / "artifacts/panel_ladder_floor01_1m_20260923/tiers/6k/gene_positions.npy"
+POSITIONS_SHA = "653ffa45ac519000baa41086c52408009391d6e68cfb218bc6a50d34163fcb24"
+SELECTED = POSITIONS.parent / "selected_genes.csv"
+BULK_H5AD = RUN / "bulk/GSE287540_salmon_counts/harmonized.h5ad"
+TMP = RUN / "assemble_tmp"
+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"]
+TOP_N = 2000
+K_PRIMARY = 5                  # ~10 % of the 46 sc libraries (Ye: k=10 for 133 sc / 207 bulk)
+RESID_K = (0, 3, 5, 8, 10)     # sensitivity
+SPECIMEN_GENES = {"hemoglobin": ["HBB", "HBA1", "HBA2", "HBD"],
+                  "neutrophil": ["FCGR3B", "CXCR2", "CSF3R", "MMP9", "CAMP", "LTF"],
+                  "lymphocyte": ["CD3E", "MS4A1", "IL7R"], "monocyte": ["CD14", "LYZ"]}
+
+
+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 (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 rank_of(scores: np.ndarray, target: int) -> int:
+    order = np.argsort(-scores, kind="mergesort")
+    return int(np.flatnonzero(order == target)[0]) + 1
+
+
+def patient_rank(scores: np.ndarray, cand_patient: np.ndarray, own: str) -> tuple[int, str, float]:
+    """Collapse candidates to patients by their best score; rank of the own patient, best patient, best score."""
+    pats = np.unique(cand_patient)
+    best = np.asarray([scores[cand_patient == q].max() for q in pats])
+    order = np.argsort(-best, kind="mergesort")
+    r = int(np.flatnonzero(pats[order] == own)[0]) + 1 if own in set(pats) else -1
+    return r, str(pats[order[0]]), float(best[order[0]])
+
+
+def auc(pos: np.ndarray, neg: np.ndarray) -> float:
+    allv = np.concatenate([pos, neg])
+    r = rankdata(allv)
+    return float((r[:len(pos)].sum() - len(pos) * (len(pos) + 1) / 2) / (len(pos) * len(neg)))
+
+
+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")
+    selected = pd.read_csv(SELECTED)
+    require(np.array_equal(selected.gene_id.to_numpy(), gene_ids[positions]), "panel ids differ from positions")
+    sym = canonical.gene_symbol.to_numpy().astype(str)
+    chr_y = canonical.chromosome.to_numpy().astype(str) == "chrY"
+
+    table = pd.read_csv(RUN / "pairing/sc_gex_libraries_with_bulk_match.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(BULK_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)
+    b_gsm = bad_.obs["source_GSM"].astype(str).to_numpy()
+    b_patient_raw = bad_.obs["source_subject"].astype(str).to_numpy()
+    require(np.array_equal(bad_.var_names.to_numpy().astype(str), gene_ids), "bulk gene order")
+    require(str(bad_.uns["units"]) == "salmon_1.10.0_gene_estimated_read_counts_as_deposited", "bulk units")
+    del bad_
+    b_patient = np.asarray([f"N{int(p[1:]):03d}" for p in b_patient_raw])
+    brow = {g: i for i, g in enumerate(b_gsm)}
+    require(len(brow) == len(b_gsm), "duplicate bulk GSM")
+    inside = bX[b_valid]
+    require(np.isfinite(inside).all() and (inside >= 0).all(), "bulk values inside the measured mask must be finite, >=0")
+    bulk_fractional = int(np.sum(inside != np.trunc(inside)))
+    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)
+
+    # ---------------- 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"]
+    tix = table.set_index("sc_gsm")
+    sc_patient = tix.loc[sc_gsms, "patient"].to_numpy().astype(str)
+    sc_key = tix.loc[sc_gsms, "library_key"].to_numpy().astype(str)
+    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)
+    sc_n_all = 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(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])
+            sc_n_all[i] = int(f["n_cells"][0, 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([brow[g] for g in pairs.bulk_gsm])
+    si = np.asarray([srow[g] for g in pairs.sc_gsm])
+    require(np.array_equal(b_index[bi], pairs.bulk_title.to_numpy()), "bulk sample id 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"]
+    bcpm = bcounts / bcounts.sum(1, keepdims=True) * 1e6
+    b_src_gsm = list(bsrc["gsm"])
+    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_sex_call"], rec["sc_sex_score"] = sex_call(rec["sc_XIST_cpm"], rec["sc_Ysum_cpm"])
+        sex_rows.append(rec)
+    sc_sex = pd.DataFrame(sex_rows).set_index("sc_gsm")
+    bulk_sex_rows = []
+    for j, g in enumerate(b_src_gsm):
+        rec = {"bulk_gsm": g}
+        for gene in SEX_GENES:
+            rec["bulk_" + gene + "_cpm"] = float(bcpm[j, bids.index(SEX_IDS[gene])])
+        rec["bulk_Ysum_cpm"] = sum(rec["bulk_" + x + "_cpm"] for x in Y_GENES)
+        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_gsm")
+
+    # ---------------- expression identity
+    common = b_valid.all(0) & sc_valid_all.all(0)
+    use_genes = common & ~chr_y          # chrY excluded: keeps the expression test independent of the sex test
+
+    def logcpm(m: np.ndarray) -> np.ndarray:
+        x = m[:, use_genes]
+        return np.log2(x / x.sum(1, keepdims=True) * 1e6 + 1)
+
+    lb_all, ls_all = logcpm(bulk_all), logcpm(sc_sum)
+    use_ids = gene_ids[use_genes]
+    # (a) Ye's "as specified" test: Spearman over the top 2,000 genes by mean, raw and modality-centred
+    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])
+    rho_rev = spearman_matrix(ls_all[si][:, top], lb_all[:, top])
+    cb, cs = lb_all - lb_all.mean(0), ls_all - ls_all.mean(0)
+    rho_c = spearman_matrix(cb[bi][:, top], cs[:, 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])
+        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": rank_of(rho[r], own), "best_is_own": bool(order[0] == own),
+                     "centred_own_rank_among_sc": rank_of(rho_c[r], own), "centred_best_is_own": bool(order_c[0] == own),
+                     "reverse_best_bulk_gsm": b_gsm[rev[0]], "reverse_own_rank_among_bulk": rank_of(rho_rev[r], bi[r]),
+                     "reverse_best_is_own": bool(rev[0] == bi[r])})
+    expr = pd.DataFrame(expr)
+
+    # (b) donor-sensitive residualised test (uses no pairing information): within each modality centre
+    # log2(CPM+1), remove the top k sample PCs (computed on expressed genes), keep the 2,000 genes with the
+    # highest residual variance in both modalities (rank sum), Pearson bulk x sc.
+    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)
+        if k == 0:
+            return xc
+        u = np.linalg.svd(xc[:, ex], full_matrices=False)[0][:, :k]
+        return xc - u @ (u.T @ xc)
+
+    disc = {}
+    fw_primary = None
+    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]
+        full = pearson_matrix(rb_[:, sel], rs_[:, sel])          # all 128 bulks x all 46 sc
+        if k == K_PRIMARY:
+            fw_primary, sel_primary = full, sel
+        cols = {c: [] for c in ("own_rank_bulk_to_sc", "own_rank_sc_to_bulk", "best_sc_gsm", "best_bulk_gsm", "r_own",
+                                "r_best", "patient_rank_bulk_to_sc", "patient_rank_sc_to_bulk", "best_sc_patient",
+                                "best_bulk_patient", "r_best_other_patient_sc", "own_tp_best_within_patient_sc",
+                                "own_tp_best_within_patient_bulk")}
+        for r in range(n):
+            fwr, bwr = full[bi[r]], full[:, si[r]]
+            own_p = pairs.patient[r]
+            cols["own_rank_bulk_to_sc"].append(rank_of(fwr, si[r]))
+            cols["own_rank_sc_to_bulk"].append(rank_of(bwr, bi[r]))
+            cols["best_sc_gsm"].append(sc_gsms[int(np.argmax(fwr))])
+            cols["best_bulk_gsm"].append(b_gsm[int(np.argmax(bwr))])
+            cols["r_own"].append(float(fwr[si[r]])); cols["r_best"].append(float(fwr.max()))
+            pr, pb, _ = patient_rank(fwr, sc_patient, own_p)
+            pr2, pb2, _ = patient_rank(bwr, b_patient, own_p)
+            cols["patient_rank_bulk_to_sc"].append(pr); cols["patient_rank_sc_to_bulk"].append(pr2)
+            cols["best_sc_patient"].append(pb); cols["best_bulk_patient"].append(pb2)
+            cols["r_best_other_patient_sc"].append(float(fwr[sc_patient != own_p].max()))
+            same = np.flatnonzero(sc_patient == own_p)
+            cols["own_tp_best_within_patient_sc"].append(
+                bool(fwr[same].argmax() == np.flatnonzero(same == si[r])[0]) if len(same) > 1 else None)
+            sameb = np.flatnonzero(b_patient == own_p)
+            cols["own_tp_best_within_patient_bulk"].append(
+                bool(bwr[sameb].argmax() == np.flatnonzero(sameb == bi[r])[0]) if len(sameb) > 1 else None)
+        for c, v in cols.items():
+            expr[f"resid_k{k}_{c}"] = v
+        # discrimination over ALL bulks / sc libraries whose patient exists in the other modality
+        have_sc = np.isin(b_patient, sc_patient)
+        top_bulk = [sc_patient[int(np.argmax(full[j]))] == b_patient[j] for j in np.flatnonzero(have_sc)]
+        have_b = np.isin(sc_patient, b_patient)
+        top_sc = [b_patient[int(np.argmax(full[:, i]))] == sc_patient[i] for i in np.flatnonzero(have_b)]
+        chance_b = float(np.mean([np.mean(sc_patient == b_patient[j]) for j in np.flatnonzero(have_sc)]))
+        chance_s = float(np.mean([np.mean(b_patient == sc_patient[i]) for i in np.flatnonzero(have_b)]))
+        same_mask = b_patient[:, None] == sc_patient[None, :]
+        pair_mask = np.zeros_like(same_mask); pair_mask[bi, si] = True
+        disc[k] = {"n_genes_selected": int(len(sel)),
+                   "pairs_own_library_top1_bulk_to_sc": int((np.asarray(cols["own_rank_bulk_to_sc"]) == 1).sum()),
+                   "pairs_own_library_top1_sc_to_bulk": int((np.asarray(cols["own_rank_sc_to_bulk"]) == 1).sum()),
+                   "pairs_own_patient_top1_bulk_to_sc": int((np.asarray(cols["patient_rank_bulk_to_sc"]) == 1).sum()),
+                   "pairs_own_patient_top1_sc_to_bulk": int((np.asarray(cols["patient_rank_sc_to_bulk"]) == 1).sum()),
+                   "all_bulks_top_sc_same_patient": f"{int(np.sum(top_bulk))}/{len(top_bulk)}",
+                   "all_bulks_chance_rate": round(chance_b, 4),
+                   "all_sc_top_bulk_same_patient": f"{int(np.sum(top_sc))}/{len(top_sc)}",
+                   "all_sc_chance_rate": round(chance_s, 4),
+                   "auc_same_patient_vs_other_patient_all_bulk_sc_combinations": auc(full[same_mask], full[~same_mask]),
+                   "median_r_paired": float(np.median(full[pair_mask])),
+                   "median_r_same_patient_other_timepoint": float(np.median(full[same_mask & ~pair_mask])),
+                   "median_r_other_patient": float(np.median(full[~same_mask])),
+                   "p99_r_other_patient": float(np.quantile(full[~same_mask], 0.99)),
+                   "timepoint_own_best_within_patient_bulk_to_sc":
+                       f"{sum(v is True for v in cols['own_tp_best_within_patient_sc'])}/"
+                       f"{sum(v is not None for v in cols['own_tp_best_within_patient_sc'])}",
+                   "timepoint_own_best_within_patient_sc_to_bulk":
+                       f"{sum(v is True for v in cols['own_tp_best_within_patient_bulk'])}/"
+                       f"{sum(v is not None for v in cols['own_tp_best_within_patient_bulk'])}"}
+    # full primary correlation matrix (bulk x sc) for audit
+    pd.DataFrame(fw_primary, index=b_gsm, columns=sc_gsms).to_csv(RUN / f"identity_resid_k{K_PRIMARY}_bulk_x_sc.csv")
+
+    # anomaly probe: N127 / N131 libraries (cell names 'N127131AC', 'N1131AC', 'N131NS'; orig.ident '...V01AC')
+    probe = {}
+    for g in sc_gsms:
+        if sc_patient[srow[g]] in ("N127", "N131"):
+            col = fw_primary[:, srow[g]]
+            o = np.argsort(-col)[:3]
+            probe[sc_key[srow[g]]] = {"top_bulk": [(b_index[j], round(float(col[j]), 3)) for j in o],
+                                      "r_bulk_N131_chili_BC": float(col[b_index.tolist().index("N131_chili_BC")])}
+    rs5 = resid(ls_all, K_PRIMARY)[:, sel_primary]
+    ids_probe = [srow[g] for g in sc_gsms if sc_patient[srow[g]] in ("N127", "N131")]
+    probe["sc_sc_residual_pearson"] = {f"{sc_key[a]}~{sc_key[b]}": float(np.corrcoef(rs5[a], rs5[b])[0, 1])
+                                       for x, a in enumerate(ids_probe) for b in ids_probe[x + 1:]}
+    other = [float(np.corrcoef(rs5[a], rs5[b])[0, 1]) for a in range(len(sc_gsms)) for b in range(a + 1, len(sc_gsms))
+             if sc_patient[a] != sc_patient[b]]
+    same_p = [float(np.corrcoef(rs5[a], rs5[b])[0, 1]) for a in range(len(sc_gsms)) for b in range(a + 1, len(sc_gsms))
+              if sc_patient[a] == sc_patient[b] and not {sc_patient[a]} & {"N127", "N131"}]
+    probe["sc_sc_reference"] = {"different_patients_median": float(np.median(other)), "different_patients_p99": float(np.quantile(other, .99)),
+                                "same_patient_other_patients_median": float(np.median(same_p)), "same_patient_min": float(np.min(same_p))}
+
+    # specimen evidence: bulk (PAXgene whole blood) vs sc (PBMC) composition marker CPM on the canonical axis
+    spec = {}
+    bc_cpm = bulk_all / bulk_all.sum(1, keepdims=True) * 1e6
+    sc_cpm = sc_sum / sc_sum.sum(1, keepdims=True) * 1e6
+    for grp, genes in SPECIMEN_GENES.items():
+        for gname in genes:
+            j = np.flatnonzero(sym == gname)
+            if len(j) == 1:
+                spec[f"{grp}:{gname}"] = {"bulk_median_cpm_paired": float(np.median(bc_cpm[bi, j[0]])),
+                                          "sc_median_cpm_paired": float(np.median(sc_cpm[si, j[0]]))}
+    hb = np.isin(sym, SPECIMEN_GENES["hemoglobin"])
+    spec["hemoglobin_fraction_of_canonical_bulk_counts_paired"] = {
+        "median": float(np.median(bulk_all[bi][:, hb].sum(1) / bulk_all[bi].sum(1))),
+        "min": float(np.min(bulk_all[bi][:, hb].sum(1) / bulk_all[bi].sum(1))),
+        "max": float(np.max(bulk_all[bi][:, hb].sum(1) / bulk_all[bi].sum(1)))}
+    spec["hemoglobin_fraction_of_canonical_sc_counts_paired"] = {
+        "median": float(np.median(sc_sum[si][:, hb].sum(1) / sc_sum[si].sum(1)))}
+
+    # ---------------- cells on the 6k panel (two passes: per-library temp files, then one CSR)
+    cm = pd.read_csv(RUN / "r_export/cell_metadata.csv.gz", dtype=str, keep_default_na=False,
+                     usecols=["cell", "predicted.celltype.l1", "predicted.celltype.l2", "predicted.celltype.l3",
+                              "predicted.celltype.l2.score", "mapping.score"]).set_index("cell")
+    if TMP.exists():
+        shutil.rmtree(TMP)
+    TMP.mkdir()
+    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.patient[r])
+        obs.insert(5, "group", pairs.timepoint[r])
+        a = cm.reindex(obs.barcode)
+        require(a.notna().all().all() and np.array_equal(a.index.to_numpy(), obs.barcode.to_numpy()), f"{g}: author labels")
+        obs["author_cell_type"] = a["predicted.celltype.l2"].to_numpy()
+        obs["row_sample"] = np.int32(r)
+        # extra columns (appended after the Ye 2026 schema)
+        obs["author_cell_type_l1"] = a["predicted.celltype.l1"].to_numpy()
+        obs["author_cell_type_l3"] = a["predicted.celltype.l3"].to_numpy()
+        obs["author_cell_type_l2_score"] = a["predicted.celltype.l2.score"].astype(float).to_numpy()
+        obs["author_mapping_score"] = a["mapping.score"].astype(float).to_numpy()
+        obs["outcome"] = pairs.outcome[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)
+    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)
+    S = lambda c: pairs[c].to_numpy().astype(str)  # noqa: E731
+    meta_arrays = {
+        "gene_ids": gene_ids, "sample_ids": S("sample_id"), "donor_ids": S("patient"), "groups": S("timepoint"),
+        "timepoints": S("timepoint"), "outcome": S("outcome"),
+        "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": S("bulk_gsm"), "sc_gsm": S("sc_gsm"), "sc_title_sample_id": S("PID_visit"),
+        "id_match": S("id_match"), "bulk_title": S("bulk_title"), "sc_title": S("sc_title"),
+        "bulk_library": S("bulk_library"), "sc_library_key": S("library_key"), "bulk_batch": S("bulk_batch"),
+        "sc_round": S("round"), "sex_geo": S("sex_geo_sc"), "age_geo": S("age_geo_sc"),
+        "age_geo_bulk": S("age_geo_bulk"), "regimen": S("regimen_sc"), "cancer_type": S("cancer_type"),
+        "steroid_bulk": S("steroid_bulk"), "steroid_sc": S("steroid_sc"),
+    }
+    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", "bulk_title", "sc_title", "id_match", "timepoint", "outcome",
+               "sex_geo_sc", "age_geo_sc", "age_geo_bulk", "regimen_sc", "cancer_type", "steroid_bulk", "steroid_sc",
+               "bulk_library", "bulk_batch", "library_key", "round", "PID_visit", "bulk_subject_raw",
+               "seurat_orig_ident", "metadata_notes"]].copy()
+    p.insert(3, "donor_id", pairs.patient.to_numpy())
+    p.insert(4, "row", np.arange(n))
+    p.insert(8, "group", pairs.timepoint.to_numpy())
+    p = p.rename(columns={"sex_geo_sc": "sex_geo", "age_geo_sc": "age_geo", "regimen_sc": "regimen"})
+    p["n_cells_library"] = [summaries[g]["n_cells"] for g in p.sc_gsm]
+    p["n_cells_retained"] = qc_cell_counts
+    for c in ("bulk_XIST_cpm", "bulk_Ysum_cpm", "bulk_sex_score", "bulk_sex_call"):
+        p[c] = bulk_sex.loc[p.bulk_gsm, c].to_numpy()
+    for c in ("sc_XIST_cpm", "sc_Ysum_cpm", "sc_sex_score", "sc_sex_call"):
+        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"):
+        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", "patient_rank_bulk_to_sc", "patient_rank_sc_to_bulk",
+                  "best_sc_gsm", "best_sc_patient", "best_bulk_patient", "r_own", "r_best", "r_best_other_patient_sc",
+                  "own_tp_best_within_patient_sc", "own_tp_best_within_patient_bulk"):
+            p[f"expr_resid_k{k}_{c}"] = e.loc[p.bulk_gsm, f"resid_k{k}_{c}"].to_numpy()
+    sc_name = dict(zip(table.sc_gsm, table.library_key))
+    kp = f"expr_resid_k{K_PRIMARY}_"
+
+    def verdict(row) -> str:
+        """pass: sex concordant AND (residualised, k=K_PRIMARY) own PATIENT ranked 1st in one direction and <=5th in
+        the other. fail: sex discordant, or own patient ranked >5th in both directions. Otherwise borderline.
+        Patient level because the same patient's other time points are legitimate near-ties."""
+        r1, r2 = row[kp + "patient_rank_bulk_to_sc"], row[kp + "patient_rank_sc_to_bulk"]
+        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) > 5:
+            issues.append(f"expression: own patient rank {r1} (bulk->28 sc patients) and {r2} (sc->61 bulk patients); "
+                          f"bulk best sc = {sc_name[row[kp + 'best_sc_gsm']]}")
+        if issues:
+            return "fail: " + "; ".join(issues)
+        if min(r1, r2) == 1 and max(r1, r2) <= 5:
+            return "pass"
+        return f"borderline: own patient 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():
+        x = []
+        if row.bulk_possible_mixture:
+            x.append("bulk has opposite-sex signal (possible minor admixture)")
+        if row[kp + "own_tp_best_within_patient_sc"] is False:
+            x.append("bulk matches this patient's other sc time point slightly better (time point not resolvable)")
+        notes.append("; ".join(x))
+    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")
+    bsx = bulk_sex.join(pd.Series(dict(zip(b_gsm, b_index)), name="sample_id"))
+    bmeta = pd.read_csv(RUN / "pairing/GSE287540_samples.csv", dtype=str, keep_default_na=False).set_index("gsm")
+    bsx["sex_geo"] = bmeta.loc[bsx.index, "ch_Sex"].to_numpy()
+    bsx["sex_discordant_with_geo"] = bsx.bulk_sex_call != bsx.sex_geo.str.lower()
+    bsx.to_csv(OUT / "identity_sex_bulk_all.csv")
+    ssx = sc_sex.join(table.set_index("sc_gsm")[["library_key", "sample_id", "sex_geo_sc", "paired"]])
+    ssx["sex_discordant_with_geo"] = ssx.sc_sex_call != ssx.sex_geo_sc.str.lower()
+    ssx.to_csv(OUT / "identity_sex_sc_all.csv")
+    expr.to_csv(OUT / "identity_expression.csv", index=False)
+
+    unmatched_sc = table[table.paired != "True"][["sc_gsm", "library_key", "sample_id", "unpaired_reason"]]
+    unmatched_bulk = pd.read_csv(RUN / "pairing/bulk_without_sc.csv", dtype=str, keep_default_na=False)
+
+    checks = {
+        "gene_positions_sha256_ok": True,
+        "panel_gene_ids_match_selected_genes_csv": True,
+        "bulk_finite_nonnegative_inside_mask": True,
+        "bulk_fractional_values_inside_mask": bulk_fractional,
+        "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,
+        "sex_concordant_pairs": f"{int(p.sex_concordant.sum())}/{n}",
+        "sex_discordant_bulk_all": bsx[bsx.sex_discordant_with_geo].sample_id.tolist(),
+        "sex_discordant_sc_all": ssx[ssx.sex_discordant_with_geo].library_key.tolist(),
+        "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}",
+        "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": "ji2025_chili_paired_ft_v1",
+        "written_utc": datetime.now(timezone.utc).isoformat(), "started_utc": t0.isoformat(),
+        "study": "Ji C et al., Cancer Immunol Immunother 2025 (PMC12049347; NCT04476563); bulk GSE287540, scRNA GSE287541",
+        "rows": n, "row_order": "bulk GSM ascending", "patients": int(pairs.patient.nunique()),
+        "pairs_by_timepoint": p.timepoint.value_counts().to_dict(), "pairs_by_outcome": p.outcome.value_counts().to_dict(),
+        "pairs_by_outcome_timepoint": (p.outcome + "_" + p.timepoint).value_counts().to_dict(),
+        "pairs_per_patient": p.donor_id.value_counts().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()),
+                  "author_filtered_cells_in_paired_libraries": int(sum(summaries[g]["n_cells"] for g in pairs.sc_gsm))},
+        "retained_cells_rule": "flag_conservative_review_pass = genes>=200 & UMIs>=500 & mito<=20% (qc_core, ImMicro definition) applied to the author-filtered Seurat cells; MAD flags are review-only columns",
+        "features_semantics": {
+            "bulk_raw": "Salmon 1.10.0 gene-level estimated read counts (QuantSeq 3' FWD, PAXgene WHOLE BLOOD) on the canonical axis, float64 exactly as deposited (never rounded; the deposited table happens to be integer-valued); 0 where bulk_valid is False",
+            "pseudo_raw_sum": "sum of retained cells' UMI counts (Seurat RNA@counts) on the canonical axis; storage 0 where sc_valid is False",
+            "bulk_valid": "harmonization_valid from qc_bulk.harmonize (gene in the Salmon table, unique mapping)",
+            "sc_valid": "harmonization_valid from qc_singlecell.canonical_export (gene in the CellRanger 2020-A feature table)",
+            "pair_valid": "bulk_valid & sc_valid",
+            "sample_ids": "<patient>_<timepoint>, e.g. N022_TOL", "donor_ids": "patient (N###, zero-padded)",
+            "groups": "= timepoints: GEO time label BC (before ICI), AC (control patients ~12 weeks after ICI start), TOL (time of liver injury), FU1 (follow-up 3-49 d after TOL)",
+            "outcome": "GEO group: ChILI or control (ICI-treated, no ChILI)",
+            "extra_keys": "timepoints, outcome, bulk_gsm, sc_gsm, sc_title_sample_id (=PID_visit), id_match, bulk_title, sc_title, bulk_library, sc_library_key, bulk_batch, sc_round, sex_geo, age_geo, age_geo_bulk, regimen, cancer_type, steroid_bulk, steroid_sc, identity_pass, identity_check, sex_bulk_expr, sex_sc_expr"},
+        "specimen_warning": "The bulk RNA is from PAXgene WHOLE BLOOD (GEO extract protocol and paper methods), not PBMC; the sc data are PBMC (dead-cell removed). Same patient and same visit, different specimen. Whole blood contains neutrophils and reticulocyte globin RNA that PBMC lack.",
+        "specimen_evidence_median_cpm": spec,
+        "identity": {"sex_rule": "CPM on the source axis (bulk: Salmon table; sc: retained cells, all RNA features); score=log2(XIST+1)-log2(RPS4Y1+DDX3Y+UTY+KDM5D+1); female>2, male<-2, else ambiguous; opposite-sex signal flag: female call with Y CPM>20 or male call with XIST CPM>50 (bulk)",
+                     "genes": f"{int(use_genes.sum())} canonical genes measured in all 128 bulks and all {len(sc_gsms)} sc libraries, chrY excluded; {int(expressed.sum())} 'expressed' (bulk mean log2CPM>3 and sc mean>1)",
+                     "expression_rule_as_ye": f"Spearman over the top {TOP_N} genes by mean log2(CPM+1), each paired bulk vs all {len(sc_gsms)} sc pseudobulks; centred and reverse variants",
+                     "expression_residualised_rule": f"within each modality centre log2(CPM+1), remove the top k sample PCs (computed on expressed genes), keep the {TOP_N} genes with the highest residual variance in both modalities (rank sum), Pearson all 128 bulks x all {len(sc_gsms)} sc libraries. Primary k={K_PRIMARY} (~10% of the 46 sc libraries; Ye used 10 for 133/207); sensitivity k={list(RESID_K)}. Uses no pairing information.",
+                     "verdict_rule": f"pass = sex concordant (bulk, sc, GEO) and at k={K_PRIMARY} the own PATIENT ranked 1st in one direction and <=5th in the other (candidates collapsed to patients by their best r: 28 sc patients, 61 bulk patients); fail = sex discordant or own patient >5th in both directions; else borderline",
+                     "discrimination_by_k": disc,
+                     "anomaly_probe_N127_N131": probe,
+                     "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_bulk": unmatched_sc.to_dict("records"),
+                     "bulk_samples_without_sc": unmatched_bulk[["gsm", "Sample_title", "ch_time", "reason"]].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(BULK_H5AD), "sha256": sha256_file(BULK_H5AD)},
+                   "r_export_summary": json.loads((RUN / "r_export/EXPORT_SUMMARY.json").read_text()),
+                   "sources": json.loads((RUN / "SOURCES.json").read_text())},
+        "code": {name: {"path": str(path), "sha256": sha256_file(path)} for name, path in [
+            ("assemble", Path(__file__).resolve()), ("pipeline", RUN / "code/ji2025_pipeline.py"),
+            ("export_seurat_counts", RUN / "code/export_seurat_counts.R"), ("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 not in ("MANIFEST.json", "QC_REPORT.md")
+                           and not q.name.startswith("cells_full")}
+    (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, "disc_primary": disc[K_PRIMARY]}, indent=1, default=str))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/20260928/diffusion/data/source_prep/ji2025_chili/code/ji2025_full_cells.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+"""data/ji2025_chili/cells_full.npz via the shared tools/build_full_cells.py, unmodified (CPU only).
+
+The shared tool keys library roots by dataset name; rather than editing it (other build agents use it), this
+wrapper imports it, registers this run's singlecell/ directory for 'ji2025_chili' in memory, and calls its main().
+All checks (panel columns equal cells_panel6k.npz; per-row full-axis sums equal pseudo_raw_sum) are the tool's own.
+"""
+import importlib.util
+import sys
+from pathlib import Path
+
+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/ji2025_chili_v1_20260928")
+
+spec = importlib.util.spec_from_file_location("build_full_cells", TOOL)
+bfc = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(bfc)
+bfc.LIBRARY_ROOT.setdefault("ji2025_chili", RUN / "singlecell")
+if bfc.LIBRARY_ROOT["ji2025_chili"] != RUN / "singlecell":
+    raise SystemExit("build_full_cells.py already maps ji2025_chili elsewhere")
+print(f"tool {TOOL} sha256 {bfc.sha(TOOL)}", flush=True)
+sys.exit(bfc.main("ji2025_chili"))

paper-releases/20260928/diffusion/data/source_prep/ji2025_chili/code/ji2025_pipeline.py

@@ -0,0 +1,486 @@
+#!/usr/bin/env python3
+"""Ji et al. 2025 ChILI (Cancer Immunol Immunother) bulk (GSE287540) + scRNA (GSE287541) processing.
+
+CPU only; never imports torch or initializes CUDA.
+
+Reuses the frozen ImMicro strict-QC code bundle v5 VERBATIM (copied to code/strict_qc_v1_code_bundle_v5,
+sha256 verified against its MANIFEST), exactly as the Ye 2026 build does:
+  * qc_core.scan_mtx                    (streaming MTX audit; cell flags min_genes 200, min_counts 500,
+                                         max mito 20 %, 5-MAD review-only outliers)
+  * qc_genes.GeneMapper                 (frozen 20,097-gene GENCODE v49 axis, ambiguity/conflict quarantine)
+  * qc_singlecell.read_axes / canonical_export (canonical sparse H5AD, measured masks, SUM pseudobulk)
+  * qc_bulk.from_assembled / harmonize  (bulk canonical matrix, NaN + source_feature_present/harmonization_valid)
+Study-specific glue only: GEO SOFT parsing, the patient x timepoint pairing rule, the Salmon count-table
+parser and the per-library obs. The single-cell MTX libraries come from code/export_seurat_counts.R
+(RNA@counts of the author-filtered GEO Seurat object; see r_export/EXPORT_SUMMARY.json).
+
+Subcommands: sources | pairing | bulk | sc
+"""
+from __future__ import annotations
+
+import argparse
+import gzip
+import json
+import re
+import sys
+import time
+from collections import defaultdict
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+DATALAKE = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc")
+RAW = {"GSE287540": DATALAKE / "datasets/GSE287540", "GSE287541": DATALAKE / "datasets/GSE287541"}
+RUN = DATALAKE / "processing/ji2025_chili_v1_20260928"
+BUNDLE = RUN / "code/strict_qc_v1_code_bundle_v5"  # verbatim copy of strict_qc_v1_20260913/code_bundle_v5
+REFERENCE = DATALAKE / "processing/strict_qc_v1_20260913/reference"  # frozen; read only
+RECEIPTS = DATALAKE / "acquisition/20260927/manifests/download_receipts.jsonl"
+EXPORT = RUN / "r_export"
+BULK_TABLE = RAW["GSE287540"] / "raw/GSE287540_ChILI_bulk_readcount.tsv.gz"
+SEURAT_GZ = RAW["GSE287541"] / "raw/GSE287541_all_pbmc_combined_filtered_SeuratObj.RDS.gz"
+SEURAT_RDS = RUN / "extracted/GSE287541_seurat.rds"
+sys.path.insert(0, str(BUNDLE))
+
+import qc_core  # noqa: E402
+import qc_genes  # noqa: E402
+
+SEX_GENES = {"XIST": "ENSG00000229807", "RPS4Y1": "ENSG00000129824", "DDX3Y": "ENSG00000067048",
+             "UTY": "ENSG00000183878", "KDM5D": "ENSG00000012817"}
+COUNT_EVIDENCE = ("GEO GSE287541 author-filtered Seurat object (SeuratObject v4 Assay 'RNA'), slot 'counts': "
+                  "integer UMI counts from CellRanger multi (GRCh38-2020-A); nCount_RNA/nFeature_RNA/percent.mt "
+                  "reproduce exactly from this slot; exported per library by code/export_seurat_counts.R")
+UNITS_BULK = "salmon_1.10.0_gene_estimated_read_counts_as_deposited"
+TIMES = ("BC", "AC", "TOL", "FU1", "FU2")
+
+
+def now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def log(event: dict) -> None:
+    event = {"t": now(), **event}
+    line = json.dumps(event, default=str)
+    print(line, flush=True)
+    with open(RUN / "events.jsonl", "a") as handle:
+        handle.write(line + "\n")
+
+
+def sha256(path: Path) -> str:
+    return qc_core.sha256_file(path)
+
+
+def verify_bundle() -> dict:
+    manifest = json.loads((BUNDLE / "MANIFEST.json").read_text())
+    for name, digest in manifest["files"].items():
+        if sha256(BUNDLE / name) != digest:
+            raise RuntimeError(f"Code bundle file changed: {name}")
+    return manifest
+
+
+def norm_patient(pid: str) -> str:
+    """'N87' -> 'N087', 'N064' -> 'N064'; the GEO/Seurat patient IDs are not consistently zero-padded."""
+    m = re.fullmatch(r"N(\d+)", pid.strip())
+    if not m:
+        raise ValueError(f"Unexpected patient ID {pid!r}")
+    return f"N{int(m.group(1)):03d}"
+
+
+# ----------------------------------------------------------------- sources
+def receipts() -> dict:
+    out = {}
+    for line in open(RECEIPTS):
+        rec = json.loads(line)
+        out[rec["local_path"]] = rec
+    return out
+
+
+def cmd_sources(_args) -> None:
+    """sha256 every acquired file used here against its acquisition receipt; hash the gunzipped RDS copy."""
+    verify_bundle()
+    known = receipts()
+    records = []
+    for acc, base in RAW.items():
+        for path in sorted(list((base / "raw").glob("*")) + list((base / "metadata").glob("*"))):
+            if not path.is_file() or path.name.endswith((".partial", ".tmp")):
+                continue
+            rec = {"accession": acc, "path": str(path), "bytes": path.stat().st_size, "sha256": sha256(path)}
+            receipt = known.get(str(path))
+            rec["acquisition_receipt"] = bool(receipt)
+            if receipt:
+                rec.update(url=receipt["url"], receipt_sha256=receipt["sha256"], receipt_bytes=receipt["bytes"],
+                           receipt_completed_at=receipt["completed_at"],
+                           matches_receipt=(receipt["sha256"] == rec["sha256"] and receipt["bytes"] == rec["bytes"]))
+                if not rec["matches_receipt"]:
+                    raise RuntimeError(f"Acquired file differs from its receipt: {path}")
+            records.append(rec)
+    # The GEO .RDS.gz is gzip around an (internally gzip-compressed) RDS: extracted/ holds the outer-gunzipped stream.
+    h = __import__("hashlib").sha256()
+    with gzip.open(SEURAT_GZ, "rb") as fh:
+        for block in iter(lambda: fh.read(1 << 24), b""):
+            h.update(block)
+    rds = {"path": str(SEURAT_RDS), "bytes": SEURAT_RDS.stat().st_size, "sha256": sha256(SEURAT_RDS),
+           "gunzip_of": str(SEURAT_GZ), "gunzip_stream_sha256": h.hexdigest()}
+    rds["identical_to_gunzip_stream"] = rds["sha256"] == rds["gunzip_stream_sha256"]
+    if not rds["identical_to_gunzip_stream"]:
+        raise RuntimeError("extracted RDS differs from the gunzipped acquired file")
+    qc_core._write_json(RUN / "SOURCES.json", {"created_at_utc": now(), "files": records, "extracted_rds": rds,
+                                               "receipts": str(RECEIPTS)})
+    log({"stage": "sources", "n_files": len(records), "rds_ok": rds["identical_to_gunzip_stream"],
+         "unreceipted": [r["path"] for r in records if not r["acquisition_receipt"]]})
+
+
+# ----------------------------------------------------------------- pairing
+def parse_soft(path: Path) -> pd.DataFrame:
+    samples, cur, section = [], None, None
+    with gzip.open(path, "rt", encoding="utf-8") as fh:
+        for line in fh:
+            line = line.rstrip("\n")
+            if line.startswith("^"):
+                section = line[1:].split(" = ")[0]
+                if section == "SAMPLE":
+                    cur = defaultdict(list)
+                    cur["gsm"] = [line.split(" = ")[1]]
+                    samples.append(cur)
+                continue
+            if section != "SAMPLE" or not line.startswith("!") or " = " not in line:
+                continue
+            key, val = line[1:].split(" = ", 1)
+            if key == "Sample_characteristics_ch1" and ": " in val:
+                k, v = val.split(": ", 1)
+                cur["ch_" + k.strip()].append(v.strip())
+            else:
+                cur[key].append(val)
+    return pd.DataFrame([{k: "|".join(v) for k, v in s.items()} for s in samples]).fillna("")
+
+
+def cmd_pairing(_args) -> None:
+    out = RUN / "pairing"
+    out.mkdir(parents=True, exist_ok=True)
+    bulk = parse_soft(RAW["GSE287540"] / "metadata/GSE287540_family.soft.gz")
+    sc = parse_soft(RAW["GSE287541"] / "metadata/GSE287541_family.soft.gz")
+    bulk.to_csv(out / "GSE287540_samples.csv", index=False)
+    sc.to_csv(out / "GSE287541_samples.csv", index=False)
+
+    # ---- bulk: GEO title '<subject>_<group>_<time>', library 'Library name: itoxNNNNNN' = count-table column
+    m = bulk.Sample_title.str.extract(r"^(N\d+)_(chili|control)_(BC|AC|TOL|FU1|FU2)$")
+    if m.isna().any().any():
+        raise RuntimeError("Unexpected bulk title format")
+    if not ((m[0] == bulk.ch_subject) & (m[1] == bulk.ch_group) & (m[2] == bulk.ch_time)).all():
+        raise RuntimeError("Bulk title disagrees with GEO characteristics")
+    bulk["bulk_library"] = bulk.Sample_description.str.extract(r"^Library name: (itox\d+)$")[0]
+    if bulk.bulk_library.isna().any() or not bulk.bulk_library.is_unique or not bulk.Sample_title.is_unique:
+        raise RuntimeError("Bulk library names missing or duplicated")
+    bulk["patient"] = bulk.ch_subject.map(norm_patient)
+    bulk["key"] = bulk.patient + "_" + bulk.ch_time
+    if not bulk.key.is_unique:
+        raise RuntimeError("Two bulk samples for one patient x timepoint")
+    header = gzip.open(BULK_TABLE, "rt").readline().rstrip("\n").split("\t")[1:]
+    if sorted(header) != sorted(bulk.bulk_library):
+        raise RuntimeError("Bulk count-table columns differ from GEO library names")
+
+    # ---- sc: GEO titles '<PID_visit>_<round>_GPEX' (GEX) or '_TCR' (V(D)J); GEX joined to the R export
+    t = sc.Sample_title.str.extract(r"^(N\d+V\d+)_(Rd\d[ab]?)_(GPEX|TCR)$")
+    if t.isna().any().any() or not (t[0] == sc.ch_subject).all() or not (t[1] == sc.ch_batch).all():
+        raise RuntimeError("Unexpected sc title format")
+    sc["PID_visit"], sc["round"], sc["library_kind"] = t[0], t[1], t[2]
+    sc["library_key"] = sc["round"] + "_" + sc.PID_visit
+    gex = sc[sc.library_kind == "GPEX"].copy()
+    tcr = sc[sc.library_kind == "TCR"].copy()
+    if not gex.library_key.is_unique:
+        raise RuntimeError("Duplicate GEX library key")
+    libs = pd.read_csv(EXPORT / "libraries.csv", dtype=str, keep_default_na=False)
+    if sorted(libs.library_key) != sorted(gex.library_key):
+        raise RuntimeError("R-export libraries differ from GEO GEX GSMs")
+    gex = gex.merge(libs, on="library_key", how="left", validate="one_to_one", suffixes=("", "_seurat"))
+    gex["patient"] = gex.PID_visit.str.extract(r"^(N\d+)V\d+$")[0].map(norm_patient)
+    # GEO vs Seurat per-library metadata must agree (Seurat fields are per-cell, one unique value per library).
+    seurat_steroid = gex.Steroid.replace({"NA": "NA"})
+    agree = {"time": gex.ch_time == gex.Time, "group": gex.ch_group == gex.Group, "sex": gex.ch_Sex == gex.Gender,
+             "age": gex.ch_age.astype(float) == gex.Age.astype(float), "steroid": gex.ch_steroid == seurat_steroid,
+             "patient": gex.patient == gex.Person.map(norm_patient)}
+    gex["geo_vs_seurat_disagree"] = [";".join(k for k, v in agree.items() if not v[i]) for i in range(len(gex))]
+    hard = gex.geo_vs_seurat_disagree.str.contains("time|group|sex|patient")
+    if hard.any():  # identity fields must agree; age/steroid differences are recorded only
+        raise RuntimeError(f"GEO vs Seurat identity metadata disagree: {gex[hard].library_key.tolist()}")
+    gex["key"] = gex.patient + "_" + gex.ch_time
+    gex["group"] = gex.ch_time  # groups = timepoint label
+    gex["outcome"] = gex.ch_group.str.lower().map({"chili": "ChILI", "control": "control"})
+
+    # ---- pairing: same patient AND same timepoint label; must agree on sex, outcome group and ICI regimen
+    by_key = bulk.set_index("key")
+    rows, used_bulk = [], defaultdict(list)
+    for _, g in gex.iterrows():
+        rec = {"sc_gsm": g.gsm, "sc_title": g.Sample_title, "library_key": g.library_key, "PID_visit": g.PID_visit,
+               "round": g["round"], "patient": g.patient, "timepoint": g.ch_time, "sample_id": g.key,
+               "outcome": g.outcome, "sex_geo_sc": g.ch_Sex, "age_geo_sc": g.ch_age, "steroid_sc": g.ch_steroid,
+               "regimen_sc": g.ch_treatment, "cancer_type": g.Cancer, "sc_subject_raw": g.ch_subject,
+               "seurat_orig_ident": g.orig_ident, "seurat_cell_name_token": g.cell_name_token,
+               "n_cells_author": int(g.n_cells), "geo_vs_seurat_disagree": g.geo_vs_seurat_disagree,
+               "steroid_seurat": g.Steroid}
+        if g.key in by_key.index:
+            b = by_key.loc[g.key]
+            mism = []
+            if b.ch_Sex.lower() != g.ch_Sex.lower():
+                mism.append("sex")
+            if b.ch_group.lower() != g.ch_group.lower():
+                mism.append("outcome_group")
+            if b.ch_treatment != g.ch_treatment:
+                mism.append("regimen")
+            notes = []
+            if abs(float(b.ch_age) - float(g.ch_age)) > 0:
+                notes.append(f"age bulk {b.ch_age} vs sc {g.ch_age}")
+            if b.ch_steroid != g.ch_steroid:
+                notes.append(f"steroid bulk {b.ch_steroid} vs sc {g.ch_steroid}")
+            if abs(float(b.ch_age) - float(g.ch_age)) > 1:
+                mism.append("age_gt_1y")
+            rec.update({"bulk_gsm": b.gsm, "bulk_title": b.Sample_title, "bulk_library": b.bulk_library,
+                        "bulk_subject_raw": b.ch_subject, "bulk_batch": b.ch_batch, "sex_geo_bulk": b.ch_Sex,
+                        "age_geo_bulk": b.ch_age, "steroid_bulk": b.ch_steroid, "regimen_bulk": b.ch_treatment,
+                        "id_match": ("exact_subject_id" if b.ch_subject == g.patient else "zero_padding_difference"),
+                        "metadata_mismatch_fields": ";".join(mism), "metadata_notes": "; ".join(notes)})
+            used_bulk[b.gsm].append(g.gsm)
+        rows.append(rec)
+    table = pd.DataFrame(rows)
+    table["candidate"] = table.bulk_gsm.notna()
+    multi = {b: s for b, s in used_bulk.items() if len(s) > 1}
+    table["sc_libraries_for_this_bulk"] = table.bulk_gsm.map(lambda b: len(used_bulk.get(b, [])) if isinstance(b, str) else 0)
+    table["paired"] = table.candidate & (table.metadata_mismatch_fields.fillna("") == "") & (table.sc_libraries_for_this_bulk == 1)
+    reasons = []
+    for _, r in table.iterrows():
+        if r.paired:
+            reasons.append("")
+        elif not r.candidate:
+            have = bulk[bulk.patient == r.patient].ch_time.tolist()
+            reasons.append(f"no bulk for {r.patient} at {r.timepoint}; bulk timepoints of this patient: "
+                           f"{','.join(have) if have else 'none (patient absent from GSE287540)'}")
+        elif r.metadata_mismatch_fields:
+            reasons.append("metadata mismatch: " + r.metadata_mismatch_fields)
+        else:
+            reasons.append("bulk matched by >1 sc library")
+    table["unpaired_reason"] = reasons
+    table.to_csv(out / "sc_gex_libraries_with_bulk_match.csv", index=False)
+    paired_bulk = set(table[table.paired].bulk_gsm)
+    ub = bulk[~bulk.gsm.isin(paired_bulk)].copy()
+    sc_keys = set(gex.key)
+    sc_patients = set(gex.patient)
+    ub["reason"] = [("sc library exists for this key but pairing was refused" if k in sc_keys else
+                     f"no sc library at {tp}; sc timepoints of this patient: "
+                     f"{','.join(sorted(gex[gex.patient == p].ch_time)) if p in sc_patients else 'none (patient absent from GSE287541)'}")
+                    for k, p, tp in zip(ub.key, ub.patient, ub.ch_time)]
+    ub[["gsm", "Sample_title", "bulk_library", "ch_subject", "patient", "ch_group", "ch_time", "ch_Sex", "ch_age",
+        "ch_treatment", "ch_steroid", "ch_batch", "reason"]].to_csv(out / "bulk_without_sc.csv", index=False)
+    p = table[table.paired]
+    summary = {"bulk_gsms": len(bulk), "bulk_subjects": int(bulk.patient.nunique()), "sc_gsms_total": len(sc),
+               "sc_gex_gsms": len(gex), "sc_tcr_gsms": len(tcr), "sc_gex_patients": int(gex.patient.nunique()),
+               "sc_gex_patient_visits": int(gex.PID_visit.nunique()),
+               "tcr_library_keys_equal_gex": sorted(tcr.library_key) == sorted(gex.library_key),
+               "pairs_total": int(len(p)), "pairs_patients": int(p.patient.nunique()),
+               "pairs_by_timepoint": p.timepoint.value_counts().to_dict(),
+               "pairs_by_outcome": p.outcome.value_counts().to_dict(),
+               "pairs_by_id_match": p.id_match.value_counts().to_dict(),
+               "pairs_per_patient": p.patient.value_counts().value_counts().sort_index().to_dict(),
+               "pairs_with_metadata_notes": p[p.metadata_notes != ""][["sample_id", "metadata_notes"]].to_dict("records"),
+               "bulk_matched_by_multiple_sc": multi,
+               "sc_without_bulk": table[~table.paired][["library_key", "sc_gsm", "sample_id", "unpaired_reason"]].to_dict("records"),
+               "bulk_without_sc": int(len(ub)),
+               "bulk_without_sc_by_timepoint": ub.ch_time.value_counts().to_dict(),
+               "rule": ("Pair = same patient AND same GEO timepoint label. Patient = GEO 'subject' (bulk: 'N064'; sc: the "
+                        "N### prefix of PID_visit 'N064V01'), zero-padded to 3 digits (bulk writes N87/N96 for N087/N096). "
+                        "Timepoint = GEO 'time' (BC/AC/TOL/FU1/FU2; for sc also equal to the Seurat per-cell Time). "
+                        "An accepted pair must also agree on GEO sex, outcome group (chili/control) and ICI regimen, and "
+                        "age within 1 year (differences recorded); steroid-status differences are recorded, not refused. "
+                        "A bulk sample may pair with only one sc library. TCR GSMs are separate V(D)J libraries and are not paired.")}
+    qc_core._write_json(out / "PAIRING_SUMMARY.json", summary)
+    log({"stage": "pairing", **{k: summary[k] for k in ("pairs_total", "pairs_patients", "pairs_by_timepoint", "pairs_by_id_match")}})
+
+
+# ----------------------------------------------------------------- bulk
+def cmd_bulk(_args) -> None:
+    import qc_bulk
+    verify_bundle()
+    mapper = qc_genes.GeneMapper(REFERENCE)
+    meta = pd.read_csv(RUN / "pairing/GSE287540_samples.csv", dtype=str, keep_default_na=False)
+    meta["bulk_library"] = meta.Sample_description.str.extract(r"^Library name: (itox\d+)$")[0]
+    lib2 = meta.set_index("bulk_library")
+    header = qc_bulk.read_original_header(BULK_TABLE)
+    frame = qc_bulk.load_table(BULK_TABLE, dtype={header[0]: str})
+    ids = frame.iloc[:, 0].astype(str)
+    if not ids.is_unique:
+        raise RuntimeError("Duplicate gene IDs in bulk table")
+    values = qc_bulk.numeric_values(frame.iloc[:, 1:])  # samples x genes, float64, unchanged
+    libraries = list(frame.columns[1:])
+    records = []
+    for s, lib in enumerate(libraries):
+        g = lib2.loc[lib]
+        v = values[s]
+        records.append((g.Sample_title, ids.tolist(), None, v,
+                        {"GSM": g.gsm, "bulk_library": lib, "subject": g.ch_subject, "time": g.ch_time,
+                         "group": g.ch_group, "batch": g.ch_batch, "library_total": float(v.sum()),
+                         "fractional_values": int(np.sum(v != np.trunc(v)))}))
+    (RUN / "bulk").mkdir(exist_ok=True)
+    np.savez_compressed(RUN / "bulk/bulk_source_counts.npz", gene_ids=ids.to_numpy().astype(str),
+                        sample_ids=np.asarray([r[0] for r in records]), gsm=np.asarray([r[4]["GSM"] for r in records]),
+                        library=np.asarray(libraries), counts=values)
+    fractional = int(np.sum(values != np.trunc(values)))
+    assay = qc_bulk.from_assembled(
+        "GSE287540", "GSE287540_salmon_counts", UNITS_BULK, records,
+        declared_raw_counts=True, sources=[BULK_TABLE],
+        caveats=["GEO/paper: RNA from WHOLE BLOOD in PAXgene tubes (PAXgene Blood RNA Kit), not PBMC; "
+                 "Lexogen QuantSeq 3' mRNA-Seq FWD (100 ng), NextSeq 2000; Salmon 1.10.0 to GRCh38.p14 / Ensembl 110; "
+                 "GEO: 'Ensembl gene ID by sample matrix of raw counts'.",
+                 f"Values are Salmon estimated read counts as deposited; {fractional} of {values.size} values are "
+                 "fractional (the deposited table is integer-valued); no rounding or other change was applied.",
+                 "Bulk-to-single-cell pairing is by GEO patient ID and timepoint label; see pairing/."],
+        extra={"source_format": "single tab-separated gene x library matrix (library names itoxNNNNNN)",
+               "fractional_values": fractional, "n_values": int(values.size)})
+    report = qc_bulk.harmonize(assay, mapper, RUN / "bulk" / assay.assay_id)
+    log({"stage": "bulk", "status": report["status"], "n_samples": report["n_samples"],
+         "raw_count_eligible": report["raw_count_eligible"], "canonical_coverage": report["canonical_coverage"],
+         "fractional_values": fractional})
+
+
+# ----------------------------------------------------------------- single cell
+def process_library(row: dict) -> dict:
+    import qc_singlecell as qs
+    import scipy.io._fast_matrix_market as fmm
+    from scipy.io import mmread
+
+    fmm.PARALLELISM = 1  # single-threaded MTX reader (host CPU budget)
+    qs.COUNT_SOURCE_EVIDENCE["GSE287541"] = COUNT_EVIDENCE  # provenance string only
+    gsm, key = row["sc_gsm"], row["library_key"]
+    lib_dir = EXPORT / key
+    out = RUN / "singlecell" / gsm
+    out.mkdir(parents=True, exist_ok=True)
+    summary_path = out / "summary.json"
+    if summary_path.exists() and json.loads(summary_path.read_text()).get("status") == "PASS":
+        return json.loads(summary_path.read_text())
+    item = {"accession": "GSE287541", "library_id": gsm, "path": str(lib_dir / "matrix.mtx.gz"), "format": "mtx",
+            "duplicate_representation": False, "features_path": str(EXPORT / "features.tsv.gz"),
+            "barcodes_path": str(lib_dir / "barcodes.tsv.gz")}
+    summary = {**item, "library_key": key, "sample_id": row["sample_id"], "status": "RUNNING",
+               "output_dir": str(out), "started": now()}
+    qc_core._write_json(summary_path, summary)
+    t0 = time.time()
+    try:
+        mapper = qc_genes.GeneMapper(REFERENCE)
+        ids, symbols, cells, rna, axes = qs.read_axes(item)
+        item["matrix_path"] = axes["matrix_path"]
+        mapping = mapper.map_features(ids, symbols)
+        mapping_summary = mapper.write_rows(mapping, out / "gene_mapping")
+        mito = np.asarray([r["mitochondrial"] for r in mapping])
+        n = len(cells)
+        if len(set(cells)) != n:
+            raise qs.QCError("Duplicate barcodes within library")
+        cm = pd.read_csv(EXPORT / "cell_metadata.csv.gz", dtype=str, keep_default_na=False,
+                         usecols=["cell", "library_key", "raw_barcode", "PID_visit"])
+        cm = cm[cm.library_key == key].set_index("cell")
+        if list(cm.index) != list(cells):
+            raise qs.QCError("Barcode order differs from the exported cell metadata")
+        obs = pd.DataFrame({"barcode": cells, "source_barcode": cm.raw_barcode.to_numpy(), "raw_10x_barcode": cm.raw_barcode.to_numpy(),
+                            "author_cell_id": cells, "library_id": gsm, "donor_id": row["patient"],
+                            "sample_id": row["sample_id"], "visit_id": row["PID_visit"], "author_retained": "true",
+                            "mapping_basis": "one 10x library per GEO GPEX GSM; author cell name prefix <round>_<PID_visit>",
+                            "protocol": "10x_5prime_GEX"})
+        obs.to_csv(out / "cell_metadata.csv.gz", index=False, compression="gzip")
+        metrics = out / "metrics"
+        if (metrics / "qc_summary.json").exists():
+            qc = json.loads((metrics / "qc_summary.json").read_text())
+        else:
+            qc = qc_core.scan_mtx(item["path"], metrics, mito_mask=mito, feature_mask=rna,
+                                  sample_ids=obs.sample_id.to_numpy(), feature_ids=ids,
+                                  feature_symbols=symbols, cell_ids=cells)
+        total = np.load(metrics / "cell_total.npy")
+        detected = np.load(metrics / "cell_detected.npy")
+        mito_pct = np.load(metrics / "cell_mito_percent.npy")
+        pd.DataFrame([{"min_genes": g, "min_abundance": 500, "max_mito_percent": m,
+                       "n_review_pass": int(((detected >= g) & (total >= 500) & (mito_pct <= m)).sum())}
+                      for g in (100, 200, 500) for m in (10, 20, 30)]).to_csv(out / "threshold_sensitivity.csv", index=False)
+        integral = qc["numeric"]["integer_fraction_selected_stored"] == 1
+        item["source_sha256"] = qc["input"].get("sha256", "")
+        item["canonical_identity_sha256"] = mapper.manifest.get("canonical_identity_sha256", "")
+        verified = bool(integral)
+        units = "UMI_counts" if verified else "nonnegative_abundance_source_units_unproven"
+        export = qs.canonical_export(item, out, mapping, mapper.canonical, obs, rna,
+                                     verified_counts=verified, units=units, full_mapping=True)
+        qcpass = np.load(metrics / "flag_conservative_review_pass.npy")
+        matrix = mmread(item["path"]).tocsc()
+        if matrix.shape != (len(ids), n):
+            raise qs.QCError("MTX shape changed")
+        all_sum = np.asarray(matrix.sum(axis=1)).ravel()
+        pass_sum = np.asarray(matrix[:, np.flatnonzero(qcpass)].sum(axis=1)).ravel()
+        if not np.isclose(all_sum[rna].sum(), total.sum(), rtol=1e-12):
+            raise qs.QCError("Source-axis sum differs from QC scan")
+        np.savez_compressed(out / "source_axis_pseudobulk.npz", feature_ids=np.asarray(ids),
+                            feature_symbols=np.asarray(symbols), rna=rna, all_cells_sum=all_sum,
+                            qc_pass_sum=pass_sum, n_cells=n, n_qc_pass=int(qcpass.sum()))
+        where = {g: i for i, g in enumerate(ids)}
+        sex_rows = [where.get(g, -1) for g in SEX_GENES.values()]
+        per_cell = np.zeros((len(SEX_GENES), n), dtype=np.float64)
+        csr = matrix.tocsr()
+        for k, r in enumerate(sex_rows):
+            if r >= 0:
+                per_cell[k] = csr[r].toarray().ravel()
+        np.savez_compressed(out / "cell_sex_gene_counts.npz", genes=np.asarray(list(SEX_GENES)),
+                            gene_ids=np.asarray(list(SEX_GENES.values())), found=np.asarray(sex_rows) >= 0,
+                            counts=per_cell)
+        del matrix, csr
+        author = {"cells": n, "genes_le_200": int((detected <= 200).sum()), "genes_ge_5000": int((detected >= 5000).sum()),
+                  "mito_ge_5": int((mito_pct >= 5).sum()), "counts_lt_500": int((total < 500).sum()),
+                  "min_genes": int(detected.min()), "max_genes": int(detected.max()), "min_counts": float(total.min()),
+                  "max_mito_pct": float(mito_pct.max())}
+        summary.update({"status": "PASS", "n_cells": n, "n_features": len(ids),
+                        "n_rna_features": int(rna.sum()), "n_qc_review_pass": int(qcpass.sum()),
+                        "flag_counts": qc["flag_counts"], "numeric": qc["numeric"], "units": units,
+                        "count_space_verified": verified, "count_provenance": COUNT_EVIDENCE,
+                        "canonicalcoverage": mapping_summary, "canonical_export": export,
+                        "author_prefilter_evidence": author, "seconds": round(time.time() - t0, 1),
+                        "finished": now()})
+    except Exception as error:  # noqa: BLE001 - recorded, not hidden
+        summary.update({"status": "QUARANTINED", "error_type": type(error).__name__, "error": str(error)})
+    qc_core._write_json(summary_path, summary)
+    return summary
+
+
+def cmd_sc(args) -> None:
+    verify_bundle()
+    table = pd.read_csv(RUN / "pairing/sc_gex_libraries_with_bulk_match.csv", dtype=str, keep_default_na=False)
+    rows = table.to_dict("records")
+    if args.gsm:
+        rows = [r for r in rows if r["sc_gsm"] in set(args.gsm.split(","))]
+    if args.limit:
+        rows = rows[:args.limit]
+    log({"stage": "sc", "event": "start", "n_libraries": len(rows), "workers": args.workers})
+    done = []
+    with ProcessPoolExecutor(max_workers=args.workers, max_tasks_per_child=1) as pool:
+        futures = {pool.submit(process_library, r): r["sc_gsm"] for r in rows}
+        for future in as_completed(futures):
+            s = future.result()
+            done.append(s)
+            log({"stage": "sc", "library": futures[future], "status": s["status"], "n_cells": s.get("n_cells"),
+                 "n_qc_review_pass": s.get("n_qc_review_pass"), "seconds": s.get("seconds"), "error": s.get("error")})
+    if not args.gsm and not args.limit:
+        qc_core._write_json(RUN / "singlecell/SINGLECELL_SUMMARY.json",
+                            {"created_at_utc": now(), "libraries": sorted(done, key=lambda s: s["library_id"])})
+    log({"stage": "sc", "event": "finish", "pass": sum(s["status"] == "PASS" for s in done), "n": len(done)})
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    sub = parser.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("sources")
+    sub.add_parser("pairing")
+    sub.add_parser("bulk")
+    p = sub.add_parser("sc")
+    p.add_argument("--workers", type=int, default=3)
+    p.add_argument("--limit", type=int, default=0)
+    p.add_argument("--gsm", default="", help="comma-separated GSM subset")
+    args = parser.parse_args()
+    RUN.mkdir(parents=True, exist_ok=True)
+    {"sources": cmd_sources, "pairing": cmd_pairing, "bulk": cmd_bulk, "sc": cmd_sc}[args.cmd](args)
+
+
+if __name__ == "__main__":
+    main()