Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261013T005008Z-reuse-audit-results-deck/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/REPORT.md

@@ -0,0 +1,34 @@
+# Existing-results reuse and duplicate-work cleanup — 2026-10-13
+
+The user authorized a whole-Model8 audit, prevention of redundant computation, rebuilding the available-results deck, and discarding assistant-created duplicate work.
+
+## Decisions implemented
+
+- The root EXPERIMENT_INDEX.md / JSONL registry cover the entire non-environment working tree, distinguish archive copies, and expose metadata reuse candidates. Matching metadata never substitutes for verified scientific equivalence.
+- Five repeated Sepsis LoRA training runs have identical64serialized tensor payloads to their original checkpoints, with matching support, base model, conditioning, optimizer and3000step recipe. The duplicate execution cost was601.36seconds. They are excluded as independent model evidence. See CONFIRMED_DUPLICATE_TRAINING.json.
+- All5completed Sepsis BayesPrism/CIBERSORTx results are now adopted with verified original support, inputs, output axes/hashes and draw-specific sampling. No method reruns were launched. Missing proof fails closed instead of falling back to expensive recomputation. Fresh corrected CPU statistics remain required.
+- Healthy strict curves differ from old n+7validation / early-stopping curves. Imperial/Giroux/Ji exact-five support differs from old12–15/12–14/7–9sample support. These are retained as explicitly changed protocols, not labelled duplicates.
+- The new34slide deck reuses completed evidence. Three saved-table redraws add healthy composition and corrected rare-state views without training or cell generation. Historical/diagnostic designs and pending strict updates are visibly separated.
+-45superseded generated working files were deleted (20,002,296bytes);36independent archivedpayload copies were read back and SHA-verified. Nine derivative rendering files are reproducible from the archivedPPTX. Original76slide deck, frozenarchives, sourcefigures, logs and manifests were preserved.
+
+## Retained evidence, not independent results
+
+Five duplicate-training serialized checkpoint files remain in place because current generation/train receipts bind their distinct full-file SHA values. Their tensorpayloads match the originals, but serialization metadata differs. Deleting them or substituting the older bytes would break existing output provenance and restart verification. Their duplicate status and canonical original links are recorded in the registry; no further training is scheduled to reproduce them. Remaining stagedmanuscript source and15authored edit templates are consumed by the campaign finalizer and are not disposable duplicates. Only the two obsolete previewPDFs were removed.
+
+## Current deck
+
+presentations/2026-09-30--paper-summary--r00/PBISC-Diffusion_results_review_20261013.pdf
+presentations/2026-09-30--paper-summary--r00/PBISC-Diffusion_results_review_20261013.pptx
+
+The old76slide deck remains the source/reference deck. The TODO-heavy8page layout and prior strict-preview deck have been retired. Figure6 remains awaiting user-prepared data.
+
+## Verification
+
+- Deconvolution integration:193passed,1dependency skip,18subtests; independent staticreview found no blockers. See deconvolution_tests_final.xml and deconvolution_verification.json.
+- Registry field/unknown/confirmedalias tests are recorded by the final verification run.
+- Deck:34nativePDF pages and34PPTX slides, source hashes and shape bounds checked; native and renderedPPTX views inspected.
+- No sealed Model8source or canonical manuscript text changed. No GitHub push or Overleaf synchronization.
+
+## Coverage boundary
+
+EXPERIMENT_REUSE_COVERAGE.json records precise scan counts and exclusions. Array/checkpoint payloads are inventoried, not all reloaded/hashed. The five confirmedSepsis duplicates have a separate streaming tensorpayload verification. Environment/cache descendants and directorysymlink targets are explicitly excluded from payload inspection; cross-host locationcatalog records are distinguished from fresh fileobservations.

paper-releases/pbisc-diffusion/updates/20261013T005008Z-reuse-audit-results-deck/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/RUNNING_OBSERVATION.json

