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/reports/deconv_strict.md

@@ -0,0 +1,39 @@
+# Strict five-pair deconvolution adapter
+
+**2026-10-13 reuse correction:** all five Sepsis draws already have completed
+BayesPrism and CIBERSORTx outputs on exactly the same five reference samples
+and 77 mixture samples. Their `ADOPTION.json` records in
+`deconvolution/ye2026_sepsis/disease/draw{0..4}/` verify source/input/output hashes,
+axes and original draw-specific sampling. Sepsis runs **adopt → fresh corrected
+CPU scoring**. Missing or changed proof fails closed; the adapter never reruns
+either method as a fallback. Historical score-file versions are recorded
+truthfully and are not relabelled as corrected results.
+
+The native instructions below apply to the 15 Imperial/Giroux/Ji units whose
+exact-five supports differ from the historical multi-visit supports. Existing
+Sepsis source outputs must remain available for their hardlink/symlink views.
+
+`tools/deconv_strict.py` runs one disease unit at a time. The support manifest is authoritative: exactly its five `train_sample_ids` form the reference, exactly its `test_sample_ids` form the real-bulk mixture, and `excluded_sample_ids` never enter either side. The old five-donor/all-visits split is not used. The original `aggregates_full.npz` is linked read-only inside the new unit output; it is a per-sample raw-count aggregate, not a fitted model or test-derived reference. The legacy builders and scorer are imported into one isolated Python invocation and redirected in memory. No legacy file is edited.
+
+For a unit such as `protocol/splits/ji2025_chili/disease/draw0/support.json`, run from this plan directory:
+
+```bash
+CUDA_VISIBLE_DEVICES='' python tools/deconv_strict.py --support-manifest protocol/splits/ji2025_chili/disease/draw0/support.json --action prepare --threads 4
+CUDA_VISIBLE_DEVICES='' python tools/deconv_strict.py --support-manifest protocol/splits/ji2025_chili/disease/draw0/support.json --action bayesprism --threads 4
+CUDA_VISIBLE_DEVICES='' python tools/deconv_strict.py --support-manifest protocol/splits/ji2025_chili/disease/draw0/support.json --action cibersortx --threads 4
+CUDA_VISIBLE_DEVICES='' python tools/deconv_strict.py --support-manifest protocol/splits/ji2025_chili/disease/draw0/support.json --action score --threads 4
+```
+
+`--action all` performs the native stages in order for non-Sepsis cohorts and adoption plus scoring for Sepsis. `--out` is accepted only when it equals the unit's canonical `deconvolution/<cohort>/disease/drawN` directory. Native method runs apply only to the 15 non-Sepsis disease support manifests, one unit at a time. The CIBERSORTx action checks the two existing local images. It reads `cibersortx.key` only at runtime, writes a temporary mode-600 env file, expands credentials inside the container, redacts any echoed values before saving a log, and removes the temp file. It does not install images. Its two containers are each capped at 16 GiB and the requested CPU count. BayesPrism reuses the existing pinned R script and R library.
+
+Memory-heavy native methods and scoring run the host guard checks first, defer when CUDA compute is present, and require at least 48 GiB `MemAvailable`. Lightweight Sepsis adoption verifies existing files without launching a method. The adapter never starts a CUDA process.
+
+Each unit writes `INPUTS.json`, BayesPrism and CIBERSORTx method outputs, and `score/{figure4_methods.csv,expression_signal.csv,SUMMARY.json}`. The shared `deconvolution/deconvolution_manifest.json` is an atomic Figure 4 input with exact support hash, reference and mixture IDs, source hashes, methods, metric summaries, and CSV hashes. Pass it to `tools/build_results_figures.py --deconvolution-manifest deconvolution/deconvolution_manifest.json`. The old five-fold results remain a separately labelled historical panel.
+
+Preparation is immutable once `INPUTS.json` exists: rerunning `prepare` verifies every input hash and the raw-count aggregate link, then returns without rewriting. A method's existing `DONE` is reusable only with a receipt bound to the support hash, prepared input hash, and method output hashes. HiRes also binds its copied Fractions signature, source GEP, and filtered fractions results. Changed inputs, an unreceipted existing `DONE`, or partial method files fail closed; the adapter does not delete or automatically relaunch those outputs.
+
+The composition CSV contains observed and predicted cell fractions by test sample and six-type gate. The signal CSV has a donor-aware primary sensitivity: visits are averaged within donor and case/control condition after per-sample log2-CPM normalization, so each donor-condition contributes once. On the same covered scoring genes, observed and method profiles receive separate unweighted limma `lmFit`/`eBayes` fits, with `duplicateCorrelation` and donor blocking when donors appear in both conditions. It exports donor-equal logFC correlation, partial correlation given real bulk, and FDR-significant top-50 DEG overlap where estimable. BayesPrism Z and CIBERSORTx HiRes are continuous posterior or imputed expression, so this is labelled continuous-expression sensitivity, separate from the raw-integer-count edgeR/limma-voom primary in `donor_statistics.py`. The historical sample-level Welch family is retained with distinct metric names and `gene_variant` values. HiRes with at most eight mixture samples, missing output, or zero imputed genes is `not_estimable`, never zero. Missing limma infrastructure is `pending`; scientifically underpowered groups or genes are `not_estimable`. Method-only scores are not relabelled as a LoRA comparison.
+
+`score/SUMMARY.json` has top-level `status`, `required_methods`, `methods`, `metrics`, and `pending_reasons`. A completed method has `methods.<name>.status=complete`; a missing required method or required HiRes output is `pending`. `metrics.<name>.corrected_deg.status` is `complete`, `not_estimable` for a scientific data limit, or `pending` for missing fit infrastructure. Any pending method or type fit makes the top-level status `pending`; the `score`/`all` CLI action returns nonzero and does not publish a Figure 4 manifest entry. If a previous completed entry exists, it moves to `inactive_units` with its evidence preserved so Figure 4 cannot mistake a pending rerun for completion. HiRes at most eight mixtures or a verified zero-imputed result is scientifically `not_estimable`.
+
+Verification so far: thirteen focused CPU tests pass, covering all 20 strict support manifests, exact five-reference selection, exclusion of visits, rejection of extra or missing method mixtures and HiRes types, output isolation and hostile unit paths, receipt/input immutability and partial-output preservation, pending readiness precedence and stale Figure 4 invalidation, credential-free host argv and saved logs, equal donor-condition weighting with repeated visits, and tiny unpaired/paired limma fixtures. No BayesPrism or CIBERSORTx method was executed as part of this implementation.

