Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261013T034842Z-expanded-131-slide-master/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/expanded_disease_materials.py

@@ -0,0 +1,802 @@
+"""Existing disease/rare-state evidence for the expanded original 76-slide master.
+
+Only small saved tables, completed score receipts and existing figures are read.
+No arrays, checkpoints, annotation, model inference or statistical fitting occurs.
+All new files are confined to the expanded_master_20261013 disease directories.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import os
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+
+import numpy as np
+import pandas as pd
+import style as ST
+import matplotlib.pyplot as plt
+from matplotlib.patches import Patch
+from matplotlib.ticker import MaxNLocator
+
+D = Path(__file__).resolve().parents[1]
+M = D.parents[1]
+P = M / "plans/paper_figures_strictpairs_20261012"
+U = M / "plans/utility_studies_final6k_20260925"
+R = M / "plans/rare_states_screen_20261004"
+B = M / "plans/bayesprism_paired_20261006"
+BC = M / "plans/behcet_c1q_lora3_20261004"
+BO = M / "plans/bulkonly_lora5_20261006"
+K4 = M / "plans/bulkonly_lora5_k4000_20261006"
+FIG = D / "figures/expanded_master_20261013/disease"
+DATA = D / "data/expanded_master_20261013/disease"
+MANIFEST = D / "data/expanded_master_20261013/disease_additions.json"
+
+GOLD, BLUE, GREY, INK = "#C5AA4B", "#2166AC", "#909090", "#1A1A1A"
+ARMS = ["raw", "refcal", "pairedcal", "scsemi", "lora"]
+LABELS = {"raw": "Raw", "refcal": "Ref.\ncal.", "pairedcal": "Pair\ncal.",
+          "scsemi": "scSemi", "lora": "LoRA", "real_R2": "Real /\nreal"}
+COLORS = {"raw": "#E9DFB9", "refcal": "#D7C788", "pairedcal": "#97802C",
+          "scsemi": BLUE, "lora": GOLD, "real_R2": GREY}
+COHORTS = ["ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili"]
+COHORT_LABELS = ["Sepsis", "Imperial", "Giroux", "Ji"]
+TYPES = ["T cell", "B cell", "Monocyte", "NK cell", "DC"]
+TYPE_LABELS = ["T cells", "B cells", "Monocytes", "NK cells", "DC"]
+STATE_SHORT = {
+    "C1Q-high monocyte (reference)": "C1Q-high mono",
+    "Cycling activated T (CD38/HLA-DR)": "Cycling activated T",
+    "Cycling monocyte (Ye 2026)": "Cycling mono",
+    "ISG-high monocyte (positive control)": "ISG-high mono (+ control)",
+    "Platelet signal in monocytes (negative control)": "Platelet in mono (− control)",
+    "MS1 monocyte (IL1R2+)": "MS1 mono (IL1R2+)",
+}
+HISTORICAL = ("Historical five-donor training can include multiple paired visits in Imperial, Giroux and Ji. "
+              "It is not the strict five-sample protocol. Existing predictions and frozen marker/label rules are reused.")
+STRICT_NOTE = ("Exactly one paired sample from each of five donors, no extra validation, fixed 3000-step LoRA. "
+               "Only completed score receipts are used. Raw, external-reference calibration, same-pair calibration, "
+               "scSemiProfiler and LoRA share the recorded held-out targets. Dots are support draws, not independent "
+               "population replicates. These slides do not certify the unfinished four-cohort campaign.")
+
+
+class Unavailable(ValueError):
+    """A requested panel has insufficient existing, verifiable evidence."""
+
+
+def sha(path: Path) -> str:
+    with path.open("rb") as f:
+        return hashlib.file_digest(f, "sha256").hexdigest()
+
+
+def short_state(state: str) -> str:
+    return STATE_SHORT.get(state, state)
+
+
+def truth(series: pd.Series) -> pd.Series:
+    values = series.astype(str).str.lower()
+    if not values.isin(["true", "false"]).all():
+        raise Unavailable("boolean gate contains missing or unrecognized values")
+    return values.eq("true")
+
+
+class Builder:
+    def __init__(self):
+        self.sources: dict[str, dict] = {}
+        self.assets: list[str] = []
+        self.slides: list[dict] = []
+        self.dropped: list[dict] = []
+        self.strict: dict[tuple[str, int], dict] = {}
+        self.started_at = datetime.now(timezone.utc).isoformat()
+        FIG.mkdir(parents=True, exist_ok=True)
+        DATA.mkdir(parents=True, exist_ok=True)
+
+    def source(self, path: Path, role: str = "existing scientific evidence") -> Path:
+        path = path.resolve()
+        if not path.is_file():
+            raise Unavailable(f"missing source: {path}")
+        if path.suffix.lower() in {".npz", ".npy", ".h5ad", ".pt", ".pth", ".rds"}:
+            raise Unavailable(f"large-array/model input is outside saved-table plotting scope: {path}")
+        if path.stat().st_size > 20_000_000:
+            raise Unavailable(f"source exceeds bounded saved-table budget: {path}")
+        record = {"path": str(path), "sha256": sha(path), "bytes": path.stat().st_size, "role": role}
+        if str(path) in self.sources and self.sources[str(path)]["sha256"] != record["sha256"]:
+            raise Unavailable(f"source changed during the build: {path}")
+        self.sources[str(path)] = record
+        return path
+
+    def table(self, path: Path, role: str = "saved score table") -> pd.DataFrame:
+        path = self.source(path, role)
+        if path.is_relative_to(P / "scores"):
+            target = DATA / "strict_snapshot_tables" / path.relative_to(P)
+            target.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(path, target)
+            if sha(target) != self.sources[str(path)]["sha256"]:
+                raise Unavailable("strict table changed during snapshot")
+            self.assets.append(str(target))
+        return pd.read_csv(path)
+
+    def document(self, path: Path, role: str = "saved protocol/provenance") -> dict:
+        return json.loads(self.source(path, role).read_text())
+
+    def save_table(self, frame: pd.DataFrame, key: str) -> Path:
+        path = DATA / f"{key}.csv"
+        frame.to_csv(path, index=False)
+        self.assets.append(str(path))
+        self.source(path, "derived display table; no new statistical fit")
+        return path
+
+    def save(self, fig, key: str) -> Path:
+        for ext in ("png", "pdf", "svg"):
+            path = FIG / f"{key}.{ext}"
+            fig.savefig(path, dpi=ST.DPI, bbox_inches="tight", pad_inches=0.07, facecolor="white")
+            self.assets.append(str(path))
+        plt.close(fig)
+        return FIG / f"{key}.png"
+
+    def add(self, key: str, title: str, figure: Path, after: int, footnote: str, notes: str,
+            refs: list[Path], *, section: str = "Additional evidence", palette: str = "native"):
+        if len(title) > 60 or len(footnote) > 180:
+            raise ValueError(f"slide text exceeds agreed length: {key}")
+        if "disease_" + key in {s["key"] for s in self.slides}:
+            raise ValueError(f"duplicate addition key: {key}")
+        figure = self.source(figure, "display figure")
+        records = [self.source(p) for p in refs]
+        source_text = "; ".join(str(p.relative_to(M)) if p.is_relative_to(M) else str(p) for p in records)
+        full = notes + "\nSources: " + source_text
+        self.slides.append({"kind": "content", "layout": "full", "key": "disease_" + key,
+            "title": title, "section_label": section, "figures": [str(figure.relative_to(D)) if figure.is_relative_to(D) else str(figure)],
+            "keywords": [], "footnote": footnote, "footnote_full": full,
+            "sources": source_text, "notes": full, "after_original": after,
+            "palette": palette, "new_experiment": False})
+
+    def ready(self, key, title, figure, after, footnote, notes, refs, section="External diagnostic"):
+        self.add(key, title, figure, after, footnote, notes, refs, section=section, palette="biological")
+
+    def attempt(self, key: str, operation):
+        try:
+            operation()
+        except (Unavailable, FileNotFoundError, KeyError) as e:
+            self.dropped.append({"candidate": key, "reason": str(e), "action": "not displayed; no replacement experiment"})
+
+    def snapshot_unit(self, cohort: str, draw: int) -> dict:
+        unit = (cohort, draw)
+        if unit in self.strict:
+            return self.strict[unit]
+        receipt = P / f"receipts/{cohort}-disease-draw{draw}-score.json"
+        record = self.document(receipt, "completed strict score receipt")
+        if record.get("state") != "completed":
+            raise Unavailable(f"score receipt is not completed: {receipt}")
+        base = P / f"scores/{cohort}/disease/draw{draw}"
+        support_path = P / f"protocol/splits/{cohort}/disease/draw{draw}/support.json"
+        support = self.document(support_path, "strict exact-support manifest")
+        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 or len(set(support["train_sample_ids"])) != 5 or len(set(support["train_donor_ids"])) != 5:
+            raise Unavailable("strict support identity/hash is invalid")
+        verified = []
+        for output in record.get("outputs", []):
+            path = self.source(Path(output["path"]), "completed strict score output")
+            if sha(path) != output["sha256"] or path.stat().st_size != output["bytes"]:
+                raise Unavailable(f"completed receipt/output mismatch: {path}")
+            verified.append(path)
+        required = {base / "score/summary.json", base / "statistics/status.json"}
+        if not required <= set(verified):
+            raise Unavailable("score receipt does not bind both summary and corrected statistics")
+        status = self.document(base / "statistics/status.json")
+        if status.get("support_sha256") != support["sha256"] or status.get("disease_deg", {}).get("status") != "ok":
+            raise Unavailable("corrected strict statistics are incomplete or support differs")
+        summary = self.document(base / "score/summary.json")
+        if set(summary.get("headline", {})) != set(ARMS):
+            raise Unavailable("strict comparator family is incomplete")
+        folder = DATA / "strict_snapshot" / cohort / f"draw{draw}"
+        folder.mkdir(parents=True, exist_ok=True)
+        for path in [receipt, support_path, *verified]:
+            rel = path.relative_to(P)
+            target = folder / rel
+            target.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(path, target)
+            if sha(target) != sha(path):
+                raise Unavailable("strict snapshot copy hash mismatch")
+            self.assets.append(str(target))
+        result = {"base": base, "receipt": receipt, "support": support_path, "summary": summary,
+                  "status": status, "verified_outputs": [str(x) for x in verified]}
+        self.strict[unit] = result
+        return result
+
+
+def bar_metrics(builder: Builder, rows: pd.DataFrame, columns: list[tuple[str, str]], key: str,
+                order: list[str] = ARMS, control: bool = False) -> Path:
+    fig, axes = plt.subplots(1, len(columns), figsize=ST.FULL, squeeze=False)
+    fig.subplots_adjust(left=0.075, right=0.98, bottom=0.26 if len(order) > 5 else 0.21,
+                        top=0.91, wspace=0.36)
+    for ax, (metric, label) in zip(axes[0], columns):
+        for i, arm in enumerate(order):
+            values = pd.to_numeric(rows.loc[rows.arm == arm, metric], errors="raise").to_numpy()
+            if len(values) == 0 or not np.isfinite(values).all():
+                raise Unavailable(f"missing/nonfinite values for {key}/{arm}/{metric}")
+            ax.bar(i, values.mean(), color=COLORS[arm], width=0.72, zorder=2)
+            if len(values) > 1:
+                ax.scatter(i + np.linspace(-0.11, 0.11, len(values)), values, s=20, color="white",
+                           edgecolor=INK, linewidth=0.55, zorder=3)
+        dense_labels = {"real_R2": "Real", "raw": "Raw", "refcal": "Ref", "pairedcal": "Pair",
+                        "scsemi": "scSP", "lora": "LoRA"}
+        ax.set_xticks(range(len(order)), [dense_labels[x] if len(order) > 5 else LABELS[x] for x in order], fontsize=12)
+        ax.tick_params(axis="x", length=0, pad=8)
+        ax.set_ylabel(label)
+        ax.grid(axis="y", color="#E8E8E8", linewidth=0.7, zorder=0)
+        ax.set_axisbelow(True)
+        ax.yaxis.set_major_locator(MaxNLocator(nbins=5))
+        if metric in ("precision", "coverage", "c2st_knn_auc"):
+            ax.set_ylim(0, 1.05)
+        if metric == "c2st_knn_auc":
+            ax.axhline(0.5, color=INK, linestyle="--", linewidth=0.8)
+    if len(order) > 5:
+        fig.text(0.53, 0.055,
+                 "Real: real/real control · Ref: external-reference calibration · Pair: same-pair calibration · scSP: scSemiProfiler",
+                 ha="center", fontsize=12, color="#4D4D4D")
+    return builder.save(fig, key)
+
+
+def heat(ax, values: pd.DataFrame, title: str = "", *, vmin=0, vmax=None, cmap="Greys",
+         fmt=".2g", show_y=True, text_size=12):
+    matrix = values.to_numpy(dtype=float)
+    cm = plt.get_cmap(cmap).copy(); cm.set_bad("#F2F2F2")
+    if vmax is None:
+        vmax = float(np.nanmax(matrix)) if np.isfinite(matrix).any() else 1
+    if vmax <= vmin:
+        vmax = vmin + 1
+    im = ax.imshow(matrix, aspect="auto", interpolation="nearest", vmin=vmin, vmax=vmax, cmap=cm)
+    ax.set_xticks(range(len(values.columns)), values.columns, fontsize=12)
+    ax.xaxis.tick_top()
+    if show_y:
+        ax.set_yticks(range(len(values)), values.index, fontsize=12)
+    else:
+        ax.set_yticks([])
+    ax.tick_params(axis="both", length=0, pad=7)
+    ax.set_xticks(np.arange(-0.5, len(values.columns), 1), minor=True)
+    ax.set_yticks(np.arange(-0.5, len(values), 1), minor=True)
+    ax.grid(which="minor", color="white", linewidth=1.2); ax.tick_params(which="minor", length=0)
+    for spine in ax.spines.values(): spine.set_visible(False)
+    for i in range(len(values)):
+        for j in range(len(values.columns)):
+            x = matrix[i, j]
+            rgb = im.cmap(im.norm(x))[:3] if np.isfinite(x) else (1, 1, 1)
+            luminance = 0.2126 * rgb[0] + 0.7152 * rgb[1] + 0.0722 * rgb[2]
+            ax.text(j, i, "NA" if not np.isfinite(x) else format(x, fmt), ha="center", va="center",
+                    fontsize=text_size, color="white" if luminance < 0.45 else INK)
+    if title: ax.set_title(title, fontsize=14, loc="left", pad=36)
+    return im
+
+
+def strict_panels(b: Builder):
+    units = [b.snapshot_unit("ye2026_sepsis", draw) for draw in range(5)]
+    rows = pd.DataFrame([dict(arm=arm, draw=draw, **unit["summary"]["headline"][arm])
+                         for draw, unit in enumerate(units) for arm in ARMS])
+    table = b.save_table(rows, "strict_sepsis_quality")
+    refs = [unit["receipt"] for unit in units] + [table]
+    fig = bar_metrics(b, rows, [("precision", "Precision ↑"), ("coverage", "Coverage ↑"),
+                               ("comp_l1", "Composition L1 ↓")], "strict_sepsis_quality")
+    b.add("strict_sepsis_quality", "Sepsis: exact-five reconstruction across five draws", fig, 38,
+          "Completed exact-five Sepsis draws. Bars = means; dots = support draws. Five matched methods; no new generation.",
+          STRICT_NOTE + " Precision, coverage and composition are read directly from completed score summaries.", refs, section="Fig. 4 update")
+    extras = []
+    extra_refs = []
+    for draw, unit in enumerate(units):
+        root = unit["base"] / "extras/ye2026_sepsis/strict"
+        mf, ef = root / "metrics.csv", root / "en.csv"
+        metrics, en = b.table(mf), b.table(ef)
+        metrics = metrics[(metrics.real_side == "R1") & (metrics["mode"] == "raw")].copy()
+        en = en[(en.cellset == "pc") & (en.distance == "sq")]
+        for arm in ["real_R2", *ARMS]:
+            a = metrics[metrics["set"] == arm]; e = en[en["set"] == arm]
+            if len(a) != 1 or len(e) != 1: raise Unavailable("strict realism selection is not unique")
+            extras.append({"draw": draw, "arm": arm, "c2st_knn_auc": a.iloc[0].c2st_knn_auc,
+                           "mmd2_bw1": a.iloc[0]["mmd2_bw1"], "en": e.iloc[0].en})
+        extra_refs += [mf, ef]
+    extra = pd.DataFrame(extras); ex = b.save_table(extra, "strict_sepsis_realism")
+    fig = bar_metrics(b, extra, [("c2st_knn_auc", "C2ST AUROC (0.5 ideal)"), ("mmd2_bw1", "MMD² ↓"),
+                                ("en", "E_N, PC sample ↓")], "strict_sepsis_realism", ["real_R2", *ARMS])
+    b.add("strict_sepsis_realism", "Sepsis: realism beyond precision and coverage", fig, 38,
+          "Completed exact-five outputs; raw readout, fixed R1 reference. Real/real control shown. Dots are five support draws.",
+          STRICT_NOTE + " C2ST uses cached kNN AUROC; MMD uses bandwidth 1; E_N uses the saved PC subsample, squared distance and exact lower bound. No refitting.",
+          extra_refs + [ex], section="Fig. 4 update")
+    strict_deg(b, "ye2026_sepsis", units, 40)
+
+
+def strict_deg(b: Builder, cohort: str, units: list[dict], after: int):
+    frames, refs = [], []
+    for j, unit in enumerate(units):
+        path = unit["base"] / "statistics/donor_deg/donor_deg_summary.csv"
+        frame = b.table(path); frame["draw"] = j
+        if not frame.status.eq("ok").all(): raise Unavailable("corrected DEG rows are not all complete")
+        if len(frame) != 25: raise Unavailable("unexpected corrected DEG comparator/type count")
+        frames.append(frame); refs += [path, unit["receipt"], unit["base"] / "statistics/status.json"]
+    table = pd.concat(frames, ignore_index=True)
+    vals = table.groupby(["celltype", "arm"]).top50_overlap_count.mean().unstack().reindex(index=TYPES, columns=ARMS)
+    vals.index = TYPE_LABELS; vals.columns = [LABELS[x] for x in ARMS]
+    fig, ax = plt.subplots(figsize=ST.FULL); fig.subplots_adjust(left=0.18, right=0.90, bottom=0.13, top=0.90)
+    heat(ax, vals, vmax=50, cmap="YlOrBr", fmt=".1f")
+    fig.text(0.54, 0.045, "Observed / generated top-50 overlap (0–50)", ha="center", fontsize=14)
+    key = "strict_" + cohort + "_deg"
+    display = b.save_table(table, key)
+    figure = b.save(fig, key)
+    name = "Sepsis" if cohort == "ye2026_sepsis" else "Imperial"
+    title = f"{name}: patient-aware disease-gene agreement"
+    foot = "Completed corrected count-based DEG fits; mean of five support draws." if len(units) == 5 else "Single completed exact-five draw 0; patient-aware DEG fits. Other draws are outside this frozen snapshot."
+    b.add(key, title, figure, after, foot,
+          STRICT_NOTE + " Values are saved FDR-filtered top-50 list overlap counts, not correlations or cell classification accuracy. "
+          "The recorded method is edgeR/TMM/limma-voom, with donor duplicateCorrelation for Imperial. "
+          "A donor can contribute to both disease conditions; group donor counts must not be summed as independent people. "
+          "Historical sample-level Welch metrics are different endpoints.", refs + [display], section="Fig. 4 update")
+
+
+def imperial_panels(b: Builder):
+    unit = b.snapshot_unit("imperial_eskd", 0)
+    rows = pd.DataFrame([dict(arm=arm, draw=0, **unit["summary"]["headline"][arm]) for arm in ARMS])
+    table = b.save_table(rows, "strict_imperial_draw0_quality")
+    fig = bar_metrics(b, rows, [("precision", "Precision ↑"), ("coverage", "Coverage ↑"),
+                               ("comp_l1", "Composition L1 ↓")], "strict_imperial_draw0_quality")
+    b.add("strict_imperial_quality", "Imperial: first completed exact-five comparison", fig, 38,
+          "One completed support draw (draw 0). Exact five paired samples; all five methods scored. Not the final five-draw comparison.",
+          STRICT_NOTE + " Single-draw evidence is shown separately from the complete Sepsis set. Repeated held-out visits remain linked to actual donor IDs.",
+          [unit["receipt"], unit["support"], table], section="Fig. 4 update")
+    strict_deg(b, "imperial_eskd", [unit], 40)
+
+
+def external_figures(b: Builder):
+    b.ready("sle_broadcast", "SLE: what is added beyond the bulk broadcast?",
+        D / "figures/sec04_sle_broadcast.png", 43,
+        "Existing SLE pseudobulk development benchmark; bulk broadcast is an explicit comparator. Separate from paired real-bulk validation.",
+        "Existing figure omitted from the original 76-slide specification. Retain its gene axis, cell-type units and seed counts. "
+        "This is a pseudobulk-conditioned benchmark, not a new external real-bulk result.",
+        [D / "data/sec04_sle_broadcast.csv", D / "tools/sec04_sle_benchmark.py"], section="Development benchmark")
+    q = U / "randolph"
+    b.ready("influenza_response", "Influenza: response order versus response genes",
+        q / "out/fig_randolph_celltype_response.png", 43,
+        "Historical zero-shot influenza test. Response-strength ordering is recovered; gene-wise agreement remains below the matched bulk broadcast.",
+        "Generated cells rank monocytes as strongest and T cells as weakest responders, but fail the preregistered "
+        "gene-wise beyond-broadcast rule. Different arms can have different eligible donor counts; each broadcast matches its arm's donors. "
+        "Observed-PBMC broadcast is an oracle. No new fitting or cell generation.",
+        [q / "RESULTS.md", q / "MANIFEST.json", q / "out/extended/extended_analysis.json"])
+    q = U / "refcal_scoring/arunachalam"
+    common = [q / "RESULTS.md", q / "MANIFEST.json", q / "receipts/receipt_checks.json"]
+    b.ready("covid_map", "COVID: calibration on a shared real-cell map",
+        q / "placement/figures/fig1_umap_seven_panels_by_label_depth1000.png", 43,
+        "Historical 7 COVID / 5 HC samples, common depth. High-resolution reference overview; following detail panels provide readable quantitative results.",
+        "This is an existing zero-shot input/calibration study, not LoRA/scSemiProfiler. Observed cells define the reference map. "
+        "Use saved quantitative endpoints rather than interpreting overlap as a performance score. Biological cell-type colors are preserved.",
+        common + [q / "placement/tables/prec_cov.csv", q / "placement/tables/composition_full_chain.csv"])
+    b.ready("covid_direction", "COVID monocytes: direction after depth matching",
+        q / "placement/figures/fig2_covid_hc_monocyte_arrows_depth1000.png", 43,
+        "Historical 7 COVID / 5 HC samples, common depth. High-resolution reference overview; following panels separate direction, magnitude and relabeling null.",
+        "Native-depth and depth-matched results differ. Relabelling-null shares are descriptive; not every directional cosine "
+        "exceeds its null. No claim of independent significance or completed Figure 6 reproduction.",
+        common + [q / "placement/tables/displacement.csv", q / "placement/tables/displacement_relabel_null.csv"])
+
+
+def covid_endpoints(b: Builder):
+    q = U / "refcal_scoring/arunachalam"
+    src = q / "effects_final/endpoints_paired12.csv"
+    rows = b.table(src)
+    endpoints = ["P1", "P2", "P3", "P4"]
+    names = ["ISG / monocyte", "HLA-DR / CD14 mono", "Plasma-cell fraction", "Plasmablast genes"]
+    arms = ["gen_raw", "gen_tpm", "gen_refcalHC", "gen_cal", "gen_pseudo"]
+    arm_names = ["Raw", "TPM", "Ref.\ncal.", "Pair\ncal.", "Pseudo"]
+    show = rows[rows.endpoint.isin(endpoints) & rows.source.isin(arms)].copy()
+    if len(show) != 20: raise Unavailable("COVID endpoint selection is not exactly four endpoints by five arms")
+    fig, axes = plt.subplots(1, 2, figsize=ST.FULL); fig.subplots_adjust(left=0.22, right=0.98, top=0.80, bottom=0.13, wspace=0.18)
+    for ax, metric, title, low, high in zip(axes, ["ratio_to_observed", "donor_spearman_with_observed"],
+            ["Effect / observed (1 = matched)", "Donor ranking (Spearman ρ)"], [0, -1], [2, 1]):
+        vals = show.pivot(index="endpoint", columns="source", values=metric).reindex(index=endpoints, columns=arms)
+        vals.index = names; vals.columns = arm_names
+        heat(ax, vals, title, vmin=low, vmax=high, cmap="Greys", show_y=ax is axes[0], fmt=".2f")
+    table = b.save_table(show, "covid_endpoints")
+    b.add("covid_endpoints", "COVID: biological endpoints give a mixed verdict", b.save(fig, "covid_endpoints"), 43,
+          "Historical 7 COVID / 5 HC samples. Saved effect ratios and donor ranks; no new fits. Reference calibration is not uniformly best.",
+          "Four predefined endpoints are all retained. Reference calibration improves some plasmablast/composition endpoints "
+          "but loses HLA-DR donor ranking and overshoots the ISG effect. All generated arms fail the original preregistered "
+          "gene-wide beyond-broadcast criterion; the alternate pipeline definition is not substituted.",
+          [src, table, q / "RESULTS.md", q / "global_r/global_logfc_r_two_definitions.csv"], section="External diagnostic")
+
+
+def covid_direction_details(b: Builder):
+    """Enlarge saved direction/length/null metrics without fitting an embedding."""
+    q = U / "refcal_scoring/arunachalam"
+    src = q / "placement/tables/displacement.csv"
+    rows = b.table(src)
+    arms = ["real_holdout", "gen_raw", "gen_tpm", "gen_refcalHC", "gen_refcalAll", "gen_cal", "gen_pseudo"]
+    labels = ["Real held-out", "Raw bulk", "TPM bulk", "Ref-cal HC", "Ref-cal all", "Paired cal", "sc pseudobulk"]
+    for population, name, key in [("Monocyte (L1)", "monocytes", "covid_monocyte_direction_detail"),
+                                  ("CD14 monocyte (L2)", "CD14 monocytes", "covid_cd14_direction_detail")]:
+        # The label is required exactly as recorded; no population substitution.
+        sub = rows[(rows.population == population) & rows["set"].isin(arms) & rows.depth.isin(["native", "depth1000"])].copy()
+        if len(sub) != 14 or sub.duplicated(["depth", "set"]).any():
+            raise Unavailable(f"saved displacement rows incomplete: {population}")
+        fig, axes = plt.subplots(1, 3, figsize=ST.FULL, sharey=True)
+        fig.subplots_adjust(left=0.19, right=0.985, bottom=0.15, top=0.81, wspace=0.22)
+        metrics = [("cos_pca50", "Direction cosine"), ("length_ratio_pca50", "Step length / real"),
+                   ("share_relabelings_cos_ge_true", "Relabeling-null share")]
+        for ax, (metric, xlabel) in zip(axes, metrics):
+            for depth, offset, marker, face, edge in [("native", -0.13, "o", "white", INK),
+                                                     ("depth1000", 0.13, "D", GOLD, INK)]:
+                values = sub[sub.depth == depth].set_index("set").loc[arms, metric].to_numpy(dtype=float)
+                if not np.isfinite(values).all(): raise Unavailable("saved COVID direction metric is nonfinite")
+                ax.scatter(values, np.arange(7) + offset, s=55, marker=marker,
+                           facecolor=face, edgecolor=edge, linewidth=0.8, zorder=3)
+            ax.set_xlabel(xlabel)
+            ax.grid(axis="x", color="#EAEAEA", linewidth=0.7)
+            ax.set_axisbelow(True)
+            ax.tick_params(axis="y", length=0, labelsize=12)
+            ax.xaxis.set_major_locator(MaxNLocator(nbins=4))
+            if metric == "cos_pca50":
+                ax.set_xlim(-0.05, 1.05)
+                ax.axvline(1, color=GREY, linewidth=0.8, linestyle="--")
+            elif metric == "length_ratio_pca50":
+                ax.set_xlim(0, max(1.1, float(sub[metric].max()) * 1.08))
+                ax.axvline(1, color=GREY, linewidth=0.8, linestyle="--")
+            else:
+                ax.set_xlim(0, max(0.1, float(sub[metric].max()) * 1.12))
+        axes[0].set_yticks(np.arange(7), labels)
+        axes[0].set_ylim(6.6, -0.6)
+        from matplotlib.lines import Line2D
+        fig.legend([Line2D([], [], linestyle="none", marker="o", markerfacecolor="white", markeredgecolor=INK, markersize=7),
+                    Line2D([], [], linestyle="none", marker="D", markerfacecolor=GOLD, markeredgecolor=INK, markersize=7)],
+                   ["Native depth", "Depth-matched to 1,000"], loc="upper center", ncol=2, fontsize=12)
+        fig.text(0.58, 0.035, "Saved PCA-50 metrics; no new embedding, projection or statistical fit", ha="center", fontsize=12, color="#4D4D4D")
+        out = b.save_table(sub, key)
+        b.add(key, f"COVID {name}: direction, magnitude and null", b.save(fig, key), 43,
+              "Readable detail of the retained COVID overview. Existing 7 COVID / 5 HC paired samples; native and depth-matched results stay separate.",
+              "Every saved arm is retained, including the held-out real-cell reference, raw, TPM, both reference calibrations, "
+              "paired calibration and own-sc-pseudobulk conditions. Cosine and length ratio use the recorded PCA-50 disease displacement; "
+              "they are not read from the 2D UMAP. Relabeling-null share is the existing descriptive fraction of label permutations "
+              "whose cosine is at least the observed one, not a newly fitted p-value or proof of biological reproduction. "
+              "The full original depth-matched spatial overview remains in the deck. Only native UMAP coordinates were persisted "
+              "in embedding_native_cells.parquet; these detail panels use saved numeric displacement tables instead of refitting depth-matched UMAP.",
+              [src, out, q / "placement/tables/displacement_relabel_null.csv", q / "RESULTS.md"], section="External diagnostic")
+
+
+def rare_misses(b: Builder):
+    src = P / "source_data/rare_all_states_aggregate.csv"
+    rows = b.table(src)
+    order_source = b.table(P / "source_data/rare_all_states.csv")
+    states = list(dict.fromkeys(order_source.state))
+    if len(states) != 15: raise Unavailable("rare rule set changed; do not silently omit states")
+    for number, selected in enumerate([states[:8], states[8:]], 1):
+        fig, axes = plt.subplots(1, 2, figsize=ST.FULL)
+        fig.subplots_adjust(left=0.30, right=0.98, top=0.80, bottom=0.10, wspace=0.12)
+        display = []
+        for ax, arm, title, color in zip(axes, ["lora5", "scsemi5"], ["PBISC LoRA", "scSemiProfiler"], [GOLD, BLUE]):
+            frame = rows[rows.arm == arm]
+            vals = frame.pivot(index="state", columns="cohort", values="missed_observed_fraction").reindex(index=selected, columns=COHORTS) * 100
+            display.append(vals.reset_index().assign(arm=arm))
+            vals.index = [short_state(x) for x in selected]; vals.columns = COHORT_LABELS
+            heat(ax, vals, title, vmax=100, cmap="Greys", show_y=ax is axes[0], fmt=".0f")
+            ax.title.set_color(color)
+        fig.text(0.64, 0.025, "Observed-positive donors missed (%) · lower is better", ha="center", fontsize=13)
+        key = f"rare_misses_{number}"
+        table = b.save_table(pd.concat(display, ignore_index=True), key)
+        b.add(key, f"Rare-state misses: rules {1 if number == 1 else 9}–{8 if number == 1 else 15}",
+              b.save(fig, key), 50,
+              "Saved zero-aware diagnostic; all 15 predefined rules are shown across two slides. NA means not evaluable, not zero error.",
+              HISTORICAL + " Each percentage is the saved mean across support draws of missed observed-positive donor fraction. "
+              "Actual donor IDs, zero draws and common depth/cell budget are retained by the existing analysis. "
+              "Mandatory IGLL5 is absent for the Ji plasmablast marker rule, which stays unavailable.",
+              [src, table, P / "reports/rare_provenance.json", P / "reports/rare_readiness.md"], section="Fig. 5 detail")
+
+
+def rare_support(b: Builder):
+    src = R / "out/sepsis_summary.csv"
+    rows = b.table(src)
+    states = list(dict.fromkeys(rows.state))
+    arms = ["zs__raw", "lora_n5__raw", "lora_n10__raw", "lora_n20__raw", "lora_n40__raw", "real_lora__raw", "zs__pseudo"]
+    vals = rows.pivot(index="state", columns="arm", values="gen_over_obs").reindex(index=states, columns=arms)
+    if vals.shape != (15, 7) or not np.isfinite(vals.to_numpy()).all(): raise Unavailable("incomplete historical support screen")
+    vals.index = [short_state(x) for x in states]
+    vals.columns = ["Raw", "5", "10", "20", "40", "Full", "Pseudo"]
+    fig, ax = plt.subplots(figsize=ST.FULL); fig.subplots_adjust(left=0.30, right=0.97, bottom=0.08, top=0.93)
+    heat(ax, vals, vmax=float(vals.to_numpy().max()), cmap="YlOrBr", fmt=".2g")
+    fig.text(0.63, 0.015, "Generated / observed within parent (1 = matched)", ha="center", fontsize=13)
+    display = b.save_table(rows, "sepsis_rare_support")
+    b.add("sepsis_rare_support", "Sepsis rare states across paired-data budgets", b.save(fig, "sepsis_rare_support"), 51,
+          "Historical cross-fitted learning curve: n training pairs plus validation, not strict total n. All 15 rules; arm-specific depth matching.",
+          "Existing pooled predictions for 82 donors and 1500 generated cells per sample. Each donor was held out from its fold model. "
+          "Raw and pseudobulk are zero-shot controls; numbered/full columns are historical LoRA budgets. "
+          "Observed cells were thinned separately to each arm's depth, so compare gen/obs within an arm. "
+          "No new generation or rare-state scoring; the full 15-rule family, including controls, is preserved.",
+          [src, display, R / "README.md", R / "tools/states.json"], section="Fig. 5 detail")
+    src = R / "out/sepsis_contrasts.csv"
+    contrasts = b.table(src)
+    contrasts["kept"] = truth(contrasts.same_direction)
+    contrasts["eligible"] = 1
+    grouped = contrasts.groupby(["contrast", "arm"])[["kept", "eligible"]].sum().reset_index()
+    names = ["adult sepsis vs adult HC", "paediatric sepsis vs paediatric HC", "all sepsis vs all controls"]
+    vals = grouped.pivot(index="contrast", columns="arm", values="kept").reindex(index=names, columns=arms)
+    den = grouped.pivot(index="contrast", columns="arm", values="eligible").reindex(index=names, columns=arms)
+    if not (den == 15).all().all(): raise Unavailable("rare contrast rule denominator differs")
+    vals.index = ["Adult sepsis / HC", "Pediatric sepsis / HC", "All sepsis / controls"]
+    vals.columns = ["Raw", "5", "10", "20", "40", "Full", "Pseudo"]
+    fig, ax = plt.subplots(figsize=ST.FULL); fig.subplots_adjust(left=0.25, right=0.97, bottom=0.21, top=0.86)
+    heat(ax, vals, vmax=15, cmap="YlOrBr", fmt=".0f", text_size=16)
+    fig.text(0.60, 0.08, "Rules with the observed disease direction, out of 15", ha="center", fontsize=14)
+    display = b.save_table(grouped, "sepsis_rare_direction")
+    b.add("sepsis_rare_direction", "Sepsis rare-state direction across support budgets", b.save(fig, "sepsis_rare_direction"), 51,
+          "Saved sign-agreement counts across all 15 rules, including controls. Historical n + validation; directions are not effect-size accuracy.",
+          "Counts summarize existing same_direction booleans; no thresholds or p-values are recomputed. "
+          "All rule-family members are retained, including weak or failed states and positive/negative controls. "
+          "A matching sign does not establish that a rare state's abundance or marker co-expression is reproduced.",
+          [src, display, R / "README.md"], section="Fig. 5 detail")
+
+
+def rare_external(b: Builder):
+    src = R / "out/summary.csv"
+    rows = b.table(src); states = list(dict.fromkeys(rows.state)); cohorts = ["dress", "kawasaki", "sle"]
+    fig, axes = plt.subplots(1, 2, figsize=ST.FULL)
+    fig.subplots_adjust(left=0.31, right=0.97, top=0.84, bottom=0.05, wspace=0.18)
+    for ax, metric, title, low, high in zip(axes, ["gen_over_obs", "spearman"],
+            ["Generated / observed", "Sample ranking (ρ)"], [0, -1], [2.5, 1]):
+        vals = rows.pivot(index="state", columns="dataset", values=metric).reindex(index=states, columns=cohorts)
+        vals.index = [short_state(x) for x in states]; vals.columns = ["DRESS", "Kawasaki", "SLE"]
+        heat(ax, vals, title, vmin=low, vmax=high, cmap="Greys", show_y=ax is axes[0], fmt=".2g")
+    table = b.save_table(rows, "external_rare_screen")
+    b.add("external_rare_screen", "Rare-state screen in DRESS, Kawasaki and SLE", b.save(fig, "external_rare_screen"), 51,
+          "Historical one-seed zero-shot screen conditioned on each sample's own sc pseudobulk. DRESS was in training; real-bulk validation is separate.",
+          "All 15 predefined states are shown. Samples' own sc pseudobulk conditions remove the real-bulk shift. "
+          "Observed marker states are thinned to generated depth. DRESS includes cultured/stimulated samples and was seen during training. "
+          "This is descriptive capability evidence, not an unseen-disease paired validation or Figure 6 reproduction.",
+          [src, table, R / "README.md", R / "tools/states.json"], section="Rare-state appendix")
+    q = M / "plans/c1q_crossdisease_20261004"
+    src = q / "out/summary.csv"; data = b.table(src).set_index("dataset").loc[cohorts]
+    fig, axes = plt.subplots(1, 2, figsize=ST.FULL); fig.subplots_adjust(left=0.08, right=0.98, bottom=0.18, top=0.82, wspace=0.30)
+    for ax, metric, ylabel in zip(axes, ["ratio_c1q_", "spearman_c1q_"], ["Generated / observed rate", "Sample ranking (Spearman ρ)"]):
+        for j, (rule, label, color) in enumerate([("ge1_pct", "Any C1Q gene", "#DDD0A0"), ("ge2_pct", "≥2 C1Q genes", GOLD)]):
+            values = data[metric + rule].to_numpy(dtype=float)
+            ax.bar(np.arange(3) + (j - 0.5) * 0.32, values, width=0.30, color=color, label=label)
+        ax.set_xticks(range(3), ["DRESS", "Kawasaki", "SLE"]); ax.set_ylabel(ylabel)
+        ax.set_ylim(0, 1.05); ax.axhline(1, color=GREY, linewidth=0.8, linestyle="--")
+        ax.set_axisbelow(True); ax.grid(axis="y", color="#EAEAEA")
+    handles, labels = axes[0].get_legend_handles_labels(); fig.legend(handles, labels, loc="upper center", ncol=2, fontsize=12)
+    table = b.save_table(data.reset_index(), "c1q_cross_disease")
+    b.add("c1q_cross_disease", "C1Q: single-gene detection versus co-detection", b.save(fig, "c1q_cross_disease"), 52,
+          "Existing pseudobulk-conditioned comparison at matched depth. Multi-gene C1Q rates remain compressed, including in-corpus DRESS.",
+          "One sampling seed. DRESS has seven samples, including four cultured/stimulated samples; Kawasaki has 15 and SLE 56. "
+          "Corpus inclusion is not randomized and DRESS samples were seen in training. Retain the distinction between any-gene detection "
+          "and at least two C1Q genes in the same cell; no causal claim about pretraining exposure.",
+          [src, table, q / "README.md"], section="Rare-state appendix")
+
+
+def behcet_k(b: Builder):
+    group = pd.concat([b.table(BC / "out/group_table.csv"), b.table(BC / "out/group_table_k4000.csv")], ignore_index=True)
+    cap = pd.concat([b.table(BC / "out/capability.csv"), b.table(BC / "out/capability_k4000.csv")], ignore_index=True)
+    settings = [("zs_raw", "Raw\nK1000", "#DDD0A0"), ("lora3_raw", "LoRA\nK1000", GOLD),
+                ("lora3k4_raw", "LoRA\nK4000", "#826B22")]
+    fig, axes = plt.subplots(1, 2, figsize=ST.FULL); fig.subplots_adjust(left=0.09, right=0.98, top=0.86, bottom=0.20, wspace=0.32)
+    display = []
+    for i, (prefix, label, color) in enumerate(settings):
+        for j, seed in enumerate(["s13", "s04"]):
+            arm = f"{prefix}_{seed}"
+            g = group[(group.arm == arm) & (group.rows == "test") & (group.metric == "c1q_high_rule_A")]
+            c = cap[cap.arm == arm]
+            if len(g) != 1 or len(c) != 1: raise Unavailable("Behcet seed/arm table row missing or duplicated")
+            gap, rate = float(g.iloc[0].gap_pp), float(c.iloc[0].pooled_rule_B_pct)
+            axes[0].scatter(i + (j - 0.5) * 0.12, gap, color=color, s=70, edgecolor=INK, linewidth=0.5)
+            axes[1].scatter(i + (j - 0.5) * 0.12, rate, color=color, s=70, edgecolor=INK, linewidth=0.5)
+            display.append({"arm": arm, "any_c1q_bd_minus_hc_pp": gap, "multi_gene_pooled_pct": rate})
+    for ax in axes:
+        ax.set_xticks(range(3), [s[1] for s in settings]); ax.set_xlim(-0.5, 2.5)
+        ax.set_axisbelow(True); ax.grid(axis="y", color="#EAEAEA")
+    axes[0].set_ylabel("Any-C1Q BD − HC gap (pp)"); axes[0].axhline(0, color=GREY, linewidth=0.8)
+    axes[1].set_ylabel("≥2 C1Q genes / monocytes (%)")
+    for arm, label, color in [("obs_thin_lora3", "Observed at K1000 LoRA depth", GREY),
+                              ("obs_thin_lora3k4", "Observed at K4000 LoRA depth", INK)]:
+        row = cap[cap.arm == arm]
+        if len(row) != 1: raise Unavailable("Behcet observed depth reference missing")
+        axes[1].axhline(float(row.iloc[0].pooled_rule_B_pct), color=color, linestyle="--", linewidth=1.2, label=label)
+    axes[1].legend(fontsize=11, loc="upper left", bbox_to_anchor=(0.02, 0.82))
+    table = b.save_table(pd.DataFrame(display), "behcet_k4000")
+    b.add("behcet_k4000", "Behçet: K=4,000 changes direction more than identity", b.save(fig, "behcet_k4000"), 52,
+          "Two existing sampling seeds; 6 BD / 10 HC held-out bulks. K is condition size; each bulk still generates 5,000 cells. Descriptive.",
+          "The real reference is 4 BD and 4 HC sc donors, mostly unmatched and including training donors. "
+          "The three BD-only training candidates include two primary identity passes and one uncertain candidate. "
+          "K4000 strengthens the any-C1Q group direction, but ≥2-gene cells remain far below observed. "
+          "Same-pair calibration can also recover direction; this plot does not claim LoRA uniquely does so. No p-values are promoted.",
+          [BC / "out/group_table.csv", BC / "out/group_table_k4000.csv", BC / "out/capability.csv", BC / "out/capability_k4000.csv",
+           BC / "README.md", P / "reports/rare_behcet_provenance.json", table], section="Behçet diagnostic")
+
+
+def k4000_panels(b: Builder):
+    frames, refs = [], []
+    for cohort in COHORTS[:2]:
+        src = K4 / "analysis/benchmark" / cohort / "per_draw.csv"
+        table = b.table(src); table["cohort"] = cohort
+        if len(table) != 10 or set(table.arm) != {"lora5", "lora5_k4000"}: raise Unavailable("K comparison lacks all paired draws")
+        frames.append(table); refs += [src, src.with_name("AGGREGATE.md")]
+    rows = pd.concat(frames, ignore_index=True)
+    for key, title, metrics, after in [
+        ("k4000_quality", "K=4,000 recipe: paired reconstruction quality", [("comp_l1", "Composition L1 ↓"), ("precision", "Precision ↑"), ("coverage", "Coverage ↑")], 67),
+        ("k4000_disease", "K=4,000 recipe: disease signal does not improve uniformly", [("logfc_r_gen", "Disease logFC Pearson r"), ("logfc_partial_r", "Partial r given bulk"), ("deg_top50_sum", "Top-50 DEG overlap (sum)")], 67)]:
+        fig, axes = plt.subplots(1, 3, figsize=ST.FULL); fig.subplots_adjust(left=0.07, right=0.99, bottom=0.18, top=0.84, wspace=0.36)
+        for ax, (metric, ylabel) in zip(axes, metrics):
+            for ci, cohort in enumerate(COHORTS[:2]):
+                for mi, (arm, color) in enumerate([("lora5", GOLD), ("lora5_k4000", "#826B22")]):
+                    values = rows[(rows.cohort == cohort) & (rows.arm == arm)].sort_values("draw")[metric].to_numpy()
+                    x = ci + (mi - 0.5) * 0.32
+                    ax.bar(x, values.mean(), width=0.30, color=color)
+                    ax.scatter(x + np.linspace(-0.06, 0.06, 5), values, s=20, color="white", edgecolor=INK, linewidth=0.5, zorder=3)
+            ax.set_xticks([0, 1], COHORT_LABELS[:2]); ax.set_ylabel(ylabel); ax.set_axisbelow(True); ax.grid(axis="y", color="#EAEAEA")
+        fig.legend([Patch(color=GOLD), Patch(color="#826B22")], ["PBISC LoRA, K1000", "PBISC LoRA, K4000"], loc="upper center", ncol=2, fontsize=12)
+        display = b.save_table(rows[["cohort", "draw", "arm", *[m[0] for m in metrics]]], key)
+        b.add(key, title, b.save(fig, key), after,
+              "Existing paired benchmark, five support draws per cohort and 1,500 cells/test sample. Bars = means; dots = draws. No new runs.",
+              "The stored K1000 re-score exactly matched 25 original metrics in every draw. K4000 uses a changed condition recipe "
+              "and draw-specific seeds; it is not a perfectly isolated one-factor K test. Imperial training uses all visits from five donors. "
+              "Disease logFC/DEG are the historical sample-level estimators, not the new patient-aware strict metrics. "
+              "No donor-draw p-values are used here; overlapping test donors are not independent replicates.", refs + [display, K4 / "README.md"], section="Recipe sensitivity")
+    records, sources = [], []
+    for cohort in COHORTS[:2]:
+        src = K4 / "analysis/compare_k1000" / cohort / "per_feature.csv"; frame = b.table(src)
+        if len(frame) != 250: raise Unavailable("calibration table lacks 50 features × five draws")
+        contrast = "adult sepsis vs adult HC" if cohort == "ye2026_sepsis" else "COVID+ vs COVID-"
+        for gate, label in [("level_ok", "Level + ranking"), (contrast + ": ok", "Disease contrast")]:
+            for version in ["k1000", "k4000"]:
+                records.append({"cohort": cohort, "gate": label, "version": version,
+                                "pass_count": int(truth(frame[gate + "_" + version]).sum()), "total": len(frame)})
+        sources += [src, src.with_name("SUMMARY.md")]
+    display = pd.DataFrame(records)
+    fig, axes = plt.subplots(1, 2, figsize=ST.FULL); fig.subplots_adjust(left=0.08, right=0.97, bottom=0.18, top=0.82, wspace=0.28)
+    for ax, cohort, name in zip(axes, COHORTS[:2], COHORT_LABELS[:2]):
+        for j, (v, color) in enumerate([("k1000", GOLD), ("k4000", "#826B22")]):
+            sub = display[(display.cohort == cohort) & (display.version == v)]
+            bars = ax.bar(np.arange(2) + (j - 0.5) * 0.32, sub.pass_count, width=0.30, color=color)
+            for bar, count in zip(bars, sub.pass_count): ax.text(bar.get_x() + bar.get_width()/2, count + 4, f"{count}/250", ha="center", fontsize=12)
+        ax.set_xticks([0, 1], ["Level + ranking", "Disease contrast"]); ax.set_ylim(0, 250)
+        ax.set_ylabel("Feature × draw gates passed"); ax.set_title(name, loc="left"); ax.set_axisbelow(True); ax.grid(axis="y", color="#EAEAEA")
+    fig.legend([Patch(color=GOLD), Patch(color="#826B22")], ["K1000", "K4000"], loc="upper center", ncol=2, fontsize=12)
+    out = b.save_table(display, "k4000_calibration")
+    b.add("k4000_calibration", "K=4,000 recipe: calibration gains are selective", b.save(fig, "k4000_calibration"), 67,
+          "Saved paired-test gates: 50 features × 5 draws per cohort. Descriptive counts, not 250 independent biological replicates.",
+          "Level gate: generated/observed ratio 0.5–2 and Spearman at least 0.3. Contrast gate: same sign and generated magnitude "
+          "0.5–2 times observed. Disease contrasts shown are adult sepsis/HC and COVID+/COVID−. "
+          "Imperial severity gates are omitted here because historical severity grouping required separate correction. "
+          "The K4000 bulk-only discovery workflow was not completed and is not inferred from calibration.", sources + [out], section="Recipe sensitivity")
+
+
+def bulkonly_history(b: Builder):
+    records, refs = [], []
+    for cohort in COHORTS[:2]:
+        src = BO / f"analysis/wf/findings_{cohort}.json"; data = b.document(src)
+        for label in ["confirmed", "qualified", "refuted"]:
+            records.append({"cohort": cohort, "grade": label, "count": int(data["counts"][label])})
+        refs += [src, BO / f"analysis/wf/REPORT_{cohort}.md"]
+    table = pd.DataFrame(records)
+    fig, ax = plt.subplots(figsize=ST.FULL); fig.subplots_adjust(left=0.15, right=0.96, bottom=0.20, top=0.86)
+    for i, (grade, color) in enumerate([("confirmed", "#333333"), ("qualified", "#BFBFBF"), ("refuted", "#777777")]):
+        values = table[table.grade == grade].set_index("cohort").loc[COHORTS[:2], "count"].to_numpy()
+        x = np.arange(2) + (i - 1) * 0.24
+        bars = ax.bar(x, values, width=0.22, color=color, label=grade.capitalize())
+        for bar, count in zip(bars, values): ax.text(bar.get_x()+bar.get_width()/2, count+0.45, str(count), ha="center", fontsize=14)
+    ax.set_xticks([0, 1], ["Sepsis · 18 candidates", "Imperial · 21 candidates"])
+    ax.set_ylabel("Candidate findings"); ax.set_ylim(0, 22); ax.legend(ncol=3, loc="upper left", fontsize=12)
+    ax.set_axisbelow(True); ax.grid(axis="y", color="#EAEAEA")
+    out = b.save_table(table, "bulkonly_verification_history")
+    b.add("bulkonly_verification_history", "Historical bulk-only search: no confirmed new finding", b.save(fig, "bulkonly_verification_history"), 55,
+          "Historical exploratory analysis of existing bulk-only generations. Review dispositions are not experimental validation. Figure 6 reproduction still awaits new data.",
+          "The original K1000 workflow considered 18 Sepsis and 21 Imperial candidate findings. Both reports retain zero confirmed "
+          "findings under their internal two-verifier grading rule. This is an account of prior exploration, not newly completed biology. "
+          "Known weaknesses include shared generation noise across draws, calibration transfer, clinical confounding and some invalid verifier p-values. "
+          "No novel cell population survived verification; the user-prepared Figure 6 reproduction is still pending.",
+          refs + [out, BO / "README.md"], section="Historical exploration", palette="biological")
+    src = BO / "analysis/wf/synthesis_imperial_eskd/i00_samples_by_set_group_wave.csv"
+    data = b.table(src)
+    vals = data.groupby(["set", "wave"]).n_samples.sum().unstack(fill_value=0).reindex(index=["paired", "bulkonly"], columns=["w1", "w2", "w1|w2"], fill_value=0)
+    totals = vals.sum(axis=1); percentages = vals.div(totals, axis=0) * 100
+    fig, ax = plt.subplots(figsize=ST.FULL); fig.subplots_adjust(left=0.15, right=0.92, bottom=0.22, top=0.84)
+    bottom = np.zeros(2)
+    for wave, label, color in [("w1", "Wave 1", "#B7B7B7"), ("w2", "Wave 2", "#5F5F5F"), ("w1|w2", "Recorded w1|w2", "#E4E4E4")]:
+        values = percentages[wave].to_numpy()
+        ax.bar([0, 1], values, bottom=bottom, color=color, label=label, width=0.48)
+        for i, (count, pct) in enumerate(zip(vals[wave], values)):
+            if pct > 0: ax.text(i, bottom[i]+pct/2, f"{int(count)} ({pct:.1f}%)", ha="center", va="center", fontsize=13, color="white" if wave=="w2" else INK)
+        bottom += values
+    ax.set_xticks([0, 1], [f"Paired samples (n={int(totals['paired'])})", f"Bulk-only samples (n={int(totals['bulkonly'])})"])
+    ax.set_ylim(0, 100); ax.set_ylabel("Samples (%)"); ax.legend(ncol=3, loc="upper center", bbox_to_anchor=(0.5, 1.16), fontsize=12)
+    out = b.save_table(data, "bulkonly_imperial_wave_shift")
+    b.add("bulkonly_imperial_wave_shift", "Bulk-only exploration: calibration populations differ", b.save(fig, "bulkonly_imperial_wave_shift"), 55,
+          "Historical Imperial sample composition. Paired and bulk-only sets differ in wave; repeated samples are not independent donors.",
+          "Counts are read from the original synthesis table, including the recorded mixed w1|w2 category rather than silently reallocating it. "
+          "This describes a calibration-transfer limitation and is not a causal wave effect or novel biological discovery. "
+          "Figure 6 remains awaiting the user's new reproduction dataset.", [src, out, BO / "analysis/wf/REPORT_imperial_eskd.md"],
+          section="Historical exploration", palette="biological")
+
+
+def deconv_coverage(b: Builder):
+    records, refs = [], []
+    for cohort in COHORTS:
+        for draw in range(5):
+            path = B / f"results/{cohort}/fewshot_draw{draw}_cibersortx/summary.json"
+            info = b.document(path)
+            corr = info["bayesprism"].get("logfc_r_mean_cp10k")
+            records.append({"cohort": cohort, "draw": draw, "covered_genes": info["genes_covered_by_Z_all_donors"],
+                            "disease_correlation_available": corr is not None and math.isfinite(float(corr))})
+            refs.append(path)
+    data = pd.DataFrame(records)
+    fig, axes = plt.subplots(1, 2, figsize=ST.FULL); fig.subplots_adjust(left=0.08, right=0.98, bottom=0.20, top=0.86, wspace=0.30)
+    method_color = "#6A51A3"  # CIBERSORTx, consistent with the original master.
+    for i, cohort in enumerate(COHORTS):
+        rows = data[data.cohort == cohort].sort_values("draw")
+        for j, row in enumerate(rows.itertuples()):
+            axes[0].scatter(i + (j - 2) * 0.055, row.covered_genes, s=55,
+                            facecolor=method_color if row.disease_correlation_available else "white", edgecolor=method_color, linewidth=1.2)
+        count = int(rows.disease_correlation_available.sum())
+        axes[1].bar(i, count, color=method_color, width=0.62)
+        axes[1].text(i, count+0.12, f"{count}/5", ha="center", fontsize=14)
+    for ax in axes: ax.set_xticks(range(4), COHORT_LABELS); ax.set_axisbelow(True); ax.grid(axis="y", color="#EAEAEA")
+    axes[0].set_ylabel("HiRes genes covered on all samples"); axes[0].set_ylim(bottom=0)
+    axes[1].set_ylabel("Draws with disease correlation"); axes[1].set_ylim(0, 5.7); axes[1].set_yticks(range(6))
+    fig.text(0.08, 0.055, "Open points: disease correlation unavailable; not a zero performance score.", fontsize=12, color="#4D4D4D")
+    out = b.save_table(data, "deconv_expression_coverage")
+    b.add("deconv_expression_coverage", "Deconvolution: expression coverage limits the comparison", b.save(fig, "deconv_expression_coverage"), 46,
+          "Completed historical CIBERSORTx five-donor runs. Missing disease correlations remain unavailable; deconvolution does not generate individual cells.",
+          HISTORICAL + " Coverage is the saved HiRes covered-gene count; some genes outside the four contrast cell types can be covered "
+          "even when the disease correlation is unavailable. Two Giroux draws and one Ji draw lack that score. "
+          "The internal summary field named bayesprism is reused by the old scorer for CIBERSORTx; these values are from CIBERSORTx files. "
+          "Existing Sepsis method adoption does not mean new corrected strict deconvolution statistics are already complete.",
+          refs + [out, B / "results/RESULTS_cibersortx.md"], section="Deconvolution detail")
+
+
+def build() -> dict:
+    b = Builder()
+    b.source(Path(__file__), "expanded disease figure/spec builder")
+    b.source(D / "tools/style.py", "original on-slide typography and figure geometry")
+    b.source(M / "EXPERIMENT_INDEX.md", "existing experiment/reuse navigation")
+    style = {"font.family": "sans-serif", "font.sans-serif": ["Arial", "Liberation Sans", "DejaVu Sans"],
+             "font.size": 14, "axes.labelsize": 14, "axes.titlesize": 14, "xtick.labelsize": 12, "ytick.labelsize": 12,
+             "legend.fontsize": 12, "legend.frameon": False, "axes.spines.top": False, "axes.spines.right": False,
+             "axes.linewidth": 1.0, "figure.facecolor": "white", "axes.facecolor": "white", "pdf.fonttype": 42,
+             "ps.fonttype": 42, "svg.fonttype": "none"}
+    with plt.rc_context(style):
+        for key, action in [("strict_sepsis", strict_panels), ("strict_imperial", imperial_panels),
+                            ("ready_external", external_figures), ("covid_direction_details", covid_direction_details),
+                            ("covid_endpoints", covid_endpoints),
+                            ("rare_misses", rare_misses), ("rare_support", rare_support), ("rare_external", rare_external),
+                            ("behcet_k4000", behcet_k), ("k4000", k4000_panels),
+                            ("historical_bulkonly", bulkonly_history), ("deconv_coverage", deconv_coverage)]:
+            b.attempt(key, lambda action=action: action(b))
+    # This addition is an explicit six-unit snapshot, not a moving live-job
+    # dashboard. Newly completed receipts are surfaced for the next refresh.
+    next_refresh = []
+    for cohort in COHORTS:
+        for draw in range(5):
+            if (cohort, draw) in b.strict:
+                continue
+            receipt = P / f"receipts/{cohort}-disease-draw{draw}-score.json"
+            if receipt.is_file():
+                record = json.loads(receipt.read_text())
+                if record.get("state") == "completed":
+                    next_refresh.append({"cohort": cohort, "draw": draw, "receipt": str(receipt),
+                                         "receipt_sha256": sha(receipt),
+                                         "state": "outside requested snapshot; verify outputs before adding"})
+    result = {"schema": "pbisc.expanded-master.disease-additions.v1",
+              "created_at": datetime.now(timezone.utc).isoformat(), "snapshot_started_at": b.started_at,
+              "snapshot_scope": "Sepsis draws 0–4 and Imperial draw 0 only; each included unit must pass receipt/output hash checks",
+              "other_completed_receipts_for_next_refresh": next_refresh,
+              "slides": b.slides, "assets": list(dict.fromkeys(b.assets)),
+              "sources": list(b.sources.values()), "dropped": b.dropped,
+              "strict_completed_units": [{"cohort": c, "draw": j, "receipt": str(v["receipt"]),
+                                           "support": str(v["support"]), "verified_outputs": v["verified_outputs"]}
+                                          for (c, j), v in b.strict.items()],
+              "new_training": False, "new_generation": False, "new_scoring": False,
+              "figure6": "new reproduction dataset still pending; bulk-only additions are historical exploration",
+              "deduplicated_root_additions": ["corrected rare-state frequencies", "corrected rare comparison", "Behcet any/multi-C1Q rules"],
+              "display_work": "saved-table aggregation/formatting and existing figure reuse only"}
+    MANIFEST.parent.mkdir(parents=True, exist_ok=True)
+    MANIFEST.write_text(json.dumps(result, indent=2, allow_nan=False) + "\n")
+    return result
+
+
+if __name__ == "__main__":
+    result = build()
+    print(json.dumps({"slides": len(result["slides"]), "assets": len(result["assets"]),
+                      "dropped": result["dropped"], "manifest": str(MANIFEST)}, indent=2))

paper-releases/pbisc-diffusion/updates/20261013T034842Z-expanded-131-slide-master/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/expanded_healthy_materials.py

@@ -0,0 +1,650 @@
+"""Additional healthy/control slides from saved tables and saved coordinates.
+
+No model, checkpoint, expression matrix, new embedding, statistical scorer or
+inference is loaded. Only display transforms (percentages, log-length axes,
+fixed display subsets) are computed. Original assets remain untouched.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import shutil
+from pathlib import Path
+from typing import Any
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+from matplotlib.lines import Line2D
+import numpy as np
+import pandas as pd
+
+D = Path(__file__).resolve().parents[1]
+M = D.parents[1]
+U = M / "plans/utility_studies_final6k_20260925"
+V = U / "umap/cell_immicro_5arm"
+FIG = D / "figures/expanded_master_20261013/healthy"
+DATA = D / "data/expanded_master_20261013/healthy"
+FULL = (12.3, 5.6)
+INK, GREY, BLUE = "#1A1A1A", "#777777", "#2166AC"
+COL = {"raw": "#E8DDAE", "tpm": "#D2BC70", "refcal": "#B59A50", "cal": "#9C8138",
+       "pseudo": "#806A25", "R2": "#777777", "refcal_aida": "#C5AA4B", "refcal_train": "#65521B",
+       "tpmrefcal": "#A68B3C"}
+ARM = ["raw", "tpm", "refcal", "cal", "pseudo"]
+LABEL = {"raw": "Raw", "tpm": "TPM", "refcal": "AIFI ref-cal", "cal": "Paired cal. (10)",
+         "pseudo": "Pseudobulk", "R2": "Held-out real", "refcal_aida": "AIDA ref-cal",
+         "refcal_train": "Training ref-cal", "tpmrefcal": "TPM + AIFI"}
+TYPES = ["T cell", "B cell", "Monocyte", "NK cell", "DC", "Other"]
+SHORT = ["T", "B", "Mono", "NK", "DC", "Other"]
+CELL_COL = {"T cell": "#4E79A7", "B cell": "#F28E2B", "Monocyte": "#E15759",
+            "NK cell": "#59A14F", "DC": "#B07AA1", "Other": "#9C755F"}
+NATIVE_FOOT = "Historical native-depth diagnostic: sc-derived depth/masks; 10-pair calibration; AIFI overlaps pretraining. One seed."
+NATIVE_NOTE = (
+    "Historical zero-shot input diagnostics, not strict-five LoRA/scSemiProfiler comparison. "
+    "Final f01 6k 1x E16 EMA; 107 ImMicro donors; 1,500 generated cells/donor; 50 DDIM steps; "
+    "Bernoulli support; generation seed 20260922 shared across input arms. Native depth and cell count, "
+    "and the output gene-availability mask, use each donor's sc data. Paired calibration uses 10 paired samples. "
+    "AIFI alpha uses no paired ImMicro sc expression, but 85 of its 108 reference donors overlap pretraining; "
+    "this is not evidence of a completely sc-free deployment. Most cell-space metrics use 150 cells/donor "
+    "and 5,508 common measured genes; PCA50/UMAP fitted only on real R1. Generated counts are Poisson readouts, "
+    "not observed UMIs. One cohort and one seed; no new uncertainty tests. The source manifest records exact "
+    "reproduction of the earlier four-arm controls."
+)
+
+
+class MaterialBuilder:
+    def __init__(self) -> None:
+        self.slides: list[dict[str, Any]] = []
+        self.assets: list[str] = []
+        self.sources: dict[str, dict[str, str]] = {}
+        self.used: set[str] = set()
+
+    def source(self, path: Path, role: str = "saved analysis input") -> Path:
+        path = path.resolve()
+        if path.suffix.lower() not in {".csv", ".json", ".md", ".py", ".png"}:
+            raise ValueError(f"Only small table/document inputs are allowed: {path}")
+        if path.stat().st_size > 16_777_216:
+            raise ValueError(f"Input exceeds 16MiB table/document cap: {path}")
+        with path.open("rb") as handle:
+            sha = hashlib.file_digest(handle, "sha256").hexdigest()
+        self.sources[str(path)] = {"path": str(path), "sha256": sha, "role": role}
+        self.used.add(str(path))
+        return path
+
+    def frame(self, path: Path, **kwargs: Any) -> pd.DataFrame:
+        return pd.read_csv(self.source(path), **kwargs)
+
+    def document(self, path: Path, role: str = "saved analysis metadata") -> dict[str, Any]:
+        return json.loads(self.source(path, role).read_text())
+
+    def begin(self, native: bool = True) -> None:
+        self.used = set()
+        if native:
+            self.source(V / "MANIFEST.json", "historical input/control provenance")
+            self.source(V / "RESULTS.md", "historical scope and limitations")
+
+    def finish(self, fig: plt.Figure, key: str, title: str, after: int,
+               data: pd.DataFrame | None = None, note: str = "", native: bool = True,
+               footnote: str | None = None, palette: str = "native") -> None:
+        if len(title) > 64:
+            raise ValueError(f"Title too long: {title}")
+        path = FIG / key
+        fig.canvas.draw()
+        for suffix in ("png", "pdf", "svg"):
+            output = path.with_suffix("." + suffix)
+            fig.savefig(output, dpi=200, bbox_inches="tight", pad_inches=0.06, facecolor="white")
+            self.assets.append(str(output))
+        plt.close(fig)
+        if data is not None:
+            output = DATA / (key + ".csv")
+            data.to_csv(output, index=False)
+            self.assets.append(str(output))
+        foot = footnote or NATIVE_FOOT
+        if len(foot) > 180:
+            raise ValueError(f"Footnote too long: {foot}")
+        full = ((NATIVE_NOTE + "\n\n") if native else "") + note
+        full += "\n\nSource files (existing results, read only):\n" + "\n".join(sorted(self.used))
+        self.slides.append({"kind": "content", "key": "healthy_" + key, "after_original": after,
+            "title": title, "section_label": "Control evidence", "layout": "full",
+            "figures": [str(path.with_suffix(".png").relative_to(D))], "keywords": [],
+            "footnote": foot, "footnote_full": full, "sources": "; ".join(sorted(self.used)),
+            "palette": palette})
+        proof = DATA / (key + ".provenance.json")
+        proof.write_text(json.dumps({"key": key, "source_records": [self.sources[p] for p in sorted(self.used)],
+            "new_training": False, "new_inference": False, "new_embedding": False,
+            "new_statistical_scoring": False, "display_transform_notes": note, "palette": palette}, indent=2) + "\n")
+        self.assets.append(str(proof))
+
+
+def clean(ax: plt.Axes, axis: str = "y") -> None:
+    ax.spines[["top", "right"]].set_visible(False)
+    ax.grid(axis=axis, color="#E8E8E8", linewidth=0.7)
+    ax.set_axisbelow(True)
+
+
+def legend_methods(fig: plt.Figure, arms: list[str], y: float = 0.01) -> None:
+    handles = [Line2D([], [], marker="o", color=COL[a], label=LABEL[a], linewidth=1.5) for a in arms]
+    fig.legend(handles=handles, loc="lower center", bbox_to_anchor=(0.5, y), ncol=min(len(arms), 6), fontsize=11,
+               frameon=False, columnspacing=1.0, handlelength=1.5)
+
+
+def coords(builder: MaterialBuilder) -> tuple[pd.DataFrame, dict[str, Any]]:
+    doc = builder.document(V / "interactive/cells_5arm.json", "previously computed display coordinates; no embedding recalculated")
+    table = pd.DataFrame(doc["cells"])
+    table["set_name"] = table["set"].map(dict(enumerate(doc["sets"])))
+    table["label"] = table["l1"].map(dict(enumerate(doc["labels_l1"])))
+    # The old JSON's illustrative extent excludes 174 cached display points.
+    # Widen only the viewing window; every stored coordinate stays unchanged.
+    doc["display_extent"] = {}
+    for coordinate in ("x", "y"):
+        lo = min(float(table[coordinate].min()), doc["meta"]["umap_extent"][coordinate][0])
+        hi = max(float(table[coordinate].max()), doc["meta"]["umap_extent"][coordinate][1])
+        pad = (hi - lo) * .025
+        doc["display_extent"][coordinate] = [lo - pad, hi + pad]
+    return table, doc
+
+
+def stored_umap(builder: MaterialBuilder) -> None:
+    builder.begin()
+    table, doc = coords(builder)
+    arms = ["R2"] + ARM
+    fig, axes = plt.subplots(2, 3, figsize=FULL)
+    for ax, arm in zip(axes.flat, arms):
+        sub = table[table.set_name == arm]
+        ax.scatter(sub.x, sub.y, c=sub.label.map(CELL_COL), s=2.1, lw=0, rasterized=True)
+        ax.set_title(LABEL[arm], fontsize=13)
+        ax.set_xlim(doc["display_extent"]["x"])
+        ax.set_ylim(doc["display_extent"]["y"])
+        ax.set_xticks([]); ax.set_yticks([])
+        for spine in ax.spines.values(): spine.set_visible(False)
+    fig.legend(handles=[Line2D([], [], marker="o", ls="", color=CELL_COL[t], label=t) for t in TYPES],
+               loc="lower center", ncol=6, frameon=False, fontsize=11)
+    fig.subplots_adjust(left=.02, right=.99, top=.93, bottom=.09, hspace=.22, wspace=.08)
+    builder.finish(fig, "stored_real_reference_umap", "Input corrections on one real-reference UMAP", 19,
+        table[["set_name", "pair_id", "donor_index", "label", "x", "y"]],
+        "Replots only the stored interactive coordinates: 3,000 displayed cells per set. "
+        "The reference PCA/UMAP was previously fitted to real R1. UMAP overlap is illustrative, not a score. "
+        "Cell-type colors are preserved; no new labels or embedding were computed. "
+        "Shared display bounds cover all saved coordinates plus 2.5% padding; the narrower old illustrative extent is not reused.", palette="preserved")
+
+
+def saved_density_reference(builder: MaterialBuilder) -> None:
+    builder.begin()
+    source = builder.source(V / 'figures/fig2_density_difference.png', 'existing high-resolution quantitative density figure')
+    destination = FIG / 'saved_density_difference.png'
+    shutil.copyfile(source, destination)
+    builder.assets.append(str(destination))
+    note = (NATIVE_NOTE + '\n\nThe original high-resolution PNG is copied byte-for-byte, with no crop, pixel recoloring, '
+        'density-grid recomputation, or fresh embedding. Its diverging colors encode signed density differences, '
+        'not PBISC/scSemiProfiler identities. Retained as a full-width working-master reference; zoom may be needed '
+        'for small panel labels. UMAP-space density is a qualitative localization diagnostic, not a calibrated biological score. '
+        '\n\nSource files:\n' + '\n'.join(sorted(builder.used)))
+    builder.slides.append({'kind':'content','key':'healthy_saved_density_difference','after_original':19,
+        'title':'Where generated-cell density differs from real cells','section_label':'Control evidence','layout':'full',
+        'figures':[str(destination.relative_to(D))],'keywords':[],
+        'footnote':'Original high-resolution density map; zoom for panel labels. Quantitative colors preserved. Historical native-depth controls.',
+        'footnote_full':note,'sources':'; '.join(sorted(builder.used)),'palette':'preserved'})
+    proof = DATA / 'saved_density_difference.provenance.json'
+    proof.write_text(json.dumps({'key':'saved_density_difference','source_records':[builder.sources[p] for p in sorted(builder.used)],
+        'unchanged_png_copy':True,'no_density_or_embedding_recomputation':True,'palette':'preserved',
+        'readability_note':'Full-width reference; small original panel labels may require zoom.'},indent=2)+'\n')
+    builder.assets.append(str(proof))
+
+
+def composition(builder: MaterialBuilder) -> None:
+    builder.begin()
+    frame = builder.frame(V / "tables/b_composition_l1.csv").set_index("label").loc[TYPES]
+    arms = ["R2"] + ARM
+    fig, ax = plt.subplots(figsize=FULL)
+    bottom = np.zeros(len(arms))
+    for cell in TYPES:
+        values = frame.loc[cell, arms].to_numpy(float) * 100
+        ax.bar(np.arange(len(arms)), values, bottom=bottom, color=CELL_COL[cell], label=cell, width=.68)
+        bottom += values
+    ax.set_xticks(np.arange(len(arms)), [LABEL[a] for a in arms])
+    ax.set_ylabel("Cell-type share (%)"); ax.set_ylim(0, 101)
+    clean(ax)
+    ax.legend(ncol=6, frameon=False, loc="upper center", bbox_to_anchor=(.5, 1.14), fontsize=11)
+    fig.subplots_adjust(left=.08, right=.98, top=.85, bottom=.17)
+    builder.finish(fig, "input_control_composition", "Input calibration changes cell-type composition", 19,
+        frame.reset_index(), "Saved fractions from 150 cells/donor; displayed as percent. "
+        "Color identifies biological cell type, not method. Do not interpret reference calibration's "
+        "composition agreement as proof of within-type state recovery.", palette="preserved")
+
+
+def matched_trajectories(builder: MaterialBuilder) -> None:
+    builder.begin()
+    table, doc = coords(builder)
+    pseudo = table[table.set_name == "pseudo"].sort_values("pair_id")
+    selected = pseudo.groupby("label", sort=False).head(12)
+    fig, axes = plt.subplots(2, 2, figsize=FULL)
+    outputs = []
+    for ax, arm in zip(axes.flat, ARM[:-1]):
+        other = table[table.set_name == arm].set_index("pair_id")
+        pairs = selected.set_index("pair_id").join(other[["x", "y", "label"]], rsuffix="_input", validate="one_to_one")
+        if pairs[["x_input", "y_input"]].isna().any().any():
+            raise ValueError("Stored matched coordinates are incomplete")
+        for pair_id, row in pairs.iterrows():
+            ax.plot([row.x_input, row.x], [row.y_input, row.y], color=COL[arm], lw=.6, alpha=.55)
+            outputs.append({"arm": arm, "pair_id": pair_id, "pseudo_label": row.label,
+                            "input_label": row.label_input, "x_input": row.x_input, "y_input": row.y_input,
+                            "x_pseudo": row.x, "y_pseudo": row.y})
+        ax.scatter(pairs.x_input, pairs.y_input, c=pairs.label_input.map(CELL_COL), s=11, lw=0)
+        ax.scatter(pairs.x, pairs.y, facecolors="none", edgecolors=pairs.label.map(CELL_COL), s=17, lw=.6)
+        ax.set_title(LABEL[arm] + " → pseudobulk-input twin", fontsize=12)
+        ax.set_xlim(doc["display_extent"]["x"]); ax.set_ylim(doc["display_extent"]["y"])
+        ax.set_xticks([]); ax.set_yticks([])
+        for spine in ax.spines.values(): spine.set_visible(False)
+    fig.text(.5, .02, "Filled: input arm   Open: matched pseudobulk-input twin   Color: frozen cell type", ha="center", fontsize=11)
+    fig.subplots_adjust(left=.02, right=.99, top=.93, bottom=.08, hspace=.22, wspace=.12)
+    builder.finish(fig, "stored_matched_trajectories", "Same noise, different input: matched-cell shifts", 19,
+        pd.DataFrame(outputs), "Display subset: first 12 stored pair IDs within each pseudobulk-predicted type, "
+        "at most 72 pairs/arm, selected deterministically from the previously stored display sample. "
+        "No embedding or labels recalculated. Lines connect generated samples sharing noise; they are not "
+        "longitudinal biological transitions. Exact displayed pairs are saved. "
+        "Shared display bounds cover all saved coordinates plus 2.5% padding.", palette="preserved")
+
+
+def similarity(builder: MaterialBuilder) -> None:
+    builder.begin()
+    frame = builder.frame(V / "tables/c_matched_cells.csv").set_index("pair")
+    arms = ARM[:-1]
+    rows = frame.loc[[a + "_vs_pseudo_matched" for a in arms]]
+    fig, axes = plt.subplots(1, 3, figsize=FULL)
+    metrics = [("median_r_scoring_genes", "Median expression correlation"),
+               ("median_support_jaccard", "Median support Jaccard"),
+               ("same_frozen_label_fraction", "Same frozen-label fraction")]
+    for ax, (metric, label) in zip(axes, metrics):
+        values = rows[metric].to_numpy(float)
+        ax.bar(np.arange(4), values, color=[COL[a] for a in arms], width=.68)
+        if metric == "median_r_scoring_genes":
+            lo = values - rows.q25_r_scoring_genes.to_numpy(float)
+            hi = rows.q75_r_scoring_genes.to_numpy(float) - values
+            ax.errorbar(np.arange(4), values, yerr=[lo, hi], fmt="none", ecolor=INK, capsize=3)
+        ax.set_xticks(np.arange(4), [LABEL[a] for a in arms], rotation=25, ha="right", fontsize=11)
+        ax.set_ylabel(label); ax.set_ylim(0, 1.08); clean(ax)
+        annotation_y = rows.q75_r_scoring_genes.to_numpy(float) if metric == "median_r_scoring_genes" else values
+        for i, v in enumerate(values): ax.text(i, annotation_y[i] + .025, f"{v:.2f}", ha="center", fontsize=11)
+    fig.subplots_adjust(left=.07, right=.99, top=.91, bottom=.23, wspace=.38)
+    builder.finish(fig, "matched_similarity", "Matched noise separates cell state from cell identity", 19,
+        rows.reset_index(), "Original model-output comparisons over 160,500 paired generated cells. "
+        "Expression-correlation whiskers show saved 25th–75th percentiles, not confidence intervals. "
+        "All comparisons are against the pseudobulk-conditioned twin, not observed individual cells.")
+
+
+def transitions(builder: MaterialBuilder) -> None:
+    builder.begin()
+    fig, axes = plt.subplots(2, 2, figsize=FULL)
+    records = []
+    for ax, arm in zip(axes.flat, ARM[:-1]):
+        frame = builder.frame(V / f"tables/c_label_transition_pseudo_to_{arm}_counts.csv").set_index("pseudo_label").loc[TYPES, TYPES]
+        values = frame.to_numpy(float)
+        pct = values / values.sum(axis=1, keepdims=True) * 100
+        ax.imshow(pct, cmap="Greys", vmin=0, vmax=100, aspect="auto")
+        ax.set_xticks(range(6), SHORT, fontsize=10); ax.set_yticks(range(6), SHORT, fontsize=10)
+        ax.set_title(LABEL[arm] + " · row %", fontsize=13)
+        for y in range(6):
+            for x in range(6):
+                ax.text(x, y, f"{pct[y,x]:.0f}", ha="center", va="center", fontsize=9,
+                        color="white" if pct[y,x] > 55 else INK)
+                records.append({"arm": arm, "pseudo_label": TYPES[y], "input_label": TYPES[x],
+                                "count": values[y,x], "row_percent": pct[y,x]})
+        ax.set_ylabel("Pseudobulk-input label", fontsize=11)
+        ax.set_xlabel("Input-arm label", fontsize=11)
+    fig.subplots_adjust(left=.10, right=.99, top=.91, bottom=.10, wspace=.25, hspace=.55)
+    builder.finish(fig, "label_transitions", "Input changes can switch the generated cell label", 19,
+        pd.DataFrame(records), "Existing matched-cell transition counts, normalized within each pseudobulk-label row for display. "
+        "Numbers are percentages. Frozen model labels, not proof of biological transdifferentiation. "
+        "Greyscale represents a quantitative transition fraction.", palette="preserved")
+
+
+def nearest_real(builder: MaterialBuilder) -> None:
+    builder.begin()
+    frame = builder.frame(V / "tables/f7_nearest_real_by_type.csv").set_index(["set", "label"])
+    arms = ["R2"] + ARM
+    fig, axes = plt.subplots(1, 2, figsize=FULL)
+    for arm in arms:
+        sub = frame.loc[arm].reindex(TYPES)
+        for ax, field in zip(axes, ["median_distance_to_nearest_real", "own_label_equals_nearest_real_label"]):
+            ax.plot(range(6), sub[field], "o-", color=COL[arm], ms=5, lw=1.5)
+    for ax in axes:
+        ax.set_xticks(range(6), SHORT); clean(ax)
+    axes[0].set_ylabel("Median distance to nearest real cell (PCA50)")
+    axes[1].set_ylabel("Same label as nearest real cell (fraction)"); axes[1].set_ylim(0, 1.04)
+    legend_methods(fig, arms)
+    fig.subplots_adjust(left=.08, right=.98, top=.94, bottom=.20, wspace=.34)
+    builder.finish(fig, "nearest_real_by_type", "Nearest real cells: distance and label agreement", 19,
+        frame.reset_index(), "Saved PCA50 nearest-reference-cell metrics from 150 cells/donor. "
+        "Different cell types have different geometry; distances are not calibrated probabilities or donor-level effect estimates.")
+
+
+def centroids(builder: MaterialBuilder) -> None:
+    builder.begin()
+    frame = builder.frame(V / "tables/b_type_centroid_shift_l1.csv").set_index("label").loc[TYPES]
+    fig, axes = plt.subplots(1, 2, figsize=FULL)
+    for arm in ["R2"] + ARM:
+        axes[0].plot(range(6), frame["shift_" + arm], "o-", color=COL[arm], ms=5, lw=1.5)
+    for arm in ARM[:-1]:
+        axes[1].plot(range(6), frame["shift_" + arm + "_vs_pseudo"], "o-", color=COL[arm], ms=5, lw=1.5)
+    for ax in axes:
+        ax.set_xticks(range(6), SHORT); ax.set_ylim(bottom=0); clean(ax)
+    axes[0].set_ylabel("Centroid shift from real R1 / real RMS spread")
+    axes[1].set_ylabel("Centroid shift from pseudobulk twin / spread")
+    legend_methods(fig, ["R2"] + ARM)
+    fig.subplots_adjust(left=.08, right=.98, top=.94, bottom=.20, wspace=.35)
+    builder.finish(fig, "within_type_centroids", "Composition agreement does not ensure state agreement", 19,
+        frame.reset_index(), "Centroids and real within-type RMS normalization are previously computed. "
+        "No new embedding, centroids or annotation are fitted. Six broad types; small Other/DC groups require caution.")
+
+
+def depth_quality(builder: MaterialBuilder) -> None:
+    builder.begin()
+    raw = builder.frame(V / "tables/a_precision_coverage_pca50.csv").set_index("set")
+    matched = builder.frame(V / "tables/e_depth_matched_precision_coverage_pca50.csv").set_index("set")
+    arms = ["R2"] + ARM
+    fig, axes = plt.subplots(1, 2, figsize=FULL)
+    records = []
+    for ax, field in zip(axes, ["precision", "coverage"]):
+        for i, arm in enumerate(arms):
+            ax.bar(i-.18, raw.loc[arm, field], .34, color=COL[arm])
+            ax.bar(i+.18, matched.loc[arm, field], .34, color=COL[arm], hatch="///", edgecolor=INK, lw=.35)
+            records.extend([{"arm": arm, "metric": field, "depth": mode, "value": table.loc[arm,field]}
+                            for mode,table in [("native",raw),("matched",matched)]])
+        ax.set_xticks(range(6), [LABEL[a] for a in arms], rotation=22, ha="right", fontsize=10)
+        ax.set_ylabel(field.capitalize()); ax.set_ylim(0, 1.08); clean(ax)
+    fig.text(.5,.03,"Solid: native depth     Hatched: previously depth-matched readout",ha="center",fontsize=12)
+    fig.subplots_adjust(left=.07,right=.99,top=.93,bottom=.27,wspace=.27)
+    builder.finish(fig, "depth_matched_quality", "Depth matching changes precision and coverage", 24,
+        pd.DataFrame(records), "Both tables already exist. The matched-depth procedure thins all seven source sets "
+        "to common detected-gene depth, as documented in the original analysis. Real R2 is a held-out real-real control; "
+        "neighborhood k=10 only. Display hatching, not a new sensitivity run.")
+
+
+def gene_length(builder: MaterialBuilder, stable: bool) -> None:
+    builder.begin()
+    frame = builder.frame(V / "tables/g_gene_shift_vs_length.csv")
+    stats = builder.frame(V / "tables/g_length_stats.csv").set_index("shift")
+    fig, axes = plt.subplots(2, 2, figsize=FULL)
+    prefix = "stable" if stable else "input"
+    x = np.log10(frame.union_exon_kb.to_numpy(float))
+    for ax, arm in zip(axes.flat, ARM[:-1]):
+        field = f"{prefix}_shift_{arm}_minus_pseudo"
+        valid = np.isfinite(x) & np.isfinite(frame[field].to_numpy(float))
+        ax.scatter(x[valid], frame.loc[valid,field], color=COL[arm], s=3, alpha=.45, lw=0, rasterized=True)
+        ax.axhline(0, color=GREY, lw=.7)
+        stat_key = f"{prefix}_{arm}_minus_pseudo"
+        if stat_key not in stats.index:
+            raise ValueError(f"Missing existing gene-length statistic: {stat_key}")
+        rho = stats.loc[stat_key,"spearman_vs_log10kb"]
+        ax.set_title(f"{LABEL[arm]}  ·  saved Spearman ρ = {rho:+.2f}", fontsize=12)
+        ax.set_xlabel("log10 union-exon length (kb)", fontsize=11)
+        ax.set_ylabel("Shift vs pseudobulk twin\n(log1p CP10K)" if stable else "Shift vs pseudobulk input\n(cpm_log1p)", fontsize=11)
+        clean(ax)
+    fig.subplots_adjust(left=.08,right=.99,top=.91,bottom=.11,hspace=.60,wspace=.28)
+    title = "Gene-length effects within label-stable cells" if stable else "Gene-length effects in the bulk input"
+    builder.finish(fig, "gene_length_stable" if stable else "gene_length_input", title, 19,
+        frame[["gene_id","symbol","union_exon_kb"] + [f"{prefix}_shift_{a}_minus_pseudo" for a in ARM[:-1]]],
+        "Only log10 axis conversion and plotting of saved per-gene shifts. The displayed Spearman values "
+        "come directly from g_length_stats.csv; no correlation or regression is recomputed. " +
+        ("Label-stable means the frozen broad label agrees between generated twins; it does not establish identical biological state. "
+         "Y values are generated log1p CP10K differences." if stable else "Y values are input cpm_log1p differences. "
+         "Gene length accounts for only part of assay mismatch; these are diagnostic associations."))
+
+
+def top_genes(builder: MaterialBuilder, reference: bool) -> None:
+    builder.begin()
+    file = "g_top_genes_refcal.csv" if reference else "g_top_genes_raw_tpm.csv"
+    frame = builder.frame(V / "tables" / file)
+    frame = frame[frame.cells == "label-stable matched cells"].copy()
+    arms = ["refcal"] if reference else ["raw","tpm"]
+    fig, axes = plt.subplots(1, 2, figsize=FULL)
+    outputs = []
+    for ax, arm in zip(axes, (["refcal","refcal"] if reference else arms)):
+        if reference:
+            direction = "down" if ax is axes[0] else "up"
+            sub = frame[frame.direction.str.startswith(direction)].sort_values("rank").head(10).iloc[::-1]
+        else:
+            sub = frame[frame.arm == arm].sort_values("rank").groupby("direction",sort=False).head(5)
+            sub = sub.sort_values("output_shift")
+        y=np.arange(len(sub)); ax.barh(y,sub.output_shift,color=COL[arm],height=.70)
+        if reference:
+            ax.scatter(sub.input_shift,y,marker="|",color=INK,s=90,label="Input shift")
+        ax.set_yticks(y,sub.symbol,fontsize=11);ax.axvline(0,color=GREY,lw=.8)
+        ax.set_xlabel("Generated-cell shift vs pseudobulk twin",fontsize=11);clean(ax,"x")
+        ax.set_title(("AIFI ref-cal: "+direction if reference else LABEL[arm]),fontsize=13)
+        outputs.append(sub)
+    if reference:
+        fig.text(.5,.025,"Gold bars: generated log1p CP10K shift   Black ticks: input cpm_log1p shift (different normalization)",ha="center",fontsize=10)
+    fig.subplots_adjust(left=.12,right=.99,top=.92,bottom=.16,wspace=.45)
+    builder.finish(fig,"refcal_top_genes" if reference else "raw_tpm_top_genes",
+        "Reference calibration leaves specific gene-state shifts" if reference else "Raw and TPM shifts persist within cell labels",19,
+        pd.concat(outputs,ignore_index=True),"Existing ranked gene lists only; no DEG testing. "
+        "Displayed ranks are original saved ranks within direction and label-stable cells. "
+        "Immediate-early/stress differences may reflect handling or cohort state; that interpretation is untested. "
+        "Input and output shifts use different normalization and should not be interpreted as an identical quantitative scale.")
+
+
+def donor_axes(builder: MaterialBuilder) -> None:
+    builder.begin()
+    frame=builder.frame(V/'tables/scorer_summary_5arm.csv')
+    def arm_name(value: str) -> str:
+        return value.replace('_native','').replace('raw_tpm','tpm')
+    frame['input_arm']=frame.arm.map(arm_name)
+    if set(frame.input_arm) != set(ARM):
+        raise ValueError(f"Unexpected donor-axis arms: {frame.arm.tolist()}")
+    frame=frame.set_index('input_arm').loc[ARM]
+    fields=['rho_y','rho_ifn_mono','rho_ifn_t','rho_klrc2_vs_obs_klrc2']
+    fig,axes=plt.subplots(1,2,figsize=FULL)
+    for i,arm in enumerate(ARM):
+        axes[0].plot(range(4),frame.loc[arm,fields].to_numpy(float),'o-',color=COL[arm],lw=1.6,ms=6)
+        axes[1].bar(i,frame.loc[arm,'pb_top1']*100,color=COL[arm],width=.66)
+    axes[0].set_xticks(range(4),['Y-gene\nexpression','IFN\nmonocytes','IFN\nT cells','KLRC2+\nNK'],fontsize=11)
+    axes[0].set_ylabel('Saved donor-level Spearman ρ');axes[0].axhline(0,color=GREY,lw=.7)
+    axes[1].set_xticks(range(5),[LABEL[a] for a in ARM],rotation=22,ha='right',fontsize=10)
+    axes[1].set_ylabel('Own-donor pseudobulk top-1 retrieval (%)')
+    axes[1].axhline(100/107,color=GREY,ls='--',lw=1,label='Chance: 1/107')
+    axes[1].legend(loc='upper right',frameon=False,fontsize=10)
+    for ax in axes:clean(ax)
+    legend_methods(fig,ARM)
+    fig.subplots_adjust(left=.08,right=.99,top=.93,bottom=.27,wspace=.37)
+    builder.finish(fig,'donor_axes','Donor trait axes and donor identification differ',19,frame.reset_index(),
+        "All Spearman and retrieval values are copied from the saved summary. Y-gene/sex calls and IFN/KLRC2 axes "
+        "are expression-derived proxies, not independent clinical-label validation. Top-1 chance line is 1/107. "
+        "High trait-axis agreement does not establish donor identity recovery.")
+
+
+def reference_choice(builder: MaterialBuilder) -> None:
+    builder.begin()
+    frame=builder.frame(U/'input_path_compare/immicro_behcet/tables/immicro_table.csv').set_index('arm')
+    arms=['raw','tpm','refcal','refcal_aida','refcal_train','tpmrefcal','cal','pseudo']
+    if not (frame.loc[arms,'status']=='scored').all():raise ValueError('Unscored input comparison')
+    fig,axes=plt.subplots(1,3,figsize=FULL)
+    for ax,field,title in zip(axes,['precision','coverage','comp_L1'],['Precision','Coverage','Composition L1']):
+        ax.bar(range(8),frame.loc[arms,field],color=[COL[a] for a in arms],width=.7)
+        ax.set_xticks(range(8),[LABEL[a] for a in arms],rotation=60,ha='right',fontsize=10)
+        ax.set_ylabel(title);clean(ax)
+        control=frame.loc['real_R2',field]
+        ax.axhline(control,color=GREY,ls='--',lw=1)
+        ax.set_title('Observed donor-mean null' if field=='comp_L1' else 'Real–real control',fontsize=11,color=GREY)
+    fig.subplots_adjust(left=.06,right=.99,top=.89,bottom=.32,wspace=.38)
+    builder.finish(fig,'reference_choice','Reference choice changes different quality endpoints',19,frame.reset_index(),
+        "All eight generated arms are already scored in immicro_table.csv. No generation or rescore. "
+        "AIDA and the training-mixture reference have their own pretraining overlap; this is not a held-out reference experiment. "
+        "The composition dashed line is the observed donor-mean leave-one-out null, NOT a real-R2 composition error. "
+        "No method-independent win claim is made across different endpoints.")
+
+
+def sparsity(builder: MaterialBuilder) -> None:
+    builder.begin()
+    frame=builder.frame(V/'tables/e_detected_genes.csv')
+    readouts=sorted(frame.readout.unique())
+    # Real counts and Poisson-read generated counts are the comparable readout.
+    selected=frame[(frame['set'].isin(['real_R1','real_R2'])) | frame.readout.str.contains('Poisson',case=False)].copy()
+    if len(selected)!=7:raise ValueError(f'Unexpected count readout selection: {readouts}; {len(selected)} rows')
+    selected['input_arm']=selected['set'].replace({'real_R1':'R1','real_R2':'R2'})
+    order=['R1','R2']+ARM;selected=selected.set_index('input_arm').loc[order]
+    fig,axes=plt.subplots(1,2,figsize=FULL)
+    colors=[GREY,GREY]+[COL[a] for a in ARM]
+    for ax,field,label in zip(axes,['detected_median','library_median'],['Median detected genes per cell','Median library size (scoring genes)']):
+        values=selected[field].to_numpy(float);ax.bar(range(7),values,color=colors,width=.66)
+        if field=='detected_median':
+            ax.errorbar(range(7),values,yerr=[values-selected.detected_p10.to_numpy(float),selected.detected_p90.to_numpy(float)-values],fmt='none',ecolor=INK,capsize=3)
+        ax.set_xticks(range(7),['Real R1','Real R2']+[LABEL[a] for a in ARM],rotation=25,ha='right',fontsize=10)
+        ax.set_ylabel(label);clean(ax)
+    fig.subplots_adjust(left=.09,right=.99,top=.94,bottom=.26,wspace=.35)
+    builder.finish(fig,'detection_and_library','Detection and library size are separate diagnostics',24,selected.reset_index(),
+        "Observed counts and the previously computed Poisson readout of generated cells. "
+        "Whiskers are saved 10th–90th cell percentiles, not donor confidence intervals. "
+        "Scoring-gene libraries are not full-transcriptome UMI totals.")
+
+
+def conditioning(builder: MaterialBuilder) -> None:
+    builder.begin(native=False)
+    source=U/'sle/conditioning_2279'
+    pairs=builder.frame(source/'paired_cells.csv').set_index('set')
+    summary=builder.frame(U/'sle/metrics_2279/summary_tidy.csv')
+    builder.source(source/'RESULTS.md','existing intervention protocol and provenance')
+    tags=['f016k_e16','f016kcondflip_e16','f016kcondperm_e16','f016kcondmean_e16']
+    names=['True input','Disease flip','Donor permutation','Cohort mean']
+    colors=['#C5AA4B','#806A25','#B59A50','#E8DDAE']
+    rows=[]
+    for tag in tags:
+        q=summary[(summary.method=='diffusion_'+tag)&(summary.celltype_gate=='common_celltype_gate')]
+        if len(q)!=1:raise ValueError(f'Ambiguous conditioning summary row: {tag}, {len(q)}')
+        rows.append(q.iloc[0])
+    sub=pd.DataFrame(rows)
+    fig,axes=plt.subplots(1,3,figsize=FULL)
+    for ax,field,label in zip(axes,['mean_logFC_pearson','total_top50_overlap','composition_l1'],['Disease logFC correlation','Top-50 DEG overlap (sum)','Composition L1']):
+        vals=sub[field].to_numpy(float);ax.bar(range(4),vals,color=colors,width=.65)
+        ax.set_xticks(range(4),names,rotation=30,ha='right',fontsize=11);ax.set_ylabel(label);clean(ax)
+        ax.axhline(0,color=GREY,lw=.7)
+    fig.text(.5,.035,'Same-noise donor swap: closest to source donor, 42/42 (flip) and 42/42 (permutation); uncentered comparison.',ha='center',fontsize=10)
+    if pairs.loc['condflip','donors_closest_source']!=42 or pairs.loc['condperm','donors_closest_source']!=42:
+        raise ValueError('Saved donor-swap control changed; update caption')
+    fig.subplots_adjust(left=.07,right=.99,top=.93,bottom=.28,wspace=.40)
+    builder.finish(fig,'sle_conditioning_interventions','Does the model follow its bulk conditioning?',14,sub,
+        "SLE development benchmark: 42 donors, 2,279 genes, f01 6k E16 EMA, 1,500 generated cells/donor, "
+        "50 DDIM steps, seed20260913. Only conditioning differs; noise is matched. These are pseudobulk inputs, "
+        "not an independent paired real-bulk validation. Donor-source caption uses saved uncentered nearest-match counts; "
+        "centered flip retrieval is 27/42, permutation42/42. Displayed benchmark metrics use the common six-type gate. "
+        "The pre-registered condition-use criterion and earlier-model tolerance context are in source RESULTS.md.",
+        native=False,footnote="Existing SLE pseudobulk controls: same noise, 42 donors, 2,279 genes. This is a conditioning intervention, not real-bulk validation.")
+
+
+def split_half(builder: MaterialBuilder) -> None:
+    builder.begin(native=False)
+    frame=builder.frame(U/'sle_broadcast/tables/splithalf_summary.csv')
+    builder.source(U/'sle_broadcast/RESULTS.md','split-half protocol and caveats')
+    methods=['ceiling_halfA','broadcast_disjoint','broadcast_full','diffusion_5seed_mean','scSemiProfiler']
+    labels=['Real A → real B','Bulk A → real B','Full bulk → real B','PBISC → real B','scSemi → real B']
+    colors=[INK,'#AAAAAA','#CCCCCC','#C5AA4B',BLUE]
+    fig,axes=plt.subplots(1,2,figsize=FULL)
+    chosen=[]
+    for ax,axis in zip(axes,[1006,2279]):
+        sub=frame[frame.axis.astype(int)==axis].set_index('method').loc[methods]
+        vals=sub.mean_over_types.to_numpy(float)
+        ax.barh(range(5),vals,color=colors,height=.64)
+        ax.errorbar(vals,range(5),xerr=sub.sd_of_mean_over_splits,fmt='none',ecolor=INK,capsize=3)
+        ax.set_yticks(range(5),labels,fontsize=11);ax.invert_yaxis();ax.set_xlim(0,.8)
+        ax.set_xlabel('Mean cell-type logFC correlation');ax.set_title(f'{axis:,} genes',fontsize=13);clean(ax,'x')
+        chosen.append(sub.reset_index())
+    fig.subplots_adjust(left=.15,right=.99,top=.91,bottom=.14,wspace=.55)
+    builder.finish(fig,'sle_disjoint_truth_control','Disjoint-cell controls test the bulk-broadcast baseline',43,
+        pd.concat(chosen,ignore_index=True),"Existing five random half-A/half-B splits of the same 42 held-out SLE donors. "
+        "Bulk A is formed from cells disjoint from per-type half-B truth. The full-bulk control includes B. "
+        "The observed type-specific half-A predictor is a split-half reference. Bars and SDs are saved summary values; "
+        "no split, expression analysis, or hypothesis test is rerun. PBISC values summarize its five existing sampling seeds.",
+        native=False,footnote="SLE pseudobulk benchmark; five existing half-cell splits. Error bars are saved split SDs. No new cell splitting or scoring.")
+
+
+def technical_repeats(builder: MaterialBuilder) -> None:
+    builder.begin(native=False)
+    doc=builder.document(U/'immicro/out/observed_summary.json')
+    builder.source(U/'immicro/out/build_manifest.json','observed-cell analysis provenance')
+    builder.source(U/'immicro/out/replicate_pseudobulk_per_donor.csv','existing donor replicate records')
+    records=[]
+    for key in ['remeasure','followup_visit','capture_halves']:
+        value=doc['replicate_pseudobulk'][key]['all_cells']
+        records.append({'replicate':key,**value})
+    frame=pd.DataFrame(records)
+    labels=['Technical remeasurement','Follow-up visit','Capture halves']
+    fig,axes=plt.subplots(1,2,figsize=FULL)
+    for ax,field,title in zip(axes,['donor_r_median','top1_retrieval'],['Median own-donor pseudobulk r','Own-donor top-1 retrieval (%)']):
+        vals=frame[field].to_numpy(float)*(100 if field=='top1_retrieval' else 1)
+        ax.bar(range(3),vals,color=['#555555','#999999','#CCCCCC'],width=.65)
+        ax.set_xticks(range(3),[f'{label}\n(n={int(n)})' for label,n in zip(labels,frame.n)],fontsize=11)
+        ax.set_ylabel(title);clean(ax)
+        for i,v in enumerate(vals):ax.text(i,v+(2 if field=='top1_retrieval' else .005),f'{v:.1f}' if field=='top1_retrieval' else f'{v:.3f}',ha='center',fontsize=12)
+        ax.set_ylim(0,110 if field=='top1_retrieval' else 1.06)
+    fig.subplots_adjust(left=.08,right=.99,top=.91,bottom=.20,wspace=.35)
+    builder.finish(fig,'immicro_replicate_controls','Technical repeats and follow-up are different controls',22,frame,
+        "Previously processed ImMicro observations. Technical remeasurement and follow-up have 16 donors; "
+        "capture-half control has its own recorded sample count. Follow-up is biological longitudinal variation, "
+        "not a technical replicate. Correlation and top-1 retrieval are saved aggregates; no new subsampling, "
+        "correlation or retrieval analysis. Use the recorded follow-up gene-support rule in observed_summary.json.",
+        native=False,footnote="Observed ImMicro controls. Technical remeasurement and follow-up: 16 donors each. Follow-up is not a technical replicate.",palette='preserved')
+
+
+def annotation_qc(builder: MaterialBuilder) -> None:
+    builder.begin(native=False)
+    frame=builder.frame(U/'immicro/out/confusion_author_vs_frozen_baseline.csv')
+    labelcol=frame.columns[0];matrix=frame[TYPES].to_numpy(float)
+    pct=matrix/matrix.sum(axis=1,keepdims=True)*100
+    doc=builder.document(U/'immicro/out/observed_summary.json')
+    builder.source(U/'immicro/out/build_manifest.json','frozen annotation comparison provenance')
+    summary=doc['agreement_baseline']
+    fig,(ax,bx)=plt.subplots(1,2,figsize=FULL,gridspec_kw={'width_ratios':[1.1,1]})
+    ax.imshow(pct,cmap='Greys',vmin=0,vmax=100,aspect='auto')
+    display_labels=frame[labelcol].replace({'author_mixed':'Mixed','author_unlabelled':'Unlabelled'})
+    ax.set_xticks(range(6),SHORT,fontsize=11);ax.set_yticks(range(len(frame)),display_labels,fontsize=10)
+    ax.set_xlabel('Frozen annotation');ax.set_ylabel('Author annotation')
+    for y in range(len(frame)):
+        for x in range(6):ax.text(x,y,f'{pct[y,x]:.0f}',ha='center',va='center',fontsize=9,color='white' if pct[y,x]>55 else INK)
+    for offset,key,label,col in [(-.17,'recall_by_author_gate','Recall','#555555'),(.17,'precision_by_frozen_label','Precision','#BBBBBB')]:
+        values=[summary[key][cell]*100 for cell in TYPES]
+        bx.bar(np.arange(6)+offset,values,.32,label=label,color=col)
+    bx.set_xticks(range(6),SHORT);bx.set_ylabel('Agreement metric (%)');bx.set_ylim(0,105);clean(bx)
+    bx.legend(frameon=False,fontsize=11)
+    ax.set_title('Row percentages, including unlabelled categories',fontsize=11)
+    bx.set_title(f"Supported six-type gate: {100*summary['agreement_six_type']:.1f}% agreement",fontsize=11)
+    fig.subplots_adjust(left=.14,right=.99,top=.88,bottom=.14,wspace=.42)
+    plot=frame.copy()
+    for j,t in enumerate(TYPES):plot[t+'_row_percent']=pct[:,j]
+    builder.finish(fig,'annotation_agreement','Annotation agreement and difficult categories',22,plot,
+        "Saved observed-cell comparison, not generated-cell model performance. Overall 97.17% agreement uses "
+        "365,404 author-labelled cells in the supported six-type gate; mixed/unlabelled categories are displayed "
+        "in the matrix but excluded from that agreement figure. Other has weak correspondence between taxonomies. "
+        "The frozen annotation's comparison to author labels is not an independent gold-standard validation. "
+        "Heatmap is a count-row normalization for display; precision/recall are saved summary metrics.",
+        native=False,footnote="Observed cells only. Overall agreement uses the supported six-type gate; author mixed/unlabelled cells are separate. Other is difficult.",palette='preserved')
+
+
+def build() -> dict[str, Any]:
+    if os.environ.get('CUDA_VISIBLE_DEVICES') != '':
+        raise RuntimeError('Set CUDA_VISIBLE_DEVICES empty for this saved-table plot builder')
+    FIG.mkdir(parents=True,exist_ok=True);DATA.mkdir(parents=True,exist_ok=True)
+    builder=MaterialBuilder()
+    settings={'font.family':'sans-serif','font.sans-serif':['Arial','Liberation Sans','DejaVu Sans'],
+        'font.size':14,'axes.labelsize':14,'axes.titlesize':14,'xtick.labelsize':12,'ytick.labelsize':12,
+        'legend.fontsize':12,'axes.spines.top':False,'axes.spines.right':False,'axes.linewidth':1.0,
+        'pdf.fonttype':42,'ps.fonttype':42,'svg.fonttype':'none','figure.facecolor':'white','axes.facecolor':'white'}
+    with plt.rc_context(settings):
+        for function in [stored_umap,saved_density_reference,composition,matched_trajectories,similarity,transitions,nearest_real,centroids,depth_quality]:function(builder)
+        gene_length(builder,False);gene_length(builder,True)
+        top_genes(builder,False);top_genes(builder,True)
+        for function in [donor_axes,reference_choice,sparsity,conditioning,split_half,technical_repeats,annotation_qc]:function(builder)
+    builder.source(Path(__file__),'new saved-table visualization code')
+    result={'slides':builder.slides,'assets':builder.assets,'sources':list(builder.sources.values()),
+        'skipped':[{'candidate':'fresh density-grid restyling','reason':'Exact density grid is not in the small CSV tables; original unchanged high-resolution PNG retained as a reference slide instead.'},
+                   {'candidate':'older three/four-arm and overlay copies','reason':'Superseded or near-duplicate views; five-arm stored-coordinate and metric evidence selected.'}],
+        'new_training':False,'new_generation':False,'new_embedding':False,'new_statistical_scoring':False}
+    if len(result['slides'])!=20:raise AssertionError('Expected 20 saved-evidence additions including the original density reference')
+    out=D/'data/expanded_master_20261013/healthy_additions.json'
+    out.write_text(json.dumps(result,indent=2,ensure_ascii=False)+'\n')
+    return result
+
+
+if __name__=='__main__':
+    result=build()
+    print(json.dumps({'slides':len(result['slides']),'assets':len(result['assets']),'sources':len(result['sources'])}))