@@ -0,0 +1,173 @@
+{
+  "at_utc": "2026-10-13T00:50:08.946968+00:00",
+  "source_host": "server_1",
+  "two_host_controller": {
+    "schema": "pbisc.two-host.status.v1",
+    "config_sha256": "56c62625359d63a2944984a4f60fd4b4b1aabc621826b1105f09be0e06a5fdd9",
+    "config_path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/two_host/config.json",
+    "state": "running",
+    "services": {
+      "local": {
+        "unit": "pbisc-strict-resume-20261012-local.service",
+        "remote": false,
+        "state": "running",
+        "properties": {
+          "Result": "success",
+          "ExecMainCode": "0",
+          "ExecMainStatus": "0",
+          "Description": "PBISC strict two-host 56c62625359d63a2944984a4f60fd4b4b1aabc621826b1105f09be0e06a5fdd9 local",
+          "LoadState": "loaded",
+          "ActiveState": "active",
+          "SubState": "running"
+        },
+        "observed_at": "2026-10-13T00:49:57.557704+00:00"
+      },
+      "remote-immicro-healthy-fold2-n5": {
+        "unit": "pbisc-strict-resume-20261012-remote-immicro-healthy-fold2-n5.service",
+        "remote": true,
+        "state": "completed",
+        "properties": {
+          "Result": "success",
+          "ExecMainCode": "1",
+          "ExecMainStatus": "0",
+          "Description": "PBISC strict two-host 56c62625359d63a2944984a4f60fd4b4b1aabc621826b1105f09be0e06a5fdd9 remote-immicro-healthy-fold2-n5",
+          "LoadState": "loaded",
+          "ActiveState": "active",
+          "SubState": "exited"
+        },
+        "observed_at": "2026-10-12T15:37:49.285312+00:00"
+      },
+      "remote-immicro-healthy-fold3-n5": {
+        "unit": "pbisc-strict-resume-20261012-remote-immicro-healthy-fold3-n5.service",
+        "remote": true,
+        "state": "completed",
+        "properties": {
+          "Result": "success",
+          "ExecMainCode": "1",
+          "ExecMainStatus": "0",
+          "Description": "PBISC strict two-host 56c62625359d63a2944984a4f60fd4b4b1aabc621826b1105f09be0e06a5fdd9 remote-immicro-healthy-fold3-n5",
+          "LoadState": "loaded",
+          "ActiveState": "active",
+          "SubState": "exited"
+        },
+        "observed_at": "2026-10-12T16:25:09.346766+00:00"
+      },
+      "remote-immicro-healthy-fold4-n5": {
+        "unit": "pbisc-strict-resume-20261012-remote-immicro-healthy-fold4-n5.service",
+        "remote": true,
+        "state": "completed",
+        "properties": {
+          "Result": "success",
+          "ExecMainCode": "1",
+          "ExecMainStatus": "0",
+          "Description": "PBISC strict two-host 56c62625359d63a2944984a4f60fd4b4b1aabc621826b1105f09be0e06a5fdd9 remote-immicro-healthy-fold4-n5",
+          "LoadState": "loaded",
+          "ActiveState": "active",
+          "SubState": "exited"
+        },
+        "observed_at": "2026-10-12T17:07:27.009369+00:00"
+      },
+      "remote-immicro-healthy-fold2-n10": {
+        "unit": "pbisc-strict-resume-20261012-remote-immicro-healthy-fold2-n10.service",
+        "remote": true,
+        "state": "completed",
+        "properties": {
+          "Result": "success",
+          "ExecMainCode": "1",
+          "ExecMainStatus": "0",
+          "Description": "PBISC strict two-host 56c62625359d63a2944984a4f60fd4b4b1aabc621826b1105f09be0e06a5fdd9 remote-immicro-healthy-fold2-n10",
+          "LoadState": "loaded",
+          "ActiveState": "active",
+          "SubState": "exited"
+        },
+        "observed_at": "2026-10-12T18:23:29.790344+00:00"
+      },
+      "remote-immicro-healthy-fold2-n20": {
+        "unit": "pbisc-strict-resume-20261012-remote-immicro-healthy-fold2-n20.service",
+        "remote": true,
+        "state": "completed",
+        "properties": {
+          "Result": "success",
+          "ExecMainCode": "1",
+          "ExecMainStatus": "0",
+          "Description": "PBISC strict two-host 56c62625359d63a2944984a4f60fd4b4b1aabc621826b1105f09be0e06a5fdd9 remote-immicro-healthy-fold2-n20",
+          "LoadState": "loaded",
+          "ActiveState": "active",
+          "SubState": "exited"
+        },
+        "observed_at": "2026-10-12T19:56:23.501050+00:00"
+      },
+      "remote-immicro-healthy-fold2-n40": {
+        "unit": "pbisc-strict-resume-20261012-remote-immicro-healthy-fold2-n40.service",
+        "remote": true,
+        "state": "completed",
+        "properties": {
+          "Result": "success",
+          "ExecMainCode": "1",
+          "ExecMainStatus": "0",
+          "Description": "PBISC strict two-host 56c62625359d63a2944984a4f60fd4b4b1aabc621826b1105f09be0e06a5fdd9 remote-immicro-healthy-fold2-n40",
+          "LoadState": "loaded",
+          "ActiveState": "active",
+          "SubState": "exited"
+        },
+        "observed_at": "2026-10-12T22:30:51.330725+00:00"
+      },
+      "remote-immicro-healthy-fold3-n10": {
+        "unit": "pbisc-strict-resume-20261012-remote-immicro-healthy-fold3-n10.service",
+        "remote": true,
+        "state": "completed",
+        "properties": {
+          "Result": "success",
+          "ExecMainCode": "1",
+          "ExecMainStatus": "0",
+          "Description": "PBISC strict two-host 56c62625359d63a2944984a4f60fd4b4b1aabc621826b1105f09be0e06a5fdd9 remote-immicro-healthy-fold3-n10",
+          "LoadState": "loaded",
+          "ActiveState": "active",
+          "SubState": "exited"
+        },
+        "observed_at": "2026-10-12T23:38:15.249264+00:00"
+      },
+      "remote-immicro-healthy-fold3-n20": {
+        "unit": "pbisc-strict-resume-20261012-remote-immicro-healthy-fold3-n20.service",
+        "remote": true,
+        "state": "running",
+        "properties": {
+          "Result": "success",
+          "ExecMainCode": "0",
+          "ExecMainStatus": "0",
+          "Description": "PBISC strict two-host 56c62625359d63a2944984a4f60fd4b4b1aabc621826b1105f09be0e06a5fdd9 remote-immicro-healthy-fold3-n20",
+          "LoadState": "loaded",
+          "ActiveState": "active",
+          "SubState": "running"
+        },
+        "observed_at": "2026-10-13T00:49:58.108393+00:00"
+      }
+    },
+    "remote_imported": [
+      "immicro-healthy-fold2-n5",
+      "immicro-healthy-fold3-n5",
+      "immicro-healthy-fold4-n5",
+      "immicro-healthy-fold2-n10",
+      "immicro-healthy-fold2-n20",
+      "immicro-healthy-fold2-n40",
+      "immicro-healthy-fold3-n10"
+    ],
+    "figure6": "waiting_user_data_no_execution",
+    "error": null,
+    "updated_at": "2026-10-13T00:49:58.108819+00:00",
+    "active": "immicro-healthy-fold3-n20",
+    "local_state": "running",
+    "remote_state": "running"
+  },
+  "local_campaign": {
+    "state": "running",
+    "stage": "all",
+    "started_at": "2026-10-12T14:35:32.695904+00:00",
+    "units_selected": 28,
+    "units_completed_this_invocation": 8,
+    "figure6": "waiting_user_data_no_execution",
+    "active": "imperial_eskd-disease-draw1",
+    "updated_at": "2026-10-13T00:29:29.149206+00:00"
+  },
+  "note": "Observation only. Ongoing scientifically changed exact-pair experiments are not marked complete by the current deck."
+}

paper-releases/pbisc-diffusion/updates/20261013T005008Z-reuse-audit-results-deck/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/backups/deconvolution/MANIFEST.json

@@ -0,0 +1,14 @@
+{
+  "files": [
+    {
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/tools/deconv_strict.py",
+      "backup": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/backups/deconvolution/tools/deconv_strict.py",
+      "sha256": "4ff691ee95f5a96722cc2e5369d5aecdee68218dfab349b73e9d29bd224b22e4"
+    },
+    {
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/tools/finalize_campaign.py",
+      "backup": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/backups/deconvolution/tools/finalize_campaign.py",
+      "sha256": "017e1a8a5d9c1a60bc082852c29019bf566c0c6aceafba91b1c9991918aba985"
+    }
+  ]
+}

paper-releases/pbisc-diffusion/updates/20261013T005008Z-reuse-audit-results-deck/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/backups/deconvolution/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())