paper-releases/pbisc-diffusion/updates/20261013T005008Z-reuse-audit-results-deck/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/tests/test_deconv_adoption.py

@@ -0,0 +1,262 @@
+"""Reject scientific/provenance drift and avoid repeating completed Sepsis methods."""
+from __future__ import annotations
+
+import gzip
+import errno
+import hashlib
+import importlib
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "tools"))
+import deconv_strict as D
+
+
+def digest(p: Path) -> str:
+    return hashlib.sha256(p.read_bytes()).hexdigest()
+
+
+def write(p: Path, value: str) -> Path:
+    p.parent.mkdir(parents=True, exist_ok=True)
+    if p.suffix == ".gz":
+        with gzip.open(p, "wt") as f:
+            f.write(value)
+    else:
+        p.write_text(value)
+    return p
+
+
+def fixture(tmp: Path, draw: int = 3) -> tuple[dict, Path, Path, Path]:
+    old, ft, out = tmp / "old", tmp / "ft", tmp / "unit"
+    train, test = [f"S{i}" for i in range(5)], [f"T{i}" for i in range(9)]
+    s = dict(schema="pbisc.paper.strict-support.v1", cohort="ye2026_sepsis",
+             design="disease_existing_draw", unit=f"draw{draw}_n5", n_pairs=5,
+             train_sample_ids=train, train_donor_ids=train, test_sample_ids=test,
+             test_donor_ids=test, excluded_sample_ids=[])
+    s["sha256"] = hashlib.sha256(json.dumps(s, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
+    for name in ("build_split.py", "build_cibersortx_inputs.py", "common.py", "score_bp.py",
+                 "run_bp.R", "run_cibersortx.sh"):
+        write(old / "tools" / name, f"source {name}\n")
+    write(ft / "tools/score_ft.py", "score source\n")
+    aggregate = write(old / "data/ye2026_sepsis/aggregates_full.npz", "aggregate fixture\n")
+    bp = old / f"inputs/ye2026_sepsis/fewshot{draw}_full"
+    cx = old / f"cibersortx/ye2026_sepsis/fewshot{draw}"
+    types = ["B cell", "DC", "Monocyte", "NK cell", "Other", "T cell"]
+    for name, val in (("reference.tsv.gz", "state\tG1\nT|a\t2\n"),
+                      ("mixture.tsv.gz", "sample\tG1\n" + "".join(f"{x}\t2\n" for x in test)),
+                      ("state_types.tsv", "state\ttype\tn_cells\nT|a\tT cell\t10\n")):
+        write(bp / name, val)
+    b = dict(dataset=s["cohort"], kind="fewshot", idx=draw, reference=train[::-1], mixture=test,
+             train_donors=train[::-1], run_json_check=True, n_reference_samples=5,
+             n_mixture_samples=9, gene_mode="full", aggregates_sha256=digest(aggregate),
+             tool_sha256=digest(old / "tools/build_split.py"),
+             common_sha256=digest(old / "tools/common.py"),
+             files={n: digest(bp / n) for n in ("reference.tsv.gz", "mixture.tsv.gz", "state_types.tsv")})
+    write(bp / "SPLIT.json", json.dumps(b))
+    for name in ("refsample.txt", "mixture.txt", "hires_genes.txt"):
+        write(cx / name, f"{name} draw {draw}\n")
+    c = dict(dataset=s["cohort"], kind="fewshot", idx=draw, reference_samples=train,
+             mixture_samples=test, seed=20261006, cells_per_type_cap=400,
+             tool_sha256=digest(old / "tools/build_cibersortx_inputs.py"),
+             common_sha256=digest(old / "tools/common.py"),
+             files={n: digest(cx / n) for n in ("refsample.txt", "mixture.txt", "hires_genes.txt")})
+    write(cx / "INPUT.json", json.dumps(c))
+    theta = "," + ",".join(types) + "\n" + "".join(f"{x},0.1,0.1,0.2,0.2,0.2,0.2\n" for x in test)
+    write(bp / "bp/theta_final.csv", theta)
+    write(bp / "bp/theta_first.csv", theta)
+    write(bp / "bp/genes_used.txt", "G1\n")
+    write(bp / "bp/DONE", "1.2\n")
+    for typ in types:
+        write(bp / f"bp/Z_type_{typ.replace(' ', '_')}.tsv.gz", "sample\tG1\n" + "".join(f"{x}\t2\n" for x in test))
+        write(cx / f"out_hires/CIBERSORTxHiRes_NA_{typ.replace(' ', '')}_Window24.txt",
+              "GeneSymbol\t" + "\t".join(test) + "\nG1\t" + "\t".join(["2"] * 9) + "\n")
+    write(cx / "out_fractions/CIBERSORTx_Adjusted.txt", theta.replace(",", "\t"))
+    write(cx / "out_fractions/DONE", "10\n")
+    write(cx / "out_hires/DONE", "20\n")
+    for a, bname, content in [("sigmatrix.txt", "fixture_inferred_refsample.bm.K999.txt", "signature\n"),
+                             ("source_geps.txt", "CIBERSORTx_cell_type_sourceGEP.txt", "gep\n")]:
+        write(cx / a, content); write(cx / "out_fractions" / bname, content)
+    write(cx / "out_hires/fractions_results.txt", theta.replace(",", "\t"))
+    for mode, method in (("full", "bayesprism"), ("cibersortx", "cibersortx")):
+        summary = dict(dataset=s["cohort"], comparison="fewshot", draw=draw, gene_mode=mode,
+                       n_donors=9, method=method, has_cell_type_expression=True,
+                       tool_sha256=digest(old / "tools/score_bp.py"),
+                       score_ft_sha256=digest(ft / "tools/score_ft.py"),
+                       gates={"observed_composition_equal": True, "broadcast_r_equal": True, "broadcast_deg_equal": True})
+        write(old / f"results/ye2026_sepsis/fewshot_draw{draw}_{mode}/summary.json", json.dumps(summary))
+    return s, old, ft, out
+
+
+def helper():
+    assert (ROOT / "tools/adopt_deconv_legacy.py").is_file(), "Missing explicit historical adoption path"
+    return importlib.import_module("adopt_deconv_legacy")
+
+
+def test_adopts_completed_methods_without_claiming_native_execution(tmp_path: Path):
+    a = helper()
+    s, old, ft, out = fixture(tmp_path)
+    proof = a.adopt(s, out, old=old, ft=ft)
+    assert proof["schema"] == "pbisc.deconvolution.adopted-legacy.v1"
+    assert proof["legacy_draw_index"] == 3
+    assert proof["method_execution"] == "historical_outputs_reused_no_method_execution"
+    assert (out / "adopted_legacy/cibersortx/ye2026_sepsis/fewshot3/INPUT.json").is_file()
+    assert not (out / "adopted_legacy/cibersortx/ye2026_sepsis/fewshot0").exists()
+    assert a.verify(s, out)["support_sha256"] == s["sha256"]
+    before = (out / "ADOPTION.json").read_bytes()
+    a.adopt(s, out, old=old, ft=ft)
+    assert (out / "ADOPTION.json").read_bytes() == before
+
+
+@pytest.mark.parametrize("change", ["support", "input", "source", "missing_done", "wrong_output_samples"])
+def test_invalid_scientific_or_provenance_inputs_fail_before_adoption(tmp_path: Path, change: str):
+    a = helper()
+    s, old, ft, out = fixture(tmp_path)
+    if change == "support":
+        s["train_sample_ids"][0] = "EXTRA"
+    elif change == "input":
+        write(old / "cibersortx/ye2026_sepsis/fewshot3/refsample.txt", "altered")
+    elif change == "source":
+        write(old / "tools/build_split.py", "changed source")
+    elif change == "missing_done":
+        (old / "inputs/ye2026_sepsis/fewshot3_full/bp/DONE").unlink()
+    else:
+        f = old / "inputs/ye2026_sepsis/fewshot3_full/bp/theta_final.csv"
+        f.write_text(f.read_text().replace("T0,", "TRAIN,"))
+    with pytest.raises((ValueError, FileNotFoundError)):
+        a.adopt(s, out, old=old, ft=ft)
+    assert not (out / "ADOPTION.json").exists()
+
+
+def test_adopted_output_mutation_is_rejected(tmp_path: Path):
+    a = helper()
+    s, old, ft, out = fixture(tmp_path)
+    a.adopt(s, out, old=old, ft=ft)
+    write(old / "cibersortx/ye2026_sepsis/fewshot3/out_hires/CIBERSORTxHiRes_NA_Tcell_Window24.txt", "altered")
+    with pytest.raises(ValueError, match="changed"):
+        a.verify(s, out)
+
+
+def test_fraction_serialization_roundoff_is_preserved_but_actual_changes_rejected(tmp_path: Path):
+    a = helper()
+    s, old, ft, out = fixture(tmp_path)
+    p = old / "cibersortx/ye2026_sepsis/fewshot3/out_hires/fractions_results.txt"
+    p.write_text(p.read_text().replace("0.2", "0.2000000000000001"))
+    assert a.verify_legacy(s, old=old, ft=ft)["fraction_serialization_max_abs_error"] < 2e-16
+    p.write_text(p.read_text().replace("0.2000000000000001", "0.21"))
+    with pytest.raises(ValueError, match="fractions differ"):
+        a.verify_legacy(s, old=old, ft=ft)
+
+
+def test_altered_adoption_manifest_cannot_drop_hash_checks(tmp_path: Path):
+    a = helper()
+    s, old, ft, out = fixture(tmp_path)
+    a.adopt(s, out, old=old, ft=ft)
+    p = out / "ADOPTION.json"
+    proof = json.loads(p.read_text())
+    proof["files"].pop()
+    p.write_text(json.dumps(proof))
+    with pytest.raises(ValueError, match="receipt hash"):
+        a.verify(s, out)
+
+
+def test_older_scoring_receipt_is_kept_as_historical_not_claimed_replayed(tmp_path: Path):
+    a = helper()
+    s, old, ft, out = fixture(tmp_path)
+    p = old / "results/ye2026_sepsis/fewshot_draw3_full/summary.json"
+    summary = json.loads(p.read_text())
+    summary.pop("has_cell_type_expression")
+    summary.pop("method")
+    summary["bayesprism"] = {"per_type_logfc_r": {k: 0.5 for k in ("T cell", "B cell", "Monocyte", "NK cell")}}
+    summary["tool_sha256"] = "a" * 64
+    p.write_text(json.dumps(summary))
+    proof = a.verify_legacy(s, old=old, ft=ft)
+    assert proof["legacy_endpoints"]["full"]["old_scores_reused"] is False
+    assert proof["legacy_endpoints"]["full"]["scorer_source_matches_current"] is False
+
+
+def test_readable_root_owned_outputs_reuse_symlinks_without_copying(tmp_path: Path, monkeypatch):
+    a = helper()
+    s, old, ft, out = fixture(tmp_path)
+    link = a.os.link
+    def protected(source, target):
+        if Path(source).name == "CIBERSORTx_Adjusted.txt":
+            raise PermissionError(errno.EPERM, "protected hardlink")
+        return link(source, target)
+    monkeypatch.setattr(a.os, "link", protected)
+    a.adopt(s, out, old=old, ft=ft)
+    target = out / "adopted_legacy/cibersortx/ye2026_sepsis/fewshot3/out_fractions/CIBERSORTx_Adjusted.txt"
+    assert target.is_symlink()
+    assert target.resolve() == old / "cibersortx/ye2026_sepsis/fewshot3/out_fractions/CIBERSORTx_Adjusted.txt"
+    assert a.verify(s, out)["legacy_draw_index"] == 3
+
+
+def test_sepsis_method_calls_reuse_and_never_spawn_method_process(tmp_path: Path, monkeypatch):
+    a = helper()
+    s, old, ft, out = fixture(tmp_path)
+    a.adopt(s, out, old=old, ft=ft)
+    monkeypatch.setattr(D.subprocess, "run", lambda *_a, **_k: pytest.fail("method subprocess launched"))
+    D.bayesprism(s, out, 2)
+    assert D.cibersortx(s, out, 2)["hires"] == "complete"
+    assert D.verify_stage_receipt(s, out, "hires")["method_execution"] == "historical_outputs_reused_no_method_execution"
+
+
+def test_unproved_sepsis_fails_without_launch_or_heavy_prepare(tmp_path: Path, monkeypatch):
+    helper()
+    s, old, ft, out = fixture(tmp_path)
+    monkeypatch.setattr(D, "OLD", tmp_path / "absent")
+    monkeypatch.setattr(D.subprocess, "run", lambda *_a, **_k: pytest.fail("unproved method relaunched"))
+    with pytest.raises((ValueError, FileNotFoundError)):
+        D.bayesprism(s, out, 2)
+
+
+def test_strict_split_dispatch_preserves_draw_specific_subsampling(tmp_path: Path):
+    s, old, ft, out = fixture(tmp_path)
+    c = D.patched_modules(s, out)
+    assert c.split_rows("ye2026_sepsis", "fewshot", 3)["reference"] == s["train_sample_ids"]
+    with pytest.raises(ValueError):
+        c.split_rows("ye2026_sepsis", "fewshot", 0)
+
+
+def test_finalizer_uses_adopt_then_score_and_preserves_existing_adoption(tmp_path: Path, monkeypatch):
+    import finalize_campaign as f
+    s, old, ft, out = fixture(tmp_path)
+    monkeypatch.setattr(f, "ROOT", tmp_path)
+    monkeypatch.setattr(f.C, "ROOT", tmp_path)
+    monkeypatch.setattr(f, "wait_cuda_idle", lambda: None)
+    path = write(tmp_path / "protocol/splits/ye2026_sepsis/disease/draw3/support.json", json.dumps(s))
+    target = tmp_path / "deconvolution/ye2026_sepsis/disease/draw3"
+    helper().adopt(s, target, old=old, ft=ft)
+    calls = []
+    class RuntimeBoundary:
+        def receipt_path(self, name):
+            return tmp_path / "receipts" / f"{name}.json"
+        def execute(self, name, argv, **kwargs):
+            action = argv[argv.index("--action") + 1]
+            calls.append((action, kwargs))
+            if action == "score":
+                write(target / "score/SUMMARY.json", '{"status":"complete"}')
+    f.deconvolution(RuntimeBoundary(), [path])
+    assert [x[0] for x in calls] == ["adopt", "score"]
+    assert calls[0][1]["previous_outputs"][str(target / "ADOPTION.json")]["sha256"] == digest(target / "ADOPTION.json")
+
+
+def test_finalizer_checks_live_sources_before_runtime_can_skip(tmp_path: Path, monkeypatch):
+    import finalize_campaign as f
+    s, old, ft, out = fixture(tmp_path)
+    monkeypatch.setattr(f, "ROOT", tmp_path)
+    monkeypatch.setattr(f.C, "ROOT", tmp_path)
+    path = write(tmp_path / "protocol/splits/ye2026_sepsis/disease/draw3/support.json", json.dumps(s))
+    target = tmp_path / "deconvolution/ye2026_sepsis/disease/draw3"
+    helper().adopt(s, target, old=old, ft=ft)
+    write(old / "cibersortx/ye2026_sepsis/fewshot3/refsample.txt", "altered")
+    class RuntimeBoundary:
+        def receipt_path(self, name):
+            return tmp_path / "receipts" / f"{name}.json"
+        def execute(self, *_args, **_kwargs):
+            pytest.fail("unchecked adoption reached runtime skip/execute")
+    with pytest.raises(ValueError, match="changed"):
+        f.deconvolution(RuntimeBoundary(), [path])

paper-releases/pbisc-diffusion/updates/20261013T005008Z-reuse-audit-results-deck/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/tools/adopt_deconv_legacy.py

@@ -0,0 +1,312 @@
+"""Bounded-memory, fail-closed adoption of completed exact-five Sepsis deconvolution.
+
+This does not execute either method or prepare new reference cells. Historical
+input manifests, completion markers, scored summaries and current source bytes
+are verified before a separate provenance receipt and linked view are created.
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import errno
+import gzip
+import hashlib
+import json
+import math
+import os
+import re
+import tempfile
+from pathlib import Path
+
+PLAN = Path(__file__).resolve().parents[1]
+OLD = PLAN.parent / "bayesprism_paired_20261006"
+FT = PLAN.parent / "paired_finetune_intradataset_20260927"
+SCHEMA = "pbisc.deconvolution.adopted-legacy.v1"
+TYPES = ("B cell", "DC", "Monocyte", "NK cell", "Other", "T cell")
+
+
+def sha(path: Path, *, unpack: bool = False) -> str:
+    h = hashlib.sha256()
+    with (gzip.open(path, "rb") if unpack else path.open("rb")) as f:
+        for chunk in iter(lambda: f.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def read(path: Path) -> dict:
+    return json.loads(path.read_text())
+
+
+def receipt_hash(proof: dict) -> str:
+    body = {k: v for k, v in proof.items() if k != "receipt_sha256"}
+    return hashlib.sha256(json.dumps(body, sort_keys=True, separators=(",", ":"), allow_nan=False).encode()).hexdigest()
+
+
+def _support(s: dict) -> int:
+    body = {k: v for k, v in s.items() if k != "sha256"}
+    expected = hashlib.sha256(json.dumps(body, sort_keys=True, separators=(",", ":"), allow_nan=False).encode()).hexdigest()
+    if s.get("sha256") != expected or s.get("schema") != "pbisc.paper.strict-support.v1":
+        raise ValueError("strict support hash/schema mismatch")
+    match = re.fullmatch(r"draw([0-4])_n5", s.get("unit", ""))
+    if s.get("cohort") != "ye2026_sepsis" or not match or s.get("design") != "disease_existing_draw":
+        raise ValueError("legacy adoption is limited to exact-five Sepsis draws")
+    train, test = s["train_sample_ids"], s["test_sample_ids"]
+    if (s.get("n_pairs") != 5 or len(train) != 5 or len(set(train)) != 5
+            or len(s["train_donor_ids"]) != 5 or len(set(s["train_donor_ids"])) != 5
+            or not test or len(test) != len(set(test)) or len(test) != len(s["test_donor_ids"])
+            or set(train) & set(test) or set(s["train_donor_ids"]) & set(s["test_donor_ids"])
+            or set(s["excluded_sample_ids"]) & set(train + test)):
+        raise ValueError("invalid exact-five support")
+    return int(match.group(1))
+
+
+def _axis(path: Path, samples: list[str], *, columns: bool = False, sep: str = "\t") -> None:
+    """Read only labels/axes, never materialize an expression matrix."""
+    with (gzip.open(path, "rt") if path.suffix == ".gz" else path.open()) as f:
+        rows = csv.reader(f, delimiter=sep)
+        header = next(rows)
+        ids = header[1:] if columns else [r[0] for r in rows if r]
+    if len(ids) != len(samples) or set(ids) != set(samples):
+        raise ValueError(f"output mixtures differ from exact support: {path}")
+
+
+def _files(manifest: dict, directory: Path, names: tuple[str, ...]) -> list[Path]:
+    if set(manifest.get("files", {})) != set(names):
+        raise ValueError(f"unexpected input file contract: {directory}")
+    paths = []
+    for name in names:
+        path = directory / name
+        if sha(path) != manifest["files"][name]:
+            raise ValueError(f"legacy input changed: {path}")
+        paths.append(path)
+    return paths
+
+
+def verify_legacy(s: dict, *, old: Path = OLD, ft: Path = FT) -> dict:
+    draw = _support(s)
+    ds, split = s["cohort"], f"fewshot{draw}"
+    bp, cx = old / "inputs" / ds / f"{split}_full", old / "cibersortx" / ds / split
+    b, c = read(bp / "SPLIT.json"), read(cx / "INPUT.json")
+    artifacts = [bp / "SPLIT.json", cx / "INPUT.json"]
+    for manifest, rk, mk in ((b, "reference", "mixture"), (c, "reference_samples", "mixture_samples")):
+        if (manifest.get("dataset") != ds or manifest.get("kind") != "fewshot" or manifest.get("idx") != draw
+                or len(manifest[rk]) != 5 or set(manifest[rk]) != set(s["train_sample_ids"])
+                or manifest[mk] != s["test_sample_ids"]):
+            raise ValueError("legacy reference/mixture differs from exact support or draw")
+    if (b.get("gene_mode") != "full" or b.get("run_json_check") is not True
+            or set(b["train_donors"]) != set(s["train_donor_ids"])
+            or b.get("n_reference_samples") != 5 or b.get("n_mixture_samples") != len(s["test_sample_ids"])
+            or c.get("seed") != 20261006 or c.get("cells_per_type_cap") != 400):
+        raise ValueError("legacy scientific recipe differs")
+    for manifest, name in ((b, "build_split.py"), (c, "build_cibersortx_inputs.py")):
+        for field, src in (("tool_sha256", old / "tools" / name),
+                           ("common_sha256", old / "tools/common.py")):
+            if sha(src) != manifest[field]:
+                raise ValueError(f"legacy source changed: {src}")
+            artifacts.append(src)
+    aggregate = old / "data" / ds / "aggregates_full.npz"
+    if sha(aggregate) != b["aggregates_sha256"]:
+        raise ValueError("legacy raw-count aggregate changed")
+    artifacts.append(aggregate)
+    artifacts += _files(b, bp, ("reference.tsv.gz", "mixture.tsv.gz", "state_types.tsv"))
+    artifacts += _files(c, cx, ("refsample.txt", "mixture.txt", "hires_genes.txt"))
+    for method in (bp / "bp", cx / "out_fractions", cx / "out_hires"):
+        done = method / "DONE"
+        if not done.is_file() or not done.read_text().strip():
+            raise FileNotFoundError(f"legacy DONE missing: {done}")
+        artifacts.append(done)
+    for name in ("theta_final.csv", "theta_first.csv"):
+        p = bp / "bp" / name
+        _axis(p, s["test_sample_ids"], sep=",")
+        artifacts.append(p)
+    artifacts.append(bp / "bp/genes_used.txt")
+    for typ in TYPES:
+        p = bp / "bp" / f"Z_type_{typ.replace(' ', '_')}.tsv.gz"
+        _axis(p, s["test_sample_ids"])
+        artifacts.append(p)
+        candidates = sorted((cx / "out_hires").glob(f"CIBERSORTxHiRes_*_{typ.replace(' ', '')}_Window*.txt"))
+        if len(candidates) != 1:
+            raise ValueError(f"missing or ambiguous historical HiRes type: {typ}")
+        _axis(candidates[0], s["test_sample_ids"], columns=True)
+        artifacts.append(candidates[0])
+    fractions = cx / "out_fractions/CIBERSORTx_Adjusted.txt"
+    _axis(fractions, s["test_sample_ids"])
+    artifacts.append(fractions)
+    signatures = sorted((cx / "out_fractions").glob("*inferred_refsample.bm.K999.txt"))
+    if len(signatures) != 1 or sha(signatures[0]) != sha(cx / "sigmatrix.txt"):
+        raise ValueError("historical HiRes signature differs from Fractions output")
+    gep = cx / "out_fractions/CIBERSORTx_cell_type_sourceGEP.txt"
+    if sha(gep) != sha(cx / "source_geps.txt"):
+        raise ValueError("historical HiRes source GEP differs from Fractions output")
+    selected_fractions = cx / "out_hires/fractions_results.txt"
+    _axis(selected_fractions, s["test_sample_ids"])
+    fraction_error = 0.0
+    with fractions.open() as f, selected_fractions.open() as g:
+        source_rows, used_rows = csv.DictReader(f, delimiter="\t"), csv.DictReader(g, delimiter="\t")
+        fields = [x for x in source_rows.fieldnames if x not in ("P-value", "Correlation", "RMSE")]
+        if fields != used_rows.fieldnames:
+            raise ValueError("historical HiRes fraction columns differ")
+        for left, right in zip(source_rows, used_rows, strict=True):
+            errors = [abs(float(left[k]) - float(right[k])) for k in fields[1:]]
+            if left[fields[0]] != right[fields[0]] or any(not math.isfinite(v) or v > 1e-15 for v in errors):
+                raise ValueError("historical HiRes fractions differ from Fractions output")
+            fraction_error = max(fraction_error, max(errors, default=0.0))
+    artifacts += [signatures[0], cx / "sigmatrix.txt", gep, cx / "source_geps.txt", selected_fractions]
+    endpoints = {}
+    for mode in ("full", "cibersortx"):
+        p = old / "results" / ds / f"fewshot_draw{draw}_{mode}/summary.json"
+        summary = read(p)
+        expression_present = summary.get("has_cell_type_expression") is True or (
+            mode == "full" and set(summary.get("bayesprism", {}).get("per_type_logfc_r", {}))
+            >= {"T cell", "B cell", "Monocyte", "NK cell"})
+        if (summary.get("dataset") != ds or summary.get("comparison") != "fewshot"
+                or summary.get("draw") != draw or summary.get("gene_mode") != mode
+                or summary.get("n_donors") != len(s["test_sample_ids"])
+                or not expression_present
+                or not all(summary.get("gates", {}).get(k) is True for k in
+                           ("observed_composition_equal", "broadcast_r_equal", "broadcast_deg_equal"))):
+            raise ValueError("legacy scoring receipt does not cover exact mixtures/expression")
+        for field, src in (("tool_sha256", old / "tools/score_bp.py"),
+                           ("score_ft_sha256", ft / "tools/score_ft.py")):
+            # Old summary estimators are not adopted as new statistics. Their
+            # source digest is retained even when the scorer has since evolved.
+            if not re.fullmatch(r"[0-9a-f]{64}", summary.get(field, "")):
+                raise ValueError(f"historical scorer digest missing: {p}")
+            if field == "score_ft_sha256" and sha(src) != summary[field]:
+                raise ValueError(f"legacy scoring source changed: {src}")
+            artifacts.append(src)
+        artifacts.append(p)
+        endpoints[mode] = {"n_samples": summary["n_donors"], "has_cell_type_expression": True,
+                           "hires_imputed_genes": summary.get("hires_imputed_genes"),
+                           "old_scores_reused": False, "fresh_corrected_scoring_required": True,
+                           "recorded_scorer_sha256": summary["tool_sha256"],
+                           "current_scorer_sha256": sha(old / "tools/score_bp.py"),
+                           "scorer_source_matches_current": sha(old / "tools/score_bp.py") == summary["tool_sha256"]}
+    artifacts += [old / "tools/run_bp.R", old / "tools/run_cibersortx.sh"]
+    files = []
+    for p in sorted(set(artifacts)):
+        if not p.is_file() or p.stat().st_size == 0:
+            raise FileNotFoundError(f"historical evidence missing or empty: {p}")
+        files.append({"source": str(p.resolve()), "sha256": sha(p), "bytes": p.stat().st_size,
+                      "view": str(p.relative_to(old)) if p.is_relative_to(old) else None})
+    return {"schema": SCHEMA, "support_sha256": s["sha256"], "cohort": ds, "unit": s["unit"],
+            "reference_sample_ids": s["train_sample_ids"], "mixture_sample_ids": s["test_sample_ids"],
+            "legacy_draw_index": draw, "legacy_split": split,
+            "method_execution": "historical_outputs_reused_no_method_execution",
+            "input_equivalence": "exact support and ordered mixtures; original recorded draw-specific reference-cell subsampling retained",
+            "output_hash_basis": "current historical completed and scored files, verified now; not a retroactive native execution receipt",
+            "aggregate_source": str(aggregate.resolve()), "aggregate_sha256": b["aggregates_sha256"],
+            "fraction_serialization_max_abs_error": fraction_error,
+            "legacy_endpoints": endpoints, "files": files}
+
+
+def _native_inputs(s: dict, out: Path, old: Path) -> list[dict]:
+    """Keep prepared draw0 bytes in place and prove their equality before adoption."""
+    receipt = out / "INPUTS.json"
+    if not receipt.exists():
+        return []
+    r = read(receipt)
+    if r.get("support_sha256") != s["sha256"]:
+        raise ValueError("existing native prepared input support differs")
+    draw = _support(s)
+    bp, cx = out / "inputs" / s["cohort"] / "fewshot0_full", out / "cibersortx" / s["cohort"] / "fewshot0"
+    if draw != 0:
+        raise ValueError("preserve and explicitly migrate pre-existing reset-index inputs before adopting this draw")
+    evidence = [receipt]
+    for directory, manifest, root, names in (
+        (bp, "SPLIT.json", old / "inputs" / s["cohort"] / "fewshot0_full", ("reference.tsv.gz", "mixture.tsv.gz", "state_types.tsv")),
+        (cx, "INPUT.json", old / "cibersortx" / s["cohort"] / "fewshot0", ("refsample.txt", "mixture.txt", "hires_genes.txt"))):
+        m = read(directory / manifest)
+        _files(m, directory, names)
+        evidence.append(directory / manifest)
+        for name in names:
+            p = directory / name
+            if sha(p, unpack=name.endswith(".gz")) != sha(root / name, unpack=name.endswith(".gz")):
+                raise ValueError(f"existing native input differs from legacy: {p}")
+            evidence.append(p)
+    for method in (bp / "bp", cx / "out_fractions", cx / "out_hires"):
+        if method.exists() and any(method.iterdir()):
+            raise ValueError("native method evidence already exists; refusing implicit replacement")
+    return [{"source": str(p.resolve()), "sha256": sha(p), "bytes": p.stat().st_size, "view": None} for p in evidence]
+
+
+def verify(s: dict, out: Path) -> dict:
+    draw = _support(s)
+    proof = read(out / "ADOPTION.json")
+    if proof.get("receipt_sha256") != receipt_hash(proof):
+        raise ValueError("adoption receipt hash changed")
+    if (proof.get("schema") != SCHEMA or proof.get("support_sha256") != s["sha256"]
+            or proof.get("legacy_draw_index") != draw or proof.get("legacy_split") != f"fewshot{draw}"
+            or proof.get("reference_sample_ids") != s["train_sample_ids"]
+            or proof.get("mixture_sample_ids") != s["test_sample_ids"]
+            or proof.get("method_execution") != "historical_outputs_reused_no_method_execution"):
+        raise ValueError("adoption receipt does not match exact support and historical draw")
+    if not proof.get("files"):
+        raise ValueError("adoption proof contains no evidence files")
+    for entry in proof["files"]:
+        src = Path(entry["source"])
+        if src.stat().st_size != entry["bytes"] or sha(src) != entry["sha256"]:
+            raise ValueError(f"adopted source changed: {src}")
+        if entry["view"] is not None:
+            rel = Path(entry["view"])
+            if rel.is_absolute() or ".." in rel.parts:
+                raise ValueError("adopted view escapes unit output")
+            target = out / "adopted_legacy" / rel
+            if target.is_symlink() and target.resolve() != src.resolve():
+                raise ValueError("adopted view symlink changed")
+            if target.stat().st_size != entry["bytes"] or sha(target) != entry["sha256"]:
+                raise ValueError(f"adopted view changed: {target}")
+    return proof
+
+
+def adopt(s: dict, out: Path, *, old: Path = OLD, ft: Path = FT) -> dict:
+    if (out / "ADOPTION.json").exists():
+        return verify(s, out)
+    proof = verify_legacy(s, old=old, ft=ft)
+    proof["files"] += _native_inputs(s, out, old)
+    proof["receipt_sha256"] = receipt_hash(proof)
+    for entry in proof["files"]:
+        if entry["view"] is None:
+            continue
+        dest = out / "adopted_legacy" / entry["view"]
+        if dest.exists() and sha(dest) != entry["sha256"]:
+            raise ValueError(f"existing adoption view differs: {dest}")
+    for entry in proof["files"]:
+        if entry["view"] is not None:
+            dest = out / "adopted_legacy" / entry["view"]
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            if not dest.exists():
+                try:
+                    os.link(entry["source"], dest)
+                except OSError as e:
+                    if e.errno not in (errno.EPERM, errno.EACCES, errno.EXDEV):
+                        raise
+                    # Official Docker outputs may be root-owned and protected
+                    # from hardlink creation. Preserve their bytes and owner.
+                    dest.symlink_to(entry["source"])
+    out.mkdir(parents=True, exist_ok=True)
+    with tempfile.NamedTemporaryFile("w", dir=out, prefix=".adoption-", delete=False) as f:
+        json.dump(proof, f, indent=2)
+        f.write("\n")
+        tmp = Path(f.name)
+    # Do not replace a concurrent or earlier receipt.
+    os.link(tmp, out / "ADOPTION.json")
+    tmp.unlink()
+    return verify(s, out)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--support-manifest", type=Path, required=True)
+    parser.add_argument("--verify-only", action="store_true")
+    args = parser.parse_args()
+    import deconv_strict as d
+    s = d.support(args.support_manifest)
+    out = d.unit_out(s, None)
+    result = verify(s, out) if args.verify_only else adopt(s, out)
+    print(json.dumps({k: result[k] for k in ("schema", "cohort", "unit", "legacy_draw_index", "method_execution")}))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261013T005008Z-reuse-audit-results-deck/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/tools/deconv_strict.py

@@ -0,0 +1,881 @@
+#!/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")
+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 split_name(s: dict) -> str:
+    return "fewshot" + s["unit"].split("_", 1)[0].removeprefix("draw")
+
+
+def method_root(s: dict, out: Path) -> Path:
+    return out / "adopted_legacy" if s["cohort"] == "ye2026_sepsis" else out
+
+
+def adopt_completed(s: dict, out: Path) -> dict:
+    """Sepsis must reuse proven historical methods; missing proof never triggers a rerun."""
+    import adopt_deconv_legacy as adoption
+    return adoption.adopt(s, out, old=OLD, ft=PLAN.parent / "paired_finetune_intradataset_20260927")
+
+
+def patched_modules(s: dict, out: Path):
+    C = importlib.import_module("common")
+    C.PLAN = method_root(s, out)
+    C.split_rows = lambda ds, kind, idx: strict_split(s) if (ds, kind, idx) == (s["cohort"], "fewshot", int(split_name(s).removeprefix("fewshot"))) else (_ for _ in ()).throw(ValueError("unexpected split"))
+    return C
+
+
+def prepare(s: dict, out: Path) -> dict:
+    if s["cohort"] == "ye2026_sepsis":
+        return adopt_completed(s, out)
+    bind(s, out)
+    previous = out / "INPUTS.json"
+    if previous.exists():
+        return require_inputs(s, out)
+    method_dirs = [out / "inputs" / s["cohort"] / f"{split_name(s)}_full" / "bp",
+                   out / "cibersortx" / s["cohort"] / split_name(s) / "out_fractions",
+                   out / "cibersortx" / s["cohort"] / split_name(s) / "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", split_name(s).removeprefix("fewshot"), "full"])
+    cx = importlib.import_module("build_cibersortx_inputs")
+    cx.SPLITS = [("fewshot", int(split_name(s).removeprefix("fewshot")))]
+    cx.main([ds])
+    bdir = out / "inputs" / ds / f"{split_name(s)}_full"
+    cdir = out / "cibersortx" / ds / split_name(s)
+    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:
+    if s["cohort"] == "ye2026_sepsis":
+        import adopt_deconv_legacy as adoption
+        return adoption.verify(s, out)
+    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"] / f"{split_name(s)}_full" / "SPLIT.json") != rec["bayesprism_split_sha256"]:
+        raise ValueError("BayesPrism split manifest changed after preparation")
+    if sha(out / "cibersortx" / s["cohort"] / split_name(s) / "INPUT.json") != rec["cibersortx_input_sha256"]:
+        raise ValueError("CIBERSORTx input manifest changed after preparation")
+    bdir = out / "inputs" / s["cohort"] / f"{split_name(s)}_full"
+    cdir = out / "cibersortx" / s["cohort"] / split_name(s)
+    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:
+    out = method_root(s, out)
+    if stage == "bayesprism":
+        return out / "inputs" / s["cohort"] / f"{split_name(s)}_full" / "bp"
+    if stage in {"fractions", "hires"}:
+        return out / "cibersortx" / s["cohort"] / split_name(s) / 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_name(s)
+        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:
+    if s["cohort"] == "ye2026_sepsis":
+        return require_inputs(s, out)
+    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"]
+    out = method_root(s, out)
+    if method == "bayesprism":
+        d = out / "inputs" / ds / f"{split_name(s)}_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_name(s)
+        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:
+    if s["cohort"] == "ye2026_sepsis":
+        adopt_completed(s, out)
+        return
+    require_inputs(s, out)
+    split = out / "inputs" / s["cohort"] / f"{split_name(s)}_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:
+    if s["cohort"] == "ye2026_sepsis":
+        adopt_completed(s, out)
+        return {"fractions": "complete", "hires": "complete", "execution": "adopted_legacy"}
+    require_inputs(s, out)
+    d = out / "cibersortx" / s["cohort"] / split_name(s)
+    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, [f"{split_name(s)}_full"], ids, v["score_ids"]) if name == "bayesprism" else B.load_cx(ds, [split_name(s)], 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": require_inputs(s, out)["aggregate_sha256"],
+                                "features": sha(C.FT / "data" / ds / "features.npz"),
+                                "observed_deg_reference": ref["deg"].get("sha256")}}
+    if s["cohort"] == "ye2026_sepsis":
+        result["method_execution"] = "historical_outputs_reused_no_method_execution"
+        result["adoption_manifest"] = str(out / "ADOPTION.json")
+        result["adoption_sha256"] = sha(out / "ADOPTION.json")
+        for method in methods.values():
+            method["execution"] = "adopted_legacy"
+            method["adoption_manifest"] = result["adoption_manifest"]
+            method["adoption_sha256"] = result["adoption_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=("adopt", "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)
+    if a.action == "adopt":
+        if s["cohort"] != "ye2026_sepsis":
+            raise ValueError("adoption is only established for Sepsis")
+        proof = adopt_completed(s, out)
+        print(json.dumps({"schema": proof["schema"], "unit": s["unit"], "method_execution": proof["method_execution"]}))
+        return 0
+    if s["cohort"] != "ye2026_sepsis" or a.action in ("score", "all"):
+        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())