paper-releases/pbisc-diffusion/updates/20261013T034842Z-expanded-131-slide-master/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/expanded_legacy_rare.py

@@ -0,0 +1,119 @@
+"""Replot saved legacy rare-state estimates with method colours kept distinct.
+
+The original module and numerical source CSVs remain unchanged. Only its output
+directories and FEW/POOL method-colour tuples are replaced; local cohort colours
+inside the original plotting routine remain intact.
+"""
+from __future__ import annotations
+
+import contextlib
+import hashlib
+import importlib.util
+import io
+import json
+from pathlib import Path
+
+import pandas as pd
+
+DECK = Path(__file__).resolve().parents[1]
+ORIGINAL = DECK / "tools/fig5_rare_states.py"
+FIGURES = DECK / "figures/expanded_master_20261013/legacy_rare"
+DATA = DECK / "data/expanded_master_20261013/legacy_rare"
+STEMS = ("fig5_rare_fraction", "fig5_rare_donors", "fig5_rare_fivefold")
+METHOD_COLOURS = {
+    "zs_raw": "#E8DDAE", "zs__raw": "#E8DDAE",
+    "scsemi5": "#2166AC", "scsemi__raw": "#2166AC",
+    "lora5": "#C5AA4B", "real_lora__raw": "#C5AA4B",
+}
+
+
+def _sha(path: Path) -> str:
+    with path.open("rb") as stream:
+        return hashlib.file_digest(stream, "sha256").hexdigest()
+
+
+def _binding(path: Path, role: str) -> dict:
+    return {"path": str(path), "sha256": _sha(path), "bytes": path.stat().st_size, "role": role}
+
+
+def _assert_same_csv(original: Path, generated_text: str) -> dict:
+    expected = pd.read_csv(original)
+    actual = pd.read_csv(io.StringIO(generated_text))
+    pd.testing.assert_frame_equal(expected, actual, check_exact=True, check_dtype=False,
+                                  check_like=False, check_names=True)
+    return {"rows": len(expected), "columns": expected.columns.tolist(),
+            "row_order_equal": True, "all_values_equal": True,
+            "numeric_tolerance": 0, "nan_positions_equal": True,
+            "byte_equal": original.read_bytes() == generated_text.encode()}
+
+
+def build() -> dict:
+    """Return asset paths, input hashes and a saved equality/preservation proof."""
+    spec = importlib.util.spec_from_file_location("_expanded_master_legacy_rare_source", ORIGINAL)
+    if spec is None or spec.loader is None:
+        raise ValueError("Original legacy rare-state plotting module cannot be loaded")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    original_table = DECK / "data/fig5_rare_states.csv"
+    inputs = [
+        _binding(ORIGINAL, "original plotting and unchanged aggregation implementation"),
+        _binding(DECK / "tools/style.py", "original deck styling"),
+        _binding(module.SRC / "summary.csv", "saved legacy state-summary input"),
+        _binding(module.SRC / "contrasts.csv", "saved legacy disease-contrast input"),
+        _binding(original_table, "original plotted numeric table, exact comparison target"),
+        _binding(Path(__file__), "colour-and-output routing wrapper"),
+    ]
+    preserved = [ORIGINAL, original_table, DECK / "data/fig5_rare_states_slide_text.json"]
+    preserved.extend(DECK / "figures" / f"{stem}.{ext}" for stem in STEMS for ext in ("png", "pdf"))
+    before = {str(path): _sha(path) for path in preserved}
+
+    # Fail before rendering if the currently saved source no longer reproduces
+    # the original plot table. Keep its exact original %.5g display precision.
+    summary, contrasts, _ = module.load()
+    rows = pd.concat([
+        module.agg_few(summary, contrasts).assign(design="5 donors (mean of 5 draws)"),
+        module.agg_pool(summary, contrasts).assign(design="5-fold pooled"),
+    ])
+    preflight_text = rows.to_csv(index=False, float_format="%.5g")
+    equality = _assert_same_csv(original_table, preflight_text)
+
+    FIGURES.mkdir(parents=True, exist_ok=True)
+    DATA.mkdir(parents=True, exist_ok=True)
+    if (FIGURES.resolve() == (DECK / "figures").resolve()
+            or DATA.resolve() == (DECK / "data").resolve()):
+        raise ValueError("Wrapper output must not be the original asset directory")
+    module.FIG, module.DAT = FIGURES, DATA
+    module.FEW = [(arm, label, METHOD_COLOURS[arm], marker) for arm, label, _colour, marker in module.FEW]
+    module.POOL = [(arm, label, METHOD_COLOURS[arm], marker) for arm, label, _colour, marker in module.POOL]
+    log = io.StringIO()
+    with contextlib.redirect_stdout(log):
+        status = module.main()
+    if status != 0:
+        raise RuntimeError("Original legacy plotting routine returned a nonzero status")
+    equality = _assert_same_csv(original_table, (DATA / "fig5_rare_states.csv").read_text())
+    if any(_sha(Path(path)) != expected for path, expected in before.items()):
+        raise ValueError("An original script, figure or numeric table changed")
+    if any(_sha(Path(item["path"])) != item["sha256"] for item in inputs):
+        raise ValueError("An input changed while generating the palette-only variant")
+
+    assets = {stem: {ext: str(FIGURES / f"{stem}.{ext}") for ext in ("png", "pdf")} for stem in STEMS}
+    outputs = [_binding(Path(path), "palette-only legacy plot") for entry in assets.values() for path in entry.values()]
+    outputs.extend(_binding(DATA / name, "rerouted legacy derived table or explanatory text")
+                   for name in ("fig5_rare_states.csv", "fig5_rare_states_slide_text.json"))
+    proof = {
+        "schema": "pbisc.expanded-master.legacy-rare-palette.v1",
+        "method_colours": METHOD_COLOURS,
+        "cohort_colours": "unchanged local COH dictionary in original module",
+        "scope": "Legacy estimates retained exactly; this does not repair or upgrade the legacy scientific protocol",
+        "new_experiment": False, "new_model_outputs": False,
+        "numeric_verification": equality, "inputs": inputs, "outputs": outputs,
+        "originals_unchanged": before, "original_stdout": log.getvalue(),
+    }
+    proof_path = DATA / "PROVENANCE.json"
+    proof_path.write_text(json.dumps(proof, indent=2, allow_nan=False) + "\n")
+    return {"assets": assets, "inputs": inputs, "proof": str(proof_path),
+            "numeric_verification": equality}
+
+
+if __name__ == "__main__":
+    print(json.dumps(build(), indent=2))

