Archive 4 checkpoints (1-4)

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

@@ -0,0 +1,312 @@
+"""Complete source-bound CPU analyses and render Figure 1–5 after the GPU campaign."""
+from __future__ import annotations
+import argparse
+import json
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import time
+
+from runtime import Runtime, atomic_json, sha256, stamp
+import campaign as C
+
+ROOT = C.ROOT
+ARMS = ("lora", "pairedcal", "scsemi", "raw", "refcal")
+PDF_PY = "/home/sj_server_1/miniforge3/bin/python"  # verified pptx, matplotlib, pandas environment
+
+
+def assert_publication_ready(figures: dict, rare: dict) -> None:
+    if figures.get("status") != "complete":
+        raise ValueError("Figure 2–4 strict evidence is incomplete")
+    if rare.get("design") != "strict5pair" or rare.get("units") != 20:
+        raise ValueError("Figure 5 requires all 20 strict units; diagnostic results are insufficient")
+
+
+def generated_arms(path: Path) -> dict[str, Path]:
+    cohort = C.read_support(path)["cohort"]
+    values = {a: C.gen_dir(path) / f"{a}.npz" for a in ("lora", "pairedcal", "scsemi")}
+    values.update({a: ROOT / "generated/global" / cohort / f"{a}.npz" for a in ("raw", "refcal")})
+    return values
+
+
+def wait_cuda_idle() -> None:
+    while True:
+        result = subprocess.run(["nvidia-smi", "--query-compute-apps=pid,process_name,used_memory",
+                                 "--format=csv,noheader"], capture_output=True, text=True, check=True)
+        if not result.stdout.strip():
+            return
+        time.sleep(15)
+
+
+def deconvolution(runtime: Runtime, units: list[Path]) -> None:
+    script = ROOT / "tools/deconv_strict.py"
+    for path in units:
+        support = C.read_support(path)
+        if support["cohort"] == "immicro":
+            continue
+        out = ROOT / "deconvolution" / C.relative(path)
+        for action in ("prepare", "bayesprism", "cibersortx", "score"):
+            wait_cuda_idle()
+            outputs = {"prepare": [out / "INPUTS.json"],
+                       "bayesprism": [out / "inputs" / support["cohort"] / "fewshot0_full/bp/DONE"],
+                       "cibersortx": [out / "cibersortx" / support["cohort"] / "fewshot0/out_fractions/DONE"],
+                       "score": [out / "score/SUMMARY.json", out / "score/figure4_methods.csv",
+                                 out / "score/expression_signal.csv"]}[action]
+            runtime.execute(f"{C.name(path)}-deconv-{action}",
+                            [C.CPU_PY, "-u", str(script), "--support-manifest", str(path),
+                             "--action", action, "--threads", "4"], memory_gib=24,
+                            inputs=[path, script], outputs=outputs,
+                            previous_outputs=preserve_preview_outputs(runtime, f"{C.name(path)}-deconv-{action}", outputs)
+                            if action == "prepare" else None)
+            if action == "score":
+                result = json.loads((out / "score/SUMMARY.json").read_text())
+                if result.get("status") not in ("complete", "complete_with_not_estimable"):
+                    raise ValueError(f"deconvolution is not complete: {out}")
+
+
+def rare_caches(runtime: Runtime, units: list[Path]) -> None:
+    script = ROOT / "tools/rare_cache_builder.py"
+    for path in units:
+        if C.read_support(path)["cohort"] == "immicro":
+            continue
+        out = ROOT / "work/rare_strict_caches" / C.relative(path)
+        score = ROOT / "scores" / C.relative(path) / "score"
+        argv = [C.CPU_PY, "-u", str(script), "--support-manifest", str(path),
+                "--score-dir", str(score), "--output-dir", str(out),
+                "--cell-budget", "1500", "--depth-target", "1000"]
+        for arm, source in generated_arms(path).items():
+            argv += ["--arm", f"{arm}={source}"]
+        runtime.execute(f"{C.name(path)}-rare-cache", argv, memory_gib=16,
+                        inputs=[path, script, score / "summary.json", score.parent / "scoring_support.json"],
+                        outputs=[out / "rare_manifest.json"])
+
+
+def preserve_diagnostic() -> None:
+    """Keep the first diagnostic's source data when strict tables replace the live navigation files."""
+    dest = ROOT / "diagnostic_legacy_v1"
+    if dest.exists():
+        return
+    files = [*sorted((ROOT / "source_data").glob("rare_*")),
+             *sorted((ROOT / "reports").glob("rare_*")),
+             *sorted((ROOT / "figures").glob("fig5*diagnostic*"))]
+    records = []
+    for path in files:
+        if path.is_file():
+            target = dest / path.relative_to(ROOT)
+            target.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(path, target)
+            records.append({"path": str(target), "sha256": sha256(target)})
+    atomic_json(dest / "PRESERVED.json", {"at": stamp(), "design": "legacy_5donor_diagnostic", "files": records})
+
+
+def preserve_preview_outputs(runtime: Runtime, name: str, paths: list[Path]) -> dict:
+    """A preview may be replaced only after preserving its exact bytes with an explicit receipt."""
+    if runtime.receipt_path(name).exists():
+        return {}
+    proof = {}
+    for path in paths:
+        if not path.exists():
+            continue
+        dest = ROOT / "previews/before_strict_final" / name / path.relative_to(ROOT)
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        if dest.exists() and sha256(dest) != sha256(path):
+            raise ValueError(f"a different preview is already preserved: {dest}")
+        if not dest.exists():
+            shutil.copy2(path, dest)
+        proof[str(path)] = {"backup": str(dest), "sha256": sha256(path)}
+    if proof:
+        atomic_json(ROOT / "previews/before_strict_final" / f"{name}.json", {"at": stamp(), "outputs": proof})
+    return proof
+
+
+def _run_preserving(runtime: Runtime, name: str, argv: list[str], *, memory_gib: int,
+                    inputs: list[Path], outputs: list[Path]) -> None:
+    runtime.execute(name, argv, memory_gib=memory_gib, inputs=inputs, outputs=outputs,
+                    previous_outputs=preserve_preview_outputs(runtime, name, outputs))
+
+
+def cross_draw_statistics(runtime: Runtime, units: list[Path]) -> None:
+    script = ROOT / "tools/finalize_outputs.py"
+    disease = [p for p in units if C.read_support(p)["cohort"] != "immicro"]
+    if len(disease) != 20:
+        raise ValueError("cross-draw statistics require all 20 disease units")
+    inputs = [script, ROOT / "tools/score_strict.py", ROOT / "tools/donor_statistics.py"]
+    for path in disease:
+        base = ROOT / "scores" / C.relative(path)
+        inputs.extend([path, base / "scoring_support.json", base / "score/summary.json",
+                       base / "score/per_donor.csv", base / "statistics/per_donor_long.csv",
+                       base / "statistics/status.json"])
+    _run_preserving(runtime, "aggregate-five-draw-donor-ci",
+                    [C.CPU_PY, str(script), "--action", "cross-draw", "--require-complete"],
+                    memory_gib=8, inputs=inputs,
+                    outputs=[ROOT / "source_data/fig4_cross_draw_donor_ci.csv",
+                             ROOT / "source_data/fig4_cross_draw_donor_ci.json"])
+
+
+def corrected_disease_signal(runtime: Runtime, units: list[Path]) -> None:
+    script = ROOT / "tools/disease_signal.py"
+    disease = [p for p in units if C.read_support(p)["cohort"] != "immicro"]
+    if len(disease) != 20:
+        raise ValueError("donor-aware disease signal requires all 20 disease units")
+    inputs = [script, ROOT / "tools/score_strict.py", ROOT / "tools/donor_statistics.py"]
+    for path in disease:
+        base = ROOT / "scores" / C.relative(path)
+        deg = base / "statistics/donor_deg"
+        inputs.extend([path, base / "scoring_support.json", base / "score/summary.json",
+                       base / "statistics/status.json", deg / "genes_kept.csv",
+                       deg / "donor_deg_summary.csv"])
+        inputs.extend(sorted(p for p in deg.glob("*/*/*") if p.is_file() and p.name in (
+            "donor_condition_pseudobulk.csv", "donor_limma_genes.csv", "limma_status.json")))
+        cohort = C.read_support(path)["cohort"]
+        inputs.extend([C.OLD / "data" / cohort / "features.npz", C.OLD / "data" / cohort / "folds.csv"])
+    names = ("fig4_donor_aware_signal.csv", "fig4_donor_aware_summary.csv",
+             "fig4_donor_aware_genes.csv", "fig4_donor_aware_cat.csv",
+             "fig4_donor_aware_provenance.json")
+    _run_preserving(runtime, "compute-donor-aware-disease-signal",
+                    [C.CPU_PY, str(script), "--require-complete"], memory_gib=12,
+                    inputs=inputs, outputs=[ROOT / "source_data" / name for name in names])
+
+
+def _figure234_outputs() -> list[Path]:
+    names = ("fig2_ablation_and_support", "fig3_healthy_strict_oof", "fig3_realism_metrics",
+             "fig3_umap_by_celltype", "fig3_composition_fractions", "fig3_runtime_components",
+             "fig3_canonical_marker_dotplot", "fig4_disease_strict_draws", "fig4_disease_signal_strict",
+             "fig4_disease_signal_scatter", "fig4_disease_signal_heatmap", "fig4_disease_signal_cat",
+             "fig4_deconvolution_strict", "fig4_deconvolution_expression_strict",
+             "fig4_deconvolution_historical_signal", "fig4_deconvolution_covered_sensitivity",
+             "fig4_historical_5fold_separate")
+    files = [ROOT / "figures" / f"{name}.{ext}" for name in names for ext in ("pdf", "svg", "png")]
+    files += [ROOT / "source_data" / name for name in (
+        "fig2_historical_rank_full.csv", "fig2_strict_curve.csv", "fig3_per_sample.csv",
+        "fig3_extras.csv", "fig4_strict_per_sample.csv", "fig4_corrected_statistics.csv",
+        "fig4_strict_contrast.csv", "fig4_deconvolution.csv", "fig4_deconvolution_signal.csv",
+        "fig4_historical_5fold.csv")]
+    files += [ROOT / "reports/figures234_readiness.json", ROOT / "reports/figures234_readiness.md"]
+    return files
+
+
+def final_documents(runtime: Runtime, figures: dict, rare: dict) -> None:
+    assert_publication_ready(figures, rare)
+    deck = ROOT / "tools/build_review_deck.py"
+    panel_outputs = [ROOT / "deck" / f"fig1_panel_{panel}.{ext}"
+                     for panel in ("ab", "cd", "e") for ext in ("png", "svg")]
+    _run_preserving(runtime, "render-final-review-deck",
+                    [PDF_PY, str(deck), "--require-complete"], memory_gib=4,
+                    inputs=[deck, ROOT / "reports/figures234_readiness.json",
+                            ROOT / "reports/rare_provenance.json", ROOT / "reports/rare_visual_provenance.json"],
+                    outputs=[ROOT / "deck/paper_figures_final.pptx", ROOT / "deck/final_gate_sources.json",
+                             ROOT / "deck/README.md", *panel_outputs])
+    manuscript = ROOT / "tools/assemble_manuscript.py"
+    stage = ROOT / "manuscript"
+    previous_sources = [*stage.glob("*.tex"), *stage.glob("sections/*.tex"),
+                        stage / "main.pdf", stage / "supplementary.pdf", stage / "integration_manifest.json"]
+    # Assembly changes many staged TeX files; preserve the earlier review copy
+    # before replacing any of them, while Runtime protects its manifest output.
+    proof = preserve_preview_outputs(runtime, "assemble-verified-manuscript", previous_sources)
+    manifest = stage / "integration_manifest.json"
+    runtime.execute("assemble-verified-manuscript", [C.CPU_PY, str(manuscript), "--require-complete"],
+                    memory_gib=4,
+                    inputs=[manuscript, ROOT / "reports/figures234_readiness.json",
+                            ROOT / "reports/rare_provenance.json",
+                            ROOT / "source_data/fig4_cross_draw_donor_ci.csv"],
+                    outputs=[manifest],
+                    previous_outputs={str(manifest): proof[str(manifest)]} if str(manifest) in proof else {})
+    export = ROOT / "tools/finalize_outputs.py"
+    _run_preserving(runtime, "compile-final-manuscript-pdfs",
+                    [PDF_PY, str(export), "--action", "manuscript-pdf", "--require-complete"],
+                    memory_gib=8, inputs=[export, manifest, stage / "main.tex", stage / "supplementary.tex"],
+                    outputs=[stage / "main.pdf", stage / "supplementary.pdf"])
+    _run_preserving(runtime, "convert-final-deck-pdf",
+                    [PDF_PY, str(export), "--action", "deck-pdf", "--require-complete"],
+                    memory_gib=8, inputs=[export, ROOT / "deck/paper_figures_final.pptx",
+                                          ROOT / "deck/final_gate_sources.json"],
+                    outputs=[ROOT / "deck/paper_figures_final.pdf"])
+
+
+def render(runtime: Runtime, units: list[Path]) -> None:
+    preserve_diagnostic()
+    cross_draw_statistics(runtime, units)
+    corrected_disease_signal(runtime, units)
+    visual = ROOT / "tools/export_healthy_visuals.py"
+    _run_preserving(runtime, "export-healthy-visuals", [C.CPU_PY, str(visual)], memory_gib=24,
+                    inputs=[visual, *units], outputs=[ROOT / "source_data" / name for name in (
+                        "fig3_visual_data.json", "fig3_visual_data.npz", "fig3_marker_codetection.csv",
+                        "fig3_runtime_evidence.json", "fig3_runtime.csv", "fig3_runtime.json",
+                        "fig3_celltype_fractions.csv", "fig3_umap_coordinates.csv")])
+    cache_root = ROOT / "work/rare_strict_caches"
+    analysis = ROOT / "tools/build_figure5.py"
+    _run_preserving(runtime, "analyze-strict-rare", [C.CPU_PY, str(analysis), "--manifest-dir", str(cache_root)],
+                    memory_gib=12, inputs=[analysis, *sorted(cache_root.rglob("rare_manifest.json"))],
+                    outputs=[ROOT / "source_data" / name for name in (
+                        "rare_per_sample.csv", "rare_per_donor.csv", "rare_summary.csv",
+                        "rare_ineligible_states.csv")])
+    export = ROOT / "tools/export_rare_visuals.py"
+    _run_preserving(runtime, "export-strict-rare-visuals",
+                    [C.CPU_PY, str(export), "--manifest-dir", str(cache_root)],
+                    memory_gib=16, inputs=[export, ROOT / "source_data/rare_summary.csv"],
+                    outputs=[ROOT / "reports/rare_visual_provenance.json", ROOT / "reports/rare_provenance.json",
+                             *[ROOT / "source_data" / n for n in ("rare_visual_cells.csv", "rare_visual_heatmap.csv",
+                                                                         "rare_visual_donor_draws.csv")],
+                             *[ROOT / "figures" / f"fig5_rare_visuals_strict.{ext}" for ext in ("pdf", "svg", "png")]])
+    plot = ROOT / "tools/figure5_panels.py"
+    _run_preserving(runtime, "render-strict-rare", [C.CPU_PY, str(plot), "--require-complete"],
+                    memory_gib=4, inputs=[plot, ROOT / "tools/figure5_details.py", ROOT / "reports/rare_provenance.json"],
+                    outputs=[ROOT / "source_data" / name for name in ("rare_behcet_descriptive.csv",
+                                "rare_behcet_per_sample.csv", "rare_all_states.csv", "rare_all_states_aggregate.csv")]
+                            + [ROOT / "reports/rare_behcet_provenance.json"]
+                            + [ROOT / "figures" / f"fig5_{stem}_strict.{ext}" for stem in
+                                ("rare_states", "all_states", "behcet_rules") for ext in ("pdf", "svg", "png")])
+    plot = ROOT / "tools/build_results_figures.py"
+    _run_preserving(runtime, "render-strict-figures234", [C.CPU_PY, str(plot), "--require-complete"],
+                    memory_gib=8, inputs=[plot, ROOT / "tools/figure2_panels.py", ROOT / "deconvolution/deconvolution_manifest.json",
+                                          ROOT / "source_data/fig4_cross_draw_donor_ci.json",
+                                          ROOT / "source_data/fig4_donor_aware_provenance.json"],
+                    outputs=_figure234_outputs())
+    ready = json.loads((ROOT / "reports/figures234_readiness.json").read_text())
+    rare = json.loads((ROOT / "reports/rare_provenance.json").read_text())
+    strict = all(u.get("design") == "strict5pair" and u.get("evidence_tier") == "strict" for u in rare.get("units", []))
+    assert_publication_ready(ready, {"design": "strict5pair" if strict else "diagnostic", "units": len(rare.get("units", []))})
+    final_documents(runtime, ready, {"design": "strict5pair" if strict else "diagnostic",
+                                   "units": len(rare.get("units", []))})
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("--stage", choices=("deconvolution", "rare", "render", "all"), default="all")
+    a = p.parse_args()
+    units = C.discover_units()
+    if len(units) != 40:
+        raise ValueError("all 40 strict support units are required before finalization")
+    runtime = Runtime(ROOT)
+    state = {"state": "running", "stage": a.stage, "at": stamp(), "figure6": "waiting_user_data"}
+    out = ROOT / "FINALIZATION_STATUS.json"
+    atomic_json(out, state)
+    try:
+        if a.stage in ("deconvolution", "all"):
+            deconvolution(runtime, units)
+        if a.stage in ("rare", "all"):
+            rare_caches(runtime, units)
+        if a.stage in ("render", "all"):
+            render(runtime, units)
+        if a.stage in ("render", "all"):
+            artifacts = [ROOT / "manuscript/main.pdf", ROOT / "manuscript/supplementary.pdf",
+                         ROOT / "deck/paper_figures_final.pptx", ROOT / "deck/paper_figures_final.pdf",
+                         ROOT / "source_data/fig4_cross_draw_donor_ci.csv",
+                         ROOT / "source_data/fig4_donor_aware_signal.csv"]
+            if any(not p.is_file() or p.stat().st_size == 0 for p in artifacts):
+                raise ValueError("final PDF/deck or disease source artifact missing after render")
+            state.update(state="complete", artifacts={str(p): sha256(p) for p in artifacts},
+                         canonical_integration="awaiting_review", archive_update="coordinator_task_end")
+        else:
+            state.update(state="selected_finalization_stage_complete")
+        state["finished_at"] = stamp()
+    except BaseException as exc:
+        state.update(state="stopped_needs_inspection", error=str(exc), stopped_at=stamp())
+        raise
+    finally:
+        atomic_json(out, state)
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,22 @@
+# Model 8 PBISC-Diffusion paper maintenance
+
+This active Model 8 source and its experiments are part of the
+`pbisc-diffusion` paper. At task start, read
+`../../paper-release-20260928/maintenance/POLICY.md` along with this
+directory's README and applicable parent instructions.
+
+At the end of each related task, follow that policy's versioned update
+workflow for the exact source, experiment, checkpoint, or evidence assets that
+changed. From the release root, use
+`maintenance/update.py prepare --request FILE --id ID`, inspect the prepared
+update, then run `maintenance/update.py publish ID --execute` and
+`maintenance/update.py status` under the policy. Record a no-op or pending
+status when no
+asset changed or publication failed; never describe that as an upload. Do not
+regenerate or alter the frozen 2026-09-28 release, its root manifests, or the
+HF `paper-20260928` revision. Inference assets are location plus receipt by
+default unless the task explicitly needs their payload.
+
+The private dataset must stay private. Include datalake, VAE, or Model 7 assets
+only with exact evidence that they are dependencies of this diffusion paper.
+The parent host GPU safety rules still apply.

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

