Archive 4 checkpoints (1-4)

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

@@ -0,0 +1,439 @@
+#!/usr/bin/env python3
+"""Build zero-aware Figure 5 data from marker caches (CPU only).
+
+Usage:
+  CUDA_VISIBLE_DEVICES='' python tools/build_figure5.py --manifest path/to/rare_manifest.json
+  CUDA_VISIBLE_DEVICES='' python tools/build_figure5.py --legacy-diagnostic
+
+Manifest: {"schema":"pbisc.figure5.marker-caches.v1","units":[{"cohort":"...",
+ "unit":"draw0","design":"strict5pair","train_sample_ids":[...],
+ "train_donor_ids":[...],"test_sample_ids":[...],
+ "sample_metadata":"...csv","support_manifest":".../support.json","observed_cache":"...npz",
+ "generated_caches":{"lora5":"...npz","scsemi5":"...npz"},
+ "cell_budget":500,"depth_target":1000}]}
+Paths are relative to the manifest. Cache arrays: markers, marker_symbols, lib_measured,
+sample_id (or legacy donor), aifi_l1, aifi_l2. All test samples and arms must be present.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("Figure 5 requires CUDA_VISIBLE_DEVICES=''")
+
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+
+from rare_metrics import (abundance_summary, aggregate_donors, bootstrap_mae,
+                          call_marker_state, validate_design, validate_marker_coverage)
+
+HERE = Path(__file__).resolve().parents[1]
+M8 = HERE.parents[1]
+OLD = M8 / "plans/rare_states_paired_20261008"
+FT = M8 / "plans/paired_finetune_intradataset_20260927"
+STATES = M8 / "plans/rare_states_screen_20261004/tools/states.json"
+COHORTS = ("ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili")
+LEGACY_ARMS = ("zs_raw", "zs_cal", "scsemi5", "lora5")
+STRICT_ARMS = frozenset(("lora", "pairedcal", "scsemi", "raw", "refcal"))
+
+
+def require_complete_strict(units: list[dict]) -> None:
+    expected = {(c, f"draw{i}") for c in COHORTS for i in range(5)}
+    seen = [(u["cohort"], u["unit"]) for u in units]
+    if len(seen) != len(set(seen)):
+        raise ValueError("duplicate strict cohort/draw")
+    missing = expected - set(seen)
+    extra = set(seen) - expected
+    if missing or extra:
+        raise ValueError(f"missing strict cohort/draw units: {sorted(missing)}; extra: {sorted(extra)}")
+    for u in units:
+        if u.get("design") != "strict5pair":
+            raise ValueError("all final Figure 5 units must be strict5pair")
+        if set(u.get("generated_caches", {})) != STRICT_ARMS:
+            raise ValueError(f'{u["cohort"]} {u["unit"]}: strict arms must be {sorted(STRICT_ARMS)}')
+    if len({int(u["cell_budget"]) for u in units}) != 1:
+        raise ValueError("strict units have mixed cell_budget")
+    if len({float(u["depth_target"]) for u in units}) != 1:
+        raise ValueError("strict units have mixed depth_target")
+
+
+def _seed(*parts: object) -> int:
+    return int.from_bytes(hashlib.sha256("|".join(map(str, parts)).encode()).digest()[:8], "little")
+
+
+def _sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        for block in iter(lambda: f.read(4 << 20), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def _load(path: Path) -> dict:
+    if not path.is_file():
+        raise FileNotFoundError(path)
+    with np.load(path, allow_pickle=False) as z:
+        d = {k: z[k] for k in ("markers", "marker_symbols", "lib_measured", "aifi_l1", "aifi_l2")}
+        d["sample_id"] = z["sample_id"] if "sample_id" in z else z["donor"]
+        if "receipt" in z:
+            d["receipt"] = str(z["receipt"])
+    n = len(d["sample_id"])
+    if d["markers"].shape != (n, len(d["marker_symbols"])) or any(
+        len(d[k]) != n for k in ("lib_measured", "aifi_l1", "aifi_l2")
+    ):
+        raise ValueError(f"unaligned cache: {path}")
+    return d
+
+
+def validate_strict_cache(cache: dict, path: Path, unit: dict, arm: str, support_sha: str) -> None:
+    expected = unit.get("generated_cache_sha256", {}).get(arm)
+    if not expected or _sha256(path) != expected:
+        raise ValueError(f"{arm}: marker cache content hash mismatch or absent")
+    try:
+        rec = json.loads(cache["receipt"])
+    except (KeyError, TypeError, json.JSONDecodeError) as exc:
+        raise ValueError(f"{arm}: invalid marker cache receipt") from exc
+    fixed = {"schema": "pbisc.figure5.marker-cache.v1", "cohort": unit["cohort"],
+             "unit": f'{unit["unit"]}_n5', "arm": arm, "support_sha256": support_sha,
+             "poisson_seed": 20260916, "benchmark_umi_reproduced": True,
+             "cells": len(cache["sample_id"])}
+    for key, value in fixed.items():
+        if rec.get(key) != value:
+            raise ValueError(f"{arm}: marker cache receipt mismatch: {key}")
+    required_files = {"scoring_support": "scoring_support_sha256",
+                      "score_summary": "score_summary_sha256",
+                      "score_generated_cells": "score_generated_cells_sha256"}
+    for source, digest in required_files.items():
+        source_path = Path(rec.get(source, ""))
+        if not source_path.is_file() or _sha256(source_path) != rec.get(digest):
+            raise ValueError(f"{arm}: marker cache source hash mismatch: {source.replace('_', ' ')}")
+    labels = Path(rec.get("score_generated_cells", "")).parent / "labels/labels.parquet"
+    if not labels.is_file() or _sha256(labels) != rec.get("score_labels_sha256"):
+        raise ValueError(f"{arm}: marker cache labels hash mismatch")
+    summary = json.loads(Path(rec["score_summary"]).read_text())
+    binding_path = Path(rec["scoring_support"])
+    if binding_path.resolve() != (Path(rec["score_summary"]).parent.parent / "scoring_support.json").resolve():
+        raise ValueError(f"{arm}: scoring support path differs from score run")
+    binding = json.loads(binding_path.read_text())
+    expected_binding = {
+        "schema": "pbisc.paper.strict-score-binding.v1",
+        "support_sha256": support_sha,
+        "cohort": unit["cohort"],
+        "unit": f'{unit["unit"]}_n5',
+        "test_sample_ids": unit["test_sample_ids"],
+        "test_donor_ids": unit.get("test_donor_ids"),
+    }
+    # The frozen support's donor list is copied into the unit during validation below.
+    if any(binding.get(k) != v for k, v in expected_binding.items()):
+        raise ValueError(f"{arm}: scoring support binding mismatch")
+    scored = summary.get("per_arm", {}).get(arm, {})
+    if (summary.get("schema") != "paired_ft_scores.v1" or summary.get("dataset") != unit["cohort"] or
+        set(summary.get("donors", [])) != set(unit["test_sample_ids"]) or
+        scored.get("npz_sha256") != rec.get("generated_npz_sha256") or
+        Path(scored.get("npz", "")).resolve() != Path(rec.get("generated_npz", "")).resolve() or
+        scored.get("receipt_verified") is not True or
+        scored.get("poisson", {}).get("seed") != 20260916 or
+        scored.get("poisson", {}).get("rule") != "whole NPZ, rows in NPZ order"):
+        raise ValueError(f"{arm}: cache differs from score summary arm provenance")
+
+
+def _observed_legacy(cohort: str, states: list[dict]) -> dict:
+    """Read the old cache source directly; avoid the old screen module's unrelated anndata import."""
+    panel_path = FT / "data" / cohort / "cells_panel6k.npz"
+    with np.load(panel_path, allow_pickle=False) as z:
+        matrix = sp.csr_matrix((z["data"], z["indices"], z["indptr"]), shape=tuple(z["shape"]))
+        panel = z["panel_gene_ids"].astype(str)
+        measured = z["panel_measured"].any(0)
+    canon = pd.read_csv(
+        Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/"
+             "strict_qc_v1_20260913/reference/canonical_genes.tsv"), sep="\t", dtype=str)
+    sym2id = dict(zip(canon.gene_symbol, canon.gene_id))
+    pos = {g: i for i, g in enumerate(panel)}
+    genes = list(dict.fromkeys(g for st in states for g in
+              (st.get("genes", []) + [v for group in st.get("require_any", []) for v in group]
+               + st.get("exclude", []))))
+    symbols = [g for g in genes if sym2id.get(g) in pos and measured[pos[sym2id[g]]]]
+    cols = [pos[sym2id[g]] for g in symbols]
+    obs = pd.read_parquet(FT / "data" / cohort / "cells_obs.parquet", columns=["sample_id"])
+    lab = pd.read_parquet(FT / "scoring_cache" / cohort / "observed_labels/labels/labels.parquet",
+                          columns=["sample_id", "aifi_l1", "aifi_l2"])
+    if len(lab) != matrix.shape[0] or not np.array_equal(lab.sample_id.astype(str), obs.sample_id.astype(str)):
+        raise ValueError(f"{cohort}: observed labels not aligned")
+    return dict(markers=matrix[:, cols].toarray().astype(np.int32),
+                marker_symbols=np.asarray(symbols),
+                lib_measured=np.asarray(matrix[:, np.flatnonzero(measured)].sum(1)).ravel(),
+                sample_id=obs.sample_id.astype(str).to_numpy(),
+                aifi_l1=lab.aifi_l1.astype(str).to_numpy(),
+                aifi_l2=lab.aifi_l2.astype(str).to_numpy())
+
+
+def _thin_subset(cache: dict, idx: np.ndarray, target: int, seed: int) -> dict:
+    rng = np.random.default_rng(seed)
+    idx = np.sort(rng.choice(idx, size=target, replace=False))
+    markers = cache["markers"][idx].astype(np.int64, copy=True)
+    libs = cache["lib_measured"][idx].astype(float)
+    return dict(markers=markers, libs=libs,
+                l1=cache["aifi_l1"][idx].astype(str), l2=cache["aifi_l2"][idx].astype(str))
+
+
+def _thin_depth(x: dict, target: float, seed: int) -> dict:
+    rng = np.random.default_rng(seed)
+    prob = np.minimum(1.0, target / np.maximum(x["libs"], 1))
+    y = dict(x)
+    y["markers"] = rng.binomial(x["markers"], prob[:, None])
+    y["below_target"] = int((x["libs"] < target).sum())
+    return y
+
+
+def _parent(x: dict, state: dict) -> np.ndarray:
+    parent = state["parent"]
+    return (np.ones(len(x["l1"]), bool) if parent == ["ALL"] else
+            np.isin(x["l1"], parent) | np.isin(x["l2"], parent))
+
+
+def _state(x: dict, symbols: list[str], state: dict) -> tuple[np.ndarray, np.ndarray, float]:
+    parent = _parent(x, state)
+    if state["kind"] == "label":
+        hit = np.isin(x["l2"], state["labels"]) & parent
+        return parent, hit, float("nan")
+    hit = call_marker_state(x["markers"], symbols, state) & parent
+    pos = {g: i for i, g in enumerate(symbols)}
+    n_detect = (x["markers"][:, [pos[g] for g in state["genes"]]] > 0).sum(axis=1)
+    codetection = float((n_detect[parent] >= 2).mean()) if parent.any() else float("nan")
+    return parent, hit, codetection
+
+
+def _metadata(path: Path) -> pd.DataFrame:
+    m = pd.read_csv(path, dtype={"sample_id": str, "donor_id": str})
+    if not {"sample_id", "donor_id", "group"} <= set(m):
+        raise ValueError(f"{path}: require sample_id, donor_id, group")
+    m = m[["sample_id", "donor_id", "group"]].drop_duplicates()
+    if m.sample_id.duplicated().any() or m[["sample_id", "donor_id", "group"]].isna().any().any():
+        raise ValueError(f"{path}: missing or ambiguous sample identity")
+    return m.set_index("sample_id")
+
+
+def analyze_unit(unit: dict, base: Path, states: list[dict], observed: dict | None = None) -> tuple[list, list, dict]:
+    tier = validate_design(unit)
+    path = lambda p: (base / p).resolve()
+    metadata = _metadata(path(unit["sample_metadata"]))
+    support_sha = None
+    if tier == "strict":
+        if not unit.get("support_manifest"):
+            raise ValueError("strict5pair requires support_manifest")
+        support = json.loads(path(unit["support_manifest"]).read_text())
+        body = {k: v for k, v in support.items() if k != "sha256"}
+        digest = hashlib.sha256(json.dumps(body, sort_keys=True, separators=(",", ":"),
+                                           allow_nan=False).encode()).hexdigest()
+        if support.get("schema") != "pbisc.paper.strict-support.v1" or support.get("sha256") != digest:
+            raise ValueError("support_manifest schema/hash mismatch")
+        for key in ("cohort", "train_sample_ids", "train_donor_ids", "test_sample_ids"):
+            if support[key] != unit[key]:
+                raise ValueError(f"support_manifest mismatch: {key}")
+        if support["unit"] != f'{unit["unit"]}_n5':
+            raise ValueError("support_manifest mismatch: unit")
+        support_sha = support["sha256"]
+        if [metadata.loc[s].donor_id for s in unit["train_sample_ids"]] != unit["train_donor_ids"]:
+            raise ValueError("training donor metadata differs from support manifest")
+        if set(metadata.loc[unit["test_sample_ids"]].donor_id) & set(unit["train_donor_ids"]):
+            raise ValueError("selected training donor appears in test")
+        if list(metadata.loc[unit["test_sample_ids"]].donor_id) != support["test_donor_ids"]:
+            raise ValueError("test donor metadata differs from support manifest")
+        unit = {**unit, "test_donor_ids": support["test_donor_ids"]}
+    obs = observed if observed is not None else _load(path(unit["observed_cache"]))
+    arms = {a: _load(path(p)) for a, p in unit["generated_caches"].items()}
+    if not arms:
+        raise ValueError("unit has no generated arms")
+    if tier == "strict":
+        observed_sha = unit.get("observed_cache_sha256")
+        if not observed_sha or _sha256(path(unit["observed_cache"])) != observed_sha:
+            raise ValueError("observed marker cache content hash mismatch or absent")
+        for arm, cache in arms.items():
+            validate_strict_cache(cache, path(unit["generated_caches"][arm]), unit, arm, support_sha)
+    symbols = list(obs["marker_symbols"].astype(str))
+    for arm, g in arms.items():
+        if list(g["marker_symbols"].astype(str)) != symbols:
+            raise ValueError(f"{arm}: markers differ from observed cache")
+    test_samples = list(map(str, unit["test_sample_ids"]))
+    if len(set(test_samples)) != len(test_samples) or not test_samples:
+        raise ValueError("test_sample_ids must be nonempty and unique")
+    if not set(test_samples) <= set(metadata.index):
+        raise ValueError("test samples lack metadata")
+    if tier == "strict" and set(unit["train_sample_ids"]) & set(test_samples):
+        raise ValueError("training samples included in test")
+    obs_ids = obs["sample_id"].astype(str)
+    arm_ids = {a: g["sample_id"].astype(str) for a, g in arms.items()}
+    for a, ids in arm_ids.items():
+        if set(ids) != set(test_samples):
+            raise ValueError(f"{a}: generated sample set differs from manifest test samples")
+    if not set(test_samples) <= set(obs_ids):
+        raise ValueError("observed cache missing test samples")
+    cell_budget = int(unit["cell_budget"])
+    depth_target = float(unit["depth_target"])
+    if cell_budget <= 0 or depth_target <= 0:
+        raise ValueError("positive common cell_budget and depth_target required")
+    eligible = []
+    omitted = []
+    for st in states:
+        try:
+            validate_marker_coverage(st, symbols)
+            eligible.append(st)
+        except ValueError as exc:
+            omitted.append({"state": st["name"], "reason": str(exc)})
+    # An unmeasured mandatory gene invalidates that rule, not every other state in the unit.
+    # Record the omission explicitly so it cannot be counted as a model miss.
+    rows = []
+    budgets = {}
+    depth_below = 0
+    for sample in test_samples:
+        oidx = np.flatnonzero(obs_ids == sample)
+        gidx = {a: np.flatnonzero(ids == sample) for a, ids in arm_ids.items()}
+        budget = min(cell_budget, len(oidx), *(len(v) for v in gidx.values()))
+        if budget <= 0:
+            raise ValueError(f"{sample}: no common cells")
+        budgets[sample] = budget
+        # The observed selection and depth draw are shared across every method.
+        o = _thin_depth(_thin_subset(obs, oidx, budget, _seed(unit["cohort"], unit["unit"], sample, "obs")),
+                        depth_target, _seed(unit["cohort"], unit["unit"], sample, "obs-depth"))
+        depth_below += o["below_target"]
+        m = metadata.loc[sample]
+        for arm, g in arms.items():
+            q = _thin_depth(_thin_subset(g, gidx[arm], budget, _seed(unit["cohort"], unit["unit"], sample, arm)),
+                            depth_target, _seed(unit["cohort"], unit["unit"], sample, arm, "depth"))
+            depth_below += q["below_target"]
+            for st in eligible:
+                po, ho, co = _state(o, symbols, st)
+                pg, hg, cg = _state(q, symbols, st)
+                rows.append(dict(cohort=unit["cohort"], unit=unit["unit"], design=unit["design"],
+                                 evidence_tier=tier, arm=arm, state=st["name"], state_kind=st["kind"],
+                                 sample_id=sample, donor_id=str(m.donor_id), group=str(m.group),
+                                 obs_total=budget, gen_total=budget, obs_parent=int(po.sum()),
+                                 obs_state=int(ho.sum()), gen_parent=int(pg.sum()), gen_state=int(hg.sum()),
+                                 obs_codetection=co, gen_codetection=cg, cell_budget_used=budget,
+                                 depth_target=depth_target))
+    per = pd.DataFrame(rows)
+    summ = []
+    for (arm, state), x in per.groupby(["arm", "state"], sort=False):
+        d = abundance_summary(x)
+        lo, hi = bootstrap_mae(x, seed=_seed(unit["cohort"], unit["unit"], arm, state), n_boot=1000)
+        d.update(dict(cohort=unit["cohort"], unit=unit["unit"], design=unit["design"],
+                      evidence_tier=tier, arm=arm, state=state, state_kind=x.state_kind.iloc[0],
+                      mae_donor_ci_low=lo, mae_donor_ci_high=hi,
+                      obs_codetection=float(x.obs_codetection.mean()),
+                      gen_codetection=float(x.gen_codetection.mean())))
+        summ.append(d)
+    prov = dict(cohort=unit["cohort"], unit=unit["unit"], design=unit["design"],
+                evidence_tier=tier, test_samples=len(test_samples),
+                support_sha256=support_sha,
+                train_samples=len(unit["train_sample_ids"]),
+                train_donors=len(set(unit["train_donor_ids"])),
+                actual_test_donors=int(metadata.loc[test_samples].donor_id.nunique()),
+                max_cell_budget=cell_budget, min_cell_budget_used=min(budgets.values()),
+                depth_target=depth_target, selected_cells_below_target=depth_below,
+                omitted_states=omitted, states_scored=len(eligible),
+                cache_paths={a: str(path(p)) for a, p in unit["generated_caches"].items()})
+    return rows, summ, prov
+
+
+def legacy_units(states: list[dict]) -> list[tuple[dict, dict]]:
+    out = []
+    for cohort in COHORTS:
+        observed = _observed_legacy(cohort, states)
+        meta = FT / "data" / cohort / "pairs.csv"
+        m = _metadata(meta)
+        for draw in range(5):
+            caches = {a: OLD / "work" / cohort / f"draw{draw}" / f"{a}.npz" for a in LEGACY_ARMS}
+            if not all(p.is_file() for p in caches.values()):
+                continue
+            with np.load(caches["lora5"], allow_pickle=False) as z:
+                samples = list(dict.fromkeys(z["donor"].astype(str)))
+            train_donors = (FT / "data" / cohort / f"fewshot_n5/draw{draw}/train_donors.txt").read_text().splitlines()
+            train = pd.read_csv(meta, dtype={"sample_id": str, "donor_id": str})
+            train = train[train.donor_id.isin(train_donors)]
+            # Legacy support includes every visit of each selected donor.
+            unit = dict(cohort=cohort, unit=f"draw{draw}", design="legacy_5donor",
+                        train_sample_ids=train.sample_id.tolist(), train_donor_ids=train.donor_id.tolist(),
+                        test_sample_ids=samples, sample_metadata=str(meta),
+                        generated_caches={a: str(p) for a, p in caches.items()},
+                        cell_budget=1500, depth_target=1000)
+            if not set(samples) <= set(m.index):
+                raise ValueError(f"{cohort} draw{draw}: legacy cache sample absent from pairs.csv")
+            out.append((unit, observed))
+    return out
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__)
+    group = ap.add_mutually_exclusive_group(required=True)
+    group.add_argument("--manifest", type=Path)
+    group.add_argument("--manifest-dir", type=Path, help="directory of 20 per-unit rare_manifest.json files")
+    group.add_argument("--legacy-diagnostic", action="store_true")
+    ap.add_argument("--output", type=Path, default=HERE)
+    args = ap.parse_args()
+    states = json.loads(STATES.read_text())
+    if args.manifest or args.manifest_dir:
+        paths = ([args.manifest] if args.manifest else
+                 sorted(args.manifest_dir.rglob("rare_manifest.json")))
+        units = []
+        for path in paths:
+            manifest = json.loads(path.read_text())
+            if manifest.get("schema") != "pbisc.figure5.marker-caches.v1":
+                raise ValueError(f"wrong marker cache manifest schema: {path}")
+            for u in manifest["units"]:
+                # Per-unit cache builder writes absolute paths; resolve relative paths here as well.
+                u = dict(u)
+                for key in ("sample_metadata", "support_manifest", "observed_cache"):
+                    if key in u:
+                        u[key] = str((path.parent / u[key]).resolve())
+                u["generated_caches"] = {a: str((path.parent / p).resolve())
+                                          for a, p in u["generated_caches"].items()}
+                units.append((u, None))
+        require_complete_strict([u for u, _ in units])
+        base = Path("/")
+    else:
+        units = legacy_units(states)
+        base = Path("/")
+    all_rows, all_summary, provenance = [], [], []
+    for unit, obs in units:
+        rows, summary, prov = analyze_unit(unit, base, states, obs)
+        all_rows.extend(rows)
+        all_summary.extend(summary)
+        provenance.append(prov)
+        print(json.dumps({"cohort": prov["cohort"], "unit": prov["unit"],
+                          "tier": prov["evidence_tier"], "states": prov["states_scored"]}), flush=True)
+    out = args.output
+    (out / "source_data").mkdir(parents=True, exist_ok=True)
+    (out / "reports").mkdir(parents=True, exist_ok=True)
+    if not all_rows:
+        raise ValueError("no complete units available")
+    per = pd.DataFrame(all_rows)
+    per.to_csv(out / "source_data/rare_per_sample.csv", index=False)
+    donor = (per.groupby(["cohort", "unit", "design", "evidence_tier", "arm", "state"], sort=False)
+             .apply(aggregate_donors, include_groups=False).reset_index())
+    donor.to_csv(out / "source_data/rare_per_donor.csv", index=False)
+    pd.DataFrame(all_summary).to_csv(out / "source_data/rare_summary.csv", index=False)
+    pd.DataFrame([dict(cohort=p["cohort"], unit=p["unit"], design=p["design"],
+                       evidence_tier=p["evidence_tier"], state=o["state"], reason=o["reason"])
+                  for p in provenance for o in p["omitted_states"]],
+                 columns=["cohort", "unit", "design", "evidence_tier", "state", "reason"]).to_csv(
+                     out / "source_data/rare_ineligible_states.csv", index=False)
+    (out / "reports/rare_provenance.json").write_text(
+        json.dumps({"schema": "pbisc.figure5.analysis.v1", "units": provenance,
+                    "visuals": {"status": "awaiting_strict_marker_visual_export"}
+                    if {p["evidence_tier"] for p in provenance} == {"strict"}
+                    else {"status": "diagnostic_only"},
+                    "metric_label": "high_low_abundance_auroc ranks abundance, not binary detection",
+                    "zero_draws": "included; conditional rate NA only if parent count is zero",
+                    "bootstrap": "donor cluster, seed derived from cohort/unit/arm/state",
+                    "legacy_notice": "legacy_5donor is diagnostic and not a strict5pair result"}, indent=2) + "\n")
+    print(json.dumps({"samples": len(per), "summary_rows": len(all_summary), "tiers":
+                      sorted({p["evidence_tier"] for p in provenance})}))
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,1035 @@
+#!/usr/bin/env python3
+"""Source-bound Figure 2–4 builder. CPU only; pending strict runs stay pending.
+
+Run with CUDA_VISIBLE_DEVICES='' python tools/build_results_figures.py.
+--require-complete fails unless all strict units and required Figure 3 visual data exist.
+The optional Figure 3 visual NPZ is an *export* from scored strict units, not a
+substitute for score summaries. Its JSON sidecar must bind all five support hashes.
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import json
+import os
+import tempfile
+from pathlib import Path
+
+if os.environ.get('CUDA_VISIBLE_DEVICES') != '':
+    raise SystemExit("Set CUDA_VISIBLE_DEVICES='' for the CPU figure builder")
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[1]
+M8 = ROOT.parents[1]
+OLD = M8 / 'plans/paired_finetune_intradataset_20260927'
+COHORTS = ('ye2026_sepsis', 'imperial_eskd', 'giroux2022', 'ji2025_chili')
+ARMS = ('raw', 'refcal', 'lora', 'scsemi', 'pairedcal')
+DECONV_METHODS = ('bayesprism', 'cibersortx')
+COLORS = {'raw':'#999999', 'refcal':'#0072B2', 'lora':'#D55E00',
+          'scsemi':'#009E73', 'pairedcal':'#CC79A7', 'real_R2_independent':'#222222',
+          'bayesprism':'#B35C1E', 'cibersortx':'#6F63A8'}
+plt.rcParams.update({'font.family':'DejaVu Sans', 'font.size':8, 'axes.titlesize':9,
+                     'axes.labelsize':8, 'legend.fontsize':7, 'svg.fonttype':'none',
+                     'pdf.fonttype':42, 'axes.spines.top':False,
+                     'axes.spines.right':False, 'savefig.dpi':300})
+
+
+def sha(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open('rb') as f:
+        for chunk in iter(lambda: f.read(1024*1024), b''):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def read_json(path: Path) -> dict:
+    return json.loads(path.read_text())
+
+
+def records(path: Path) -> list[dict]:
+    with path.open(newline='') as f:
+        return list(csv.DictReader(f))
+
+
+def write_csv(path: Path, rows: list[dict], columns: list[str]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open('w', newline='') as f:
+        w = csv.DictWriter(f, fieldnames=columns, extrasaction='ignore')
+        w.writeheader(); w.writerows(rows)
+
+
+def save(fig, name: str):
+    out = ROOT/'figures'/name
+    out.parent.mkdir(exist_ok=True)
+    for ext in ('pdf','svg','png'):
+        fig.savefig(out.with_suffix('.'+ext), bbox_inches='tight', dpi=300)
+    plt.close(fig)
+
+
+def pending(ax, title, detail):
+    ax.set_axis_off()
+    ax.text(0.02, 0.87, title, weight='bold', transform=ax.transAxes)
+    ax.text(0.02, 0.52, 'PENDING', color='#9A6700', weight='bold', fontsize=11,
+            transform=ax.transAxes)
+    ax.text(0.02, 0.34, detail, color='#555555', wrap=True, transform=ax.transAxes)
+    ax.add_patch(plt.Rectangle((0.01,0.04),.98,.91, fill=False, edgecolor='#CCCCCC',
+                               transform=ax.transAxes, clip_on=False))
+
+
+def strict_unit(support_path: Path, require_stats=False) -> tuple[dict|None, str]:
+    """Return a verified strict score, or an explicit pending reason; reject wrong designs."""
+    support = read_json(support_path)
+    if support.get('schema') != 'pbisc.paper.strict-support.v1':
+        raise ValueError(f'wrong support schema: {support_path}')
+    body = {k:v for k,v in support.items() if k != 'sha256'}
+    digest = hashlib.sha256(json.dumps(body, sort_keys=True, separators=(',', ':'), allow_nan=False).encode()).hexdigest()
+    if support.get('sha256') != digest:
+        raise ValueError(f'support hash mismatch: {support_path}')
+    expected_design = 'healthy_outerfold' if support['cohort'] == 'immicro' else 'disease_existing_draw'
+    if support.get('design') != expected_design or support.get('n_pairs') not in ((5,10,20,40) if expected_design == 'healthy_outerfold' else (5,)):
+        raise ValueError(f'wrong strict support design: {support_path}')
+    if support.get('n_pairs') != len(support.get('train_donor_ids', [])) or len(set(support['train_donor_ids'])) != support['n_pairs']:
+        raise ValueError(f'nonunique or incomplete donor support: {support_path}')
+    if set(support['train_donor_ids']) & set(support['test_donor_ids']):
+        raise ValueError(f'train/test donor overlap: {support_path}')
+    if len(support['train_sample_ids']) != support['n_pairs']:
+        raise ValueError(f'wrong sample count: {support_path}')
+    rel = support_path.relative_to(ROOT/'protocol/splits').parent
+    out = ROOT/'scores'/rel
+    summary_path = out/'score/summary.json'
+    if not summary_path.is_file():
+        return None, f'missing {summary_path.relative_to(ROOT)}'
+    summary = read_json(summary_path)
+    if summary.get('dataset') != support['cohort'] or set(summary.get('donors', [])) != set(support['test_sample_ids']):
+        raise ValueError(f'score/test sample mismatch: {summary_path}')
+    if set(summary.get('arms', [])) != set(ARMS):
+        raise ValueError(f'wrong strict arms: {summary_path}')
+    if summary.get('schema') != 'paired_ft_scores.v1':
+        raise ValueError(f'wrong score schema: {summary_path}')
+    binding_path=out/'scoring_support.json'
+    if not binding_path.is_file():
+        return None, f'missing strict score binding: {binding_path.relative_to(ROOT)}'
+    binding=read_json(binding_path)
+    if (binding.get('schema')!='pbisc.paper.strict-score-binding.v1'
+        or binding.get('support_sha256')!=support['sha256']
+        or binding.get('cohort')!=support['cohort'] or binding.get('unit')!=support['unit']
+        or binding.get('test_sample_ids')!=support['test_sample_ids']
+        or binding.get('test_donor_ids')!=support['test_donor_ids']
+        or set(binding.get('arm_bindings',{}))!=set(ARMS)):
+        raise ValueError(f'strict score binding differs from support: {binding_path}')
+    per = out/'score/per_donor.csv'
+    if not per.is_file():
+        return None, f'missing {per.relative_to(ROOT)}'
+    rows = records(per)
+    if not rows or {(r['arm'],r['donor']) for r in rows} != {(a,d) for a in ARMS for d in support['test_sample_ids']}:
+        raise ValueError(f'incomplete or duplicate per-donor cells: {per}')
+    for arm in ARMS:
+        pa = summary['per_arm'].get(arm, {})
+        bound=binding['arm_bindings'][arm]
+        source = Path(pa.get('npz',''))
+        expected = (ROOT/'generated/global'/support['cohort']/f'{arm}.npz' if arm in ('raw','refcal')
+                    else ROOT/'generated'/rel/f'{arm}.npz')
+        if source.resolve() != expected.resolve() or not source.is_file() or not pa.get('receipt_verified') or not pa.get('npz_sha256'):
+            raise ValueError(f'unverified strict source for {arm}: {summary_path}')
+        if (bound.get('support_sha256')!=support['sha256']
+            or bound.get('npz')!=str(source) or bound.get('npz_sha256')!=pa['npz_sha256']):
+            raise ValueError(f'{arm} score source differs from strict generation binding: {binding_path}')
+        for key in ('receipt','source_binding'):
+            item=Path(bound.get(key,''))
+            if not item.is_file() or sha(item)!=bound.get(key+'_sha256'):
+                raise ValueError(f'{arm} source binding changed: {item}')
+        if not (out/'score/arms'/arm/'generated_cells.parquet').is_file():
+            return None, f'missing generated-cell labels for {arm}: {rel}'
+    stats = out/'statistics/status.json'
+    if require_stats:
+        if not stats.is_file() or not (out/'statistics/donor_bootstrap_2000.csv').is_file():
+            return None, f'corrected donor statistics pending: {rel}'
+        stat = read_json(stats)
+        if stat.get('support_sha256') != support['sha256'] or stat.get('bootstrap_replicates') != 2000:
+            raise ValueError(f'wrong donor statistics provenance: {stats}')
+    return {'support':support, 'summary':summary, 'rows':rows, 'summary_path':str(summary_path),
+            'binding_sha256':sha(binding_path),
+            'per_path':str(per), 'stat_path':str(stats) if stats.exists() else None,
+            'rel':str(rel)}, ''
+
+
+def collect(cohort: str, kind: str, sizes=(5,), require_stats=False):
+    complete, missing = [], []
+    for i in range(5):
+        for n in sizes:
+            path = ROOT/'protocol/splits'/cohort/kind/f'{"fold" if kind=="healthy" else "draw"}{i}'
+            if kind == 'healthy': path = path/f'n{n}'
+            path = path/'support.json'
+            if not path.is_file():
+                missing.append(str(path.relative_to(ROOT))); continue
+            if read_json(path).get('cohort') != cohort:
+                raise ValueError(f'cohort/path mismatch: {path}')
+            unit, reason = strict_unit(path, require_stats=require_stats)
+            if unit: complete.append(unit)
+            else: missing.append(reason)
+    return complete, missing
+
+
+def fig2(pretrain: list[dict], strict: list[dict], missing: list[str], provenance: list[dict]):
+    import figure2_panels
+    import sys
+    return figure2_panels.render(pretrain, strict, missing, provenance, sys.modules[__name__])
+
+
+def fig3_type_palette() -> dict[str,str]:
+    return {'T cell':'#0072B2','B cell':'#E69F00','Monocyte':'#009E73',
+            'NK cell':'#CC79A7','DC':'#D55E00','Other':'#666666'}
+
+
+def fig3_umap_by_type(xy: np.ndarray, arms: np.ndarray, celltypes: np.ndarray) -> tuple[float,float,float,float]:
+    """Six fixed-coordinate panels, with one shared biological cell-type palette."""
+    from matplotlib.lines import Line2D
+    palette=fig3_type_palette()
+    methods=('real_R2','raw','refcal','pairedcal','scsemi','lora')
+    if xy.ndim!=2 or xy.shape[1]!=2 or len(xy)!=len(arms) or len(arms)!=len(celltypes):
+        raise ValueError('Figure 3 UMAP arrays unaligned')
+    if not set(celltypes) <= set(palette):
+        raise ValueError(f'Figure 3 UMAP has unknown cell types: {sorted(set(celltypes)-set(palette))}')
+    use=np.isin(arms,methods)
+    if not np.isfinite(xy[use]).all():raise ValueError('Figure 3 UMAP has nonfinite coordinates')
+    bounds=np.array([xy[use,0].min(),xy[use,0].max(),xy[use,1].min(),xy[use,1].max()],float)
+    dx=max(1e-6,bounds[1]-bounds[0]);dy=max(1e-6,bounds[3]-bounds[2])
+    limits=(bounds[0]-.03*dx,bounds[1]+.03*dx,bounds[2]-.03*dy,bounds[3]+.03*dy)
+    fig,axs=plt.subplots(2,3,figsize=(7.09,4.8),sharex=True,sharey=True,layout='constrained')
+    for ax,arm in zip(axs.flat,methods):
+        sel=arms==arm
+        if not sel.any():raise ValueError(f'Figure 3 UMAP arm missing: {arm}')
+        for label,color in palette.items():
+            mask=sel&(celltypes==label)
+            if mask.any():ax.scatter(xy[mask,0],xy[mask,1],s=.45,alpha=.42,
+                                     color=color,linewidths=0)
+        ax.set(xlim=limits[:2],ylim=limits[2:])
+        ax.set_title('Real R2' if arm=='real_R2' else arm,loc='left',weight='bold',fontsize=8)
+    handles=[Line2D([0],[0],marker='o',linestyle='',color=color,markersize=5,label=label)
+             for label,color in palette.items()]
+    fig.legend(handles=handles,loc='lower center',ncol=6,frameon=False,
+               bbox_to_anchor=(.5,-.075),fontsize=6,columnspacing=1.15)
+    fig.suptitle('Figure 3 · pooled OOF illustration on one real-R1 PCA/UMAP',fontsize=10,weight='bold')
+    save(fig,'fig3_umap_by_celltype')
+    return limits
+
+
+def fig3_composition_fractions(rows: list[dict], units: list[dict]) -> None:
+    """Full scored observed and 1,500-generated-cell fractions per held-out sample."""
+    palette=fig3_type_palette();methods=('raw','refcal','pairedcal','scsemi','lora')
+    expected={s for u in units for s in u['support']['test_sample_ids']}
+    expected_rows={(s,a,t) for s in expected for a in methods for t in palette}
+    if (len(rows)!=len(expected_rows) or
+        {(r['sample_id'],r['arm'],r['cell_type']) for r in rows}!=expected_rows):
+        raise ValueError('Figure 3 composition fractions have missing/duplicate sample-arm-type rows')
+    binding={u['support']['unit']:sha(Path(u['per_path'])) for u in units}
+    sample_fold={s:u['support']['unit'] for u in units for s in u['support']['test_sample_ids']}
+    for r in rows:
+        observed=float(r['observed_fraction']);generated=float(r['generated_fraction'])
+        if (r['fold']!=sample_fold[r['sample_id']]
+            or r.get('score_per_donor_sha256')!=binding[r['fold']]
+            or int(r['generated_total'])!=1500 or int(r['observed_total'])<=0
+            or not 0<=observed<=1 or not 0<=generated<=1):
+            raise ValueError('Figure 3 full-cell composition provenance or fraction differs')
+    for sample in expected:
+        for arm in methods:
+            rr=[r for r in rows if r['sample_id']==sample and r['arm']==arm]
+            if (not np.isclose(sum(float(r['observed_fraction']) for r in rr),1,atol=1e-5)
+                or not np.isclose(sum(float(r['generated_fraction']) for r in rr),1,atol=1e-5)):
+                raise ValueError('Figure 3 full-cell composition fractions do not sum to one')
+    fig,axs=plt.subplots(2,3,figsize=(7.09,4.25),layout='constrained')
+    for ax,(cell_type,color) in zip(axs.flat,palette.items()):
+        base=[float(r['observed_fraction']) for r in rows if r['arm']=='raw' and r['cell_type']==cell_type]
+        ax.bar(0,100*np.mean(base),color='#444444',alpha=.65)
+        for j,arm in enumerate(methods,1):
+            vals=[float(r['generated_fraction']) for r in rows if r['arm']==arm and r['cell_type']==cell_type]
+            ax.bar(j,100*np.mean(vals),color=COLORS[arm],alpha=.65)
+            fold_vals=[np.mean([float(r['generated_fraction']) for r in rows if r['arm']==arm
+                                and r['cell_type']==cell_type and r['fold']==u['support']['unit']])
+                       for u in units]
+            ax.scatter([j]*len(fold_vals),100*np.asarray(fold_vals),s=9,color=COLORS[arm])
+        ax.set_xticks(range(6),('Real R2',*methods),rotation=65,ha='right',fontsize=5)
+        ax.set_ylabel('Cell fraction (%)',fontsize=6)
+        ax.set_title(cell_type,loc='left',weight='bold',color=color)
+    fig.suptitle('Figure 3 · observed versus generated cell-type fractions; dots are outer folds',
+                 fontsize=10,weight='bold')
+    save(fig,'fig3_composition_fractions')
+
+
+def validate_fig3_runtime_components(rows: list[dict]) -> None:
+    required={'fold','arm','adaptation_seconds','generation_seconds','operational_seconds'}
+    if not rows or not required <= set(rows[0]):
+        raise ValueError('Figure 3 runtime components missing')
+    for r in rows:
+        adaptation=float(r['adaptation_seconds']);generation=float(r['generation_seconds'])
+        total=float(r['operational_seconds'])
+        if (not np.isfinite([adaptation,generation,total]).all()
+            or min(adaptation,generation,total)<0
+            or not np.isclose(adaptation+generation,total,rtol=1e-8,atol=1e-5)
+            or r['arm'] in ('raw','refcal','pairedcal') and adaptation!=0):
+            raise ValueError('Figure 3 adaptation/generation runtime components disagree')
+
+
+def fig3(units: list[dict], missing: list[str]):
+    rows=[]
+    for u in units:
+        for r in u['rows']:
+            rows.append({'fold':u['support']['unit'].split('_')[0],'arm':r['arm'],'sample_id':r['donor'],
+                         'comp_l1':r.get('comp_l1',''),'pb_r':r.get('pb_r',''),
+                         'precision':r.get('precision',''),'coverage':r.get('coverage',''),
+                         'support_sha256':u['support']['sha256'],
+                         'score_sha256':sha(Path(u['summary_path']))})
+    write_csv(ROOT/'source_data/fig3_per_sample.csv',rows,
+              ['fold','arm','sample_id','comp_l1','pb_r','precision','coverage','support_sha256','score_sha256'])
+    complete=len(units)==5 and not missing
+    extra_rows=[]
+    if complete:
+        for u in units:
+            base=ROOT/'scores'/u['rel']/'extras/immicro/strict'
+            manifest=base/'manifest.json'
+            if not manifest.is_file(): break
+            m=read_json(manifest)
+            call=m.get('calls',{}).get(u['summary_path'])
+            if not call or call.get('summary_sha256')!=sha(Path(u['summary_path'])):
+                raise ValueError(f'Figure 3 extras do not bind strict score: {manifest}')
+            for filename in ('metrics.csv','en.csv'):
+                source=base/filename
+                if not source.is_file(): break
+                for r in records(source):
+                    extra_rows.append({'fold':u['support']['unit'],'table':filename,
+                                       'source_sha256':sha(source),**r})
+    if extra_rows:
+        write_csv(ROOT/'source_data/fig3_extras.csv',extra_rows,
+                  list(dict.fromkeys(k for r in extra_rows for k in r)))
+    fig,axs=plt.subplots(2,3,figsize=(7.09,5.0),layout='constrained')
+    labels=[('A  Common real-R1 projection','Real R2 + five arms; fixed PCA/UMAP'),
+            ('B  Canonical marker expression','All measured canonical marker genes'),
+            ('C  Cell composition','Observed versus generated; donor paired'),
+            ('D  Precision / coverage','Strict out-of-fold scores'),
+            ('E  C2ST / MMD / energy','Strict extras, matched reference'),
+            ('F  Operational time','Fine-tuning + inference; pretraining excluded')]
+    # Render only direct scorer values with all five verified folds. Visual fields
+    # require a separate source-bound export; never infer them from labels alone.
+    for ax,(title,detail) in zip(axs.flat,labels): pending(ax,title,detail)
+    visual=ROOT/'source_data/fig3_visual_data.npz'
+    sidecar=ROOT/'source_data/fig3_visual_data.json'
+    visual_ready=False
+    if complete and visual.is_file() and sidecar.is_file():
+        v=read_json(sidecar)
+        hashes=sorted(u['support']['sha256'] for u in units)
+        if v.get('schema')!='pbisc.fig3.visual.v1' or sorted(v.get('support_sha256s',[]))!=hashes or v.get('npz_sha256')!=sha(visual):
+            raise ValueError('Figure 3 visual export has wrong strict provenance')
+        if (sorted(v.get('score_sha256s',[]))!=sorted(sha(Path(u['summary_path'])) for u in units)
+            or sorted(v.get('score_binding_sha256s',[]))!=sorted(u['binding_sha256'] for u in units)
+            or sorted(v.get('generated_npz_sha256s',[]))!=sorted(
+                u['summary']['per_arm'][arm]['npz_sha256'] for u in units for arm in ARMS)):
+            raise ValueError('Figure 3 visual export is not bound to the strict score and generated cells')
+        if v.get('reference_fit')!='real_R1_only' or v.get('projection')!='fixed_real_R1_pca_umap' or not v.get('canonical_marker_gene_ids'):
+            raise ValueError('Figure 3 visual export lacks fixed real-R1 projection or canonical marker definition')
+        for path_key,hash_key in (('coordinates_csv','coordinates_sha256'),
+                                  ('composition_csv','composition_sha256')):
+            source=Path(v.get(path_key,''))
+            if not source.is_file() or sha(source)!=v.get(hash_key):
+                raise ValueError(f'Figure 3 source-data provenance differs: {path_key}')
+        # Fixed real-R1 coordinates, with all arms projected by the exporter.
+        with np.load(visual,allow_pickle=False) as z:
+            required={'xy','arm','cell_type','sample_id','marker_values','marker_detected','marker_symbols'}
+            if not required <= set(z.files): raise ValueError('Figure 3 visual data missing required arrays')
+            xy,arms,celltypes=z['xy'],z['arm'].astype(str),z['cell_type'].astype(str)
+            sample_ids=z['sample_id'].astype(str)
+            markers,symbols=z['marker_values'],z['marker_symbols'].astype(str)
+            detected=z['marker_detected']
+            if (len(symbols)!=len(v['canonical_marker_gene_ids']) or len(set(symbols))!=len(symbols)
+                or list(symbols)!=v.get('canonical_marker_symbols')
+                or not {'real_R2',*ARMS} <= set(arms)):
+                raise ValueError('Figure 3 canonical marker list is incomplete or duplicated')
+            allowed_samples=set().union(*(set(u['support']['test_sample_ids']) for u in units))
+            if (xy.ndim!=2 or xy.shape[1]!=2 or len(xy)!=len(arms)
+                or len(arms)!=len(celltypes) or len(sample_ids)!=len(arms)
+                or not set(sample_ids) <= allowed_samples
+                or markers.shape!=(len(arms),len(symbols)) or detected.shape!=markers.shape):
+                raise ValueError('Figure 3 visual arrays are unaligned')
+            for arm in ('real_R2',*ARMS):
+                if set(sample_ids[arms==arm])!=allowed_samples:
+                    raise ValueError(f'Figure 3 visual export misses strict OOF samples for {arm}')
+            fig3_umap_by_type(xy,arms,celltypes)
+            fig3_composition_fractions(records(Path(v['composition_csv'])),units)
+            axs[0,0].clear()
+            sel=arms=='real_R2'
+            for label,color in fig3_type_palette().items():
+                mask=sel&(celltypes==label)
+                if mask.any():axs[0,0].scatter(xy[mask,0],xy[mask,1],s=.35,alpha=.4,
+                                              color=color,label=label)
+            axs[0,0].set_title('A  Real R2 on shared real-R1 axes',loc='left',weight='bold')
+            axs[0,0].legend(markerscale=5,fontsize=4.5,ncol=2)
+            axs[0,1].clear()
+            show=len(symbols)
+            mat=np.vstack([np.nanmean(markers[arms==a,:show],axis=0) for a in ('real_R2','lora','scsemi','refcal','pairedcal')])
+            axs[0,1].imshow(mat,aspect='auto',cmap='viridis');axs[0,1].set_yticks(range(5),('Real R2','LoRA','scSemi','Ref-cal','Pair-cal'),fontsize=6)
+            axs[0,1].set_xticks(range(show),symbols[:show],rotation=90,fontsize=5);axs[0,1].set_title(labels[1][0],loc='left',weight='bold')
+            dfig,dax=plt.subplots(figsize=(7.09,max(3.0,0.22*len(set(celltypes))*5)),layout='constrained')
+            ylabels=[]; xx=[]; yy=[]; sizes=[]; means=[]
+            for arm in ('real_R2','lora','scsemi','refcal','pairedcal'):
+                for cell_type in sorted(set(celltypes)):
+                    mask=(arms==arm)&(celltypes==cell_type)
+                    if not mask.any(): continue
+                    y=len(ylabels);ylabels.append(f'{arm} · {cell_type}')
+                    for j in range(len(symbols)):
+                        xx.append(j);yy.append(y)
+                        sizes.append(4+70*float(np.mean(detected[mask,j])))
+                        means.append(float(np.mean(markers[mask,j])))
+            art=dax.scatter(xx,yy,s=sizes,c=means,cmap='viridis',edgecolor='none')
+            dfig.colorbar(art,ax=dax,label='Mean log1p(CP10k)')
+            dax.set_xticks(range(len(symbols)),symbols,rotation=90,fontsize=6)
+            dax.set_yticks(range(len(ylabels)),ylabels,fontsize=5)
+            dax.invert_yaxis();dax.set_title('Figure 3 marker dot plot · size = detection fraction',loc='left',weight='bold')
+            save(dfig,'fig3_canonical_marker_dotplot')
+        visual_ready=True
+    if complete:
+        axs[0,2].clear()
+        for j,arm in enumerate(ARMS):
+            vals=[]
+            for u in units:
+                rr=[float(r['comp_l1']) for r in rows if r['arm']==arm and r['fold']==u['support']['unit'].split('_')[0] and r['comp_l1']]
+                if rr: vals.append(np.mean(rr))
+            if vals:
+                axs[0,2].bar(j,np.mean(vals),color=COLORS[arm],alpha=.55)
+                axs[0,2].scatter([j]*len(vals),vals,s=10,color=COLORS[arm])
+        axs[0,2].set_xticks(range(5),ARMS,rotation=30,ha='right',fontsize=5)
+        axs[0,2].set_ylabel('Mean donor composition L1')
+        axs[0,2].set_title('C  Composition · 5 fold means + points',loc='left',weight='bold')
+        axs[1,0].clear()
+        for arm in ARMS:
+            rr=[u['summary']['per_arm'][arm].get('precision_coverage',{}) for u in units]
+            rr=[x for x in rr if 'precision' in x and 'coverage' in x]
+            if rr:
+                cov=[float(x['coverage']) for x in rr];pre=[float(x['precision']) for x in rr]
+                axs[1,0].scatter(cov,pre,s=10,alpha=.35,color=COLORS[arm])
+                axs[1,0].scatter(np.mean(cov),np.mean(pre),s=35,label=arm+' mean',color=COLORS[arm])
+        axs[1,0].set_title('D  P/C · 5 fold means + points',loc='left',weight='bold')
+        axs[1,0].set_xlabel('Coverage');axs[1,0].set_ylabel('Precision');axs[1,0].legend(fontsize=5)
+        metric=[r for r in extra_rows if r.get('table')=='metrics.csv' and r.get('mode')=='raw'
+                and r.get('set') in ARMS]
+        if metric:
+            axs[1,1].clear()
+            for j,arm in enumerate(ARMS):
+                rr=[r for r in metric if r['set']==arm and r.get('c2st_rf_auc')]
+                if rr:
+                    vals=[float(r['c2st_rf_auc']) for r in rr]
+                    axs[1,1].bar(j,np.mean(vals),color=COLORS[arm],alpha=.55)
+                    axs[1,1].scatter([j]*len(vals),vals,s=10,color=COLORS[arm])
+            axs[1,1].set_xticks(range(5),ARMS,rotation=30,ha='right',fontsize=5)
+            axs[1,1].set_ylabel('C2ST RF AUC')
+            axs[1,1].set_title('E  C2ST · 5 fold means + points',loc='left',weight='bold')
+    runtime=ROOT/'source_data/fig3_runtime.csv'
+    runtime_manifest=ROOT/'source_data/fig3_runtime.json'
+    runtime_ready=False
+    if complete and runtime.is_file() and runtime_manifest.is_file():
+        rm=read_json(runtime_manifest)
+        rr=records(runtime)
+        if (rm.get('schema')!='pbisc.fig3.runtime.v2' or rm.get('csv_sha256')!=sha(runtime)
+            or sorted(rm.get('support_sha256s',[]))!=sorted(u['support']['sha256'] for u in units)
+            or rm.get('pretraining_excluded') is not True
+            or rm.get('runtime_scope')!='gpu_job_wall_seconds_only'
+            or rm.get('components')!=['adaptation_seconds','generation_seconds']
+            or {(r['fold'],r['arm']) for r in rr}!={(u['support']['unit'],a) for u in units for a in ARMS}):
+            raise ValueError('Figure 3 runtime source is incomplete or has wrong provenance')
+        validate_fig3_runtime_components(rr)
+        for r in rr:
+            if not r.get('receipt_path') or not Path(r['receipt_path']).is_file() or not r.get('receipt_sha256') or sha(Path(r['receipt_path']))!=r['receipt_sha256']:
+                raise ValueError('Figure 3 runtime receipt missing or changed')
+        evidence=read_json(Path(rr[0]['receipt_path']))
+        if (evidence.get('schema')!='pbisc.fig3.runtime-evidence.v1'
+            or evidence.get('pretraining_excluded') is not True
+            or evidence.get('runtime_scope')!='gpu_job_wall_seconds_only'):
+            raise ValueError('Figure 3 operational-time evidence schema differs')
+        for unit in evidence.get('units',{}).values():
+            for arm in unit.values():
+                for source in arm['sources']:
+                    path=Path(source['path'])
+                    if not path.is_file() or sha(path)!=source['sha256']:
+                        raise ValueError(f'Figure 3 operational-time source changed: {path}')
+        rfig,rax=plt.subplots(figsize=(7.09,2.9),layout='constrained')
+        axs[1,2].clear()
+        for j,arm in enumerate(ARMS):
+            vals=[float(r['operational_seconds']) for r in rr if r['arm']==arm]
+            axs[1,2].bar(j,np.mean(vals)/3600,color=COLORS[arm],alpha=.55)
+            axs[1,2].scatter([j]*len(vals),np.asarray(vals)/3600,s=10,color=COLORS[arm])
+            adapt=[float(r['adaptation_seconds'])/3600 for r in rr if r['arm']==arm]
+            generate=[float(r['generation_seconds'])/3600 for r in rr if r['arm']==arm]
+            rax.bar(j,np.mean(adapt),color=COLORS[arm],alpha=.9,
+                    label='Adaptation / training' if j==0 else None)
+            rax.bar(j,np.mean(generate),bottom=np.mean(adapt),color=COLORS[arm],alpha=.35,
+                    hatch='//',label='Generation / inference' if j==0 else None)
+            rax.scatter([j]*len(vals),np.asarray(vals)/3600,s=11,color=COLORS[arm])
+        axs[1,2].set_xticks(range(5),ARMS,rotation=30,ha='right',fontsize=5)
+        axs[1,2].set_ylabel('GPU-job wall hours · corpus pretraining excluded')
+        axs[1,2].set_title('F  Training / sampling GPU jobs',loc='left',weight='bold')
+        rax.set_xticks(range(5),ARMS)
+        rax.set_ylabel('GPU-job wall hours · corpus pretraining excluded')
+        rax.set_title('Figure 3 · GPU adaptation and generation components; dots are outer folds',
+                      loc='left',weight='bold')
+        rax.legend(frameon=False,fontsize=7)
+        save(rfig,'fig3_runtime_components')
+        runtime_ready=True
+    save(fig,'fig3_healthy_strict_oof')
+    extras_complete=all(
+        {'metrics.csv','en.csv'} <= {r['table'] for r in extra_rows if r['fold']==u['support']['unit']}
+        and set(ARMS) <= {r.get('set') for r in extra_rows if r['fold']==u['support']['unit'] and r['table']=='metrics.csv'}
+        for u in units) and len(units)==5
+    if extras_complete:
+        efig,eaxs=plt.subplots(1,3,figsize=(7.09,2.35),layout='constrained')
+        defs=(('C2ST RF AUC','metrics.csv','c2st_rf_auc'),
+              ('MMD² sum','metrics.csv','mmd2_sum'),('Normalized error E_N','en.csv','en'))
+        for ax,(title,table,key) in zip(eaxs,defs):
+            for j,arm in enumerate(ARMS):
+                rr=[r for r in extra_rows if r['table']==table and r.get('set')==arm
+                    and r.get(key) and (table=='en.csv' and r.get('cellset')=='pc' and r.get('distance')=='sq'
+                                   or table=='metrics.csv' and r.get('mode')=='raw')]
+                if rr:
+                    vals=[float(r[key]) for r in rr]
+                    ax.bar(j,np.mean(vals),color=COLORS[arm],alpha=.55)
+                    ax.scatter([j]*len(vals),vals,s=8,color=COLORS[arm])
+            ax.set_xticks(range(5),ARMS,rotation=45,ha='right',fontsize=5)
+            ax.set_title(title,loc='left',weight='bold')
+        save(efig,'fig3_realism_metrics')
+    return {'strict_complete_folds':len(units),'strict_expected_folds':5,'missing':missing,
+            'visual_export_ready':visual_ready,'visual_export':str(visual) if visual_ready else None,
+            'umap_by_celltype_ready':visual_ready,'composition_fractions_ready':visual_ready,
+            'extras_rows':len(extra_rows),'extras_complete':extras_complete,
+            'runtime_ready':runtime_ready,'runtime_components_ready':runtime_ready}
+
+
+def donor_signal_panels(all_units: dict[str, list[dict]]) -> tuple[list[dict], list[str]]:
+    """Render only source-bound corrected signals; legacy headline is never primary."""
+    def number(value):
+        try: return float(value)
+        except (ValueError, TypeError): return float('nan')
+    provenance = ROOT/'source_data/fig4_donor_aware_provenance.json'
+    reason = []
+    data = {key: [] for key in ('signal', 'summary', 'genes', 'cat')}
+    if not provenance.is_file():
+        reason.append('Donor-aware signal processor has not completed.')
+    else:
+        manifest = read_json(provenance)
+        if manifest.get('schema') != 'pbisc.fig4.donor-aware-signal.v1':
+            raise ValueError('wrong corrected Figure 4 signal schema')
+        if manifest.get('status') != 'complete':
+            reason.append('All 20 corrected disease units are required.')
+        else:
+            expected = {u['rel']: u['support']['sha256'] for units in all_units.values() for u in units}
+            actual = {key: item['support_sha256'] for key, item in manifest.get('units', {}).items()}
+            if len(expected) != 20 or actual != expected:
+                raise ValueError('corrected Figure 4 source support differs from strict scores')
+            for source, digest in manifest.get('sources', {}).items():
+                path = Path(source)
+                if not path.is_file() or sha(path) != digest:
+                    raise ValueError(f'corrected disease input changed: {source}')
+            for key in data:
+                item = manifest['outputs'][key]
+                path = Path(item['path'])
+                if not path.is_file() or sha(path) != item['sha256']:
+                    raise ValueError(f'corrected disease output changed: {path}')
+                data[key] = records(path)
+    names = ('fig4_disease_signal_strict', 'fig4_disease_signal_scatter',
+             'fig4_disease_signal_heatmap', 'fig4_disease_signal_cat')
+    if reason:
+        for name in names:
+            fig, ax = plt.subplots(figsize=(7.09, 3.4))
+            pending(ax, 'Figure 4 · donor-aware primary disease signal', '\n'.join(reason))
+            save(fig, name)
+        return [], reason
+    metric_defs = (('pearson_r', 'Pearson logFC r'), ('spearman_r', 'Spearman logFC r'),
+                   ('partial_r', 'Partial r given bulk'), ('cat50', 'Signed CAT@50'),
+                   ('limma_top50', 'Donor-limma top-50 overlap'))
+    types = sorted({r['celltype'] for r in data['signal']})
+    fig, axs = plt.subplots(len(metric_defs), 4, figsize=(7.09, 9.3), layout='constrained')
+    for i, (metric, label) in enumerate(metric_defs):
+        for j, cohort in enumerate(COHORTS):
+            ax = axs[i, j]
+            for t, celltype in enumerate(types):
+                for a, arm in enumerate(ARMS):
+                    candidates = [r for r in data['summary'] if r['cohort'] == cohort and r['arm'] == arm and r['celltype'] == celltype]
+                    if len(candidates) != 1:
+                        raise ValueError('corrected disease summary has an incomplete method/type grid')
+                    row = candidates[0]
+                    y = t + (a - 2) * .13
+                    try: value = float(row.get(metric, 'nan'))
+                    except ValueError: value = float('nan')
+                    if not np.isfinite(value):
+                        ax.text(.98, y, 'NE', transform=ax.get_yaxis_transform(), ha='right', va='center',
+                                color=COLORS[arm], fontsize=3.2)
+                        continue
+                    ax.plot(value, y, 'o', ms=2.5, color=COLORS[arm], label=arm if t == 0 else None)
+                    try:
+                        lo, hi = float(row.get(metric+'_ci_low', 'nan')), float(row.get(metric+'_ci_high', 'nan'))
+                    except ValueError:
+                        lo = hi = float('nan')
+                    if np.isfinite([lo, hi]).all():
+                        ax.plot([lo, hi], [y, y], color=COLORS[arm], lw=.65)
+                    # Draw points are descriptive variation; they are not independent patients.
+                    draws = [r for r in data['signal'] if r['cohort'] == cohort and r['arm'] == arm and r['celltype'] == celltype]
+                    for draw in draws:
+                        try: val = float(draw.get(metric, 'nan'))
+                        except ValueError: val = float('nan')
+                        if np.isfinite(val): ax.plot(val, y, '|', ms=3.5, alpha=.3, color=COLORS[arm])
+                    if metric in ('cat50', 'limma_top50'):
+                        try: chance = float(row[metric+'_chance'])
+                        except (KeyError, ValueError): chance = float('nan')
+                        if np.isfinite(chance): ax.plot(chance, y, 'x', ms=2.4, color='#444444')
+            ax.set_yticks(range(len(types)), types if j == 0 else [], fontsize=5.5)
+            ax.set_ylim(len(types)-.5, -.5)
+            if metric in ('pearson_r', 'spearman_r', 'partial_r'): ax.set_xlim(-1, 1)
+            elif metric == 'cat50': ax.set_xlim(0, 1)
+            else: ax.set_xlim(0, 50)
+            ax.set_xlabel(label, fontsize=6)
+            ax.tick_params(axis='x', labelsize=5.5)
+            if i == 0: ax.set_title(cohort, fontsize=7, weight='bold', loc='left')
+    handles = [plt.Line2D([0], [0], marker='o', color=COLORS[a], label=a, lw=.7, ms=3) for a in ARMS]
+    fig.legend(handles=handles, loc='outside lower center', ncol=5, fontsize=6)
+    fig.suptitle('Exact five pairs · equal-patient contrasts\nLines: patient-bootstrap 95% CI; ticks: five adaptation draws; ×: rank chance; NE: not estimable', fontsize=8)
+    save(fig, names[0])
+    # Fixed visual slice: draw0 monocytes, selected before generated results.
+    genes = [r for r in data['genes'] if r['draw'] == 'draw0' and r['celltype'] == 'monocyte']
+    if not genes:
+        # Canonical references currently spell this type with an initial capital.
+        genes = [r for r in data['genes'] if r['draw'] == 'draw0' and r['celltype'].lower() == 'monocyte']
+    finite = [abs(float(r[k])) for r in genes for k in ('observed_logFC', 'generated_logFC')
+              if r.get(k) not in ('', 'nan') and np.isfinite(float(r[k]))]
+    limit = max([1.] + finite) * 1.04
+    fig, axs = plt.subplots(5, 4, figsize=(7.09, 8.8), layout='constrained')
+    for i, arm in enumerate(ARMS):
+        for j, cohort in enumerate(COHORTS):
+            ax = axs[i, j]
+            subset = [r for r in genes if r['cohort'] == cohort and r['arm'] == arm]
+            if subset:
+                ax.scatter([number(r['observed_logFC']) for r in subset], [number(r['generated_logFC']) for r in subset],
+                           s=1.1, color=COLORS[arm], alpha=.25, rasterized=True)
+                ax.plot([-limit, limit], [-limit, limit], '--', color='#555555', lw=.5)
+                ax.set(xlim=(-limit, limit), ylim=(-limit, limit))
+            else: pending(ax, arm, 'Monocyte contrast not estimable.')
+            if i == 0: ax.set_title(cohort, fontsize=7, loc='left')
+            if j == 0: ax.set_ylabel(arm+'\ngenerated logFC', fontsize=6)
+            if i == 4: ax.set_xlabel('Observed logFC', fontsize=6)
+            ax.tick_params(labelsize=5)
+    fig.suptitle('Prespecified illustration: draw 0 · monocytes · all common expressed genes', fontsize=8)
+    save(fig, names[1])
+    fig, axs = plt.subplots(2, 2, figsize=(7.09, 5.4), layout='constrained')
+    for ax, cohort in zip(axs.flat, COHORTS):
+        selected = [r for r in genes if r['cohort'] == cohort and r['arm'] == 'raw'
+                    and np.isfinite(number(r['observed_logFC']))]
+        selected = sorted(selected, key=lambda r: (-abs(float(r['observed_logFC'])), r['gene_id']))[:20]
+        gene_ids = [r['gene_id'] for r in selected]
+        values = [[float(r['observed_logFC']) for r in selected]]
+        for arm in ARMS:
+            lookup = {r['gene_id']: r for r in genes if r['cohort'] == cohort and r['arm'] == arm}
+            values.append([number(lookup[g]['generated_logFC']) if g in lookup else np.nan for g in gene_ids])
+        if gene_ids:
+            im = ax.imshow(np.asarray(values), cmap='RdBu_r', vmin=-limit, vmax=limit, aspect='auto')
+            ax.set_xticks(range(len(gene_ids)), gene_ids, rotation=90, fontsize=3.8)
+            ax.set_yticks(range(6), ['observed', *ARMS], fontsize=6)
+            fig.colorbar(im, ax=ax, fraction=.025, pad=.02, label='logFC')
+        else: pending(ax, cohort, 'Monocyte contrast not estimable.')
+        ax.set_title(cohort+' · top 20 observed |logFC|', fontsize=7, loc='left')
+    save(fig, names[2])
+    fig, axs = plt.subplots(len(types), 4, figsize=(7.09, 8.8), layout='constrained', squeeze=False)
+    for i, celltype in enumerate(types):
+        for j, cohort in enumerate(COHORTS):
+            ax = axs[i, j]
+            for arm in ARMS:
+                selected = [r for r in data['cat'] if r['cohort'] == cohort and r['arm'] == arm and r['celltype'] == celltype]
+                xx, yy, chance = [], [], []
+                for k in sorted({int(r['k']) for r in selected}):
+                    rr = [r for r in selected if int(r['k']) == k and r['status'] == 'ok']
+                    if len(rr) == 5:
+                        xx.append(k); yy.append(np.mean([float(r['cat_same_sign']) for r in rr]))
+                        chance.append(np.mean([float(r['chance_same_sign']) for r in rr]))
+                if xx:
+                    ax.plot(xx, yy, color=COLORS[arm], lw=.8)
+                    if arm == 'raw': ax.plot(xx, chance, '--', color='#555555', lw=.6)
+            ax.set_xscale('log'); ax.set_ylim(0, 1)
+            ax.tick_params(labelsize=5)
+            if i == 0: ax.set_title(cohort, fontsize=7, loc='left')
+            if j == 0: ax.set_ylabel(celltype+'\nsigned CAT', fontsize=6)
+            if i == len(types)-1: ax.set_xlabel('Top k corrected limma |t|', fontsize=6)
+    fig.suptitle('Mean of five fixed adaptation draws; dashed: independent-rank/sign chance', fontsize=8)
+    save(fig, names[3])
+    return data['signal'], []
+
+
+def historical_fivefold_rows() -> tuple[list[dict], list[str]]:
+    """Match historical real-bulk LoRA and scSemiProfiler before comparing them."""
+    rows, missing = [], []
+    for cohort in COHORTS:
+        score_root = OLD/('scores_nosex' if cohort == 'giroux2022' else 'scores')/cohort
+        paths = {'lora': score_root/'pooled/summary.json',
+                 'scsemi': score_root/'scsemi_cv_20261002/pooled/summary.json'}
+        if any(not p.is_file() for p in paths.values()):
+            missing.append(cohort+': historical real-bulk LoRA/scSemi five-fold pair missing')
+            continue
+        lora, scsemi = (read_json(paths[k]) for k in ('lora', 'scsemi'))
+        if (lora['donors'] != scsemi['donors']
+                or lora['reference']['reference_sha256'] != scsemi['reference']['reference_sha256']
+                or lora['reference']['features_sha256'] != scsemi['reference']['features_sha256']
+                or lora.get('gene_exclusion') != scsemi.get('gene_exclusion')
+                or lora['contrast_definition'] != scsemi['contrast_definition']):
+            raise ValueError('historical five-fold comparison does not share test/reference/gene/contrast protocol: '+cohort)
+        if cohort == 'giroux2022':
+            ex = lora.get('gene_exclusion', {})
+            if (not ex or Path(ex['file']).name != 'sex_linked_genes_exclude.csv'
+                    or sha(Path(ex['file'])) != ex['sha256']):
+                raise ValueError('Giroux historical comparison requires the canonical sex-linked exclusion')
+        lp, sp = lora['per_arm']['real_lora__raw'], scsemi['per_arm']['scsemi__raw']
+        for key in ('seed', 'rule', 'n_rows_whole_npz'):
+            if lp['poisson'][key] != sp['poisson'][key]:
+                raise ValueError('historical five-fold readout differs: '+cohort)
+        if (lp['annotation']['model_pt_sha256'] != sp['annotation']['model_pt_sha256']
+                or lp['generation']['input_condition_sha256'] != sp['generation']['input_condition_sha256']):
+            raise ValueError('historical five-fold annotation or bulk condition differs: '+cohort)
+        # Fold-specific identities establish that this is the same outer split.
+        folds = []
+        for f in range(5):
+            a = OLD/'scores'/cohort/f'fold{f}'/'summary.json'
+            b = OLD/'scores'/cohort/'scsemi_cv_20261002'/f'fold{f}'/'summary.json'
+            if not a.is_file() or not b.is_file():
+                missing.append(f'{cohort}: historical fold {f} source missing')
+                break
+            aa, bb = read_json(a), read_json(b)
+            if aa['donors'] != bb['donors']:
+                raise ValueError('historical outer-fold samples differ: '+cohort)
+            folds.extend(aa['donors'])
+        if len(folds) != len(set(folds)) or set(folds) != set(lora['donors']):
+            raise ValueError('historical pooled samples do not cover five disjoint test folds: '+cohort)
+        for arm, source_name, summary, path in (('lora', 'real_lora__raw', lora, paths['lora']),
+                                               ('scsemi', 'scsemi__raw', scsemi, paths['scsemi']),
+                                               ('raw', 'zs__raw', lora, paths['lora']),
+                                               ('legacy_cal', 'zs__cal', lora, paths['lora'])):
+            if source_name not in summary['per_arm']:
+                missing.append(f'{cohort}: historical {source_name} missing'); continue
+            pa = summary['per_arm'][source_name]
+            contrast = pa.get('contrast', {}).get('mean_cp10k', {})
+            rows.append({'cohort': cohort, 'design': 'historical_5fold_separate', 'arm': arm,
+                         'source_arm': source_name, 'pb_r_median': pa.get('pseudobulk', {}).get('r_median'),
+                         'comp_l1_mean': pa.get('composition', {}).get('l1_mean'),
+                         'logfc_pearson_legacy_mean': contrast.get('mean_r_generated'),
+                         'partial_r_legacy_mean': contrast.get('mean_partial_r'),
+                         'deg_welch_legacy_sum': pa.get('deg_top50', {}).get('sum'),
+                         'statistical_scope': 'historical sample-level estimators; not donor-corrected strict primary',
+                         'n_test_samples': len(summary['donors']), 'reference_sha256': summary['reference']['reference_sha256'],
+                         'gene_exclusion_sha256': summary.get('gene_exclusion', {}).get('sha256', ''),
+                         'source': str(path), 'source_sha256': sha(path)})
+    return rows, missing
+
+
+def fig4(all_units: dict[str,list[dict]], all_missing: dict[str,list[str]],
+         deconvolution_manifest: Path | None = None):
+    rows=[]; statrows=[]; contrast_rows=[]; legacy_contrast_missing=[]
+    fig,axs=plt.subplots(2,2,figsize=(7.09,5.2),layout='constrained')
+    for ax,cohort in zip(axs.flat,COHORTS):
+        units=all_units[cohort]
+        complete=len(units)==5 and not all_missing[cohort]
+        if not complete:
+            pending(ax,cohort,'Exact five-pair disease draws and corrected donor statistics pending.')
+            continue
+        for u in units:
+            patient_of = dict(zip(u['support']['test_sample_ids'], u['support']['test_donor_ids']))
+            for r in u['rows']:
+                rows.append({'cohort':cohort,'design':'strict_exact5_donor_draw','draw':u['support']['unit'].removesuffix('_n5'),
+                             'arm':r['arm'],'sample_id':r['donor'],'donor_id':patient_of[r['donor']], 'comp_l1':r.get('comp_l1',''),
+                             'pb_r':r.get('pb_r',''),'support_sha256':u['support']['sha256'],
+                             'summary_sha256':sha(Path(u['summary_path']))})
+            sf=Path(u['stat_path']).parent/'donor_bootstrap_2000.csv'
+            for r in records(sf):
+                statrows.append({'cohort':cohort,**r,'draw':u['support']['unit'].removesuffix('_n5'),
+                                 'support_sha256':u['support']['sha256'],'source_sha256':sha(sf)})
+            cb=ROOT/'scores'/u['rel']/'contrast'/cohort/'strict'
+            manifest=cb/'manifest.json'
+            required=('headline.csv','cat.csv','deg_limma.csv')
+            if not manifest.is_file() or any(not (cb/f).is_file() for f in required):
+                legacy_contrast_missing.append(f'{u["rel"]}: historical-sensitivity contrast pending')
+            else:
+                cm=read_json(manifest)
+                call=cm.get('calls',{}).get(u['summary_path'])
+                if not call or call.get('summary_sha256')!=sha(Path(u['summary_path'])):
+                    raise ValueError(f'Figure 4 contrast does not bind strict score: {manifest}')
+                for filename in required:
+                    source=cb/filename
+                    for r in records(source):
+                        contrast_rows.append({'cohort':cohort,'draw':u['support']['unit'].removesuffix('_n5'),
+                                              'design':'legacy_visit_level_sensitivity_not_primary',
+                                              'table':filename,'source_sha256':sha(source),**r})
+        for j,arm in enumerate(ARMS):
+            patient_values={}
+            for r in rows:
+                if r['cohort']==cohort and r['arm']==arm and r['pb_r']:
+                    patient_values.setdefault(r['donor_id'],[]).append(float(r['pb_r']))
+            if patient_values:
+                ax.bar(j,np.mean([np.mean(values) for values in patient_values.values()]),color=COLORS[arm])
+        ax.set_xticks(range(5),ARMS,rotation=30,ha='right',fontsize=6)
+        ax.set_title(cohort+' · strict exact five-pair draws',loc='left',weight='bold')
+        ax.set_ylabel('Patient-mean pseudobulk correlation')
+    save(fig,'fig4_disease_strict_draws')
+    write_csv(ROOT/'source_data/fig4_strict_per_sample.csv',rows,
+              ['cohort','design','draw','arm','sample_id','donor_id','comp_l1','pb_r','support_sha256','summary_sha256'])
+    if statrows:
+        cols=list(dict.fromkeys(k for r in statrows for k in r))
+        write_csv(ROOT/'source_data/fig4_corrected_statistics.csv',statrows,cols)
+    if contrast_rows:
+        write_csv(ROOT/'source_data/fig4_strict_contrast.csv',contrast_rows,
+                  list(dict.fromkeys(k for r in contrast_rows for k in r)))
+    corrected_rows, contrast_missing = donor_signal_panels(all_units)
+    deconv_rows=[]; deconv_missing=[]; deconv_signal=[]; signal_missing=[]
+    mapping=deconvolution_manifest or ROOT/'deconvolution/deconvolution_manifest.json'
+    if mapping.is_file():
+        dm=read_json(mapping)
+        if dm.get('schema')!='pbisc.fig4.deconvolution-sources.v1':
+            raise ValueError('wrong Figure 4 deconvolution mapping schema')
+        configs=dm.get('units',{})
+        for cohort in COHORTS:
+            for u in all_units[cohort]:
+                config=configs.get(u['rel'])
+                if not config:
+                    deconv_missing.append(f'{u["rel"]}: no deconvolution mapping');continue
+                source=Path(config['csv'])
+                if (config.get('support_sha256')!=u['support']['sha256'] or not source.is_file()
+                    or sha(source)!=config.get('sha256')):
+                    raise ValueError(f'deconvolution source/provenance mismatch: {u["rel"]}')
+                if (set(config.get('reference_sample_ids',[]))!=set(u['support']['train_sample_ids'])
+                    or set(config.get('mixture_sample_ids',[]))!=set(u['support']['test_sample_ids'])):
+                    raise ValueError(f'deconvolution reference/mixture support mismatch: {u["rel"]}')
+                vals=records(source)
+                if not vals or not {'arm','sample_id','donor_id','cell_type','observed','predicted','composition_l1'} <= set(vals[0]):
+                    raise ValueError(f'deconvolution columns missing: {source}')
+                patient_of=dict(zip(u['support']['test_sample_ids'],u['support']['test_donor_ids']))
+                if ({r['sample_id'] for r in vals} != set(u['support']['test_sample_ids'])
+                    or {r['arm'] for r in vals} != set(DECONV_METHODS)
+                    or {(r['sample_id'],r['arm']) for r in vals}!={(s,a) for s in patient_of for a in DECONV_METHODS}
+                    or any(r['donor_id']!=patient_of[r['sample_id']] for r in vals)):
+                    raise ValueError(f'deconvolution samples/arms differ from strict support: {source}')
+                for r in vals:
+                    deconv_rows.append({'cohort':cohort,'draw':u['support']['unit'].removesuffix('_n5'),
+                                        'support_sha256':u['support']['sha256'],
+                                        'source_sha256':sha(source),**r})
+                signal_path=Path(config.get('signal_csv',''))
+                if not signal_path.is_file() or not config.get('signal_sha256'):
+                    signal_missing.append(f'{u["rel"]}: cell-type expression signal missing')
+                elif sha(signal_path)!=config['signal_sha256']:
+                    raise ValueError(f'deconvolution signal hash differs: {u["rel"]}')
+                else:
+                    signal_vals=records(signal_path)
+                    needed={'arm','cell_type','metric','value','status','gene_variant','statistic',
+                            'n_genes','n_test_samples','n_independent_donors','n_case_samples',
+                            'n_control_samples','method_expression_unit','deg_method'}
+                    if not signal_vals or not needed <= set(signal_vals[0]):
+                        raise ValueError(f'deconvolution expression columns missing: {signal_path}')
+                    if {r['arm'] for r in signal_vals}!=set(DECONV_METHODS):
+                        raise ValueError(f'deconvolution expression methods differ: {signal_path}')
+                    for r in signal_vals:
+                        if r['status'] in ('ok','available','complete'):
+                            try: valid=np.isfinite(float(r['value']))
+                            except ValueError: valid=False
+                            if not valid:
+                                raise ValueError(f'available deconvolution expression has no finite value: {signal_path}')
+                        deconv_signal.append({'cohort':cohort,'draw':u['support']['unit'].removesuffix('_n5'),
+                                              'support_sha256':u['support']['sha256'],
+                                              'source_sha256':sha(signal_path),**r})
+    else:
+        deconv_missing.append(f'{mapping} missing')
+    if deconv_rows:
+        write_csv(ROOT/'source_data/fig4_deconvolution.csv',deconv_rows,
+                  list(dict.fromkeys(k for r in deconv_rows for k in r)))
+        dfig,daxs=plt.subplots(2,2,figsize=(7.09,5.2),layout='constrained')
+        for ax,cohort in zip(daxs.flat,COHORTS):
+            for arm in DECONV_METHODS:
+                rr=[r for r in deconv_rows if r['cohort']==cohort and r['arm']==arm]
+                if rr:
+                    obs=np.asarray([float(r['observed']) for r in rr]);pred=np.asarray([float(r['predicted']) for r in rr])
+                    ax.scatter(obs,pred,s=3,alpha=.25,label=arm,color=COLORS[arm])
+            ax.plot([0,1],[0,1],color='#444444',linewidth=.7,linestyle='--')
+            ax.set(xlim=(0,1),ylim=(0,1),xlabel='Observed fraction',ylabel='Predicted fraction')
+            ax.set_title(cohort+' · strict same-support',loc='left',weight='bold')
+        daxs[0,0].legend(fontsize=5)
+        save(dfig,'fig4_deconvolution_strict')
+    if deconv_signal:
+        write_csv(ROOT/'source_data/fig4_deconvolution_signal.csv',deconv_signal,
+                  list(dict.fromkeys(k for r in deconv_signal for k in r)))
+        efig,eaxs=plt.subplots(3,4,figsize=(7.09,5.5),layout='constrained')
+        definitions=(('donor_logfc_r','Donor logFC r'),
+                     ('donor_partial_r_given_bulk','Donor partial r'),
+                     ('donor_limma_top50_overlap','Donor limma top-50'))
+        for i,(metric,label) in enumerate(definitions):
+            for j,cohort in enumerate(COHORTS):
+                ax=eaxs[i,j]
+                found=False
+                for k,arm in enumerate(DECONV_METHODS):
+                    rr=[r for r in deconv_signal if r['cohort']==cohort and r['arm']==arm
+                        and r['metric']==metric and r['status'] in ('ok','available','complete')
+                        and r['gene_variant']=='donor_covered']
+                    if rr:
+                        found=True
+                        ax.bar(k,np.mean([float(r['value']) for r in rr]),color=COLORS[arm])
+                if not found: pending(ax,label,'Donor-aware method signal is not estimable or pending.')
+                else: ax.set_xticks(range(len(DECONV_METHODS)),DECONV_METHODS,rotation=45,ha='right',fontsize=5)
+                if i==0: ax.set_title(cohort,loc='left',weight='bold',fontsize=7)
+                if j==0: ax.set_ylabel(label,fontsize=7)
+        save(efig,'fig4_deconvolution_expression_strict')
+        hfig,haxs=plt.subplots(3,4,figsize=(7.09,5.5),layout='constrained')
+        historical=(('logfc_r','LogFC r · zero-filled'),
+                    ('partial_r_given_bulk','Partial r · zero-filled'),
+                    ('top50_deg_overlap','Welch top-50 · exploratory'))
+        for i,(metric,label) in enumerate(historical):
+            for j,cohort in enumerate(COHORTS):
+                ax=haxs[i,j]
+                for k,arm in enumerate(DECONV_METHODS):
+                    rr=[r for r in deconv_signal if r['cohort']==cohort and r['arm']==arm
+                        and r['metric']==metric and r['status']=='ok'
+                        and (metric=='top50_deg_overlap' or
+                             r['gene_variant']=='zero_filled' and r['statistic']=='mean_cp10k')]
+                    if rr: ax.bar(k,np.mean([float(r['value']) for r in rr]),color=COLORS[arm])
+                ax.set_xticks(range(len(DECONV_METHODS)),DECONV_METHODS,rotation=45,ha='right',fontsize=5)
+                if i==0: ax.set_title(cohort,loc='left',weight='bold',fontsize=7)
+                if j==0: ax.set_ylabel(label,fontsize=7)
+        save(hfig,'fig4_deconvolution_historical_signal')
+        sfig,saxs=plt.subplots(2,4,figsize=(7.09,3.8),layout='constrained')
+        for i,(metric,label) in enumerate((('logfc_r','LogFC r'),
+                                           ('partial_r_given_bulk','Partial r'))):
+            for j,cohort in enumerate(COHORTS):
+                ax=saxs[i,j]
+                for k,arm in enumerate(DECONV_METHODS):
+                    for v,variant in enumerate(('zero_filled','covered')):
+                        rr=[r for r in deconv_signal if r['cohort']==cohort and r['arm']==arm
+                            and r['metric']==metric and r['gene_variant']==variant
+                            and r['statistic']=='mean_cp10k' and r['status']=='ok']
+                        if rr:ax.bar(k+(.22 if v else -.22),np.mean([float(r['value']) for r in rr]),
+                                     width=.38,color=COLORS[arm],alpha=1 if v==0 else .55,
+                                     hatch='' if v==0 else '//')
+                ax.set_xticks(range(len(DECONV_METHODS)),DECONV_METHODS,rotation=45,ha='right',fontsize=5)
+                if i==0:ax.set_title(cohort,loc='left',weight='bold',fontsize=7)
+                if j==0:ax.set_ylabel(label+'\nsolid: zero-filled\nhatched: covered',fontsize=6)
+        save(sfig,'fig4_deconvolution_covered_sensitivity')
+    legacy, historical_missing = historical_fivefold_rows()
+    write_csv(ROOT/'source_data/fig4_historical_5fold.csv',legacy,
+              list(dict.fromkeys(k for r in legacy for k in r)) if legacy else ['cohort','design','arm'])
+    oldfig,oldaxs=plt.subplots(3,4,figsize=(7.09,6.2),layout='constrained')
+    for i,(metric,label) in enumerate((('pb_r_median','Pseudobulk r median'),
+                                       ('logfc_pearson_legacy_mean','Historical logFC r'),
+                                       ('partial_r_legacy_mean','Historical partial r'))):
+        for j,cohort in enumerate(COHORTS):
+            ax=oldaxs[i,j]
+            rr=[r for r in legacy if r['cohort']==cohort and r.get(metric) is not None]
+            for k,r in enumerate(rr):ax.bar(k,float(r[metric]),color=COLORS.get(r['arm'],'#666666'))
+            ax.set_xticks(range(len(rr)),[r['arm'] for r in rr],rotation=60,ha='right',fontsize=5)
+            if i==0:ax.set_title(cohort,loc='left',weight='bold',fontsize=7)
+            if j==0:ax.set_ylabel(label,fontsize=7)
+    oldfig.suptitle('Historical donor-level five-fold design · original sample-level signal estimator\nReal-bulk LoRA and scSemiProfiler share test folds, reference, gene exclusion and readout',fontsize=8)
+    save(oldfig,'fig4_historical_5fold_separate')
+    return {'strict_complete_draws':{c:len(all_units[c]) for c in COHORTS},
+            'strict_expected_draws_per_cohort':5,'strict_missing':all_missing,
+            'historical_design':'historical_5fold_separate','legacy_rows':len(legacy),
+            'historical_missing':historical_missing,
+            'contrast_rows':len(corrected_rows),'contrast_missing':contrast_missing,
+            'legacy_contrast_rows':len(contrast_rows),'legacy_contrast_missing':legacy_contrast_missing,
+            'primary_signal_source':'fig4_donor_aware_signal.csv; corrected patient-aware counts/limma',
+            'deconvolution_rows':len(deconv_rows),'deconvolution_missing':deconv_missing,
+            'deconvolution_signal_rows':len(deconv_signal),'deconvolution_signal_missing':signal_missing,
+            'deconvolution_scope':'composition and method-supported cell-type expression; no generated-cell P/C',
+            'deconvolution_deg':'donor-aware continuous-expression limma sensitivity primary where estimable; historical Welch separate'}
+
+
+def self_test_collectors():
+    """Exercise pending, invalid design, and mismatched score provenance in isolation."""
+    global ROOT
+    original=ROOT
+    try:
+        with tempfile.TemporaryDirectory() as tmp:
+            ROOT=Path(tmp)
+            path=ROOT/'protocol/splits/immicro/healthy/fold0/n5/support.json'
+            path.parent.mkdir(parents=True)
+            support={'schema':'pbisc.paper.strict-support.v1','cohort':'immicro',
+                     'design':'healthy_outerfold','unit':'fold0_n5','n_pairs':5,
+                     'train_sample_ids':[f'T{i}' for i in range(5)],
+                     'train_donor_ids':[f'T{i}' for i in range(5)],
+                     'test_sample_ids':['Q'],'test_donor_ids':['Q']}
+            def write():
+                body={k:v for k,v in support.items() if k!='sha256'}
+                support['sha256']=hashlib.sha256(json.dumps(body,sort_keys=True,separators=(',',':')).encode()).hexdigest()
+                path.write_text(json.dumps(support))
+            write()
+            assert strict_unit(path)[0] is None, 'missing score must remain pending'
+            support['design']='historical_nplus7';write()
+            try: strict_unit(path)
+            except ValueError as e: assert 'wrong strict support design' in str(e)
+            else: raise AssertionError('wrong design accepted')
+            support['design']='healthy_outerfold';write()
+            summary=ROOT/'scores/immicro/healthy/fold0/n5/score/summary.json'
+            summary.parent.mkdir(parents=True)
+            summary.write_text(json.dumps({'schema':'paired_ft_scores.v1','dataset':'immicro',
+                                           'donors':['WRONG'],'arms':list(ARMS)}))
+            try: strict_unit(path)
+            except ValueError as e: assert 'score/test sample mismatch' in str(e)
+            else: raise AssertionError('mismatched score provenance accepted')
+            summary.write_text(json.dumps({'schema':'paired_ft_scores.v1','dataset':'immicro',
+                                           'donors':['Q'],'arms':list(ARMS)}))
+            assert 'missing strict score binding' in strict_unit(path)[1]
+            binding=summary.parent.parent/'scoring_support.json'
+            binding.write_text(json.dumps({'schema':'pbisc.paper.strict-score-binding.v1',
+                                           'support_sha256':'WRONG','arm_bindings':{}}))
+            try: strict_unit(path)
+            except ValueError as e: assert 'strict score binding differs' in str(e)
+            else: raise AssertionError('wrong strict binding accepted')
+    finally:
+        ROOT=original
+    print('collector self-test passed: pending, wrong design, wrong score/test and binding provenance')
+
+
+def main():
+    p=argparse.ArgumentParser()
+    p.add_argument('--require-complete',action='store_true')
+    p.add_argument('--self-test',action='store_true')
+    p.add_argument('--deconvolution-manifest',type=Path,
+                   help='explicit same-support disease deconvolution source mapping')
+    a=p.parse_args()
+    if a.self_test:
+        self_test_collectors();return
+    pre=records(ROOT/'source_data/ablation_pretrain_pc.csv')
+    receipt=ROOT/'source_data/ablation_pretrain_pc_receipt.json'
+    pr=read_json(receipt)
+    if (pr.get('schema')!='pbisc.fig2.pretrain_pc.v1' or pr.get('recipe',{}).get('n_pcs')!=50
+        or pr.get('recipe',{}).get('local_k')!=10 or pr.get('gene_axis',{}).get('n')!=1006):
+        raise ValueError('Figure 2 pretraining receipt differs from shared P/C protocol')
+    expected={'architecture_floor1pct','panel_floor0.1pct'}
+    if {r['family'] for r in pre}!=expected or not all(r['n_genes']=='1006' and r['n_donors']=='42' and r['local_k']=='10' for r in pre):
+        raise ValueError('Figure 2 pretraining source has wrong families or shared rescore definition')
+    healthy, hm=collect('immicro','healthy',sizes=(5,10,20,40))
+    h5,h5m=collect('immicro','healthy',sizes=(5,))
+    disease={}; missing={}
+    for cohort in COHORTS:
+        disease[cohort],missing[cohort]=collect(cohort,'disease',require_stats=True)
+    out={'schema':'pbisc.paper.figures234.v1',
+         'figure2':fig2(pre,healthy,hm,[]),
+         'figure3':fig3(h5,h5m),
+         'figure4':fig4(disease,missing,a.deconvolution_manifest)}
+    complete=(out['figure2']['strict_complete_units']==20 and out['figure2']['pretrain_composition_ready']
+              and out['figure3']['visual_export_ready']
+              and out['figure3']['extras_complete'] and out['figure3']['runtime_ready']
+              and all(len(disease[c])==5 for c in COHORTS)
+              and not out['figure4']['contrast_missing'] and not out['figure4']['deconvolution_missing']
+              and not out['figure4']['deconvolution_signal_missing'])
+    out['status']='complete' if complete else 'pending'
+    (ROOT/'reports/figures234_readiness.json').write_text(json.dumps(out,indent=2)+'\n')
+    lines=['# Figure 2–4 readiness','',f"Status: **{out['status']}**.",'',
+           'Figure 2 measured pretraining P/C is plotted. Historical rank/full uses a pooled 107-donor reference; strict size points will use each outer fold\'s 21–22 donor reference.',
+           f"Strict healthy support-size scores: {len(healthy)}/20 units. Figure 3 strict n=5 folds: {len(h5)}/5; visual export: {out['figure3']['visual_export_ready']}.",
+           'Figure 4 corrected exact-five-pair draws: '+', '.join(f'{c} {len(disease[c])}/5' for c in COHORTS)+'.',
+           f"Figure 4 deconvolution composition rows: {out['figure4']['deconvolution_rows']}; expression signal rows: {out['figure4']['deconvolution_signal_rows']}.",
+           '', 'No strict, DEG, deconvolution, C2ST, MMD, energy, marker, or runtime value is inferred from a missing file.',
+           'Historical five-fold values remain in separate source tables.']
+    (ROOT/'reports/figures234_readiness.md').write_text('\n'.join(lines)+'\n')
+    print(json.dumps({'status':out['status'],'strict_healthy':len(healthy),'strict_disease':{c:len(disease[c]) for c in COHORTS}}))
+    if a.require_complete and not complete: raise SystemExit(2)
+
+if __name__=='__main__': main()

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

@@ -0,0 +1,280 @@
+#!/usr/bin/env python3
+"""Assemble a clearly labeled review PPTX; fail closed for a final deck."""
+from __future__ import annotations
+import argparse
+import csv
+import hashlib
+import json
+import os
+import re
+import tempfile
+from pathlib import Path
+if os.environ.get('CUDA_VISIBLE_DEVICES') != '':
+    raise SystemExit("Set CUDA_VISIBLE_DEVICES='' for the CPU deck builder")
+from pptx import Presentation
+from pptx.util import Inches, Pt
+from pptx.dml.color import RGBColor
+from pptx.enum.shapes import MSO_SHAPE
+
+ROOT=Path(__file__).resolve().parents[1]
+COHORTS=('ye2026_sepsis','imperial_eskd','giroux2022','ji2025_chili')
+RARE_ARMS={'raw','refcal','pairedcal','scsemi','lora'}
+
+
+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 final_gate(root: Path) -> dict:
+    """Fail closed unless Figures 2–5 have current strict source evidence."""
+    ready=json.loads((root/'reports/figures234_readiness.json').read_text())
+    if ready.get('status')!='complete':
+        raise ValueError('Figure 2–4 strict results are pending')
+    provenance=root/'reports/rare_provenance.json'
+    visual=root/'reports/rare_visual_provenance.json'
+    if not provenance.is_file() or not visual.is_file():
+        raise ValueError('strict Figure 5 numeric or visual provenance missing')
+    rare=json.loads(provenance.read_text());vis=json.loads(visual.read_text())
+    expected={(c,f'draw{i}') for c in COHORTS for i in range(5)}
+    units=rare.get('units',[])
+    if (rare.get('schema')!='pbisc.figure5.analysis.v1' or len(units)!=20
+        or {(u.get('cohort'),u.get('unit')) for u in units}!=expected
+        or any(u.get('design')!='strict5pair' or u.get('evidence_tier')!='strict' for u in units)
+        or rare.get('visuals',{}).get('status')!='complete'):
+        raise ValueError('Figure 5 source is diagnostic or incomplete; exact 20 strict units required')
+    if (vis.get('schema')!='pbisc.figure5.marker-visuals.v1' or vis.get('status')!='complete'
+        or vis.get('evidence_tier')!='strict' or len(vis.get('examples',[]))!=3
+        or not any(x.get('status')=='available' for x in vis['examples'])
+        or any(x.get('status') not in ('available','unavailable') for x in vis['examples'])):
+        raise ValueError('Figure 5 strict marker visuals incomplete')
+    hashes={str(provenance):sha(provenance),str(visual):sha(visual)}
+    for name in ('rare_per_sample.csv','rare_per_donor.csv','rare_summary.csv','rare_ineligible_states.csv',
+                 'rare_visual_cells.csv','rare_visual_heatmap.csv','rare_visual_donor_draws.csv'):
+        path=root/'source_data'/name
+        if not path.is_file() or path.stat().st_size==0:raise ValueError(f'Figure 5 source data missing: {path}')
+        hashes[str(path)]=sha(path)
+    for name in ('rare_per_sample.csv','rare_per_donor.csv','rare_summary.csv'):
+        path=root/'source_data'/name
+        with path.open(newline='') as f:
+            reader=csv.DictReader(f)
+            if not reader.fieldnames or 'evidence_tier' not in reader.fieldnames:
+                raise ValueError(f'Figure 5 table lacks evidence tier: {path}')
+            if not any(True for _ in reader):raise ValueError(f'Figure 5 table empty: {path}')
+        with path.open(newline='') as f:
+            if any(r['evidence_tier']!='strict' for r in csv.DictReader(f)):
+                raise ValueError(f'Figure 5 table mixes diagnostic rows: {path}')
+    for u in units:
+        cohort,draw=u['cohort'],u['unit']
+        manifest=root/'work/rare_strict_caches'/cohort/'disease'/draw/'rare_manifest.json'
+        support=root/'protocol/splits'/cohort/'disease'/draw/'support.json'
+        if not manifest.is_file() or not support.is_file():
+            raise ValueError(f'Figure 5 strict support/cache manifest missing: {cohort}/{draw}')
+        s=json.loads(support.read_text());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('sha256')!=digest or u.get('support_sha256')!=digest:
+            raise ValueError(f'Figure 5 support hash differs: {cohort}/{draw}')
+        m=json.loads(manifest.read_text())
+        mu=m.get('units',[])
+        if (m.get('schema')!='pbisc.figure5.marker-caches.v1' or len(mu)!=1
+            or mu[0].get('cohort')!=cohort or mu[0].get('unit')!=draw
+            or mu[0].get('design')!='strict5pair'
+            or Path(mu[0].get('support_manifest','')).resolve()!=support.resolve()
+            or set(mu[0].get('generated_caches',{}))!=RARE_ARMS):
+            raise ValueError(f'Figure 5 cache manifest design/arms differ: {cohort}/{draw}')
+        item=mu[0]
+        cache_paths={'observed':(item['observed_cache'],item['observed_cache_sha256'])}
+        cache_paths.update({arm:(item['generated_caches'][arm],item['generated_cache_sha256'][arm])
+                            for arm in RARE_ARMS})
+        for arm,(raw,expected_sha) in cache_paths.items():
+            path=Path(raw)
+            if not path.is_file() or sha(path)!=expected_sha:
+                raise ValueError(f'Figure 5 {arm} source hash differs: {cohort}/{draw}')
+            hashes[str(path)]=expected_sha
+        if u.get('cache_paths')!=item['generated_caches']:
+            raise ValueError(f'Figure 5 analyzed cache paths differ: {cohort}/{draw}')
+        hashes[str(manifest)]=sha(manifest);hashes[str(support)]=sha(support)
+    for stem in ('fig5_rare_states_strict','fig5_rare_visuals_strict','fig5_all_states_strict','fig5_behcet_rules_strict'):
+        for ext in ('pdf','svg','png'):
+            path=root/'figures'/f'{stem}.{ext}'
+            if not path.is_file() or path.stat().st_size==0:
+                raise ValueError(f'Figure 5 strict figure missing: {path}')
+            hashes[str(path)]=sha(path)
+    return {'schema':'pbisc.review-deck.final-gate.v1','status':'complete',
+            'strict_rare_units':20,'source_sha256':hashes}
+
+
+def text(slide,x,y,w,h,value,size=16,bold=False,color=(25,38,48)):
+    box=slide.shapes.add_textbox(Inches(x),Inches(y),Inches(w),Inches(h))
+    frame=box.text_frame;frame.word_wrap=True
+    p=frame.paragraphs[0];p.text=value
+    p.font.name='Aptos';p.font.size=Pt(size);p.font.bold=bold;p.font.color.rgb=RGBColor(*color)
+    return box
+
+
+def add_picture(slide,image: Path, crop: tuple[float,float] | None = None):
+    from PIL import Image
+    with Image.open(image) as im: ratio=im.width/im.height
+    if crop:
+        top,bottom=crop
+        if not 0<=top<bottom<=1:raise ValueError('invalid figure crop')
+        ratio/=bottom-top
+    maxw,maxh=11.9,5.7
+    w=min(maxw,maxh*ratio);h=w/ratio
+    picture=slide.shapes.add_picture(str(image),Inches((13.333-w)/2),
+                                     Inches(.95+(maxh-h)/2),width=Inches(w),height=Inches(h))
+    if crop:
+        picture.crop_left=0;picture.crop_right=0
+        picture.crop_top=top;picture.crop_bottom=1-bottom
+    return picture
+
+
+def white_band(slide,y: float,h: float):
+    band=slide.shapes.add_shape(MSO_SHAPE.RECTANGLE,Inches(0),Inches(y),Inches(13.333),Inches(h))
+    band.fill.solid();band.fill.fore_color.rgb=RGBColor(255,255,255)
+    band.line.fill.background()
+
+
+def export_figure1_panels(root: Path) -> dict[str,Path]:
+    """Crop the source SVG viewBox; retain editable vector panel exports."""
+    import cairosvg
+    source=root/'figures/fig1_overview.svg'
+    raw=source.read_text()
+    match=re.search(r'<svg\s[^>]*>',raw)
+    if not match:raise ValueError('Figure 1 SVG root missing')
+    tag=match.group(0)
+    view=re.search(r'viewBox="([^"]+)"',tag)
+    if not view:raise ValueError('Figure 1 SVG viewBox missing')
+    x,y,width,height=map(float,view.group(1).split())
+    result={}
+    for slug,(start,end) in {'ab':(0,.395),'cd':(.395,.65),'e':(.65,1)}.items():
+        top=y+height*start;crop_h=height*(end-start)
+        new=tag
+        new=re.sub(r'width="[^"]+"',f'width="{width:g}pt"',new,count=1)
+        new=re.sub(r'height="[^"]+"',f'height="{crop_h:g}pt"',new,count=1)
+        new=re.sub(r'viewBox="[^"]+"',f'viewBox="{x:g} {top:g} {width:g} {crop_h:g}"',new,count=1)
+        svg=root/'deck'/f'fig1_panel_{slug}.svg'
+        png=root/'deck'/f'fig1_panel_{slug}.png'
+        svg.parent.mkdir(exist_ok=True)
+        svg.write_text(raw[:match.start()]+new+raw[match.end():])
+        cairosvg.svg2png(url=str(svg),write_to=str(png),output_width=2126,
+                         output_height=round(2126*crop_h/width))
+        result[slug]=png
+    return result
+
+
+def self_test_gate():
+    with tempfile.TemporaryDirectory() as tmp:
+        root=Path(tmp)
+        (root/'reports').mkdir()
+        (root/'reports/figures234_readiness.json').write_text(json.dumps({'status':'complete'}))
+        (root/'reports/rare_provenance.json').write_text(json.dumps({
+            'schema':'pbisc.figure5.analysis.v1','units':[{'cohort':'ye2026_sepsis',
+              'unit':'draw0','design':'legacy_5donor','evidence_tier':'diagnostic'}],
+            'visuals':{'status':'diagnostic_only'}}))
+        (root/'reports/rare_visual_provenance.json').write_text(json.dumps({'status':'complete'}))
+        try:final_gate(root)
+        except ValueError as e:assert 'diagnostic or incomplete' in str(e)
+        else:raise AssertionError('final deck accepted legacy rare-state evidence')
+    print('final-deck gate self-test passed: complete Figures 2–4 cannot admit diagnostic Figure 5')
+
+
+def main():
+    ap=argparse.ArgumentParser();ap.add_argument('--require-complete',action='store_true')
+    ap.add_argument('--self-test',action='store_true')
+    a=ap.parse_args()
+    if a.self_test:self_test_gate();return
+    ready=json.loads((ROOT/'reports/figures234_readiness.json').read_text())
+    gate=None
+    if a.require_complete:
+        try:gate=final_gate(ROOT)
+        except (ValueError,FileNotFoundError) as e:raise SystemExit(f'Final deck blocked: {e}')
+    export_figure1_panels(ROOT)
+    prs=Presentation();prs.slide_width=Inches(13.333);prs.slide_height=Inches(7.5)
+    sections=[('Figure 1 · complete overview','fig1_overview.png','Index view; following slides enlarge each section.',None),
+              ('Figure 1 · pretraining and adaptation','deck/fig1_panel_ab.png','Sections a–b: five independent paired donors and measured-gene diffusion.',None),
+              ('Figure 1 · condition and sampling','deck/fig1_panel_cd.png','Sections c–d: K_cond, per-cell depth and N_gen are distinct quantities.',None),
+              ('Figure 1 · pretraining corpus','deck/fig1_panel_e.png','Section e: assay, condition and cell-type coverage.',None),
+              ('Figure 2 · Ablations and support size','fig2_ablation_and_support.png','Measured pretraining P/C; historical pooled-107 scores separate from strict foldwise curve.',None),
+              ('Figure 2 · Native pseudobulk ablations','fig2_ablation_and_support.png','Same held-out cells/readout; architecture and gene-panel floors are separate sweeps.',(0,.35)),
+              ('Figure 2 · Real-bulk rank selection','fig2_ablation_and_support.png','Matched five-fold full FT versus LoRA r=4, 16, 64; quality and trainable parameters.',(.35,.69)),
+              ('Figure 2 · Strict paired-data budget','fig2_ablation_and_support.png','All five comparators; raw and external ref-cal use zero target paired sc. Pending units remain unfilled.',(.69,1)),
+              ('Figure 3 · Healthy out-of-fold','fig3_healthy_strict_oof.png','Strict n=5 results and fixed real-R1 projection are pending where indicated.'),
+              ('Figure 4 · Disease cohorts','fig4_disease_strict_draws.png','Four exact-five-pair cohorts; pending panels do not claim performance.'),
+              ]
+    sections=[x if len(x)==4 else (*x,None) for x in sections]
+    if (ROOT/'figures/fig3_canonical_marker_dotplot.png').is_file():
+        sections.append(('Figure 3 · canonical marker dot plot','fig3_canonical_marker_dotplot.png',
+                         'Strict scored cells; dot size is marker detection fraction.',None))
+    for detail in ('umap_by_celltype','composition_fractions','runtime_components'):
+        if (ROOT/f'figures/fig3_{detail}.png').is_file():
+            sections.append((f'Figure 3 · {detail.replace("_"," ")}',f'fig3_{detail}.png',
+                             'Common real-only reference, observed/generated cell fractions and split operating time.',None))
+    if (ROOT/'figures/fig4_disease_signal_strict.png').is_file():
+        sections.append(('Figure 4 · disease signal','fig4_disease_signal_strict.png',
+                         'Exact five-pair draws; source-bound partial logFC, CAT and donor DEG.',None))
+    for detail in ('scatter','heatmap','cat'):
+        if (ROOT/f'figures/fig4_disease_signal_{detail}.png').is_file():
+            sections.append((f'Figure 4 · disease {detail}',f'fig4_disease_signal_{detail}.png',
+                             'Donor-aware effects; shared patient resampling across all draws.',None))
+    if (ROOT/'figures/fig4_deconvolution_strict.png').is_file():
+        sections.append(('Figure 4 · deconvolution composition','fig4_deconvolution_strict.png',
+                         'BayesPrism and CIBERSORTx on identical five-pair support.',None))
+    if (ROOT/'figures/fig4_deconvolution_expression_strict.png').is_file():
+        sections.append(('Figure 4 · deconvolution expression','fig4_deconvolution_expression_strict.png',
+                         'Donor-aware continuous-expression signal where estimable.',None))
+    if (ROOT/'figures/fig4_deconvolution_historical_signal.png').is_file():
+        sections.append(('Figure 4 · exploratory expression comparison','fig4_deconvolution_historical_signal.png',
+                         'Historical Welch comparison; separate from donor-aware sensitivity.',None))
+    sections.append(('Figure 4 · historical comparison','fig4_historical_5fold_separate.png',
+                     'Historical five-fold design shown separately from exact five-pair draws.',None))
+    if a.require_complete:
+        sections.extend([('Figure 5 · strict rare states','fig5_rare_states_strict.png',
+                          'Twenty exact five-pair draws; all zero-state draws retained.',None),
+                         ('Figure 5 · strict marker visuals','fig5_rare_visuals_strict.png',
+                          'Fixed real-only marker projection; illustrations separate from numeric scores.',None),
+                         ('Figure 5 · all predefined states','fig5_all_states_strict.png',
+                          'Every state and draw; observed-zero refers to the declared sampled cell budget.',None),
+                         ('Figure 5 · Behcet rule comparison','fig5_behcet_rules_strict.png',
+                          'Single-gene versus multi-gene C1Q; descriptive unmatched reference includes training donors.',None)])
+    else:
+        sections.append(('Figure 5 · diagnostic only','fig5_rare_states_diagnostic.png',
+                         'Legacy five-donor caches; not an exact five-pair result.',None))
+        for detail in ('all_states','behcet_rules'):
+            path=ROOT/f'figures/fig5_{detail}_diagnostic.png'
+            if path.is_file():
+                sections.append((f'Figure 5 · {detail.replace("_"," ")} · diagnostic',path.name,
+                                 'Descriptive preview; Behcet calibration uses the same three candidate pairs.',None))
+    for title,basename,note,crop in sections:
+        image=ROOT/basename if basename.startswith('deck/') else ROOT/'figures'/basename
+        if not image.is_file(): raise FileNotFoundError(image)
+        slide=prs.slides.add_slide(prs.slide_layouts[6])
+        add_picture(slide,image,crop)
+        white_band(slide,0,.88)
+        white_band(slide,6.72,.78)
+        text(slide,.55,.32,12.2,.55,title,24,True)
+        text(slide,.55,6.85,12.2,.38,note,11,color=(90,97,104))
+        if not a.require_complete and ready['status']!='complete' and title.startswith(('Figure 2','Figure 3','Figure 4')):
+            text(slide,11.1,.3,1.65,.45,'REVIEW · PENDING',10,True,(154,103,0))
+        if not a.require_complete and title.startswith('Figure 5'):
+            text(slide,10.8,.3,2.0,.45,'DIAGNOSTIC ONLY',10,True,(154,103,0))
+    slide=prs.slides.add_slide(prs.slide_layouts[6])
+    text(slide,.6,.45,12,.55,'Evidence and readiness',25,True)
+    f2,f3,f4=ready['figure2'],ready['figure3'],ready['figure4']
+    lines=[f"Figure 2 strict healthy support scores: {f2['strict_complete_units']}/20 units",
+           f"Figure 3 strict n=5 folds: {f3['strict_complete_folds']}/5; visual export: {f3['visual_export_ready']}",
+           'Figure 4 exact-five-pair draws: '+', '.join(f'{k} {v}/5' for k,v in f4['strict_complete_draws'].items()),
+           'Figure 5: 20 strict units and three visual examples verified.' if gate else
+           'Figure 5: diagnostic legacy caches; strict data and visuals pending.',
+           'Historical five-fold results use separate source tables and are not strict support.',
+           'Figure 6 awaits user-provided bulk-only reproduction data.']
+    for i,line in enumerate(lines):text(slide,.8,1.35+i*.82,11.8,.66,line,17)
+    out=ROOT/'deck'/('paper_figures_final.pptx' if a.require_complete else 'paper_figures_review.pptx')
+    out.parent.mkdir(exist_ok=True)
+    prs.save(out)
+    if gate:(ROOT/'deck'/'final_gate_sources.json').write_text(json.dumps(gate,indent=2)+'\n')
+    (ROOT/'deck'/'README.md').write_text('# Paper figure decks\n\nReview PPTX/PDF includes a clearly labeled diagnostic Figure 5 and visible pending panels. `--require-complete` checks Figures 2–5 source evidence and writes a separate final PPTX only when all strict inputs are complete. Figure 1 has vector panel exports and readable method/corpus slides. The PDF is exported from the PPTX using bounded headless LibreOffice.\n')
+    print(out)
+if __name__=='__main__':main()

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

@@ -0,0 +1,292 @@
+"""Run authorized Figure 1–5 exact-pair experiments sequentially with immutable receipts."""
+from __future__ import annotations
+import argparse
+import fcntl
+import json
+from pathlib import Path
+import sys
+from datetime import datetime, timezone
+
+from runtime import Runtime, ReceiptError, atomic_json, sha256, stamp
+
+ROOT = Path(__file__).resolve().parents[1]
+M8 = ROOT.parents[1]
+OLD = M8 / "plans/paired_finetune_intradataset_20260927"
+COHORTS = ("immicro", "ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili")
+PY = "/home/sj_server_1/miniforge3/envs/b2sc-cu130/bin/python"
+CPU_PY = "/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python"
+SC_PY = str(M8 / "plans/immicro_scsemi_comparison_20260927/runtime_env/bin/python")
+BASE = M8 / "runs/f01_6k_1x_seed20260627/checkpoint_epoch_016.pt"
+BASE_SHA = "8c7cd0e83e2bc19fe03dfcbc084919a1e2f61be8cc8bc12f4caf543dfda91633"
+
+
+def read_support(path: Path) -> dict:
+    m = json.loads(path.read_text())
+    if m["cohort"] not in COHORTS:
+        raise ValueError("cohort outside authorized Figure 1–5 scope")
+    return m
+
+
+def relative(path: Path) -> Path:
+    return path.relative_to(ROOT / "protocol/splits").parent
+
+
+def name(path: Path) -> str:
+    return "-".join(relative(path).parts)
+
+
+def discover_units() -> list[Path]:
+    paths = list((ROOT / "protocol/splits").glob("**/support.json"))
+    return sorted(paths, key=lambda p: (read_support(p)["n_pairs"] != 5,
+                                      COHORTS.index(read_support(p)["cohort"]), str(p)))
+
+
+def is_full_campaign(stage: str, units: list[Path]) -> bool:
+    """Partial/pilot invocations must never render a final paper."""
+    return stage == "all" and set(units) == set(discover_units()) and len(units) == 40
+
+
+def archive_completed_campaign(runtime: Runtime) -> None:
+    """One task-end versioned delta under the paper's standing archive authorization."""
+    final = json.loads((ROOT / "FINALIZATION_STATUS.json").read_text())
+    if final.get("state") != "complete" or final.get("stage") != "all":
+        raise ReceiptError("cannot publish completed assets before all-stage finalization")
+    pointer = ROOT / "FINAL_ARCHIVE_REQUEST.json"
+    if pointer.exists():
+        identifier = json.loads(pointer.read_text())["id"]
+    else:
+        identifier = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ") + "-strictpairs-results"
+        atomic_json(pointer, {"id": identifier, "state": "prepared_for_task_end", "at": stamp()})
+    release = Path("/home/sj_server_1/PBISC/paper-release-20260928")
+    helper = ROOT / "tools/archive_completed.py"
+    request = ROOT / "archive" / identifier / "request.json"
+    runtime.execute("archive-final-snapshot", [CPU_PY, str(helper), "--state", "complete", "--id", identifier],
+                    memory_gib=4, threads=2, inputs=[helper, ROOT / "FINALIZATION_STATUS.json"], outputs=[request])
+    cli = release / "maintenance/update.py"
+    python = "/home/sj_server_1/miniforge3/bin/python"
+    runtime.execute("archive-final-prepare", [python, str(cli), "prepare", "--request", str(request), "--id", identifier],
+                    memory_gib=4, threads=2, inputs=[request, cli], outputs=[release / "updates" / identifier / "manifest.json"])
+    verified = release / "updates" / identifier / "UPDATE_VERIFIED.json"
+    runtime.execute("archive-final-publish", [python, str(cli), "publish", identifier, "--execute"],
+                    memory_gib=4, threads=2, inputs=[request, cli], outputs=[verified])
+    latest = json.loads((release / "LATEST.json").read_text())
+    if latest.get("id") != identifier or latest.get("verified_receipt_sha256") != sha256(verified):
+        raise ReceiptError("published archive verification/latest pointer mismatch")
+    atomic_json(ROOT / "FINAL_ARCHIVE_VERIFIED.json", {"id": identifier, "receipt": str(verified),
+                                                      "sha256": sha256(verified), "at": stamp()})
+
+
+def data_dir(path: Path) -> Path:
+    return ROOT / "data" / relative(path)
+
+
+def run_dir(path: Path) -> Path:
+    return ROOT / "runs" / relative(path) / "lora"
+
+
+def gen_dir(path: Path) -> Path:
+    return ROOT / "generated" / relative(path)
+
+
+def check_support(path: Path) -> dict:
+    import pandas as pd
+    from support_manifest import load_manifest
+    m = read_support(path)
+    m = load_manifest(path, pd.read_csv(OLD / "data" / m["cohort"] / "folds.csv"))
+    rec = json.loads((data_dir(path) / "CONDITIONS.json").read_text())
+    if rec["support_sha256"] != m["sha256"] or rec["fit_sample_ids"] != m["train_sample_ids"]:
+        raise ReceiptError("condition calibration support mismatch")
+    for f, expected in rec["files_sha256"].items():
+        if sha256(data_dir(path) / f) != expected:
+            raise ReceiptError(f"condition hash mismatch: {f}")
+    return m
+
+
+def train_command(path: Path) -> list[str]:
+    m = read_support(path)
+    return [PY, "-u", str(OLD / "tools/ft_sdd.py"), "--checkpoint", str(BASE), "--checkpoint-sha", BASE_SHA,
+            "--dataset-dir", str(OLD / "data" / m["cohort"]), "--condition-npz",
+            str(OLD / "data" / m["cohort"] / "conditions_raw_fixed.npz"), "--fold", "0", "--mode", "lora",
+            "--lora-rank", "16", "--lora-alpha", "16", "--lr", "0.0005", "--fixed-steps", "3000",
+            "--seed", "20260927", "--support-manifest", str(path), "--out-dir", str(run_dir(path))]
+
+
+def train_inputs(path: Path) -> list[Path]:
+    cohort = read_support(path)["cohort"]
+    data = OLD / "data" / cohort
+    return [path, data / "conditions_raw_fixed.npz", OLD / "tools/ft_sdd.py",
+            ROOT / "tools/support_manifest.py", data / "cells_panel6k.npz", data / "folds.csv"]
+
+
+def sample(runtime: Runtime, tag: str, checkpoint: Path, ck_sha: str, condition: Path, output: Path,
+           support: Path | None = None, seed: int = 20260928) -> None:
+    wrapper = ROOT / "tools/sample_one.py"
+    argv = [PY, "-u", str(wrapper), "--checkpoint", str(checkpoint), "--checkpoint-sha", ck_sha,
+            "--condition", str(condition), "--output", str(output), "--seed", str(seed)]
+    runtime.execute(tag, argv, resource="gpu", memory_gib=16,
+                    inputs=[wrapper, M8 / "scripts/sample_sdd_standalone.py", condition,
+                            *([support] if support else [])], outputs=[output, output.with_suffix(".log")])
+
+
+def run_diffusion(runtime: Runtime, path: Path) -> None:
+    m = check_support(path)
+    tag, out = name(path), gen_dir(path)
+    runtime.execute(f"{tag}-train", train_command(path), resource="gpu", memory_gib=16,
+                    inputs=train_inputs(path),
+                    outputs=[run_dir(path) / "checkpoint_ft.pt", run_dir(path) / "RUN.json"])
+    record = json.loads((run_dir(path) / "RUN.json").read_text())
+    if set(record["train_rows"]) != set(m["train_sample_ids"]) or record["inner_val_rows"]:
+        raise ReceiptError("trained support differs from strict manifest")
+    if record["fixed_steps"] != 3000 or record["selected_step"] != 3000:
+        raise ReceiptError("strict training did not finish its fixed schedule")
+    sample(runtime, f"{tag}-lora", run_dir(path) / "checkpoint_ft.pt", record["checkpoint_sha256"],
+           data_dir(path) / "test_raw.npz", out / "lora.npz", path)
+    sample(runtime, f"{tag}-pairedcal", BASE, BASE_SHA, data_dir(path) / "test_cal.npz",
+           out / "pairedcal.npz", path)
+
+
+def scsemi_command(path: Path, phase: str) -> list[str]:
+    return [SC_PY, "-u", str(ROOT / "tools/run_scsemi_strict.py"), "--support-manifest", str(path),
+            "--work", str(ROOT / "scsemi" / relative(path)), "--phase", phase,
+            "--device", "cpu" if phase == "prepare" else "cuda:0", "--threads", "4", "--lean-hvset"]
+
+
+def run_scsemi(runtime: Runtime, path: Path) -> None:
+    m = check_support(path)
+    tag, work, output = name(path), ROOT / "scsemi" / relative(path), gen_dir(path) / "scsemi.npz"
+    adoption = work / "adopted_legacy/ADOPTION.json"
+    if adoption.is_file():
+        verifier = ROOT / "tools/verify_scsemi_adoption.py"
+        runtime.execute(f"{tag}-scadopt", [SC_PY, str(verifier), "--support-manifest", str(path),
+                        "--npz", str(output), "--out", str(work / "ADOPTED_OUTPUT_VALIDATION.json")],
+                        memory_gib=8, threads=2,
+                        inputs=[path, verifier, ROOT / "tools/import_scsemi_legacy.py", adoption, output.with_suffix(".log")],
+                        outputs=[work / "ADOPTED_OUTPUT_VALIDATION.json"])
+        return
+    prepare = OLD / "scsemi/tools/prepare_draw_inputs.py"
+    runtime.execute(f"{tag}-scinputs", [SC_PY, "-u", str(prepare), "--dataset", m["cohort"],
+                    "--support-manifest", str(path), "--work", str(work)], memory_gib=16,
+                    inputs=[path, prepare], outputs=[work / "inputs/inputs_manifest.json"])
+    wrapper = ROOT / "tools/run_scsemi_strict.py"
+    runtime.execute(f"{tag}-scprepare", scsemi_command(path, "prepare"), memory_gib=16,
+                    inputs=[path, wrapper, work / "inputs/inputs_manifest.json"], outputs=[work / "prepared.json"])
+    for phase, completed, counter, bound in (("pretrain", "pretrain_complete", "reps_pretrained", "--max-reps"),
+                                             ("infer", "infer_complete", "targets_done", "--max-targets")):
+        while True:
+            status = json.loads((work / "status.json").read_text())
+            if status[completed]:
+                break
+            before = status[counter]
+            argv = scsemi_command(path, phase) + [bound, "2" if phase == "pretrain" else "8"]
+            runtime.execute(f"{tag}-sc{phase}-{before}", argv, resource="gpu", memory_gib=48,
+                            inputs=[path, wrapper, work / "prepared.json"])
+            after = json.loads((work / "status.json").read_text())
+            if after[counter] <= before:
+                raise ReceiptError("scSemi phase returned without progress")
+    output.parent.mkdir(parents=True, exist_ok=True)
+    exporter = ROOT / "tools/export_scsemi_strict.py"
+    runtime.execute(f"{tag}-scexport", [SC_PY, str(exporter), "--support-manifest", str(path),
+                    "--work", str(work), "--out", str(output)], memory_gib=16,
+                    inputs=[path, exporter, work / "prepared.json"], outputs=[output, output.with_suffix(".log")])
+    validation = output.with_suffix(".validation.json")
+    runtime.execute(f"{tag}-scvalidate", [SC_PY, str(OLD / "scsemi/tools/validate_export.py"),
+                    "--work", str(work), "--npz", str(output)], memory_gib=16,
+                    inputs=[path, output.with_suffix(".log")], outputs=[validation])
+    if not json.loads(validation.read_text())["passed"]:
+        raise ReceiptError("scSemi export validation failed")
+
+
+def run_global(runtime: Runtime, cohort: str) -> None:
+    source = ROOT / "data/external_refcal" / cohort
+    for arm in ("raw", "refcal"):
+        sample(runtime, f"global-{cohort}-{arm}", BASE, BASE_SHA, source / f"conditions_{arm}.npz",
+               ROOT / "generated/global" / cohort / f"{arm}.npz")
+
+
+def run_score(runtime: Runtime, path: Path) -> None:
+    m = check_support(path)
+    output = ROOT / "scores" / relative(path)
+    argv = [CPU_PY, "-u", str(ROOT / "tools/score_strict.py"), "--support-manifest", str(path),
+            "--out", str(output), "--action", "all", "--threads", "4"]
+    arms = {arm: gen_dir(path) / f"{arm}.npz" for arm in ("lora", "pairedcal", "scsemi")}
+    arms.update({arm: ROOT / "generated/global" / m["cohort"] / f"{arm}.npz" for arm in ("raw", "refcal")})
+    for arm, artifact in arms.items():
+        if not artifact.is_file():
+            raise ReceiptError(f"required output not yet ready: {artifact}")
+        argv.extend(["--arm", f"{arm}={artifact}"])
+    runtime.execute(f"{name(path)}-score", argv, memory_gib=32,
+                    inputs=[path, *[ROOT / "tools" / f for f in
+                            ("score_strict.py", "donor_statistics.py", "donor_limma.R")],
+                            *[OLD / "tools" / f for f in
+                            ("score_ft.py", "extra_metrics.py", "contrast_extra.py")],
+                            *[p.with_suffix(".log") for p in arms.values()]],
+                    outputs=[output / "score/summary.json", output / "statistics/status.json",
+                             output / "statistics/donor_bootstrap_2000.csv",
+                             output / "extras" / m["cohort"] / "strict/manifest.json",
+                             output / "contrast" / m["cohort"] / "strict/manifest.json"])
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("action", choices=("status", "run"))
+    p.add_argument("--stage", choices=("diffusion", "scsemi", "global", "score", "all"), default="all")
+    p.add_argument("--only", help="unit name, e.g. immicro-healthy-fold0-n5")
+    p.add_argument("--max-units", type=int)
+    p.add_argument("--wait-lock", action="store_true", help="queue behind an already authorized controller")
+    a = p.parse_args()
+    units = discover_units()
+    if a.only:
+        units = [path for path in units if name(path) == a.only]
+        if not units:
+            p.error("no such unit")
+    if a.max_units is not None:
+        units = units[:a.max_units]
+    status_path = ROOT / "CAMPAIGN_STATUS.json"
+    if a.action == "status":
+        print(status_path.read_text() if status_path.exists() else json.dumps({"state": "prepared", "units": len(units)}))
+        return
+    lock = (ROOT / ".campaign.lock").open("a")
+    if a.wait_lock:
+        print("Waiting for the active campaign controller to release its lock.", flush=True)
+    fcntl.flock(lock, fcntl.LOCK_EX | (0 if a.wait_lock else fcntl.LOCK_NB))
+    runtime = Runtime(ROOT)
+    state = {"state": "running", "stage": a.stage, "started_at": stamp(), "units_selected": len(units),
+             "units_completed_this_invocation": 0, "figure6": "waiting_user_data_no_execution"}
+    atomic_json(status_path, state)
+    try:
+        if a.stage in ("global", "all"):
+            for cohort in COHORTS:
+                if any(read_support(x)["cohort"] == cohort for x in units):
+                    state.update(active=f"global-{cohort}", updated_at=stamp())
+                    atomic_json(status_path, state)
+                    run_global(runtime, cohort)
+        for path in units:
+            state.update(active=name(path), updated_at=stamp())
+            atomic_json(status_path, state)
+            if a.stage in ("diffusion", "all"):
+                run_diffusion(runtime, path)
+            if a.stage in ("scsemi", "all"):
+                run_scsemi(runtime, path)
+            if a.stage in ("score", "all"):
+                run_score(runtime, path)
+            state["units_completed_this_invocation"] += 1
+        if is_full_campaign(a.stage, units):
+            state.update(active="finalize-figures-and-documents", updated_at=stamp())
+            atomic_json(status_path, state)
+            finalizer = ROOT / "tools/finalize_campaign.py"
+            runtime.execute("finalize-campaign", [CPU_PY, "-u", str(finalizer), "--stage", "all"],
+                            memory_gib=2, inputs=[finalizer],
+                            outputs=[ROOT / "FINALIZATION_STATUS.json"])
+            state.update(active="archive-completed-figures-and-documents", updated_at=stamp())
+            atomic_json(status_path, state)
+            archive_completed_campaign(runtime)
+        state.update(state="selected_stage_completed", active=None, updated_at=stamp())
+    except BaseException as exc:
+        state.update(state="stopped_needs_inspection", error=str(exc), updated_at=stamp())
+        raise
+    finally:
+        atomic_json(status_path, state)
+
+
+if __name__ == "__main__":
+    main()