paper-releases/pbisc-diffusion/updates/20261013T034842Z-expanded-131-slide-master/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/verify_expanded_master_20261013.py

@@ -0,0 +1,286 @@
+#!/usr/bin/env python3
+"""Verify and render the expanded paper master without changing source assets.
+
+Automated checks never stand in for visual inspection. All output is confined
+to data/expanded_master_20261013/qa and the visual-review state stays pending.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+from collections import Counter
+from datetime import datetime, timezone
+from pathlib import Path
+
+import fitz
+from PIL import Image, ImageDraw, ImageFont
+from pptx import Presentation
+from pptx.enum.shapes import MSO_SHAPE_TYPE
+
+DECK = Path(__file__).resolve().parents[1]
+ARTIFACT = DECK / "data/expanded_master_20261013"
+QA = ARTIFACT / "qa"
+PDF_BOUND_TOLERANCE_PT = 0.75
+EMU_BOUND_TOLERANCE = 2
+ORIGINAL_FULL_REVIEW = {6, 14, 20, 21, 22, 43, 51, 67, 71, 72}
+
+
+def sha(path: Path) -> str:
+    with path.open("rb") as stream:
+        return hashlib.file_digest(stream, "sha256").hexdigest()
+
+
+def resolve(value: str, *, base: Path = DECK) -> Path:
+    path = Path(value)
+    return path.resolve() if path.is_absolute() else (base / path).resolve()
+
+
+def load(path: Path) -> dict:
+    return json.loads(path.read_text())
+
+
+def _font_names(run, paragraph) -> list[str]:
+    """Return explicitly declared editable text fonts, including EA/complex-script."""
+    found = []
+    for node in (run._r, paragraph._p):
+        for tag in ("a:latin", "a:ea", "a:cs"):
+            for item in node.xpath(f"./a:rPr/{tag}" if node is run._r else f"./a:pPr/a:defRPr/{tag}"):
+                value = item.get("typeface")
+                if value:
+                    found.append(value)
+    if not found:
+        name = run.font.name or paragraph.font.name
+        if name:
+            found.append(name)
+    return found
+
+
+def _text_frames(shape):
+    if shape.has_text_frame:
+        yield shape.text_frame
+    if shape.has_table:
+        for row in shape.table.rows:
+            for cell in row.cells:
+                yield cell.text_frame
+
+
+def _image_proofs(slide, record: dict, page_number: int, failures: list[dict]) -> dict:
+    expected = []
+    for value in record.get("figures", []):
+        path = resolve(value)
+        if not path.is_file():
+            failures.append({"check": "figure_source_exists", "slide": page_number, "path": str(path)})
+        else:
+            expected.append(sha(path))
+    actual, picture_details = [], []
+    for shape in slide.shapes:
+        if shape.shape_type != MSO_SHAPE_TYPE.PICTURE:
+            continue
+        digest = hashlib.sha256(shape.image.blob).hexdigest()
+        actual.append(digest)
+        crops = [float(shape.crop_left), float(shape.crop_top), float(shape.crop_right), float(shape.crop_bottom)]
+        if any(abs(value) > 1e-12 for value in crops):
+            failures.append({"check": "zero_picture_crop", "slide": page_number,
+                             "shape": shape.name, "crop": crops})
+        picture_details.append({"shape": shape.name, "sha256": digest, "crop": crops})
+    if Counter(actual) != Counter(expected):
+        failures.append({"check": "embedded_figure_bytes", "slide": page_number,
+                         "expected": dict(Counter(expected)), "actual": dict(Counter(actual))})
+    return {"slide": page_number, "expected_images": len(expected), "actual_images": len(actual),
+            "byte_multiset_equal": Counter(actual) == Counter(expected), "pictures": picture_details}
+
+
+def _check_palette_records(manifest: dict, failures: list[dict]) -> list[dict]:
+    records, seen = [], set()
+
+    def visit(value):
+        if isinstance(value, list):
+            for child in value:
+                visit(child)
+        elif isinstance(value, dict):
+            if "preservation_pass" in value and value["preservation_pass"] is not True:
+                failures.append({"check": "palette_preservation", "record": value})
+            for key, child in value.items():
+                if key in {"proof", "proof_path", "palette_proof", "precolored_proof"} and isinstance(child, str):
+                    path = resolve(child)
+                    if path in seen:
+                        continue
+                    seen.add(path)
+                    if not path.is_file():
+                        failures.append({"check": "palette_proof_exists", "path": str(path)})
+                        continue
+                    proof = load(path)
+                    passed = proof.get("preservation_pass")
+                    if passed is not None and passed is not True:
+                        failures.append({"check": "palette_proof_preservation", "path": str(path)})
+                    records.append({"path": str(path), "sha256": sha(path),
+                                    "preservation_pass": passed,
+                                    "kind": "vector-preservation" if passed is not None else "native-figure-provenance"})
+                elif isinstance(child, (dict, list)):
+                    visit(child)
+
+    visit(manifest.get("palette_records", []))
+    return records
+
+
+def _render(document, slides: list[dict]) -> dict:
+    pages = []
+    for index, page in enumerate(document, 1):
+        path = QA / f"slide{index:03d}.png"
+        pixmap = page.get_pixmap(matrix=fitz.Matrix(1, 1), alpha=False)
+        pixmap.save(path)
+        record = slides[index - 1] if index <= len(slides) else {}
+        pages.append({"slide": index, "path": str(path), "width": pixmap.width, "height": pixmap.height,
+                      "original_slide": record.get("original_slide"), "addition_key": record.get("addition_key"),
+                      "selected_full_review": record.get("original_slide") in ORIGINAL_FULL_REVIEW
+                                              or bool(record.get("addition_key"))})
+    font_path = Path("/usr/share/fonts/truetype/msttcorefonts/Arial.ttf")
+    font = ImageFont.truetype(str(font_path), 14) if font_path.is_file() else ImageFont.load_default()
+    contacts = []
+    for start in range(0, len(pages), 12):
+        canvas = Image.new("RGB", (2000, 900), "white")
+        draw = ImageDraw.Draw(canvas)
+        for local, item in enumerate(pages[start:start + 12]):
+            x, y = (local % 4) * 500, (local // 4) * 300
+            with Image.open(item["path"]) as original:
+                thumb = original.convert("RGB")
+                thumb.thumbnail((500, 281), Image.Resampling.LANCZOS)
+                canvas.paste(thumb, (x + (500 - thumb.width) // 2, y + (281 - thumb.height) // 2))
+            origin = f"original {item['original_slide']}" if item["original_slide"] else f"added {item['addition_key']}"
+            draw.text((x + 8, y + 282), f"{item['slide']:03d} | {origin}"[:68], fill="#222222", font=font)
+        path = QA / f"contact{start // 12 + 1:02d}.png"
+        canvas.save(path)
+        contacts.append({"path": str(path), "slides": [item["slide"] for item in pages[start:start + 12]],
+                         "width": 2000, "height": 900})
+    return {"page_renders": pages, "contacts": contacts,
+            "full_review_slides": [item["slide"] for item in pages if item["selected_full_review"]]}
+
+
+def verify(*, render: bool = True) -> dict:
+    QA.mkdir(parents=True, exist_ok=True)
+    failures = []
+    spec_path, manifest_path = ARTIFACT / "spec.json", ARTIFACT / "manifest.json"
+    spec, manifest = load(spec_path), load(manifest_path)
+    records = spec["slides"]
+    pptx_path = resolve(spec["deck"]["output_pptx"])
+    pdf_path = resolve(spec["deck"]["output_pdf"])
+    pptx = Presentation(pptx_path)
+    pdf = fitz.open(pdf_path)
+    counts = {"spec": len(records), "pptx": len(pptx.slides), "pdf": len(pdf)}
+    if len(set(counts.values())) != 1 or len(records) <= 76:
+        failures.append({"check": "expanded_page_counts", "counts": counts})
+    if manifest.get("slides") != records:
+        failures.append({"check": "spec_manifest_slide_equality"})
+
+    retained = [row["original_slide"] for row in records if "original_slide" in row]
+    if retained != list(range(1, 77)):
+        failures.append({"check": "original_slide_coverage_and_order", "observed": retained})
+    additions = [row for row in records if "original_slide" not in row]
+    addition_keys = [row.get("addition_key") for row in additions]
+    if any(not key for key in addition_keys) or len(set(addition_keys)) != len(addition_keys):
+        failures.append({"check": "addition_identifiers", "observed": addition_keys})
+
+    source_checks = []
+    for value, binding in manifest.get("sources", {}).items():
+        path = resolve(value)
+        expected = binding["sha256"] if isinstance(binding, dict) else binding
+        actual = sha(path) if path.is_file() else None
+        source_checks.append({"path": str(path), "expected": expected, "actual": actual, "equal": actual == expected})
+        if actual != expected:
+            failures.append({"check": "manifest_source_hash", "path": str(path), "expected": expected, "actual": actual})
+    if not source_checks:
+        failures.append({"check": "manifest_sources_empty"})
+    originals = load(ARTIFACT / "original_source_hashes.json")
+    original_checks = []
+    for value, binding in originals.items():
+        path = resolve(value)
+        expected = binding["sha256"] if isinstance(binding, dict) else binding
+        actual = sha(path) if path.is_file() else None
+        original_checks.append({"path": str(path), "expected": expected, "actual": actual, "unchanged": actual == expected})
+        if actual != expected:
+            failures.append({"check": "original_unchanged", "path": str(path), "expected": expected, "actual": actual})
+    if not original_checks:
+        failures.append({"check": "original_hash_registry_empty"})
+
+    picture_proofs = []
+    text_runs, shapes_checked = 0, 0
+    for index, slide in enumerate(pptx.slides, 1):
+        for shape in slide.shapes:
+            shapes_checked += 1
+            if shape.shape_type == MSO_SHAPE_TYPE.GROUP:
+                failures.append({"check": "group_requires_transform_audit", "slide": index, "shape": shape.name})
+            edges = (shape.left, shape.top, shape.left + shape.width, shape.top + shape.height)
+            if (edges[0] < -EMU_BOUND_TOLERANCE or edges[1] < -EMU_BOUND_TOLERANCE
+                    or edges[2] > pptx.slide_width + EMU_BOUND_TOLERANCE
+                    or edges[3] > pptx.slide_height + EMU_BOUND_TOLERANCE):
+                failures.append({"check": "pptx_shape_bounds", "slide": index, "shape": shape.name,
+                                 "edges_emu": list(edges)})
+            for frame in _text_frames(shape):
+                for paragraph in frame.paragraphs:
+                    for run in paragraph.runs:
+                        if not run.text.strip():
+                            continue
+                        text_runs += 1
+                        fonts = _font_names(run, paragraph)
+                        if not fonts or any(font.casefold() != "arial" for font in fonts):
+                            failures.append({"check": "editable_text_arial", "slide": index,
+                                             "shape": shape.name, "fonts": fonts, "text": run.text[:100]})
+        if index <= len(records):
+            picture_proofs.append(_image_proofs(slide, records[index - 1], index, failures))
+
+    pdf_spans = 0
+    for index, page in enumerate(pdf, 1):
+        bounds = page.rect
+        for block in page.get_text("dict", flags=0).get("blocks", []):
+            for line in block.get("lines", []):
+                for span in line.get("spans", []):
+                    if not span.get("text", "").strip():
+                        continue
+                    pdf_spans += 1
+                    x0, y0, x1, y1 = span["bbox"]
+                    if (not all(math.isfinite(value) for value in (x0, y0, x1, y1))
+                            or x0 < bounds.x0 - PDF_BOUND_TOLERANCE_PT
+                            or y0 < bounds.y0 - PDF_BOUND_TOLERANCE_PT
+                            or x1 > bounds.x1 + PDF_BOUND_TOLERANCE_PT
+                            or y1 > bounds.y1 + PDF_BOUND_TOLERANCE_PT):
+                        failures.append({"check": "pdf_text_bounds", "slide": index,
+                                         "bbox": list(span["bbox"]), "text": span["text"][:100]})
+    palette_checks = _check_palette_records(manifest, failures)
+    renders = _render(pdf, records) if render else {"page_renders": [], "contacts": [], "full_review_slides": []}
+    pdf.close()
+    result = {
+        "schema": "pbisc.expanded-master.qa.v1", "checked_at_utc": datetime.now(timezone.utc).isoformat(),
+        "automated_checks_pass": not failures,
+        "status": "automated_checks_passed_visual_review_pending" if not failures else "automated_checks_failed",
+        "artifacts": {"pptx": {"path": str(pptx_path), "sha256": sha(pptx_path)},
+                      "pdf": {"path": str(pdf_path), "sha256": sha(pdf_path)},
+                      "spec": {"path": str(spec_path), "sha256": sha(spec_path)},
+                      "manifest": {"path": str(manifest_path), "sha256": sha(manifest_path)}},
+        "page_counts": counts, "original_slide_order": retained,
+        "added_slide_count": len(additions), "addition_keys": addition_keys,
+        "source_checks": source_checks, "original_checks": original_checks,
+        "editable_text_runs_checked": text_runs, "pptx_shapes_checked": shapes_checked,
+        "pdf_text_spans_checked": pdf_spans, "pdf_bound_tolerance_pt": PDF_BOUND_TOLERANCE_PT,
+        "picture_checks": picture_proofs, "palette_proof_checks": palette_checks,
+        "failures": failures, **renders,
+        "visual_review": {"status": "pending", "passed": None,
+                          "reason": "Rendering and structural checks do not establish visual readability; inspect the contact sheets and selected full slides."},
+    }
+    (QA / "VERIFICATION.json").write_text(json.dumps(result, indent=2, allow_nan=False) + "\n")
+    return result
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--no-render", action="store_true", help="Run structural/hash checks without PNG exports")
+    args = parser.parse_args()
+    result = verify(render=not args.no_render)
+    print(json.dumps({"status": result["status"], "page_counts": result["page_counts"],
+                      "failures": len(result["failures"]), "report": str(QA / "VERIFICATION.json")}, indent=2))
+    return 0 if result["automated_checks_pass"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())