@@ -0,0 +1,316 @@
+# PBISC-Diffusion paper summary deck (2026-09-30, r00; ordered by the six manuscript figures since 2026-10-06)
+
+76-slide English deck, ordered by the six main figures of the Nature-style manuscript plan (user request 2026-10-06,
+following `paper-release-20260928/reference-papers/Nature Style Manuscript Writing.pdf`):
+- Title and outline: 6 figures, Supplementary, Appendix, Discussion.
+- "Manuscript plan: six main figures": a table of each figure's claim and how many panels are ready.
+- For each figure:
+  - a divider;
+  - a plan slide, a table of panel / content / evidence slide / status (Ready, Adapt, Draft, Build, Run, Plan);
+  - the existing slides that serve its panels, each labelled "Fig. 2c" etc. in the top-right corner.
+- Supplementary: a plan slide plus the from-scratch results. Appendix: the modified scSemiProfiler run. Discussion: the
+  other-tissues outlook.
+
+User decisions of 2026-10-06:
+- No PBISC-VAE: scSemiProfiler, a VAE-based method, is the comparison (Fig. 3).
+- Fig. 2 shows LoRA first on the healthy cohort (ImMicro) with the realism metrics (precision, coverage, classifier
+  AUROC, MMD, E_N); the disease-cohort comparison comes later.
+- CYBERSORTx and other bulk deconvolution methods go to the Supplementary only (PBISC generates single cells).
+- Figs 4 and 6 stay unplanned. Their existing slides are kept in the section as "Fig. 4 candidate" / "Fig. 6 candidate".
+
+Only order, section labels, the agenda and new plan or draft slides changed. The new slides are "Overview draft (Nature
+style)", the manuscript's candidate Fig. 1, and "Pretraining corpus", the Fig. 1d strip. No new result figures were
+made.
+- The plan lives in `data/figure_plan.json`.
+- `tools/figure_plan.py` draws the plan tables and the slide text, and checks that every slide is placed exactly once.
+- `tools/restructure_figure_order_20261006.py` rebuilds the order from the plan. It is rerun after every plan change and
+  keeps all slide fields.
+- The earlier section order (10 sections, 45 slides) is in `_archive/2026-10-06_before_figure_order/`.
+
+Short keyword lines only; the figures carry the results. Every slide that uses a published method, metric or
+baseline has a one-line "References:" footer; full citations are in the speaker notes.
+
+- `PBISC-Diffusion_paper_summary_20260930.pptx`: the deck
+- `PBISC-Diffusion_paper_summary_20260930.pdf`: LibreOffice PDF of the deck
+- `data/slides_spec.json`: slide order, titles, keywords, footnotes, references, speaker-note text
+- `generate_deck.py`: builds the pptx from `data/slides_spec.json` only (python-pptx)
+- `figures/`: exactly the figures the slides show (PNG + PDF), made by `tools/sec*.py`. Intermediate panels go to a
+  temporary folder; superseded figures are deleted, not kept (2026-10-02, user request; every deleted file was
+  checked to be in the paper archive by sha256 first).
+- `data/sec*.csv` and `data/*_slide_text.json`: every plotted or quoted number with its source path
+- `render/`: PDF and 70-dpi slide JPGs for checking
+
+## Slide order
+
+| section | slides |
+|---|---|
+| 1 Model overview | bulk in, cells out; denoiser |
+| 2 Backbone | SDD → PBISC-Diffusion; bulk conditioning |
+| 3 Architecture ablation | width & context (loss, benchmark); gene panel |
+| 4 Metrics + SLE benchmark | **how we score generated cells** (metric table with references); SLE benchmark; per cell type; bulk broadcast baseline |
+| 5 Real bulk vs pseudobulk | input shift; same shift in three cohorts; cells off-manifold; disease direction flips |
+| 6 Paired fine-tuning | method; evaluation design |
+| 7 LoRA ablations | full vs LoRA vs cond.-encoder-only; LoRA rank r = 4 / 16 / 64; K diversification |
+| 8 Pairs needed | composition / coverage / steps (with scSemiProfiler at the same n); donor and disease signal; pairs from other cohorts; longer training on them (with training minutes) |
+| 9 Paired validation | cohorts; 5 donors: cells, realism beyond P/C, P/C at k = 3 / 5 / 10, scSemiProfiler copies its representative, disease signal, CAT curves, time to apply; 5-fold CV (with scSemiProfiler on the same pairs); same training pairs: LoRA vs scSemiProfiler; 5-fold realism metrics |
+| 10 Next steps | paired-subset cohorts (planned); other tissues from a few dozen pairs (Discussion framing of the from-scratch results) |
+| Supplementary | no pretraining: same cohort, from scratch (pilot); no pretraining: other cohorts, from scratch (pilot); rare states: from scratch vs pretrained; deconvolution with the same pairs: composition; deconvolution with the same pairs: disease signal |
+| Appendix | scSemiProfiler without its output threshold (sensitivity; modified read-out, not the official output) |
+
+## Rebuild
+
+Everything is CPU only; no GPU or checkpoint is touched.
+
+```bash
+# prerequisites (plan folder plans/paired_finetune_intradataset_20260927/, CPU):
+#   scsemi/tools/representative_dependence.py      -> scsemi/analysis/representative_dependence_20261002/
+#   tools/contrast_extra.py (+ tools/contrast_extra_tables.py) -> scores_contrast/   (Spearman, ceiling, limma, CAT, RBO)
+#   tools/build_tpm_zeroshot.py + tools/score_tpm_zeroshot.sh -> scores/<ds>/zeroshot_tpm_20261002/pooled/
+#     (the length-corrected zero-shot arm needs one GPU sampling step: tools/sample_lockwait.sh, coordinator only)
+cd /home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00
+# shared helpers, not run directly: style.py, sec03_common.py, scsemi_results.py, fold_sizes.py
+for f in sec01_overview sec02_backbone sec03_width_loss sec03_width_bench sec03_panel \
+         sec04_metrics_overview sec04_sle_benchmark sec05_condition_space sec05_cells_offmanifold \
+         sec05_behcet_direction sec05_shift_cohorts sec06_finetune_method sec07_ft_modes \
+         sec07_k_aug sec07_rank_sweep sec08_pairs_needed sec08_cross_cohort sec09_paired_validation sec09_extra_metrics \
+         sec09_time_to_apply sec09_scsemi_representative sec09_cat_curves sec10_paired_subset_cohorts \
+         secA_scsemi_readout sec07_no_pretraining sec08_cross_scratch sec09_same_pairs \
+         secS_scratch_rare_states secS_deconvolution fig3_time_days fig4_disease fig23_healthy fig5_rare_states sec10_other_tissues figure_plan; do   # keep this order (sec10 reads secS; figure_plan last)
+  python3 "tools/$f.py" || break
+done
+python3 tools/restructure_figure_order_20261006.py   # order the slides by data/figure_plan.json
+python3 tools/sync_sec09_text.py      # copy every generated slide text (sec09_index / text_source) into the spec
+python3 generate_deck.py              # -> PBISC-Diffusion_paper_summary_20260930.pptx
+soffice --headless --convert-to pdf --outdir render PBISC-Diffusion_paper_summary_20260930.pptx
+pdftoppm -jpeg -r 70 render/PBISC-Diffusion_paper_summary_20260930.pdf render/slide
+cp render/PBISC-Diffusion_paper_summary_20260930.pdf .
+```
+
+`generate_deck.py` stops with an error if a figure is missing, a title does not fit on one line, a footnote needs
+more than 2 lines (1 line when the slide has references), the reference line needs more than 1 line, or any text
+contains Korean or placeholder words. `tools/restructure_20261002.py` is the one-off script that produced the current
+slide order and the references (it refuses to run twice).
+
+## Notes
+
+- **No "all" label (2026-10-02).** The 5-fold arm trains each fold model on the other four folds minus 7–8
+  inner-validation donors; its test fold is never trained on (RUN.json `test_rows_never_loaded_for_training`). Figures
+  label it "5-fold CV (other 4 folds)" and learning-curve ticks show the training-pair count per fold (78–79 ImMicro,
+  58–59 sepsis), read by `tools/fold_sizes.py`.
+- **Learning curve x = 0 uses no pairs (2026-10-02).** It shows the zero-shot model fed the real bulk as measured
+  and after exon-length correction (counts / Ensembl union-exon kb, then the same fixed-depth arithmetic;
+  `plans/.../tools/build_tpm_zeroshot.py`, scored in `scores/<ds>/zeroshot_tpm_20261002/pooled`). The old x = 0
+  calibration point, whose alpha used every training pair of the fold, is gone; calibration appears only fitted on the
+  same n pairs as the LoRA point (squares; `cal_budget_20261001`).
+- **Disease metrics (2026-10-02).** Next to Pearson logFC r and the Welch top-50 DEG overlap: Spearman r, the
+  split-half ceiling (observed vs observed, Spearman–Brown), limma-voom top-50 DEG, each arm's chance overlap, and
+  CAT curves with the k / 2G chance line (`plans/.../scores_contrast/`, tools/contrast_extra.py; every Pearson r and
+  Welch count reproduced exactly). Repeated samples of one patient (Imperial, Giroux, Ji) count as separate samples in
+  both DE tests, as in the scorer (footnote).
+- Section 9 text is generated: `tools/sec09_paired_validation.py`, `sec09_extra_metrics.py`, `sec07_rank_sweep.py`,
+  `sec09_time_to_apply.py`, `sec09_scsemi_representative.py`, `sec09_cat_curves.py` write slide text JSON; sync copies
+  it. Hand-written: the keywords of the two "Pairs needed" slides (section 8) and of every slide in sections 1–7 and 10.
+- Giroux's disease metrics exclude 196 sex-linked genes (severity is confounded with sex), from
+  `plans/.../scores_nosex/`. The calibration comparator is "Zero-shot + calibration" (user decision 2026-10-01).
+- Story rule (user decision 2026-09-30): no PBISC-VAE and no reference calibration (refcal). The exon-length-corrected
+  input is used only as the no-pair x = 0 point of the learning curve (user decision 2026-10-02).
+  `tools/sec04_immicro.py` (refcal vs scSemiProfiler on ImMicro) is kept but is not part of the deck or the rebuild.
+- scSemiProfiler 5-fold and equal-budget results are picked up automatically when they appear (`tools/scsemi_results.py`;
+  arm `scsemi__raw` in `scores/<cohort>/scsemi_cv_20261002/pooled*/`, `scsemi_n{5,10,20,40}__raw` in
+  `scores/<cohort>/scsemi_budget_20261002/pooled*/`; same donors and reference cells as the main pooled call only).
+  Then rerun sections 8 and 9, sync, recheck the section 8 keywords and rebuild.
+- Earlier versions: `_archive/2026-09-30_before_no_vae_refcal/`, `_archive/2026-10-01_before_extra_metrics/`,
+  `_archive/2026-10-02_before_time_to_apply/`, `_archive/2026-10-02_before_restructure/` (pptx, PDF, spec; their
+  figures are in the paper archive). `DRAFT_1150_*`: the copy shown at the 2026-09-30 12:00 meeting.
+
+- Added 2026-10-03 (user decision: the cross-cohort experiment is reported at K = 1000 only and is the figure that explains
+  why PBISC fits LoRA on a few pairs of each cohort): slides 25-26 in section 8, `tools/sec08_cross_cohort.py`.
+  - Slide 25 "Pairs from other cohorts do not transfer": per held-out cohort, composition L1 / coverage / disease logFC r of
+    zero-shot, calibration fitted on the other cohorts, LoRA r16 / r64 / full fine-tune trained on the other cohorts
+    (+ Liu 2021) at step saturation, and LoRA on the cohort's own pairs (5-fold pooled).
+  - Slide 26 "Longer training on other cohorts" (": gap stays" since 2026-10-06): the same metrics at every 20k-step
+    milestone.
+  - Source plan: `plans/paired_crosscohort_20261002/` (README; same-reference and same-sample checks in the script).
+    Agenda item 8 now reads "How many pairs, and do other cohorts' pairs transfer". The deck has 37 slides.
+    Pre-update copy: `_archive/2026-10-03_before_cross_cohort/`.
+
+## Sources
+
+Final model: `runs/f01_6k_1x_seed20260627` (epoch 16, EMA). Scores and receipts come from
+`plans/utility_studies_final6k_20260925/`, `plans/paired_finetune_intradataset_20260927/`,
+`plans/immicro_scsemi_comparison_20260927/`, `plans/floor01_campaign_20260923/`,
+`analysis/scsemi_benchmark_diffusion_20260913/` and the run folders named in each `data/sec*.csv`. Reference PDFs:
+`/home/sj_server_1/PBISC/paper-release-20260928/reference-papers/` (INDEX.md). Manuscript:
+`/home/sj_server_1/PBISC/paper-release-20260928/manuscript/`.
+- 2026-10-04 appendix (user decision: supplementary, appendix only, because it changes scSemiProfiler's official
+  output). Slide 38 is the divider "Appendix" and slide 39 is "Appendix: scSemiProfiler without output threshold"
+  (`tools/secA_scsemi_readout.py`, `data/secA_scsemi_readout{.csv,_slide_text.json}`).
+  - Inputs: `plans/paired_finetune_intradataset_20260927/scsemi/analysis/output_variants_20261003/`. The script checks
+    that its LoRA-5 and official scSemiProfiler values equal the section 9 slide data draw by draw.
+  - Result: without upstream's output threshold, scSemiProfiler's coverage rises in 5/5 cohorts, and 23/23 LoRA-5
+    comparisons (coverage, precision, composition, logFC r, DEG) keep their winner.
+  - The outline keeps its 10 sections (the builder requires 10). The pre-change copy is in
+    `_archive/2026-10-04_before_appendix/`. The deck has 39 slides.
+- 2026-10-05 update (user request: put the results so far into the deck). Pre-change copy: `_archive/2026-10-05_before_scratch_cv/`.
+  - New slide 23, "No pretraining: same cohort, from scratch" (`tools/sec07_no_pretraining.py`). Pilot on sepsis fold 0
+    (17 donors). Reads `fold0_scratch_20261005/` and the runs' RUN.json. The donor composition r is recomputed from
+    per_donor.csv and reproduces ablation_extra_donor.csv.
+  - New slide 28, "No pretraining: other cohorts, from scratch" (`tools/sec08_cross_scratch.py`). Held-out sepsis pilot.
+    Every arm is read from `paired_crosscohort_20261002/scores_masked/`: genes no training cohort measured are zeroed
+    in all arms, because the unmasked scratch arm puts 91–94 % of its UMI there (read from the generated_masked logs
+    since 2026-10-06).
+  - New slide 38, "Same training pairs: LoRA vs scSemiProfiler" (`tools/sec09_same_pairs.py`). scSemiProfiler 5-fold
+    CV with LoRA's own training pairs, plus GPU hours per fold from the receipts on either host. Cohorts that are still
+    running show "in progress"; rerun the script as they finish.
+  - These two slides now draw the scSemiProfiler CV / budget runs automatically:
+    - Slide 24, "Pairs needed" (diamonds; ImMicro so far): keyword 2 reworded, footnote extended.
+    - Slide 37, "5-fold CV" (yellow bar; ImMicro and Ji so far).
+  - `tools/sec09_paired_validation.py` reads the scSemiProfiler CV arm's Spearman / limma values from
+    `scores_contrast/<cohort>/scsemi_cv_20261002/pooled/` (contrast_extra.py --design scored). Pearson r and the Welch
+    DEG must match the scorer; the values stay blank until computed. Cohorts not yet run say "in progress".
+  - Agenda item 7 now reads "LoRA: compute, rank, K; training from scratch". The deck has 42 slides.
+  - New helper: `tools/grouped_bars.py`.
+- 2026-10-06 update (user request: check that the cross-cohort LoRA / full FT, cross-cohort from-scratch and
+  same-cohort from-scratch (+ recipes) results, with benchmarks and training times, and the scratch-vs-pretrained rare
+  states are in the deck; user decision: the from-scratch results go to the paper's Supplementary and the Discussion
+  presents them as a route to other tissues). Pre-change copy: `_archive/2026-10-06_before_supplementary/`.
+  - **Supplementary block (new divider, slides 40-43).**
+    - "No pretraining: same cohort, from scratch" and "No pretraining: other cohorts, from scratch" moved here from
+      sections 7 and 8. Their content is unchanged; slide 42's notes now name the cross-cohort slides by title.
+    - New "Rare states: from scratch vs pretrained" (`tools/secS_scratch_rare_states.py`).
+      - It reads the rare-state screen (`plans/rare_states_screen_20261004/out/sepsis_fold0_*` and
+        `sepsis_loco_masked_*`).
+      - The cross-cohort arms use the masked scoring (46 never-measured genes zeroed in every arm).
+      - The donor bootstrap reproduces the verified analysis in `out/scratch_vs_lora_20261005/REPORT.md`.
+  - **Section 10 "Next steps".**
+    - New "Next: other tissues from a few dozen pairs" (`tools/sec10_other_tissues.py`): a comparison table, pretrained
+      + LoRA vs from scratch.
+    - Every value is read from the deck's own source tables. The say text is the user's Discussion framing.
+  - **Slide 26 "Longer training on other cohorts".** The first keyword is now training minutes to saturation (RUN.json
+    wall seconds), with per-cohort minutes and steps in the notes (`tools/sec08_cross_cohort.py`).
+  - **Slide 34 "5 donors: time to apply".**
+    - The pretraining hours are read from `data/sec06_ft_method.csv`, no longer hard-coded.
+    - The note names the 'Fine-tuning with paired bulk + sc' slide by title. Its old "slide 15" pointed at the wrong
+      slide.
+  - Agenda items 7 and 10 updated. Spec change: `tools/restructure_20261006.py` (refuses to run twice). The deck has 45
+    slides; no Korean text.
+  - **Review pass (same day).** An independent 5-agent review of the changed slides confirmed 39 issues; all are
+    fixed. Pre-review copies of the touched scripts and the spec: `_archive/2026-10-06_before_supplementary/*.pre_review`.
+    - Slide 39: pretraining now reads 33.1 M train cells (`train_split_cells`; the 41.4 M corpus includes val/test).
+      The rare-state row follows the bootstrap verdicts on both sides (closer on ISG-high T / on DN2 B; labels and
+      states both arms miss by > 4-fold are not counted). "No corpus" became "come close": the scratch runs still took
+      the panel, value scaler and z-score constants from the PBMC checkpoint (RUN.json `kept_from_checkpoint`, now in
+      the notes). The say text carries the one-fold pilot qualifier; the footnote names both pilots.
+    - Slide 43: "no significant difference on average" (not "no difference"). Keyword 2 is the cycling T/NK count
+      (8 of 8 comparisons). The notes add the ISG-high T split by panel, the scratch-closer states (DN2 B, MS1), the
+      52-call tally, the fold-0 caveat (fold 0 is the own-pair LoRA's best fold for C1Q-high and cycling T/NK,
+      computed from `folds.csv`), label states unthinned, and "8 of 13 states shown".
+    - Slide 26: title "...: gap stays" and "drifts in Sepsis and Ji" are computed from the milestones (gap = no milestone
+      reaches the own-cohort coverage; drift = full fine-tune L1 up by >= 0.05). Minutes are in
+      `data/sec08_cross_cohort.csv` (wall_seconds, minutes, run_receipt) and in the numbers list.
+    - Slide 42: UMI share (94 %, 91–94 % across milestones), the observed share (0.014 %, from `cells_panel6k.npz`)
+      and both arms' stopping settings are read from the receipts; the "none" label sits inside the axes.
+    - Slide 34: keywords use the cohort means of the figure (17–59×, 57 min–4.1 h); the per-draw range 11–63× is in the
+      notes. The right panel shares the bars' rows and has a title.
+    - Talk text and pointers: slides 23, 25, 26, 45 (say), 22 (recipes description), 32 and 36 (slide pointers by
+      title), slide 1 subtitle "updated 2026-10-06".
+- 2026-10-08 update (user request: put the BayesPrism, CIBERSORTx and scSemiProfiler 5-fold results into the deck).
+  Pre-change copy: `_archive/2026-10-08_before_deconvolution/`.
+  - **Two new Supplementary slides** (`tools/secS_deconvolution.py`, `data/secS_deconvolution{.csv,_slide_text.json}`):
+    "Deconvolution with the same pairs: composition" and "...: disease signal".
+    - Source: `plans/bayesprism_paired_20261006/` (README, `results/RESULTS_full.md`, `RESULTS_cibersortx.md`).
+    - BayesPrism (recommended genes) and official CIBERSORTx (Fractions S-mode + HiRes) use the same paired donors
+      as the reference and the test samples' real bulk as the mixture, with the benchmark's own truth and scorer.
+    - Keywords and notes are computed from the tables.
+  - **Supplementary plan.** The planned "Bulk deconvolution methods" row is replaced by the two Ready slides.
+    `tools/figure_plan.py` now takes an optional per-slide note (`supplementary.notes`) and drops "Planned:" when
+    nothing is planned.
+  - **New scSemiProfiler results picked up (server_1):**
+    - Sepsis and Giroux 5-fold CV. Giroux was finalized on server_1 from sha-checked copies of its fold NPZs, and
+      rescored without sex-linked genes in `scores_nosex/giroux2022/scsemi_cv_20261002/pooled`.
+    - Sepsis equal-budget n = 5/10/20/40.
+    - Imperial 5-fold: finished on server_2 at 13:45 and was finalized on server_1 from sha-checked fold copies.
+      scSemiProfiler 5-fold now covers all five cohorts.
+    - Spearman/limma extras for sepsis, Giroux and Imperial; realism extras for all five cohorts.
+  - **Text changes from the new results:**
+    - "Same training pairs": keywords are data-driven. LoRA leads on coverage and precision in 5/5 cohorts;
+      composition 4/5 and logFC r 3/4, where scSemiProfiler leads in Giroux. The GPU-time ratio is 19–62×.
+    - sec09_same_pairs.py now reads the sepsis fold-0 pilot queue tag (`sep_f0`). For Giroux it quotes DEG from
+      scores_nosex, and for older pooled LoRA calls from pooled_deg.
+    - "5-fold CV" keyword: logFC r 3/4.
+    - "Pairs needed" (hand-written): scSemiProfiler coverage 0.04 / 0.10. On sepsis disease logFC r,
+      scSemiProfiler at 5–40 pairs (0.52–0.58) is above LoRA (0.29–0.48), while its top-50 DEG stays at 2–6.
+- 2026-10-08, new figure split (user decision; supersedes the 2026-10-06 split; pre-change copy
+  `_archive/2026-10-08_before_new_figure_plan/`).
+  - Fig. 2: LoRA fine-tuning with no disease metrics.
+  - Fig. 3: PBISC vs scSemiProfiler on healthy donors, with time as a main result.
+  - Fig. 4: disease benchmarks on the paired cohorts (PBISC versions, scSemiProfiler, and BayesPrism / CIBERSORTx
+    labelled as cell-type deconvolution; the deconvolution slides moved here from the Supplementary).
+  - Fig. 5: rare-cell fractions and detection.
+  - Fig. 6: new findings from the bulk-only sepsis and COVID samples (K = 1,000 and 4,000).
+  - The cross-cohort transfer slides moved to the Supplementary; their placement is open.
+  - New slide "Time: days for scSemiProfiler, minutes for LoRA" (`tools/fig3_time_days.py`, Fig. 3d).
+    - Inputs: GPU hours per 5-fold experiment from the receipts (`data/sec09_same_pairs.csv`, checked against
+      the scSemiProfiler event logs on both hosts), the 5-donor draws (`data/sec09_time_to_apply.csv`) and the
+      one-time pretraining (`data/sec06_ft_method.csv`).
+    - Results: ImMicro 24 h vs 1.2 h, sepsis 38 h vs 37 min. All runs: scSemiProfiler 184 h (7.7 days) vs PBISC
+      22 h including pretraining.
+    - The equal-budget scSemiProfiler runs are excluded: they reuse the 5-fold run's representative models.
+  - Panel status: Build / Run marks new slides or analyses still to do; Adapt marks slides to re-scope (healthy-only
+    Fig. 2-3, disease columns into Fig. 4).
+- 2026-10-08, comparison rules (user decision; memory feedback_paper_comparison_rules):
+  - **Time.** Only per-cohort GPU work counts: no PBISC pretraining, no GPU queue waits. The time slide now shows the
+    5-donor draws (main) next to the 5-fold runs (separate). All runs: 7.7 GPU-days vs 5.7 h.
+  - **No bulk-broadcast baseline.** It is removed from the SLE benchmark, CAT, deconvolution and "Pairs needed"
+    figures.
+    - The "Bulk broadcast baseline" slide is gone. Its partial r panel is now on the SLE benchmark slide
+      (0.21 vs 0.17).
+    - Still to rebuild in their own phases: Fig. 2e (ImMicro only) and Fig. 6a.
+  - **Main comparison = 5 pairs** (LoRA-5 vs scSemiProfiler-5); 5-fold is reported separately. Partial r is
+    emphasised (bold panel titles).
+  - **New `tools/fig4_disease.py`**, which checks all 200 logFC r / DEG values against the section-9 tables:
+    - "Disease signal with 5 pairs: LoRA-5 vs others" (4b);
+    - "5-fold CV: disease signal" (4c);
+    - "Sepsis: fine-tuning variants" (details).
+  - The old "5 donors: LoRA vs scSemiProfiler — disease signal" slide is retired. `tools/sync_sec09_text.py` lists it
+    in RETIRED.
+  - The deconvolution slides are retitled "Cell-type deconvolution, same pairs: ...".
+- 2026-10-08, healthy-only Figs 2-3 (`tools/fig23_healthy.py`).
+  - Eight ImMicro-only slides, re-plotted from the deck's own data tables; nothing is re-scored.
+  - Fig. 2 (no disease metrics):
+    - cells, realism, full / LoRA / condition encoder, pairs needed, rank and K;
+    - 5 donors (main) shown next to 5-fold (separate).
+  - Fig. 3 (vs scSemiProfiler):
+    - LoRA-5 vs scSemiProfiler-5 on 6 cell metrics: LoRA ahead on 6 of 6;
+    - the same pairs, 5 to all;
+    - scSemiProfiler copies its representative;
+    - time.
+  - The earlier all-cohort slides moved to the Supplementary (note "all five cohorts").
+  - "5-fold CV: train on the other 4 folds" is retired (it carried the broadcast; its content is now in Fig. 4c and
+    the healthy slides). It is listed in RETIRED of `tools/sync_sec09_text.py`.
+- 2026-10-08, Fig. 5 rare cells (`tools/fig5_rare_states.py`).
+  - Source: new plan `plans/rare_states_paired_20261008` (README). It covers 4 paired disease cohorts, the 5-donor
+    draws and 5-fold, and the arms zero-shot, calibration, scSemiProfiler and LoRA. Each NPZ is sha-checked and the
+    benchmark's Poisson read-out and labels are reproduced cell by cell.
+  - Three slides:
+    - fraction (5a);
+    - donors and disease direction (5b);
+    - 5-fold, separate (5c).
+  - Results over 56 state × cohort pairs, 5 donors:
+    - LoRA-5 closer to the observed fraction than scSemiProfiler-5 in 51/56;
+    - within 2-fold: 19 vs 5;
+    - better donor ranking: 43/56;
+    - disease direction kept: 73% vs 61%.
+  - Fig. 6a no longer mentions the broadcast. No slide text mentions it now.
+- 2026-10-10, last broadcast mention removed from a figure (found while rewriting the manuscript from this deck).
+  - Fig. 2d "How we score generated cells" (`tools/sec04_metrics_overview.py`) still listed "broadcast; split-half
+    ceiling" as the comparator of logFC r inside the table image. It now reads "zero-shot; partial r (vs bulk)".
+  - Old tool, CSV and figure: `_archive/2026-10-10_metrics_overview_broadcast/`. The deck was rebuilt (76 slides); a
+    text search of every slide, the notes and the PDF twin of every figure a slide uses finds no "broadcast". Three
+    figure files of retired slides still contain it and are not used: `sec04_sle_broadcast`, `sec09_fewpair_disease`,
+    `sec09_fivefold`.
+  - The manuscript was rewritten from this deck on 2026-10-10 (`paper-release-20260928/manuscript/`,
+    `editorial/rewrite_20261010.md`); its figures are copies of this folder's figure PDFs.
+- 2026-10-10, LoRA rank figure key (`tools/sec07_rank_sweep.py`): "LoRA rank r = 16 (used in the deck)" now reads
+  "(used throughout)", because the same panel is Supplementary Fig. 12a of the manuscript. Old files:
+  `_archive/2026-10-10_rank_sweep_label/`. Deck rebuilt (76 slides).

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

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