Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/tools/deconv_strict.py

@@ -0,0 +1,838 @@
+#!/usr/bin/env python3
+"""Exact-support BayesPrism/CIBERSORTx adapter for one strict disease unit.
+
+CPU only. Each invocation is an isolated process; legacy modules are imported
+unchanged and their output root and split function are patched in memory.
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import importlib
+import json
+import os
+import re
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+for key in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS"):
+    os.environ.setdefault(key, "4")
+
+import numpy as np  # noqa: E402
+import pandas as pd  # noqa: E402
+
+PLAN = Path(__file__).resolve().parents[1]
+OLD = PLAN.parent / "bayesprism_paired_20261006"
+OLD_TOOLS = OLD / "tools"
+KEY = Path("/home/sj_server_1/cibersortx.key")
+GUARD = Path("/home/sj_server_1/.local/libexec/ml-memory-guard")
+SPLIT = "fewshot0"
+sys.path.insert(0, str(OLD_TOOLS))
+
+
+def sha(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def host_preflight() -> None:
+    """Host-wide GB10 guard checks before memory-heavy CPU preparation or methods."""
+    active = subprocess.run(["systemctl", "--user", "is-active", "ml-memory-guard.service"],
+                            capture_output=True, text=True)
+    if active.returncode or active.stdout.strip() != "active":
+        subprocess.run(["systemctl", "--user", "restart", "ml-memory-guard.service"], check=True)
+        active = subprocess.run(["systemctl", "--user", "is-active", "ml-memory-guard.service"],
+                                capture_output=True, text=True)
+        if active.returncode or active.stdout.strip() != "active":
+            raise RuntimeError("ml-memory-guard.service is inactive after restart")
+    subprocess.run([str(GUARD), "--check"], check=True)
+    apps = subprocess.run(["nvidia-smi", "--query-compute-apps=pid,process_name,used_memory", "--format=csv,noheader"],
+                          check=True, capture_output=True, text=True)
+    if apps.stdout.strip():
+        raise RuntimeError("a CUDA compute job is active; queue this memory-heavy CPU unit until it completes")
+    available_kib = next(int(line.split()[1]) for line in Path("/proc/meminfo").read_text().splitlines()
+                         if line.startswith("MemAvailable:"))
+    if available_kib < 48 * 1024 * 1024:
+        raise RuntimeError("less than 48 GiB MemAvailable; defer the memory-heavy deconvolution unit")
+
+
+def validate_support_data(s: dict) -> dict:
+    body = {k: v for k, v in s.items() if k != "sha256"}
+    digest = hashlib.sha256(json.dumps(body, sort_keys=True, separators=(",", ":"), allow_nan=False).encode()).hexdigest()
+    if s.get("schema") != "pbisc.paper.strict-support.v1" or s.get("sha256") != digest:
+        raise ValueError("strict support schema or hash mismatch")
+    train, test = s.get("train_sample_ids", []), s.get("test_sample_ids", [])
+    td, vd = s.get("train_donor_ids", []), s.get("test_donor_ids", [])
+    if not train or not test or len(train) != len(td) or len(test) != len(vd):
+        raise ValueError("strict support requires aligned sample and donor IDs")
+    if len(set(train)) != len(train) or len(set(test)) != len(test) or len(set(td)) != len(td):
+        raise ValueError("duplicate strict reference or mixture identity")
+    if set(td) & set(vd) or set(train) & set(test):
+        raise ValueError("reference and mixture donors/samples overlap")
+    if s["cohort"] not in {"ye2026_sepsis", "ji2025_chili", "imperial_eskd", "giroux2022"}:
+        raise ValueError("deconvolution supports disease cohorts only")
+    if s.get("design") != "disease_existing_draw" or not re.fullmatch(r"draw[0-4]_n5", str(s.get("unit", ""))):
+        raise ValueError("deconvolution requires a canonical disease draw unit")
+    if s["n_pairs"] != 5 or len(s["train_sample_ids"]) != 5:
+        raise ValueError("deconvolution requires exact five-pair support")
+    if set(s["excluded_sample_ids"]) & (set(s["train_sample_ids"]) | set(s["test_sample_ids"])):
+        raise ValueError("excluded visits entered the reference or mixture")
+    return s
+
+
+def support(path: Path) -> dict:
+    s = validate_support_data(json.loads(path.read_text()))
+    draw = s["unit"].replace("_n5", "")
+    canonical = PLAN / "protocol" / "splits" / s["cohort"] / "disease" / draw / "support.json"
+    if path.resolve() != canonical.resolve() or not canonical.is_file():
+        raise ValueError("support manifest must be the canonical protocol file")
+    return s
+
+
+def unit_out(s: dict, out: Path | None) -> Path:
+    validate_support_data(s)
+    expected = (PLAN / "deconvolution" / s["cohort"] / "disease" /
+                s["unit"].replace("_n5", "")).resolve()
+    if not expected.is_relative_to((PLAN / "deconvolution").resolve()):
+        raise ValueError("unit output escapes deconvolution directory")
+    chosen = (out or expected).resolve()
+    if chosen != expected:
+        raise ValueError(f"--out must be the strict unit output: {expected}")
+    return chosen
+
+
+def strict_split(s: dict) -> dict:
+    return {"reference": list(s["train_sample_ids"]), "mixture": list(s["test_sample_ids"]),
+            "train_donors": list(s["train_donor_ids"]), "excluded_samples": list(s["excluded_sample_ids"]),
+            "support_sha256": s["sha256"], "run_json_check": "strict_manifest"}
+
+
+def bind(s: dict, out: Path) -> None:
+    out.mkdir(parents=True, exist_ok=True)
+    p = out / "SUPPORT.json"
+    if p.exists() and json.loads(p.read_text()) != {
+        "support_sha256": s["sha256"], "reference": s["train_sample_ids"],
+        "mixture": s["test_sample_ids"], "excluded": s["excluded_sample_ids"]}:
+        raise ValueError("output directory is bound to another strict support")
+    p.write_text(json.dumps({"support_sha256": s["sha256"], "reference": s["train_sample_ids"],
+                             "mixture": s["test_sample_ids"], "excluded": s["excluded_sample_ids"]}, indent=2) + "\n")
+
+
+def patched_modules(s: dict, out: Path):
+    C = importlib.import_module("common")
+    C.PLAN = out
+    C.split_rows = lambda ds, kind, idx: strict_split(s) if (ds, kind, idx) == (s["cohort"], "fewshot", 0) else (_ for _ in ()).throw(ValueError("unexpected split"))
+    return C
+
+
+def prepare(s: dict, out: Path) -> dict:
+    bind(s, out)
+    previous = out / "INPUTS.json"
+    if previous.exists():
+        return require_inputs(s, out)
+    method_dirs = [out / "inputs" / s["cohort"] / "fewshot0_full" / "bp",
+                   out / "cibersortx" / s["cohort"] / SPLIT / "out_fractions",
+                   out / "cibersortx" / s["cohort"] / SPLIT / "out_hires"]
+    if any(d.is_dir() and any(d.iterdir()) for d in method_dirs):
+        raise ValueError("existing method output has no prepared-input receipt; refusing to rewrite inputs")
+    C = patched_modules(s, out)
+    ds = s["cohort"]
+    aggregate = OLD / "data" / ds / "aggregates_full.npz"
+    if not aggregate.is_file():
+        raise FileNotFoundError(f"read-only raw-count aggregate missing: {aggregate}")
+    link = out / "data" / ds / "aggregates_full.npz"
+    link.parent.mkdir(parents=True, exist_ok=True)
+    if link.is_symlink() and link.resolve() != aggregate.resolve():
+        raise ValueError("aggregate link points to a different source")
+    if link.exists() and (not link.is_symlink() or link.resolve() != aggregate.resolve()):
+        raise ValueError("aggregate destination is not the read-only legacy link")
+    if not link.exists():
+        link.symlink_to(aggregate)
+    bp = importlib.import_module("build_split")
+    bp.main([ds, "fewshot", "0", "full"])
+    cx = importlib.import_module("build_cibersortx_inputs")
+    cx.SPLITS = [("fewshot", 0)]
+    cx.main([ds])
+    bdir = out / "inputs" / ds / "fewshot0_full"
+    cdir = out / "cibersortx" / ds / SPLIT
+    b = json.loads((bdir / "SPLIT.json").read_text())
+    c = json.loads((cdir / "INPUT.json").read_text())
+    if b["reference"] != s["train_sample_ids"] or b["mixture"] != s["test_sample_ids"]:
+        raise ValueError("BayesPrism input rows differ from strict support")
+    if c["reference_samples"] != s["train_sample_ids"] or c["mixture_samples"] != s["test_sample_ids"]:
+        raise ValueError("CIBERSORTx input rows differ from strict support")
+    rec = {"schema": "pbisc.deconvolution.strict-inputs.v1", "support_sha256": s["sha256"],
+           "reference_sample_ids": s["train_sample_ids"], "mixture_sample_ids": s["test_sample_ids"],
+           "excluded_sample_ids": s["excluded_sample_ids"], "aggregate_source": str(aggregate),
+           "aggregate_sha256": sha(aggregate), "bayesprism_split_sha256": sha(bdir / "SPLIT.json"),
+           "cibersortx_input_sha256": sha(cdir / "INPUT.json"), "adapter_sha256": sha(Path(__file__))}
+    (out / "INPUTS.json").write_text(json.dumps(rec, indent=2) + "\n")
+    return rec
+
+
+def require_inputs(s: dict, out: Path) -> dict:
+    rec = json.loads((out / "INPUTS.json").read_text())
+    if (rec["support_sha256"] != s["sha256"] or rec["reference_sample_ids"] != s["train_sample_ids"]
+            or rec["mixture_sample_ids"] != s["test_sample_ids"]
+            or rec["excluded_sample_ids"] != s["excluded_sample_ids"]):
+        raise ValueError("prepared inputs differ from strict support")
+    aggregate = Path(rec["aggregate_source"])
+    link = out / "data" / s["cohort"] / "aggregates_full.npz"
+    if not link.is_symlink() or link.resolve() != aggregate.resolve():
+        raise ValueError("read-only raw-count aggregate link changed after preparation")
+    if sha(aggregate) != rec["aggregate_sha256"]:
+        raise ValueError("read-only raw-count aggregate changed after preparation")
+    if sha(out / "inputs" / s["cohort"] / "fewshot0_full" / "SPLIT.json") != rec["bayesprism_split_sha256"]:
+        raise ValueError("BayesPrism split manifest changed after preparation")
+    if sha(out / "cibersortx" / s["cohort"] / SPLIT / "INPUT.json") != rec["cibersortx_input_sha256"]:
+        raise ValueError("CIBERSORTx input manifest changed after preparation")
+    bdir = out / "inputs" / s["cohort"] / "fewshot0_full"
+    cdir = out / "cibersortx" / s["cohort"] / SPLIT
+    for directory, filename, field in ((bdir, "SPLIT.json", "files"), (cdir, "INPUT.json", "files")):
+        entries = json.loads((directory / filename).read_text())[field]
+        for name, digest in entries.items():
+            if sha(directory / name) != digest:
+                raise ValueError(f"prepared input changed: {directory / name}")
+    return rec
+
+
+def stage_dir(s: dict, out: Path, stage: str) -> Path:
+    if stage == "bayesprism":
+        return out / "inputs" / s["cohort"] / "fewshot0_full" / "bp"
+    if stage in {"fractions", "hires"}:
+        return out / "cibersortx" / s["cohort"] / SPLIT / f"out_{stage}"
+    raise ValueError(f"unknown method stage {stage}")
+
+
+def stage_outputs(s: dict, out: Path, stage: str) -> list[Path]:
+    d = stage_dir(s, out, stage)
+    if stage == "bayesprism":
+        zfiles = sorted(d.glob("Z_type_*.tsv.gz"))
+        if not zfiles:
+            raise FileNotFoundError("BayesPrism type expression Z files missing")
+        files = [d / "theta_final.csv", d / "theta_first.csv", d / "genes_used.txt", *zfiles]
+    elif stage == "fractions":
+        files = [d / "CIBERSORTx_Adjusted.txt"]
+        if len(s["test_sample_ids"]) > 8:
+            sig = next(iter(sorted(d.glob("*inferred_refsample.bm.K999.txt"))), None)
+            if sig is None:
+                raise FileNotFoundError("CIBERSORTx Fractions HiRes signature missing")
+            files.extend([sig, d / "CIBERSORTx_cell_type_sourceGEP.txt"])
+    else:
+        files = []
+        for typ in ("T cell", "B cell", "Monocyte", "NK cell"):
+            f = next(iter(sorted(d.glob(f"CIBERSORTxHiRes_*_{typ.replace(' ', '')}_Window*.txt"))), None)
+            if f is None:
+                raise FileNotFoundError(f"CIBERSORTx HiRes required type output missing: {typ}")
+            files.append(f)
+        files.extend(p for p in sorted(d.glob("CIBERSORTxHiRes_*.txt")) if p not in files)
+    if not files or any(not f.is_file() for f in files):
+        raise FileNotFoundError(f"{stage} required output missing")
+    return files
+
+
+def stage_input_hashes(s: dict, out: Path, stage: str) -> dict[str, str]:
+    hashes = {"prepared_inputs": sha(out / "INPUTS.json")}
+    if stage == "hires":
+        d = out / "cibersortx" / s["cohort"] / SPLIT
+        files = [d / "out_fractions" / "RECEIPT.json", d / "sigmatrix.txt",
+                 d / "source_geps.txt", d / "out_hires" / "fractions_results.txt"]
+        if any(not f.is_file() for f in files):
+            raise FileNotFoundError("HiRes source inputs or Fractions receipt missing")
+        hashes.update({str(f.relative_to(d)): sha(f) for f in files})
+    return hashes
+
+
+def write_stage_receipt(s: dict, out: Path, stage: str) -> None:
+    require_inputs(s, out)
+    d = stage_dir(s, out, stage)
+    if not (d / "DONE").is_file():
+        raise FileNotFoundError(f"{stage} completion marker missing")
+    files = stage_outputs(s, out, stage)
+    receipt = {"schema": "pbisc.deconvolution.method-receipt.v1", "stage": stage,
+               "support_sha256": s["sha256"], "input_hashes": stage_input_hashes(s, out, stage),
+               "outputs_sha256": {f.name: sha(f) for f in files}}
+    (d / "RECEIPT.json").write_text(json.dumps(receipt, indent=2) + "\n")
+
+
+def verify_stage_receipt(s: dict, out: Path, stage: str) -> dict:
+    require_inputs(s, out)
+    d = stage_dir(s, out, stage)
+    if not (d / "DONE").is_file():
+        raise FileNotFoundError(f"{stage} completion marker missing")
+    p = d / "RECEIPT.json"
+    if not p.is_file():
+        raise ValueError(f"{stage} has DONE without a support/input-bound receipt")
+    rec = json.loads(p.read_text())
+    expected = {"schema": "pbisc.deconvolution.method-receipt.v1", "stage": stage,
+                "support_sha256": s["sha256"], "input_hashes": stage_input_hashes(s, out, stage),
+                "outputs_sha256": {f.name: sha(f) for f in stage_outputs(s, out, stage)}}
+    if rec != expected:
+        raise ValueError(f"{stage} receipt differs from prepared inputs or method outputs")
+    return rec
+
+
+def method_output_hashes(s: dict, out: Path, method: str) -> dict[str, str]:
+    """Fail closed on extra or missing mixtures; hash every output used by scoring."""
+    ds = s["cohort"]
+    if method == "bayesprism":
+        d = out / "inputs" / ds / "fewshot0_full" / "bp"
+        primary = d / "theta_final.csv"
+        files = [primary, d / "theta_first.csv", *sorted(d.glob("Z_type_*.tsv.gz"))]
+        if not (d / "DONE").is_file():
+            raise FileNotFoundError("BayesPrism DONE missing")
+        samples = pd.read_csv(primary, index_col=0).index.astype(str).tolist()
+    else:
+        d = out / "cibersortx" / ds / SPLIT
+        primary = d / "out_fractions" / "CIBERSORTx_Adjusted.txt"
+        files = [primary, *sorted((d / "out_hires").glob("CIBERSORTxHiRes_*.txt"))]
+        if not (d / "out_fractions" / "DONE").is_file():
+            raise FileNotFoundError("CIBERSORTx Fractions DONE missing")
+        samples = pd.read_csv(primary, sep="\t", index_col=0).index.astype(str).tolist()
+    if len(samples) != len(s["test_sample_ids"]) or set(samples) != set(s["test_sample_ids"]):
+        raise ValueError(f"{method} output mixtures differ from strict support")
+    return {str(p): sha(p) for p in files}
+
+
+def bayesprism(s: dict, out: Path, threads: int) -> None:
+    require_inputs(s, out)
+    split = out / "inputs" / s["cohort"] / "fewshot0_full"
+    if (split / "bp" / "DONE").is_file():
+        verify_stage_receipt(s, out, "bayesprism")
+        return
+    if (split / "bp").is_dir() and any((split / "bp").iterdir()):
+        raise ValueError("partial BayesPrism output exists without a completion receipt")
+    subprocess.run(["/home/sj_server_1/miniforge3/bin/Rscript", str(OLD_TOOLS / "run_bp.R"), str(split), str(threads)],
+                   check=True, env={**os.environ, "CUDA_VISIBLE_DEVICES": ""})
+    if not (split / "bp" / "DONE").is_file():
+        raise RuntimeError("BayesPrism completion marker missing")
+    write_stage_receipt(s, out, "bayesprism")
+
+
+def credentials(path: Path) -> tuple[str, str]:
+    txt = path.read_text()
+    user = re.search(r"(?im)^\s*(?:email|username|user)\s*[:=]\s*(\S+)", txt)
+    token = re.search(r"(?im)^\s*token\s*[:=]\s*(\S+)", txt)
+    bare = [x.strip() for x in txt.splitlines() if x.strip() and not re.match(r"(?i)^\s*(email|username|user)\s*[:=]", x)]
+    value = token.group(1) if token else (bare[0] if len(bare) == 1 and re.fullmatch(r"[0-9a-fA-F]{20,}", bare[0]) else None)
+    if not user or not value:
+        raise ValueError("CIBERSORTx credential file lacks email or token")
+    return user.group(1), value
+
+
+def cx_argv(image: str, binary: str, work: Path, dest: Path, env_file: Path,
+            threads: int, flags: list[str]) -> list[str]:
+    """Credentials expand only inside the container and never enter host argv."""
+    script = f'exec ./{binary} --username "$CX_USER" --token "$CX_TOKEN" "$@"'
+    return ["docker", "run", "--rm", "--ulimit", "core=0", "--platform", "linux/amd64",
+            "--memory=16g", "--memory-swap=16g", f"--cpus={threads}", "--env-file", str(env_file),
+            "-v", f"{work}:/src/data:ro", "-v", f"{dest}:/src/outdir", "--entrypoint", "/bin/bash",
+            image, "-c", script, "_", *flags]
+
+
+def run_cx(argv: list[str], log: Path, user: str, token: str) -> None:
+    log.parent.mkdir(parents=True, exist_ok=True)
+    with log.open("w") as f, subprocess.Popen(argv, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                                               text=True, bufsize=1) as p:
+        assert p.stdout is not None
+        for line in p.stdout:
+            line = line.replace(user, "[REDACTED]").replace(token, "[REDACTED]")
+            line = re.sub(r"(?i)^(>\[Options\]\s*(?:token|username)[^:]*:).*", r"\1 [REDACTED]", line)
+            f.write(line)
+        if p.wait() != 0:
+            raise RuntimeError(f"CIBERSORTx failed; see redacted log {log}")
+    if "Abort!" in log.read_text():
+        raise RuntimeError(f"CIBERSORTx aborted; see redacted log {log}")
+
+
+def cibersortx(s: dict, out: Path, threads: int) -> dict:
+    require_inputs(s, out)
+    d = out / "cibersortx" / s["cohort"] / SPLIT
+    meta = json.loads((d / "INPUT.json").read_text())
+    if meta["mixture_samples"] != s["test_sample_ids"]:
+        raise ValueError("CIBERSORTx mixture differs from strict support")
+    images = ["cibersortx/fractions:latest"]
+    if len(s["test_sample_ids"]) > 8:
+        images.append("cibersortx/hires:latest")
+    for image in images:
+        subprocess.run(["docker", "image", "inspect", image], stdout=subprocess.DEVNULL, check=True)
+    user, token = credentials(KEY)
+    with tempfile.TemporaryDirectory(prefix="cx_env_", dir=out) as tmp:
+        envfile = Path(tmp) / "env"
+        envfile.write_text(f"CX_USER={user}\nCX_TOKEN={token}\n")
+        envfile.chmod(0o600)
+        fd = d / "out_fractions"
+        fd.mkdir(exist_ok=True)
+        if (fd / "DONE").exists():
+            verify_stage_receipt(s, out, "fractions")
+        else:
+            if any(fd.iterdir()):
+                raise ValueError("partial CIBERSORTx Fractions output exists without a completion receipt")
+            flags = ["--single_cell", "TRUE", "--refsample", "refsample.txt", "--mixture", "mixture.txt",
+                     "--rmbatchSmode", "TRUE", "--fraction", "0", "--replicates", "5", "--sampling", "0.5",
+                     "--G.min", "300", "--G.max", "500", "--q.value", "0.01", "--perm", "0", "--QN", "FALSE", "--verbose", "TRUE"]
+            run_cx(cx_argv("cibersortx/fractions:latest", "CIBERSORTxFractions", d, fd, envfile, threads, flags), fd / "run.redacted.log", user, token)
+            if not (fd / "CIBERSORTx_Adjusted.txt").is_file():
+                raise RuntimeError("CIBERSORTx fractions output missing")
+            (fd / "DONE").write_text("ok\n")
+            write_stage_receipt(s, out, "fractions")
+        status = {"fractions": "complete", "hires": "pending"}
+        if len(s["test_sample_ids"]) <= 8:
+            status.update(hires="not_estimable", reason="HiRes needs more than eight mixture samples")
+        else:
+            hd = d / "out_hires"
+            hd.mkdir(exist_ok=True)
+            if (hd / "DONE").exists():
+                verify_stage_receipt(s, out, "hires")
+            else:
+                if any(hd.iterdir()):
+                    raise ValueError("partial CIBERSORTx HiRes output exists without a completion receipt")
+                sig = next(iter(sorted(fd.glob("*inferred_refsample.bm.K999.txt"))), None)
+                src = fd / "CIBERSORTx_cell_type_sourceGEP.txt"
+                res = fd / "CIBERSORTx_Adjusted.txt"
+                if sig is None or not src.is_file() or not res.is_file():
+                    raise RuntimeError("CIBERSORTx Fractions signature/source/results missing for HiRes")
+                (d / "sigmatrix.txt").write_bytes(sig.read_bytes())
+                (d / "source_geps.txt").write_bytes(src.read_bytes())
+                fr = pd.read_csv(res, sep="\t", index_col=0)
+                fr[[c for c in fr if c not in ("P-value", "Correlation", "RMSE")]].to_csv(hd / "fractions_results.txt", sep="\t")
+                flags = ["--mixture", "mixture.txt", "--sigmatrix", "sigmatrix.txt", "--cibresults", "fractions_results.txt",
+                         "--rmbatchSmode", "TRUE", "--sourceGEPs", "source_geps.txt", "--subsetgenes", "hires_genes.txt", "--threads", str(threads)]
+                run_cx(cx_argv("cibersortx/hires:latest", "CIBERSORTxHiRes", d, hd, envfile, threads, flags), hd / "run.redacted.log", user, token)
+                if not list(hd.glob("CIBERSORTxHiRes_*.txt")):
+                    raise RuntimeError("CIBERSORTx HiRes output missing")
+                (hd / "DONE").write_text("ok\n")
+                write_stage_receipt(s, out, "hires")
+            status["hires"] = "complete"
+    (d / "STATUS.json").write_text(json.dumps(status, indent=2) + "\n")
+    return status
+
+
+CONTRAST_GROUPS = {
+    "ye2026_sepsis": ({"adult_sepsis", "ped_sepsis"}, {"adult_HC", "adult_ICU_ctrl", "ped_HC", "ped_ICU_ctrl"}),
+    "ji2025_chili": ({"TOL", "FU1"}, {"BC", "AC"}),
+    "imperial_eskd": ({"covid_positive"}, {"covid_negative"}),
+    "giroux2022": ({"severe"}, {"mild"}),
+}
+
+LIMMA_R = r'''suppressPackageStartupMessages(library(limma))
+args <- commandArgs(trailingOnly=TRUE)
+if (length(args) != 4L) stop("usage: limma.R metadata.csv observed.tsv.gz method.tsv.gz outdir")
+meta <- read.csv(args[1], stringsAsFactors=FALSE)
+out <- args[4]
+dir.create(out, recursive=TRUE, showWarnings=FALSE)
+group <- factor(meta$condition, levels=c("control", "case"))
+design <- model.matrix(~group)
+blocked <- any(table(meta$donor_id) > 1L)
+for (side in c("observed", "method")) {
+  path <- if (side == "observed") args[2] else args[3]
+  tab <- read.delim(gzfile(path), row.names=1, check.names=FALSE)
+  X <- as.matrix(tab)
+  if (ncol(X) != nrow(meta) || nrow(X) < 3L || any(!is.finite(X))) stop("invalid matched expression matrix")
+  if (blocked) {
+    dc <- duplicateCorrelation(X, design, block=meta$donor_id)
+    if (!is.finite(dc$consensus.correlation)) stop("duplicateCorrelation undefined")
+    fit <- lmFit(X, design, block=meta$donor_id, correlation=dc$consensus.correlation)
+  } else fit <- lmFit(X, design)
+  fit <- eBayes(fit)
+  top <- topTable(fit, coef=2L, number=Inf, sort.by="none", adjust.method="BH")
+  top$gene_id <- rownames(top)
+  write.csv(top[,c("gene_id","logFC","P.Value","adj.P.Val")], file.path(out,paste0(side,"_limma.csv")), row.names=FALSE)
+}
+'''
+
+
+def _log2_cpm(x: np.ndarray) -> np.ndarray:
+    x = np.asarray(x, np.float64)
+    lib = x.sum(axis=1, keepdims=True)
+    if not np.isfinite(x).all() or (x < 0).any() or (lib <= 0).any():
+        raise ValueError("nonfinite, negative, or zero-library expression")
+    return np.log2(1 + np.divide(x * 1e6, lib, out=np.zeros_like(x), where=lib > 0))
+
+
+def _collapse_donor_condition(s: dict, case: np.ndarray, ctrl: np.ndarray,
+                              obs: np.ndarray, method: np.ndarray, bulk: np.ndarray) -> tuple[pd.DataFrame, np.ndarray, np.ndarray, np.ndarray]:
+    """Each donor contributes once per condition, regardless of visit count."""
+    donors = np.asarray(s["test_donor_ids"], dtype=str)
+    condition = np.where(case, "case", "control")
+    keys = sorted(set(zip(donors, condition)), key=lambda x: (x[0], x[1]))
+    O, M, U = (_log2_cpm(x) for x in (obs, method, bulk))
+    meta = pd.DataFrame(keys, columns=["donor_id", "condition"])
+    out = []
+    for x in (O, M, U):
+        out.append(np.stack([x[(donors == d) & (condition == c)].mean(axis=0) for d, c in keys]))
+    return meta, *out
+
+
+def _pearson(x: np.ndarray, y: np.ndarray) -> float:
+    if x.size < 3 or np.std(x) == 0 or np.std(y) == 0:
+        return float("nan")
+    return float(np.corrcoef(x, y)[0, 1])
+
+
+def _partial(x: np.ndarray, y: np.ndarray, bulk: np.ndarray) -> float:
+    centered = bulk - bulk.mean()
+    den = float(np.dot(centered, centered))
+    if den == 0:
+        return float("nan")
+    residual = lambda z: z - z.mean() - centered * (np.dot(z - z.mean(), centered) / den)
+    return _pearson(residual(x), residual(y))
+
+
+def _top50(tab: pd.DataFrame) -> set[str]:
+    ok = tab.loc[tab["adj.P.Val"].astype(float) < 0.05].copy()
+    return set(ok.assign(abs_lfc=ok.logFC.abs()).sort_values("abs_lfc", ascending=False).head(50).gene_id.astype(str))
+
+
+def corrected_expression(s: dict, B, v: dict, pred: dict, arm: str, out: Path) -> list[dict]:
+    """Matched donor-aware limma on continuous log2-CPM; never call this voom."""
+    F = B.F
+    C = importlib.import_module("common")
+    ds = s["cohort"]
+    cases, controls = CONTRAST_GROUPS[ds]
+    groups = np.asarray(v["groups"], str)
+    case, ctrl = np.isin(groups, list(cases)), np.isin(groups, list(controls))
+    feat = np.load(C.FT / "data" / ds / "features.npz", allow_pickle=False)
+    fsid = (feat["sample_ids"] if "sample_ids" in feat.files else feat["donor_ids"]).astype(str)
+    sidpos = {x: i for i, x in enumerate(fsid)}
+    genepos = {x: i for i, x in enumerate(feat["gene_ids"].astype(str))}
+    bulk = np.asarray(feat["bulk_raw"], np.float64)[[sidpos[x] for x in s["test_sample_ids"]]][:,
+                                                   [genepos[x] for x in v["score_ids"]]]
+    covered = pred["covered_type"].all(0) if "covered_type" in pred else pred["covered"].all(0)
+    base_keep = np.asarray(v.get("keep", np.ones(len(v["score_ids"]), bool)), bool)
+    rows = []
+    for typ in v["deg_types"]:
+        gi = F.GATE.index(typ)
+        di = v["deg_types"].index(typ)
+        mask = base_keep & (covered[gi] if covered.ndim == 2 else covered)
+        observed = np.asarray(v["deg_sum"][:, di, :], np.float64)
+        method = np.asarray(pred["Z"][:, gi, :], np.float64)
+        mask &= observed.sum(axis=0) > 0
+        mask &= method.sum(axis=0) > 0
+        eligible = (v["deg_n"][:, di] > 0) & (method.sum(axis=1) > 0) & (case | ctrl)
+        donors = np.asarray(s["test_donor_ids"])
+        ncase = len(set(donors[eligible & case]))
+        nctrl = len(set(donors[eligible & ctrl]))
+        common = {"arm": arm, "cell_type": typ, "gene_variant": "donor_covered", "statistic": "limma_log2_cpm",
+                  "n_genes": int(mask.sum()), "n_test_samples": int(eligible.sum()),
+                  "n_independent_donors": len(set(donors[eligible])), "n_case_samples": int((eligible & case).sum()),
+                  "n_control_samples": int((eligible & ctrl).sum()), "n_case_donors": ncase, "n_control_donors": nctrl,
+                  "method_expression_unit": "continuous log2-CPM on matched observed/method profiles",
+                  "deg_method": "limma lmFit/eBayes on donor-condition means; duplicateCorrelation for repeated donor conditions"}
+        metric_names = ("donor_logfc_r", "donor_partial_r_given_bulk", "donor_limma_top50_overlap")
+        if ncase < 2 or nctrl < 2 or mask.sum() < 3:
+            reason = "fewer than two independent donors per group or fewer than three common expressed genes"
+            rows.extend({**common, "metric": m, "value": "", "status": "not_estimable", "reason": reason} for m in metric_names)
+            continue
+        if any(np.any(x[eligible][:, mask].sum(axis=1) <= 0) for x in (observed, method, bulk)):
+            reason = "a matched profile has zero library on common covered genes"
+            rows.extend({**common, "metric": m, "value": "", "status": "not_estimable", "reason": reason} for m in metric_names)
+            continue
+        ss = {**s, "test_donor_ids": donors[eligible].tolist()}
+        meta, O, M, U = _collapse_donor_condition(ss, case[eligible], ctrl[eligible],
+                                                   observed[eligible][:, mask], method[eligible][:, mask], bulk[eligible][:, mask])
+        iscase = meta.condition.eq("case").to_numpy()
+        obs_fc = O[iscase].mean(0) - O[~iscase].mean(0)
+        method_fc = M[iscase].mean(0) - M[~iscase].mean(0)
+        bulk_fc = U[iscase].mean(0) - U[~iscase].mean(0)
+        values = {"donor_logfc_r": _pearson(obs_fc, method_fc),
+                  "donor_partial_r_given_bulk": _partial(obs_fc, method_fc, bulk_fc)}
+        work = out / "score" / "continuous_limma" / arm / typ.replace(" ", "_")
+        work.mkdir(parents=True, exist_ok=True)
+        meta.to_csv(work / "metadata.csv", index=False)
+        genes = np.asarray(v["score_ids"])[mask]
+        for side, matrix in (("observed", O), ("method", M)):
+            pd.DataFrame(matrix.T, index=pd.Index(genes, name="gene_id")).to_csv(work / f"{side}.tsv.gz", sep="\t")
+        script = out / "score" / "continuous_limma" / "limma_continuous.R"
+        script.write_text(LIMMA_R)
+        try:
+            run = subprocess.run(["/home/sj_server_1/miniforge3/bin/Rscript", str(script), str(work / "metadata.csv"), str(work / "observed.tsv.gz"),
+                                  str(work / "method.tsv.gz"), str(work)], capture_output=True, text=True)
+        except FileNotFoundError:
+            run = None
+        if run is None or run.returncode:
+            (work / "limma_error.txt").write_text(run.stderr[-8000:] if run is not None else "Rscript unavailable\n")
+            values["donor_limma_top50_overlap"] = float("nan")
+            reason = "limma continuous-expression fit unavailable; see unit limma_error.txt"
+        else:
+            obs_top = _top50(pd.read_csv(work / "observed_limma.csv"))
+            method_top = _top50(pd.read_csv(work / "method_limma.csv"))
+            values["donor_limma_top50_overlap"] = len(obs_top & method_top)
+            reason = ""
+        for m in metric_names:
+            value = values[m]
+            rows.append({**common, "metric": m, "value": value if np.isfinite(value) else "",
+                         "status": "ok" if np.isfinite(value) else "pending" if m == "donor_limma_top50_overlap" else "not_estimable",
+                         "reason": reason if not np.isfinite(value) else ""})
+    return rows
+
+
+def score_readiness(methods: dict, metrics: dict) -> tuple[str, list[str]]:
+    required = ("bayesprism", "cibersortx")
+    pending = []
+    for name in required:
+        record = methods.get(name)
+        if record is None or record.get("status") != "complete":
+            pending.append(f"{name}: {record.get('reason', 'required method output incomplete') if record else 'required method output missing'}")
+        if record and record.get("hires", {}).get("status") == "pending":
+            pending.append(f"{name}: {record['hires']['reason']}")
+        correction = metrics.get(name, {}).get("corrected_deg", {})
+        if record and correction.get("status") not in {"complete", "not_estimable"}:
+            pending.append(f"{name}: corrected DEG infrastructure pending")
+    return ("pending" if pending else "complete", pending)
+
+
+def expression_signal(s: dict, B, v: dict, pred: dict, arm: str) -> list[dict]:
+    """Legacy metric family on exact strict test samples; donor-aware DEG is separate."""
+    SF, F = B.SF, B.F
+    C = importlib.import_module("common")
+    ds = s["cohort"]
+    groups = np.asarray(v["groups"], dtype=str)
+    cases, controls = CONTRAST_GROUPS[ds]
+    case, ctrl = np.isin(groups, list(cases)), np.isin(groups, list(controls))
+    if not case.any() or not ctrl.any() or np.any(~(case | ctrl)):
+        raise ValueError("strict test samples do not match the declared case/control groups")
+    feat = np.load(C.FT / "data" / ds / "features.npz", allow_pickle=False)
+    fsid = (feat["sample_ids"] if "sample_ids" in feat.files else feat["donor_ids"]).astype(str)
+    sidpos = {x: i for i, x in enumerate(fsid)}
+    genepos = {x: i for i, x in enumerate(feat["gene_ids"].astype(str))}
+    sample_rows = [sidpos[x] for x in s["test_sample_ids"]]
+    gene_cols = [genepos[x] for x in v["score_ids"]]
+    valid = np.asarray(feat["bulk_valid"])[sample_rows][:, gene_cols].astype(bool)
+    if not valid.all():
+        raise ValueError("scoring genes must be bulk-valid for every strict mixture")
+    bulk = np.asarray(feat["bulk_raw"], dtype=np.float64)[sample_rows][:, gene_cols]
+    if not np.isfinite(bulk).all() or (bulk < 0).any():
+        raise ValueError("invalid strict bulk counts")
+    if ds == "giroux2022":
+        exclude = C.FT / "data/sex_linked_genes/sex_linked_genes_exclude.csv"
+        v["keep"], _ = SF.gene_exclusion(exclude, v["score_ids"])
+    contrast = {"enabled": True, "case": case, "ctrl": ctrl}
+    obs_deg = SF.observed_deg(v, contrast)
+    n_case_donors = len(set(np.asarray(s["test_donor_ids"])[case]))
+    n_control_donors = len(set(np.asarray(s["test_donor_ids"])[ctrl]))
+    base = {"arm": arm, "n_test_samples": len(s["test_sample_ids"]),
+            "n_independent_donors": len(set(s["test_donor_ids"])),
+            "n_case_samples": int(case.sum()), "n_control_samples": int(ctrl.sum()),
+            "n_case_donors": n_case_donors, "n_control_donors": n_control_donors,
+            "method_expression_unit": "BayesPrism posterior type expression" if arm == "bayesprism" else "CIBERSORTx HiRes imputed GEP",
+            "deg_method": "historical Welch top50 on method expression; corrected donor-aware DEG pending"}
+    if arm == "cibersortx" and (len(s["test_sample_ids"]) <= 8 or not pred.get("has_z") or not any(pred.get("imputed_genes", {}).values())):
+        return [{**base, "cell_type": "all", "metric": metric, "value": "", "status": "not_estimable",
+                 "gene_variant": "covered", "statistic": "mean_cp10k", "n_genes": 0}
+                for metric in ("logfc_r", "partial_r_given_bulk", "top50_deg_overlap")]
+    G = len(v["score_ids"])
+    covered = pred["covered_type"].all(0) if "covered_type" in pred else pred["covered"].all(0)
+    masks = (("zero_filled", None), ("covered", covered))
+    rows = []
+    for variant, mask in masks:
+        contrast_rows, deg, _ = B.bp_metrics(v, pred, bulk, contrast, obs_deg, mask)
+        for _, r in contrast_rows.iterrows():
+            for metric, key in (("logfc_r", "r_generated"), ("partial_r_given_bulk", "partial_r_generated_given_broadcast")):
+                value = float(r[key])
+                rows.append({**base, "cell_type": r["celltype"], "metric": metric,
+                             "value": value if np.isfinite(value) else "", "status": "ok" if np.isfinite(value) else "not_estimable",
+                             "gene_variant": variant, "statistic": r["statistic"], "n_genes": int(r["n_genes"])})
+        for typ, overlap in deg.items():
+            n_genes = (int(mask[F.GATE.index(typ)].sum()) if mask is not None and mask.ndim == 2
+                       else int(mask.sum()) if mask is not None else G)
+            rows.append({**base, "cell_type": typ, "metric": "top50_deg_overlap",
+                         "value": int(overlap) if overlap is not None else "", "status": "ok" if overlap is not None else "not_estimable",
+                         "gene_variant": variant, "statistic": F.DEG_STATISTIC,
+                         "n_genes": n_genes})
+    return rows
+
+
+def score(s: dict, out: Path) -> dict:
+    require_inputs(s, out)
+    C = patched_modules(s, out)
+    B = importlib.import_module("score_bp")
+    F = B.F
+    ds = s["cohort"]
+    ids = np.asarray(s["test_sample_ids"], dtype=str)
+    ref, man = F.load_reference(F.CACHE_ROOT / F.DATASETS[ds].name)
+    ref["deg"] = F.load_deg_reference(F.CACHE_ROOT / F.DATASETS[ds].name, man, ref)
+    if not set(ids) <= set(ref["donors"].astype(str)):
+        raise ValueError("strict test IDs absent from observed reference")
+    v = B.light_view(ref, ids.tolist())
+    rows, signals, metrics, methods = [], [], {}, {}
+    for name in ("bayesprism", "cibersortx"):
+        hires_pending = False
+        try:
+            if name == "bayesprism":
+                verify_stage_receipt(s, out, "bayesprism")
+            else:
+                verify_stage_receipt(s, out, "fractions")
+                if len(ids) > 8:
+                    try:
+                        verify_stage_receipt(s, out, "hires")
+                    except FileNotFoundError:
+                        hires_pending = True
+            hashes = method_output_hashes(s, out, name)
+            pred = B.load_bp(ds, ["fewshot0_full"], ids, v["score_ids"]) if name == "bayesprism" else B.load_cx(ds, [SPLIT], ids, v["score_ids"])
+        except (SystemExit, FileNotFoundError) as e:
+            methods[name] = {"status": "pending", "reason": str(e)}
+            continue
+        fractions = B.to_cells(pred["theta"]["final"], pred["size"])
+        if not np.isfinite(fractions).all():
+            raise ValueError(f"{name} fractions contain nonfinite values")
+        l1 = F.IC.l1(fractions, v["comp"])
+        metrics[name] = {"composition_l1_mean": float(np.mean(l1)), "n_samples": len(ids),
+                         "n_independent_donors": len(set(s["test_donor_ids"]))}
+        methods[name] = {"status": "pending" if hires_pending else "complete",
+                         "composition": "cell_fraction_size_corrected", "output_sha256": hashes}
+        for i, sample in enumerate(ids):
+            for j, typ in enumerate(F.GATE):
+                rows.append({"arm": name, "sample_id": sample, "donor_id": s["test_donor_ids"][i],
+                             "cell_type": typ, "observed": float(v["comp"][i, j]), "predicted": float(fractions[i, j]),
+                             "composition_l1": float(l1[i])})
+        if name == "cibersortx":
+            imputed = pred.get("imputed_genes", {})
+            if hires_pending:
+                methods[name]["hires"] = {"status": "pending", "reason": "required HiRes output missing"}
+            elif len(ids) <= 8:
+                methods[name]["hires"] = {"status": "not_estimable", "reason": "at most eight mixture samples"}
+            elif not pred.get("has_z"):
+                methods[name]["hires"] = {"status": "pending", "reason": "required HiRes result files missing"}
+                methods[name]["status"] = "pending"
+            elif not any(imputed.values()):
+                methods[name]["hires"] = {"status": "not_estimable", "reason": "verified HiRes result has zero imputed genes"}
+            else:
+                methods[name]["hires"] = {"status": "available", "imputed_genes": imputed}
+        method_view = v.copy()
+        if hires_pending or (name == "cibersortx" and methods[name]["hires"]["status"] == "pending"):
+            corrected = [{"arm": name, "cell_type": typ, "metric": metric, "value": "", "status": "pending",
+                          "reason": "required HiRes output missing", "gene_variant": "donor_covered",
+                          "statistic": "limma_log2_cpm", "n_genes": 0,
+                          "n_test_samples": len(ids), "n_independent_donors": len(set(s["test_donor_ids"])),
+                          "method_expression_unit": "CIBERSORTx HiRes imputed GEP"}
+                         for typ in v["deg_types"] for metric in
+                         ("donor_logfc_r", "donor_partial_r_given_bulk", "donor_limma_top50_overlap")]
+        else:
+            signals.extend(expression_signal(s, B, method_view, pred, name))
+            corrected = corrected_expression(s, B, method_view, pred, name, out)
+        signals.extend(corrected)
+        deg_rows = [r for r in corrected if r["metric"] == "donor_limma_top50_overlap"]
+        metrics[name]["corrected_deg"] = {"method": "limma on matched donor-condition continuous log2-CPM",
+                                           "status": "pending" if any(r["status"] == "pending" for r in deg_rows)
+                                           else "complete" if any(r["status"] == "ok" for r in deg_rows)
+                                           else "not_estimable",
+                                           "n_types_estimable": sum(r["status"] == "ok" for r in deg_rows),
+                                           "n_types_total": len(deg_rows)}
+    status, pending = score_readiness(methods, metrics)
+    result = {"schema": "pbisc.deconvolution.strict-score.v1", "cohort": ds, "unit": s["unit"],
+              "status": status,
+              "pending_reasons": pending, "required_methods": ["bayesprism", "cibersortx"],
+              "support_sha256": s["sha256"], "reference_sample_ids": s["train_sample_ids"],
+              "mixture_sample_ids": s["test_sample_ids"], "methods": methods, "metrics": metrics,
+              "observed_reference_sha256": man["reference_sha256"],
+              "source_sha256": {"adapter": sha(Path(__file__)), "score_bp": sha(OLD_TOOLS / "score_bp.py"),
+                                "common": sha(OLD_TOOLS / "common.py"),
+                                "legacy_aggregate": json.loads((out / "INPUTS.json").read_text())["aggregate_sha256"],
+                                "features": sha(C.FT / "data" / ds / "features.npz"),
+                                "observed_deg_reference": ref["deg"].get("sha256")}}
+    p = out / "score"
+    p.mkdir(exist_ok=True)
+    csvpath = p / "figure4_methods.csv"
+    if rows:
+        with csvpath.open("w", newline="") as f:
+            writer = csv.DictWriter(f, fieldnames=list(rows[0]))
+            writer.writeheader(); writer.writerows(rows)
+        result["figure4_csv"] = str(csvpath)
+        result["figure4_csv_sha256"] = sha(csvpath)
+        signalpath = p / "expression_signal.csv"
+        with signalpath.open("w", newline="") as f:
+            writer = csv.DictWriter(f, fieldnames=list(dict.fromkeys(k for row in signals for k in row)))
+            writer.writeheader(); writer.writerows(signals)
+        result["signal_csv"] = str(signalpath)
+        result["signal_sha256"] = sha(signalpath)
+        result["expression_metric_provenance"] = {
+            "gene_axis": "cohort scoring genes; Giroux sex-linked genes excluded",
+            "reference_expression": "observed sample-level cell-type aggregates on strict test samples",
+            "method_expression": "BayesPrism posterior type expression or CIBERSORTx HiRes imputed GEP",
+            "bulk": "strict test sample real bulk raw counts from features.npz",
+            "sample_unit": "sample; repeated visits retained with explicit donor IDs",
+            "top50_deg": "historical Welch benchmark statistic; not corrected patient-level inference",
+            "corrected_deg": "limma lmFit/eBayes on matched observed/method continuous log2-CPM donor-condition means; duplicateCorrelation if needed; sensitivity distinct from raw-count edgeR/limma-voom primary",
+            "corrected_profile_script_sha256": hashlib.sha256(LIMMA_R.encode()).hexdigest()}
+    (p / "SUMMARY.json").write_text(json.dumps(result, indent=2) + "\n")
+    if result["status"] == "complete":
+        update_figure4(s, result)
+    else:
+        invalidate_figure4(s, result["pending_reasons"])
+    return result
+
+
+def invalidate_figure4(s: dict, reasons: list[str]) -> None:
+    """Retain a prior mapping as inactive so pending reruns cannot look complete."""
+    path = PLAN / "deconvolution" / "deconvolution_manifest.json"
+    if not path.is_file():
+        return
+    data = json.loads(path.read_text())
+    rel = f'{s["cohort"]}/disease/{s["unit"].replace("_n5", "")}'
+    previous = data.get("units", {}).get(rel)
+    if previous is None:
+        return
+    data.setdefault("inactive_units", {})[rel] = {"previous": previous, "reason": reasons}
+    del data["units"][rel]
+    with tempfile.NamedTemporaryFile("w", dir=path.parent, prefix=".deconv_", delete=False) as f:
+        json.dump(data, f, indent=2)
+        f.write("\n")
+        tmp = Path(f.name)
+    tmp.replace(path)
+
+
+def update_figure4(s: dict, result: dict) -> None:
+    """Atomic global index consumed by build_results_figures.py --deconvolution-manifest."""
+    path = PLAN / "deconvolution" / "deconvolution_manifest.json"
+    data = json.loads(path.read_text()) if path.exists() else {"schema": "pbisc.fig4.deconvolution-sources.v1", "units": {}}
+    rel = f'{s["cohort"]}/disease/{s["unit"].replace("_n5", "")}'
+    data["units"][rel] = {"csv": result["figure4_csv"], "sha256": result["figure4_csv_sha256"],
+                          "signal_csv": result["signal_csv"], "signal_sha256": result["signal_sha256"],
+                          "support_sha256": s["sha256"], "reference_sample_ids": s["train_sample_ids"],
+                          "mixture_sample_ids": s["test_sample_ids"], "methods": result["methods"],
+                          "metrics": result["metrics"], "source_sha256": result["source_sha256"],
+                          "expression_metric_provenance": result["expression_metric_provenance"]}
+    data.get("inactive_units", {}).pop(rel, None)
+    with tempfile.NamedTemporaryFile("w", dir=path.parent, prefix=".deconv_", delete=False) as f:
+        json.dump(data, f, indent=2)
+        f.write("\n")
+        tmp = Path(f.name)
+    tmp.replace(path)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--support-manifest", type=Path, required=True)
+    parser.add_argument("--action", choices=("prepare", "bayesprism", "cibersortx", "score", "all"), required=True)
+    parser.add_argument("--out", type=Path)
+    parser.add_argument("--threads", type=int, default=4)
+    a = parser.parse_args(argv)
+    if not 1 <= a.threads <= 16:
+        parser.error("--threads must be 1..16")
+    s = support(a.support_manifest)
+    out = unit_out(s, a.out)
+    host_preflight()
+    if a.action in ("prepare", "all"):
+        prepare(s, out)
+    if a.action in ("bayesprism", "all"):
+        bayesprism(s, out, a.threads)
+    if a.action in ("cibersortx", "all"):
+        cibersortx(s, out, a.threads)
+    if a.action in ("score", "all"):
+        result = score(s, out)
+        print(json.dumps(result, indent=2))
+        if result["status"] != "complete":
+            return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/tools/disease_signal.py

@@ -0,0 +1,467 @@
+#!/usr/bin/env python3
+"""Donor-aware primary Figure 4 signals from strict scored pseudobulks.
+
+No legacy contrast/headline value is read. Counts and corrected limma fits come
+from score_strict's donor_deg outputs. Correlation uncertainty resamples whole
+patients with the SAME weights across all methods and overlapping draws.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+import numpy as np
+import pandas as pd
+from scipy.stats import rankdata
+
+ROOT = Path(__file__).resolve().parents[1]
+OLD = ROOT.parent / "paired_finetune_intradataset_20260927"
+COHORTS = ("ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili")
+ARMS = ("raw", "refcal", "lora", "scsemi", "pairedcal")
+METRICS = ("pearson_r", "spearman_r", "partial_r")
+TABLES = {"signal": "fig4_donor_aware_signal.csv", "summary": "fig4_donor_aware_summary.csv",
+          "genes": "fig4_donor_aware_genes.csv", "cat": "fig4_donor_aware_cat.csv"}
+
+
+def sha(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        for block in iter(lambda: f.read(1024 * 1024), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def load(path: Path) -> dict:
+    return json.loads(path.read_text())
+
+
+def prepare_profiles(rows: pd.DataFrame, genes: list[str], cases: list[str], controls: list[str]) -> dict:
+    """One log2-CPM profile per donor×contrast group, with equal condition weights.
+
+    Upstream sums visits within donor×original condition. We normalize that
+    pseudobulk once, then average original conditions within a contrast group.
+    Thus a patient with two case labels does not count twice in the case mean.
+    Missing cell-type profiles remain absent rather than becoming zero cells.
+    """
+    if set(cases) & set(controls):
+        raise ValueError("case and control labels overlap")
+    rows = rows.loc[rows.condition.isin(cases + controls)].copy()
+    if rows.empty:
+        return {"donors": np.array([], str), "case": np.array([], bool),
+                "values": np.empty((0, len(genes))), "zero_libraries": 0}
+    keys = ["donor_id", "condition", "gene_id"]
+    if rows.duplicated(keys).any() or rows[keys].isna().any().any():
+        raise ValueError("duplicate or missing donor-condition-gene identity")
+    if set(rows.gene_id.astype(str)) != set(genes):
+        raise ValueError("pseudobulk gene axis differs from genes_kept")
+    matrix = rows.pivot(index=["donor_id", "condition"], columns="gene_id", values="count").reindex(columns=genes)
+    if matrix.isna().any().any():
+        raise ValueError("a donor-condition profile has an incomplete measured gene axis")
+    values = matrix.to_numpy(float)
+    if not np.isfinite(values).all() or (values < 0).any():
+        raise ValueError("pseudobulk counts must be finite and nonnegative")
+    totals = values.sum(axis=1)
+    good = totals > 0
+    matrix = matrix.iloc[np.flatnonzero(good)]
+    values = np.log2(1. + 1e6 * values[good] / totals[good, None])
+    ids = matrix.index.get_level_values("donor_id").astype(str).to_numpy()
+    labels = matrix.index.get_level_values("condition").astype(str).to_numpy()
+    groups = np.isin(labels, cases)
+    unique = sorted(set(zip(ids, groups)))
+    return {"donors": np.asarray([x[0] for x in unique]),
+            "case": np.asarray([x[1] for x in unique], bool),
+            "values": np.stack([values[(ids == d) & (groups == c)].mean(0) for d, c in unique])
+                      if unique else np.empty((0, len(genes))),
+            "zero_libraries": int((~good).sum())}
+
+
+def effect(profiles: dict, weights: dict[str, int] | None = None) -> np.ndarray:
+    p = profiles
+    w = np.ones(len(p["donors"])) if weights is None else np.asarray([weights.get(x, 0) for x in p["donors"]])
+    result = []
+    for group in (True, False):
+        selected = p["case"] == group
+        if len(set(p["donors"][selected & (w > 0)])) < 2:
+            return np.full(p["values"].shape[1], np.nan)
+        result.append(np.average(p["values"][selected], axis=0, weights=w[selected]))
+    return result[0] - result[1]
+
+
+def patient_weights(donors: list[str], *, n_boot: int, seed: int) -> np.ndarray:
+    if len(set(donors)) != len(donors) or not donors or n_boot < 1:
+        raise ValueError("bootstrap requires unique patients and a positive replicate count")
+    return np.random.default_rng(seed).multinomial(len(donors), np.full(len(donors), 1 / len(donors)), size=n_boot)
+
+
+def bootstrap_effect(profiles: dict, donors: list[str], weights: np.ndarray) -> np.ndarray:
+    pos = {d: i for i, d in enumerate(donors)}
+    if not set(profiles["donors"]) <= set(pos):
+        raise ValueError("pseudobulk donor lies outside bootstrap population")
+    w = weights[:, [pos[d] for d in profiles["donors"]]]
+    result = []
+    valid = np.ones(len(weights), bool)
+    for group in (True, False):
+        selected = profiles["case"] == group
+        wg = w[:, selected]
+        # prepare_profiles guarantees one row per donor in each contrast group.
+        valid &= (wg > 0).sum(axis=1) >= 2
+        den = wg.sum(axis=1)
+        result.append(np.divide(wg @ profiles["values"][selected], den[:, None],
+                                out=np.full((len(weights), profiles["values"].shape[1]), np.nan),
+                                where=den[:, None] > 0))
+    answer = result[0] - result[1]
+    answer[~valid] = np.nan
+    return answer
+
+
+def row_correlation(x: np.ndarray, y: np.ndarray) -> np.ndarray:
+    x, y = np.atleast_2d(x), np.atleast_2d(y)
+    if x.shape != y.shape or x.shape[1] < 3:
+        return np.full(x.shape[0], np.nan)
+    xc, yc = x - x.mean(axis=1, keepdims=True), y - y.mean(axis=1, keepdims=True)
+    den = np.linalg.norm(xc, axis=1) * np.linalg.norm(yc, axis=1)
+    return np.divide((xc * yc).sum(axis=1), den, out=np.full(len(x), np.nan), where=den > 1e-12)
+
+
+def correlations(observed: np.ndarray, generated: np.ndarray, bulk: np.ndarray) -> dict:
+    o, g, b = (np.atleast_2d(x) for x in (observed, generated, bulk))
+    if o.shape != g.shape or o.shape != b.shape:
+        raise ValueError("observed, generated and bulk contrasts must share the gene axis")
+    if o.shape[1] < 3:
+        return {k: (float('nan') if observed.ndim == 1 else np.full(len(o), np.nan)) for k in METRICS}
+    bc = b - b.mean(axis=1, keepdims=True)
+    den = (bc * bc).sum(axis=1)
+    residual = []
+    for x in (o, g):
+        xc = x - x.mean(axis=1, keepdims=True)
+        slope = np.divide((xc * bc).sum(axis=1), den, out=np.full(len(x), np.nan), where=den > 1e-12)
+        residual.append(xc - slope[:, None] * bc)
+    answer = {"pearson_r": row_correlation(o, g),
+              "spearman_r": row_correlation(rankdata(o, axis=1), rankdata(g, axis=1)),
+              "partial_r": row_correlation(*residual)}
+    return {k: float(v[0]) for k, v in answer.items()} if observed.ndim == 1 else answer
+
+
+def interval(x: np.ndarray) -> tuple[float, float, int]:
+    good = np.asarray(x)[np.isfinite(x)]
+    if len(good) < max(2, .8 * len(x)):
+        return float("nan"), float("nan"), len(good)
+    lo, hi = np.quantile(good, [.025, .975])
+    return float(lo), float(hi), len(good)
+
+
+def mean_bootstraps(arrays: list[np.ndarray]) -> np.ndarray:
+    """Same patient draw across every adaptation draw; require every draw finite."""
+    return np.stack(arrays).mean(axis=0)
+
+
+def rank_metrics(observed: pd.DataFrame, generated: pd.DataFrame, genes: list[str],
+                 ks=(10, 25, 50, 100, 200, 500)) -> tuple[dict, list[dict], pd.DataFrame]:
+    """Corrected limma FDR top50; CAT ranks |moderated t|, deterministic gene ties."""
+    required = {"gene_id", "logFC", "t", "adj.P.Val"}
+    for table in (observed, generated):
+        if not required <= set(table) or table.gene_id.duplicated().any():
+            raise ValueError("corrected limma gene table invalid")
+    tables = [t[t.gene_id.isin(genes)].copy() for t in (observed, generated)]
+    top, rankings = [], []
+    merged = pd.DataFrame({"gene_id": genes})
+    for label, table in zip(("observed", "generated"), tables):
+        if not np.isfinite(table[["logFC", "t", "adj.P.Val"]].to_numpy(float)).all():
+            raise ValueError("nonfinite corrected limma output")
+        sig = table[table["adj.P.Val"] < .05].assign(abs_lfc=lambda x: x.logFC.abs())
+        top.append(set(sig.sort_values(["abs_lfc", "gene_id"], ascending=[False, True]).head(50).gene_id))
+        rank = table.assign(abs_t=lambda x: x.t.abs()).sort_values(["abs_t", "gene_id"], ascending=[False, True])
+        rankings.append(rank)
+        merged = merged.merge(table[list(required)].rename(columns={"logFC": label + "_limma_logFC",
+                                                                    "t": label + "_limma_t",
+                                                                    "adj.P.Val": label + "_limma_q"}),
+                              on="gene_id", how="left", validate="one_to_one")
+    result = {"limma_top50": len(top[0] & top[1]), "observed_top50_size": len(top[0]),
+              "generated_top50_size": len(top[1]),
+              "limma_top50_chance": len(top[0]) * len(top[1]) / len(genes) if genes else np.nan,
+              "n_limma_tested_observed": len(tables[0]), "n_limma_tested_generated": len(tables[1])}
+    curves = []
+    for k in ks:
+        available = all(len(t) >= k for t in rankings)
+        a, b = rankings[0].head(k), rankings[1].head(k)
+        intersection = set(a.gene_id) & set(b.gene_id)
+        signs = [dict(zip(t.gene_id, np.sign(t.logFC))) for t in (a, b)]
+        same = sum(signs[0][g] == signs[1][g] and signs[0][g] != 0 for g in intersection)
+        curves.append({"k": k, "status": "ok" if available else "not_estimable",
+                       "cat_same_sign": same / k if available else np.nan,
+                       "cat_any_sign": len(intersection) / k if available else np.nan,
+                       "chance_same_sign": k / (2 * len(genes)) if available else np.nan,
+                       "chance_model": "uniform_independent_rankings_symmetric_signs"})
+    for c in curves:
+        if c["k"] == 50:
+            result.update(cat50=c["cat_same_sign"], cat50_chance=c["chance_same_sign"])
+    # Extrapolated finite equal-length RBO: lists restricted to the shared fitted universe.
+    common = set(rankings[0].gene_id) & set(rankings[1].gene_id)
+    ranks = [[g for g in t.gene_id if g in common] for t in rankings]
+    p, total, seen_a, seen_b, overlap = .9, 0., set(), set(), 0
+    for d, (a, b) in enumerate(zip(*ranks), start=1):
+        seen_a.add(a); seen_b.add(b)
+        overlap = len(seen_a & seen_b)
+        total += (1 - p) * p ** (d - 1) * overlap / d
+    result["rbo_p09"] = total + (p ** len(common) * overlap / len(common) if common else np.nan)
+    return result, curves, merged
+
+
+def checked_unit(support_path: Path) -> tuple[dict, dict, Path, dict]:
+    """Validate canonical support, strict source binding and completed corrected fits."""
+    import score_strict as S
+    support = S.read_support(support_path)
+    rel = support_path.parent.relative_to(ROOT / "protocol/splits")
+    if (support["cohort"] not in COHORTS or support["n_pairs"] != 5
+            or support.get("design") != "disease_existing_draw"
+            or rel.parts != (support["cohort"], "disease", support["unit"].removesuffix("_n5"))):
+        raise ValueError("noncanonical disease strict-five support")
+    out = ROOT / "scores" / rel
+    summary_path, binding_path, status_path = (out / "score/summary.json", out / "scoring_support.json", out / "statistics/status.json")
+    for path in (summary_path, binding_path, status_path, out / "statistics/donor_deg/donor_deg_summary.csv"):
+        if not path.is_file():
+            raise FileNotFoundError(str(path))
+    summary, binding, status = load(summary_path), load(binding_path), load(status_path)
+    if (set(summary["arms"]) != set(ARMS) or summary["dataset"] != support["cohort"]
+            or summary["donors"] != support["test_sample_ids"]
+            or binding.get("schema") != "pbisc.paper.strict-score-binding.v1"
+            or binding.get("support_sha256") != support["sha256"]
+            or binding.get("test_sample_ids") != support["test_sample_ids"]
+            or binding.get("test_donor_ids") != support["test_donor_ids"]
+            or set(binding.get("arm_bindings", {})) != set(ARMS)
+            or status.get("support_sha256") != support["sha256"]):
+        raise ValueError("disease source does not bind canonical strict score")
+    if status.get("disease_deg", {}).get("status") not in ("ok", "complete_with_not_estimable"):
+        raise FileNotFoundError("corrected disease DEG is pending: " + str(status_path))
+    sources = {str(p): sha(p) for p in (support_path, summary_path, binding_path, status_path)}
+    for arm in ARMS:
+        bound = binding["arm_bindings"][arm]
+        pa = summary["per_arm"][arm]
+        if bound.get("support_sha256") != support["sha256"] or bound.get("npz_sha256") != pa.get("npz_sha256"):
+            raise ValueError("generated NPZ binding differs from corrected score")
+        for key in ("receipt", "source_binding"):
+            path = Path(bound[key])
+            if not path.is_file() or sha(path) != bound[key + "_sha256"]:
+                raise ValueError("generation provenance changed: " + str(path))
+            sources[str(path)] = bound[key + "_sha256"]
+    return support, summary, out, sources
+
+
+def bulk_rows(support: dict, summary: dict, genes: list[str]) -> tuple[pd.DataFrame, dict]:
+    path = OLD / "data" / support["cohort"] / "features.npz"
+    folds_path = path.with_name("folds.csv")
+    folds = pd.read_csv(folds_path, dtype=str).set_index("sample_id")
+    ids = summary["donors"]
+    groups = summary["contrast_definition"]["groups"]
+    if (folds.loc[ids, "donor_id"].tolist() != support["test_donor_ids"]
+            or folds.loc[ids, "group"].tolist() != groups):
+        raise ValueError("bulk patient or condition mapping differs from scored support")
+    with np.load(path, allow_pickle=False) as z:
+        sid = (z["sample_ids"] if "sample_ids" in z.files else z["donor_ids"]).astype(str)
+        spos, gpos = {s: i for i, s in enumerate(sid)}, {g: i for i, g in enumerate(z["gene_ids"].astype(str))}
+        ix, jx = [spos[x] for x in ids], [gpos[g] for g in genes]
+        if not z["bulk_valid"][np.ix_(ix, jx)].all():
+            raise ValueError("a scoring gene is unmeasured in a target bulk")
+        x = z["bulk_raw"][np.ix_(ix, jx)].astype(float)
+    rows = pd.DataFrame({"donor_id": np.repeat(support["test_donor_ids"], len(genes)),
+                         "condition": np.repeat(groups, len(genes)), "gene_id": np.tile(genes, len(ids)),
+                         "count": x.reshape(-1)})
+    return rows.groupby(["donor_id", "condition", "gene_id"], as_index=False)["count"].sum(), {
+        str(path): sha(path), str(folds_path): sha(folds_path)}
+
+
+def _coverage(profile: dict, prefix: str) -> dict:
+    return {prefix + "_n_donors": len(set(profile["donors"])),
+            prefix + "_n_case_donors": len(set(profile["donors"][profile["case"]])),
+            prefix + "_n_control_donors": len(set(profile["donors"][~profile["case"]])),
+            prefix + "_zero_libraries": profile.get("zero_libraries", 0)}
+
+
+def process_unit(support: dict, summary: dict, out: Path, donors: list[str], weights: np.ndarray,
+                 sources: dict) -> tuple[list, list, list, dict]:
+    dest = out / "statistics/donor_deg"
+    genes_path, summary_path = dest / "genes_kept.csv", dest / "donor_deg_summary.csv"
+    sources.update({str(p): sha(p) for p in (genes_path, summary_path)})
+    genes = pd.read_csv(genes_path).gene_id.astype(str).tolist()
+    if len(set(genes)) != len(genes) or not genes:
+        raise ValueError("invalid corrected gene axis")
+    if support["cohort"] == "giroux2022":
+        exclusion = summary.get("gene_exclusion", {})
+        if not exclusion or sha(Path(exclusion["file"])) != exclusion["sha256"]:
+            raise ValueError("Giroux sex-linked gene exclusion missing or changed")
+        if set(genes) & set(pd.read_csv(exclusion["file"]).gene_id.astype(str)):
+            raise ValueError("Giroux corrected gene axis includes an excluded sex-linked gene")
+        sources[exclusion["file"]] = exclusion["sha256"]
+    definitions = summary["contrast_definition"]
+    cases, controls = definitions["case_groups"], definitions["control_groups"]
+    br, bsources = bulk_rows(support, summary, genes)
+    sources.update(bsources)
+    bulk = prepare_profiles(br, genes, cases, controls)
+    bfc, bboot = effect(bulk), bootstrap_effect(bulk, donors, weights)
+    fit_summary = pd.read_csv(summary_path)
+    if fit_summary.duplicated(["arm", "celltype"]).any() or set(fit_summary.arm) != set(ARMS):
+        raise ValueError("corrected fit summary is incomplete or duplicated")
+    types = sorted(fit_summary.celltype.unique())
+    if set(zip(fit_summary.arm, fit_summary.celltype)) != {(a, t) for a in ARMS for t in types}:
+        raise ValueError("corrected fit summary is not a complete arm by cell-type grid")
+    allowed = set(zip(support["test_donor_ids"], definitions["groups"]))
+    rows, gene_rows, cat_rows, bootstrap = [], [], [], {}
+    for typ in types:
+        ref = None
+        for arm in ARMS:
+            f = fit_summary[(fit_summary.arm == arm) & (fit_summary.celltype == typ)].iloc[0]
+            if f.status == "pending":
+                raise FileNotFoundError(f"corrected limma pending for {out}: {arm}/{typ}")
+            slug = __import__("re").sub(r"[^a-z0-9]+", "_", typ.lower()).strip("_")
+            directory = dest / arm / slug
+            pb_path, limma_path, status_path = (directory / "donor_condition_pseudobulk.csv",
+                                               directory / "donor_limma_genes.csv", directory / "limma_status.json")
+            if not pb_path.is_file() or not status_path.is_file():
+                raise FileNotFoundError(str(directory))
+            sources.update({str(p): sha(p) for p in (pb_path, status_path)})
+            fit_status = load(status_path)
+            jobs = {j["side"]: j for j in fit_status.get("jobs", [])}
+            if (fit_status.get("status") not in ("ok", "complete_with_not_estimable")
+                    or (f.status == "ok" and any(jobs.get(s, {}).get("status") != "ok" for s in ("observed", arm)))):
+                raise ValueError("corrected limma summary and actual fit status differ")
+            table = pd.read_csv(pb_path, dtype={"donor_id": str, "condition": str, "gene_id": str})
+            if (not set(table.side) <= {"observed", arm} or not set(table.celltype) <= {typ}
+                    or not set(zip(table.donor_id, table.condition)) <= allowed):
+                raise ValueError("corrected pseudobulk contains a foreign patient/condition/population")
+            observed = table[table.side == "observed"].sort_values(["donor_id", "condition", "gene_id"]).reset_index(drop=True)
+            if ref is not None and not observed.equals(ref):
+                raise ValueError("observed reference differs between methods")
+            ref = observed
+            o = prepare_profiles(observed, genes, cases, controls)
+            g = prepare_profiles(table[table.side == arm], genes, cases, controls)
+            keep = observed.groupby("gene_id")["count"].sum().reindex(genes, fill_value=0).to_numpy() > 0
+            gene_axis = np.asarray(genes)[keep].tolist()
+            ofc, gfc = effect(o), effect(g)
+            values = correlations(ofc[keep], gfc[keep], bfc[keep])
+            boot = correlations(bootstrap_effect(o, donors, weights)[:, keep],
+                                bootstrap_effect(g, donors, weights)[:, keep], bboot[:, keep])
+            key = (arm, typ)
+            bootstrap[key] = boot
+            meta = {"cohort": support["cohort"], "draw": support["unit"].removesuffix("_n5"),
+                    "support_unit": support["unit"], "arm": arm, "celltype": typ,
+                    "support_sha256": support["sha256"], "n_genes": int(keep.sum()),
+                    "status": "ok" if np.isfinite(values["pearson_r"]) else "not_estimable",
+                    "deg_status": str(f.status), "reference_scope": "full_observed_heldout_population",
+                    "generated_scope": "available_generated_population_no_zero_fill",
+                    "statistic": "equal_patient_group_mean_log2_cpm_plus1_difference",
+                    "bootstrap_unit": "same_patient_weights_across_all_methods_and_draws",
+                    "n_bootstrap": len(weights), **_coverage(o, "observed"), **_coverage(g, "generated"), **values}
+            if meta["status"] != "ok":
+                meta["reason"] = "fewer than two donors per group, fewer than three expressed genes, or constant contrast"
+            for metric in METRICS:
+                lo, hi, n = interval(boot[metric])
+                meta.update({metric + "_ci_low": lo, metric + "_ci_high": hi, metric + "_bootstrap_valid": n})
+            gene = pd.DataFrame({"gene_id": gene_axis, "observed_logFC": ofc[keep],
+                                 "generated_logFC": gfc[keep], "bulk_logFC": bfc[keep]})
+            if f.status == "ok":
+                if not limma_path.is_file():
+                    raise FileNotFoundError(str(limma_path))
+                sources[str(limma_path)] = sha(limma_path)
+                lm = pd.read_csv(limma_path, dtype={"gene_id": str})
+                ranks, curves, ranks_gene = rank_metrics(lm[lm.side == "observed"], lm[lm.side == arm], gene_axis)
+                meta.update(ranks)
+                gene = gene.merge(ranks_gene, on="gene_id", how="left", validate="one_to_one")
+                cat_rows.extend({**{k: meta[k] for k in ("cohort", "draw", "arm", "celltype", "support_sha256")}, **c}
+                                for c in curves)
+            else:
+                meta["deg_reason"] = "; ".join(str(f.get(k)) for k in ("reason_observed", "reason_generated", "reason_population") if pd.notna(f.get(k)))
+            rows.append(meta)
+            gene_rows.extend(gene.assign(**{k: meta[k] for k in ("cohort", "draw", "arm", "celltype", "support_sha256")}).to_dict("records"))
+    return rows, gene_rows, cat_rows, bootstrap
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--require-complete", action="store_true")
+    parser.add_argument("--n-bootstrap", type=int, default=2000)
+    parser.add_argument("--seed", type=int, default=20261012)
+    args = parser.parse_args()
+    if args.require_complete and (args.n_bootstrap != 2000 or args.seed != 20261012):
+        parser.error("publication protocol requires 2000 patient bootstraps and seed 20261012")
+    all_rows, all_genes, all_cat, aggregate, missing, units, sources = [], [], [], [], [], {}, {}
+    for ci, cohort in enumerate(COHORTS):
+        available = []
+        for draw in range(5):
+            path = ROOT / "protocol/splits" / cohort / "disease" / f"draw{draw}" / "support.json"
+            try:
+                support, summary, out, source = checked_unit(path)
+                available.append((support, summary, out, source))
+            except FileNotFoundError as exc:
+                missing.append(str(exc))
+        if len(available) != 5:
+            continue  # cohort estimates require all five prespecified adaptation draws
+        donors = sorted({d for support, _, _, _ in available for d in support["test_donor_ids"]})
+        weights = patient_weights(donors, n_boot=args.n_bootstrap, seed=args.seed + ci)
+        boot_by_key = {}
+        cohort_rows = []
+        for support, summary, out, source in available:
+            rows, genes, cats, boots = process_unit(support, summary, out, donors, weights, source)
+            all_rows.extend(rows); cohort_rows.extend(rows); all_genes.extend(genes); all_cat.extend(cats)
+            sources.update(source)
+            units[str(out.relative_to(ROOT / "scores"))] = {"support_sha256": support["sha256"],
+                                                              "sources": source}
+            for key, item in boots.items():
+                boot_by_key.setdefault(key, []).append(item)
+        frame = pd.DataFrame(cohort_rows)
+        for (arm, celltype), group in frame.groupby(["arm", "celltype"], sort=True):
+            row = {"cohort": cohort, "arm": arm, "celltype": celltype, "n_draws": len(group),
+                   "n_independent_patients": len(donors), "patient_bootstrap_replicates": args.n_bootstrap,
+                   "status": "ok" if group.status.eq("ok").all() else "contains_not_estimable_draws",
+                   "bootstrap_unit": "shared_patients_across_draws_and_methods",
+                   "draw_variation": "SD_across_five_fixed_adaptation_draws_not_a_CI"}
+            for metric in (*METRICS, "limma_top50", "limma_top50_chance", "cat50", "cat50_chance", "rbo_p09"):
+                values = pd.to_numeric(group.get(metric, pd.Series(dtype=float)), errors="coerce")
+                good = values[np.isfinite(values)]
+                row[metric + "_n_draws"] = len(good)
+                row[metric] = float(good.mean()) if len(good) == 5 else np.nan
+                row[metric + "_draw_sd"] = float(good.std(ddof=1)) if len(good) == 5 else np.nan
+                if metric in METRICS:
+                    boot = mean_bootstraps([b[metric] for b in boot_by_key[(arm, celltype)]])
+                    lo, hi, n = interval(boot)
+                    row.update({metric + "_ci_low": lo, metric + "_ci_high": hi, metric + "_bootstrap_valid": n})
+                    baseline = frame[(frame.arm == "scsemi") & (frame.celltype == celltype)]
+                    base_values = pd.to_numeric(baseline[metric], errors="coerce")
+                    row[metric + "_minus_scsemi"] = (row[metric] - float(base_values.mean())
+                                                      if len(base_values) == 5 and np.isfinite(base_values).all() else np.nan)
+                    base_boot = mean_bootstraps([b[metric] for b in boot_by_key[("scsemi", celltype)]])
+                    lo, hi, n = interval(boot - base_boot)
+                    row.update({metric + "_minus_scsemi_ci_low": lo, metric + "_minus_scsemi_ci_high": hi,
+                                metric + "_minus_scsemi_bootstrap_valid": n})
+            aggregate.append(row)
+    output = ROOT / "source_data"
+    output.mkdir(parents=True, exist_ok=True)
+    outputs = {}
+    for key, data in (("signal", all_rows), ("summary", aggregate), ("genes", all_genes), ("cat", all_cat)):
+        path = output / TABLES[key]
+        frame = pd.DataFrame(data) if data else pd.DataFrame(columns=["cohort", "draw", "arm", "celltype", "status"])
+        frame.to_csv(path, index=False)
+        outputs[key] = {"path": str(path), "sha256": sha(path), "rows": len(frame)}
+    complete = len(units) == 20 and not missing
+    provenance = {"schema": "pbisc.fig4.donor-aware-signal.v1", "status": "complete" if complete else "pending",
+                  "units": units, "missing": missing, "outputs": outputs, "sources": sources,
+                  "script_sha256": sha(Path(__file__)), "n_bootstrap": args.n_bootstrap, "seed": args.seed,
+                  "gene_filter": "genes_kept from corrected score including Giroux exclusion; then observed nonzero per type, shared across methods",
+                  "observed_reference": "full observed heldout population identical across methods; generated absent populations remain absent",
+                  "expression": "visits summed within original donor-condition, log2(CPM+1), original conditions averaged within group and patient, equal patient case-control difference",
+                  "bulk_adjustment": "same raw measured bulk contrast for all methods; same patient aggregation; never calibration-specific bulk",
+                  "uncertainty": "2000 default multinomial patient resamples; shared weights across draws/methods; all visits travel together; >=80% valid required; draw SD separate",
+                  "deg": "corrected edgeR TMM limma-voom; duplicateCorrelation when repeated donor conditions; FDR<0.05 then top50 absolute logFC; no relabelled Welch",
+                  "rank_uncertainty": "CAT, RBO and DEG overlap have adaptation draw SD only; limma not refit per patient bootstrap; no fabricated rank CI",
+                  "legacy_contrast": "not consumed; retained separately as historical sensitivity"}
+    (output / "fig4_donor_aware_provenance.json").write_text(json.dumps(provenance, indent=2, allow_nan=False) + "\n")
+    print(json.dumps({"status": provenance["status"], "units": len(units), "signal_rows": len(all_rows)}))
+    if args.require_complete and not complete:
+        raise SystemExit("All 20 corrected disease units are required")
+
+
+if __name__ == "__main__":
+    main()

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/tools/donor_limma.R

@@ -0,0 +1,105 @@
+#!/usr/bin/env Rscript
+# Corrected disease DEG: existing donor x cell-type summed counts, collapsed by
+# donor x condition.  Paired conditions use duplicateCorrelation(block=donor).
+suppressPackageStartupMessages({
+  library(edgeR)
+  library(limma)
+  library(jsonlite)
+})
+args <- commandArgs(trailingOnly=TRUE)
+if (length(args) != 4L) stop("usage: donor_limma.R PSEUDOBULK.csv OUT_DIR CASE_LABELS CONTROL_LABELS")
+inp <- read.csv(args[1], stringsAsFactors=FALSE, check.names=FALSE)
+out <- args[2]
+case <- strsplit(args[3], ",", fixed=TRUE)[[1]]
+control <- strsplit(args[4], ",", fixed=TRUE)[[1]]
+if (length(intersect(case, control))) stop("case and control labels overlap")
+if (!"side" %in% names(inp)) inp$side <- "observed"
+required <- c("donor_id", "condition", "celltype", "gene_id", "count", "side")
+if (!all(required %in% names(inp))) stop("pseudobulk columns missing")
+if (any(!is.finite(inp$count) | inp$count < 0)) stop("nonfinite or negative counts")
+inp <- inp[inp$condition %in% c(case, control), , drop=FALSE]
+jobs <- split(inp, interaction(inp$side, inp$celltype, drop=TRUE), drop=TRUE)
+statuses <- list()
+genes_out <- list()
+for (name in names(jobs)) {
+  z <- jobs[[name]]
+  side <- z$side[1]
+  celltype <- z$celltype[1]
+  d <- unique(z[,c("donor_id", "condition")])
+  d <- d[order(d$donor_id, d$condition),,drop=FALSE]
+  d$group <- ifelse(d$condition %in% case, "case", "control")
+  ncase <- length(unique(d$donor_id[d$group == "case"]))
+  nctrl <- length(unique(d$donor_id[d$group == "control"]))
+  blocked <- any(table(d$donor_id) > 1L)
+  status <- list(side=side, celltype=celltype, n_donor_condition=nrow(d),
+                 n_case_donors=ncase, n_control_donors=nctrl,
+                 n_unique_donors=length(unique(d$donor_id)),
+                 method=if (blocked) "edgeR_TMM_limma_voom_duplicateCorrelation" else "edgeR_TMM_limma_voom",
+                 status="pending")
+  if (ncase < 2L || nctrl < 2L) {
+    status$status <- "not_estimable"
+    status$reason <- "fewer than two unique donors in a group"
+    statuses[[length(statuses)+1L]] <- status
+    next
+  }
+  result <- tryCatch({
+    gs <- sort(unique(z$gene_id))
+    sam <- paste(d$donor_id, d$condition, sep="\034")
+    M <- matrix(0, nrow=length(gs), ncol=nrow(d), dimnames=list(gs, sam))
+    ii <- match(z$gene_id, gs)
+    jj <- match(paste(z$donor_id, z$condition, sep="\034"), sam)
+    # Input may have multiple sample rows per donor-condition; sum them.
+    for (k in seq_len(nrow(z))) M[ii[k], jj[k]] <- M[ii[k], jj[k]] + z$count[k]
+    if (any(colSums(M) <= 0)) stop("zero donor-condition library")
+    grp <- factor(d$group, levels=c("control", "case"))
+    design <- model.matrix(~grp)
+    y <- DGEList(counts=M)
+    keep <- rowSums(M) > 0  # legacy primary 'nonzero' filter, now donor-aware fit
+    if (sum(keep) < 3L) stop("fewer than 3 genes pass nonzero filter")
+    y <- y[keep,,keep.lib.sizes=FALSE]
+    y <- calcNormFactors(y, method="TMM")
+    v <- voom(y, design, plot=FALSE)
+    corr <- NA_real_
+    if (blocked) {
+      dc <- duplicateCorrelation(v, design, block=d$donor_id)
+      corr <- dc$consensus.correlation
+      if (!is.finite(corr)) stop("duplicateCorrelation undefined")
+      v <- voom(y, design, plot=FALSE, block=d$donor_id, correlation=corr)
+      fit <- eBayes(lmFit(v, design, block=d$donor_id, correlation=corr))
+    } else {
+      fit <- eBayes(lmFit(v, design))
+    }
+    tt <- topTable(fit, coef=2, number=Inf, sort.by="none")
+    cols <- c("logFC", "AveExpr", "t", "P.Value", "adj.P.Val", "B")
+    if (!identical(rownames(tt), rownames(y))) stop("gene row order changed")
+    g <- data.frame(side=side, celltype=celltype, gene_id=rownames(tt),
+                    tt[,cols,drop=FALSE], check.names=FALSE)
+    ord <- order(-abs(g$logFC), g$gene_id)
+    significant <- g[ord, , drop=FALSE]
+    significant <- significant[is.finite(significant$adj.P.Val) & significant$adj.P.Val < 0.05,,drop=FALSE]
+    g$top50 <- g$gene_id %in% head(significant$gene_id, 50L)
+    list(genes=g, n_tested=nrow(g), n_sig=nrow(significant),
+         top50=head(significant$gene_id, 50L), correlation=corr)
+  }, error=function(e) e)
+  if (inherits(result, "error")) {
+    status$reason <- conditionMessage(result)
+    if (grepl("zero donor-condition library|fewer than 3 genes|duplicateCorrelation undefined",
+              status$reason)) status$status <- "not_estimable"
+  } else {
+    status$status <- "ok"
+    status$n_tested <- result$n_tested
+    status$n_significant_fdr05 <- result$n_sig
+    status$top50_gene_ids <- as.list(result$top50)
+    if (blocked) status$duplicate_correlation <- result$correlation
+    genes_out[[length(genes_out)+1L]] <- result$genes
+  }
+  statuses[[length(statuses)+1L]] <- status
+}
+if (length(genes_out)) write.csv(do.call(rbind, genes_out), file.path(out, "donor_limma_genes.csv"), row.names=FALSE)
+job_states <- vapply(statuses, function(x) x$status, character(1))
+overall <- if (length(statuses) == 0L) "complete_with_not_estimable" else
+           if (any(job_states == "pending")) "partial_or_pending" else
+           if (any(job_states == "not_estimable")) "complete_with_not_estimable" else "ok"
+write_json(list(schema="pbisc.paper.donor-deg.v1", status=overall,
+                jobs=statuses, versions=list(R=R.version.string, limma=as.character(packageVersion("limma")), edgeR=as.character(packageVersion("edgeR")))),
+           file.path(out, "limma_status.json"), auto_unbox=TRUE, pretty=TRUE, na="null")

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/tools/donor_statistics.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+"""Donor-clustered comparisons and donor-aware pseudobulk DEG for strict pairs.
+
+The legacy scorers remain untouched.  This module reports corrected inference
+separately; visits and reused draw members never become independent donors.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+DEFAULT_BOOTSTRAPS = 2000
+DEFAULT_SEED = 20261012
+REQUIRED_PB = {"donor_id", "sample_id", "condition", "celltype", "gene_id", "count"}
+
+
+def validate_patient_mapping(mapping: pd.DataFrame) -> pd.DataFrame:
+    """One explicit patient per sample; repeated visits of a patient are allowed."""
+    need = {"sample_id", "donor_id"}
+    if not need <= set(mapping):
+        raise ValueError(f"patient mapping missing {sorted(need - set(mapping))}")
+    x = mapping.loc[:, ["sample_id", "donor_id"]].copy()
+    if x.isna().any().any() or x.astype(str).apply(lambda c: c.str.strip().eq("")).any().any():
+        raise ValueError("missing sample or donor identity")
+    x = x.astype(str)
+    if x.groupby("sample_id").donor_id.nunique().gt(1).any():
+        raise ValueError("conflicting donor IDs for a sample")
+    return x.drop_duplicates().reset_index(drop=True)
+
+
+def paired_donor_bootstrap(rows: pd.DataFrame, arm: str, baseline: str, *,
+                           n_boot: int = DEFAULT_BOOTSTRAPS, seed: int = DEFAULT_SEED) -> dict:
+    """Difference arm-baseline, paired by draw+sample, averaged within donor, then bootstrapped by donor.
+
+    A donor is sampled once per replicate, carrying all its visits and appearances
+    across draws.  Donors have equal weight irrespective of their visit count.
+    """
+    need = {"draw", "donor_id", "sample_id", "arm", "value"}
+    if not need <= set(rows):
+        raise ValueError(f"paired rows missing {sorted(need - set(rows))}")
+    if n_boot < 1:
+        raise ValueError("n_boot must be positive")
+    x = rows.loc[rows.arm.isin((arm, baseline)), list(need)].copy()
+    validate_patient_mapping(x)
+    if x.duplicated(["draw", "donor_id", "sample_id", "arm"]).any():
+        raise ValueError("duplicate draw/sample/arm metric")
+    x["value"] = pd.to_numeric(x.value, errors="coerce")
+    wide = x.pivot(index=["draw", "donor_id", "sample_id"], columns="arm", values="value")
+    if arm not in wide or baseline not in wide:
+        raise ValueError("no paired observations")
+    paired = wide[[arm, baseline]].replace([np.inf, -np.inf], np.nan)
+    n_bad = int(paired.isna().any(axis=1).sum())
+    paired = paired.dropna()
+    if paired.empty:
+        raise ValueError("no paired finite observations")
+    differences = paired[arm] - paired[baseline]
+    donor_mean = differences.groupby(level="donor_id").mean().sort_index()
+    values = donor_mean.to_numpy(dtype=float)
+    if len(values) < 2:
+        raise ValueError("bootstrap CI needs at least two independent donors")
+    rng = np.random.default_rng(seed)
+    draws = rng.integers(0, len(values), size=(n_boot, len(values)))
+    estimates = values[draws].mean(axis=1)
+    lo, hi = np.quantile(estimates, [0.025, 0.975])
+    return {"arm": arm, "baseline": baseline, "estimate": float(values.mean()),
+            "ci_low": float(lo), "ci_high": float(hi), "n_donors": len(values),
+            "n_paired_samples": int(len(paired)), "n_excluded_nonfinite_pairs": n_bad,
+            "n_boot": n_boot, "seed": seed, "bootstrap_unit": "donor_all_draws_and_visits"}
+
+
+def donor_condition_pseudobulk(rows: pd.DataFrame) -> pd.DataFrame:
+    """Sum existing per-sample cell-type counts within donor×condition; no new units."""
+    if not REQUIRED_PB <= set(rows):
+        raise ValueError(f"pseudobulk missing {sorted(REQUIRED_PB - set(rows))}")
+    keys = sorted(REQUIRED_PB | ({"side"} if "side" in rows else set()))
+    x = rows.loc[:, keys].copy()
+    validate_patient_mapping(x)
+    if x[list(REQUIRED_PB - {"count"})].isna().any().any():
+        raise ValueError("missing pseudobulk identity")
+    for col in ("donor_id", "sample_id", "condition", "celltype", "gene_id") + (("side",) if "side" in x else ()):
+        if x[col].astype(str).str.strip().eq("").any():
+            raise ValueError(f"empty {col}")
+        x[col] = x[col].astype(str)
+    x["count"] = pd.to_numeric(x["count"], errors="coerce")
+    if not np.isfinite(x["count"]).all() or x["count"].lt(0).any():
+        raise ValueError("pseudobulk counts must be finite and nonnegative")
+    if x.groupby("sample_id").condition.nunique().gt(1).any():
+        raise ValueError("conflicting conditions for a sample")
+    keys = ["donor_id", "condition", "celltype", "gene_id"] + (["side"] if "side" in x else [])
+    out = x.groupby(keys, as_index=False, sort=True)["count"].sum()
+    return out
+
+
+def pseudobulk_rows_from_arrays(*, sample_ids: np.ndarray, donors: np.ndarray,
+                                conditions: np.ndarray, gene_ids: np.ndarray, celltype: str,
+                                side: str, n_cells: np.ndarray, sums: np.ndarray) -> pd.DataFrame:
+    """Convert legacy sample×celltype summed counts to a narrow table.
+
+    One row per gene is retained, including measured zeros; samples with no
+    cells of this type are excluded, matching the legacy DEG row definition.
+    """
+    sample_ids, donors, conditions = (np.asarray(x).astype(str) for x in (sample_ids, donors, conditions))
+    gene_ids = np.asarray(gene_ids).astype(str)
+    n_cells = np.asarray(n_cells)
+    sums = np.asarray(sums, dtype=float)
+    S, G = len(sample_ids), len(gene_ids)
+    if len(donors) != S or len(conditions) != S or n_cells.shape != (S,) or sums.shape != (S, G):
+        raise ValueError("pseudobulk array shapes differ")
+    if not np.isfinite(sums).all() or (sums < 0).any() or (n_cells < 0).any():
+        raise ValueError("invalid pseudobulk counts or cell numbers")
+    keep = n_cells > 0
+    return pd.DataFrame({"sample_id": np.repeat(sample_ids[keep], G),
+                         "donor_id": np.repeat(donors[keep], G),
+                         "condition": np.repeat(conditions[keep], G),
+                         "celltype": celltype, "side": side,
+                         "gene_id": np.tile(gene_ids, int(keep.sum())),
+                         "count": sums[keep].reshape(-1)})
+
+
+def requires_donor_block(aggregated: pd.DataFrame) -> bool:
+    """Use duplicateCorrelation when any donor contributes multiple conditions."""
+    return bool(aggregated.groupby("donor_id").condition.nunique().gt(1).any())
+
+
+def score_table_with_patients(per_donor: pd.DataFrame, mapping: pd.DataFrame,
+                              *, draw: str) -> pd.DataFrame:
+    """Turn numeric legacy per-sample metrics into mapped long rows for inference."""
+    if not {"donor", "arm"} <= set(per_donor):
+        raise ValueError("legacy per_donor.csv missing donor/sample or arm")
+    patients = validate_patient_mapping(mapping)
+    x = per_donor.rename(columns={"donor": "sample_id"}).copy()
+    x["sample_id"] = x.sample_id.astype(str)
+    x = x.merge(patients, on="sample_id", how="left", validate="many_to_one")
+    if x.donor_id.isna().any():
+        raise ValueError(f"unmapped scored samples: {x.loc[x.donor_id.isna(), 'sample_id'].unique().tolist()[:5]}")
+    metrics = [c for c in per_donor if c not in {"donor", "arm", "group"} and pd.api.types.is_numeric_dtype(per_donor[c])]
+    out = x.melt(id_vars=["sample_id", "donor_id", "arm"], value_vars=metrics,
+                 var_name="metric", value_name="value")
+    out.insert(0, "draw", str(draw))
+    return out
+
+
+def summarize_metrics(long_rows: pd.DataFrame, *, baseline: str, n_boot: int = DEFAULT_BOOTSTRAPS,
+                      seed: int = DEFAULT_SEED) -> pd.DataFrame:
+    """One corrected CI per metric and paired arm, with explicit undefined status."""
+    outputs = []
+    for metric, group in long_rows.groupby("metric", sort=True):
+        for arm in sorted(set(group.arm) - {baseline}):
+            try:
+                result = paired_donor_bootstrap(group, arm, baseline, n_boot=n_boot, seed=seed)
+                result.update(metric=metric, status="ok")
+            except ValueError as exc:
+                result = {"metric": metric, "arm": arm, "baseline": baseline,
+                          "status": "undefined", "reason": str(exc)}
+            outputs.append(result)
+    return pd.DataFrame(outputs)
+
+
+def run_donor_limma(aggregated: pd.DataFrame, out_dir: Path, *,
+                    case: str = "case", control: str = "control", threads: int = 4) -> dict:
+    """Fit edgeR TMM + limma voom, adding duplicateCorrelation for paired donors.
+
+    The R worker writes status per cell type.  Any unavailable fit stays an
+    explicit gap; its results are never substituted with the old Welch score.
+    """
+    out_dir = Path(out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    path = out_dir / "donor_condition_pseudobulk.csv"
+    aggregated.to_csv(path, index=False)
+    worker = Path(__file__).with_name("donor_limma.R")
+    rscript = Path("/home/sj_server_1/miniforge3/bin/Rscript")
+    if not worker.is_file() or not rscript.is_file():
+        return {"status": "pending", "reason": "donor limma R worker or Rscript missing"}
+    env = dict(os.environ, CUDA_VISIBLE_DEVICES="", OMP_NUM_THREADS=str(threads),
+               OPENBLAS_NUM_THREADS=str(threads), MKL_NUM_THREADS=str(threads))
+    proc = subprocess.run([str(rscript), "--vanilla", str(worker), str(path), str(out_dir), case, control],
+                          env=env, capture_output=True, text=True)
+    (out_dir / "limma.log").write_text(proc.stdout + "\n--- stderr ---\n" + proc.stderr)
+    if proc.returncode:
+        return {"status": "pending", "reason": f"R fit failed (exit {proc.returncode}); inspect limma.log"}
+    return json.loads((out_dir / "limma_status.json").read_text())