Archive 4 checkpoints (1-4)

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

@@ -0,0 +1,53 @@
+"""Composition must share the exact selected readout and retain zero classes."""
+
+import importlib.util
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pytest
+
+TOOLS = Path(__file__).parents[1] / "tools"
+sys.path.insert(0, str(TOOLS))
+spec = importlib.util.spec_from_file_location("ablation_composition", TOOLS / "ablation_composition.py")
+mod = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(mod)
+
+
+def test_truth_labels_require_exact_unique_row_and_donor_identity():
+    frame = pd.DataFrame({"cell_index": [1, 0], "sample_id": ["d2", "d1"],
+                          "celltype_l1_pred": ["B cell", "T cell"]})
+    got = mod.align_truth_labels(frame, np.array(["d1", "d2"]))
+    assert got.tolist() == ["T cell", "B cell"]
+    with pytest.raises(ValueError, match="donor"):
+        mod.align_truth_labels(frame, np.array(["d2", "d1"]))
+    with pytest.raises(ValueError, match="unique"):
+        mod.align_truth_labels(pd.concat([frame, frame.iloc[[0]]]), np.array(["d1", "d2"]))
+
+
+def test_composition_includes_absent_types_and_weights_donors_equally():
+    reference = np.array(["T cell", "B cell", "T cell", "T cell"])
+    candidate = np.array(["T cell", "T cell", "B cell", "B cell"])
+    donors = np.array(["d1", "d1", "d2", "d2"])
+    rows, proportions = mod.composition_rows(reference, candidate, donors, donors, ["d1", "d2"],
+                                             ["T cell", "B cell", "DC"])
+    assert [r["comp_l1"] for r in rows] == [1.0, 2.0]
+    assert len(proportions) == 6
+    assert all(r["observed_fraction"] == r["candidate_fraction"] == 0 for r in proportions if r["cell_type"] == "DC")
+
+
+def test_composition_rejects_missing_donors_and_unknown_labels():
+    with pytest.raises(ValueError, match="candidate cells"):
+        mod.composition_rows(np.array(["T"]), np.array(["T"]), np.array(["d1"]),
+                             np.array(["d2"]), ["d1"], ["T"])
+    with pytest.raises(ValueError, match="label"):
+        mod.composition_rows(np.array(["T"]), np.array(["mystery"]), np.array(["d1"]),
+                             np.array(["d1"]), ["d1"], ["T"])
+
+
+def test_selected_readout_must_match_pc_hash():
+    counts = np.array([[1, 0], [0, 3]], dtype=np.float32)
+    mod.assert_array_hash(counts, mod.pc.sha_array(counts), "selected counts")
+    with pytest.raises(ValueError, match="P/C"):
+        mod.assert_array_hash(counts + 1, mod.pc.sha_array(counts), "selected counts")

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

@@ -0,0 +1,54 @@
+import importlib.util
+from pathlib import Path
+import sys
+import unittest
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "tools"))
+
+
+class CampaignTests(unittest.TestCase):
+    def module(self):
+        path = ROOT / "tools/campaign.py"
+        self.assertTrue(path.exists(), "campaign is not implemented")
+        spec = importlib.util.spec_from_file_location("strict_campaign", path)
+        mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(mod)
+        return mod
+
+    def test_training_command_enforces_fixed_steps_and_exact_support(self):
+        mod = self.module()
+        support = ROOT / "protocol/splits/immicro/healthy/fold0/n5/support.json"
+        argv = mod.train_command(support)
+        self.assertEqual(argv[argv.index("--fixed-steps") + 1], "3000")
+        self.assertEqual(argv[argv.index("--support-manifest") + 1], str(support))
+        self.assertNotIn("--train-donors-file", argv)
+        self.assertNotIn("--train-n", argv)
+        self.assertEqual(argv[argv.index("--lora-rank") + 1], "16")
+
+    def test_no_figure6_units_can_enter_campaign(self):
+        mod = self.module()
+        units = mod.discover_units()
+        self.assertEqual(len(units), 40)
+        self.assertTrue(all("bulkonly" not in str(p) for p in units))
+        self.assertEqual({mod.read_support(p)["cohort"] for p in units}, set(mod.COHORTS))
+
+    def test_only_whole_campaign_can_finalize(self):
+        mod = self.module()
+        units = mod.discover_units()
+        self.assertTrue(mod.is_full_campaign("all", units))
+        self.assertFalse(mod.is_full_campaign("all", units[:1]))
+        self.assertFalse(mod.is_full_campaign("score", units))
+
+    def test_scssemi_commands_do_not_reuse_larger_reference(self):
+        mod = self.module()
+        path = ROOT / "protocol/splits/immicro/healthy/fold0/n5/support.json"
+        argv = mod.scsemi_command(path, "prepare")
+        self.assertIn("--support-manifest", argv)
+        self.assertIn("--lean-hvset", argv)
+        self.assertNotIn("--reuse-from", argv)
+        self.assertIn("run_scsemi_strict.py", " ".join(argv))
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,159 @@
+import importlib.util
+from pathlib import Path
+import sys
+import unittest
+import json
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "tools"))
+
+
+class CompletionTests(unittest.TestCase):
+    def function(self):
+        path = ROOT / "tools/finalize_campaign.py"
+        self.assertTrue(path.exists(), "campaign finalizer not implemented")
+        spec = importlib.util.spec_from_file_location("campaign_finalizer", path)
+        mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(mod)
+        return mod.assert_publication_ready
+
+    def test_diagnostic_rare_panel_cannot_finish_manuscript(self):
+        with self.assertRaises(ValueError):
+            self.function()({"status": "complete"}, {"design": "legacy_5donor", "units": 20})
+
+    def test_pending_metrics_cannot_finish_manuscript(self):
+        with self.assertRaises(ValueError):
+            self.function()({"status": "pending"}, {"design": "strict5pair", "units": 20})
+
+    def test_all_five_figures_required_but_figure6_is_explicitly_waiting(self):
+        self.function()({"status": "complete"}, {"design": "strict5pair", "units": 20})
+
+
+if __name__ == "__main__":
+    unittest.main()
+
+
+def test_final_documents_run_only_after_strict_gates_and_target_final_outputs(tmp_path, monkeypatch):
+    import finalize_campaign as F
+    monkeypatch.setattr(F, "ROOT", tmp_path)
+    monkeypatch.setattr(F, "preserve_preview_outputs", lambda runtime, name, paths: {})
+    calls = []
+    class RuntimeFake:
+        def execute(self, name, argv, **kwargs):
+            calls.append((name, argv, kwargs))
+    runtime = RuntimeFake()
+    with pytest.raises(ValueError):
+        F.final_documents(runtime, {"status": "pending"}, {"design": "strict5pair", "units": 20})
+    assert calls == []
+    F.final_documents(runtime, {"status": "complete"}, {"design": "strict5pair", "units": 20})
+    assert [x[0] for x in calls] == ["render-final-review-deck", "assemble-verified-manuscript",
+                                     "compile-final-manuscript-pdfs", "convert-final-deck-pdf"]
+    assert calls[0][2]["outputs"][0] == tmp_path / "deck/paper_figures_final.pptx"
+    assert calls[2][2]["outputs"] == [tmp_path / "manuscript/main.pdf", tmp_path / "manuscript/supplementary.pdf"]
+    assert calls[3][2]["outputs"] == [tmp_path / "deck/paper_figures_final.pdf"]
+    assert "--require-complete" in calls[0][1] and "--require-complete" in calls[1][1]
+
+
+def test_cross_draw_requires_five_verified_draws_and_preserves_donor_dependence(tmp_path, monkeypatch):
+    import finalize_outputs as O
+    import score_strict as S
+    monkeypatch.setattr(O, "ROOT", tmp_path)
+    supports = []
+    for draw in range(5):
+        support = {"schema": "pbisc.paper.strict-support.v1", "cohort": "ji2025_chili",
+                   "design": "disease_existing_draw", "unit": f"draw{draw}_n5", "n_pairs": 5,
+                   "train_sample_ids": [f"tr{draw}{i}" for i in range(5)],
+                   "train_donor_ids": [f"td{draw}{i}" for i in range(5)],
+                   "test_sample_ids": ["sA", "sB"], "test_donor_ids": ["A", "B"],
+                   "excluded_sample_ids": []}
+        support["sha256"] = S.manifest_digest(support)
+        p = tmp_path / f"protocol/splits/ji2025_chili/disease/draw{draw}/support.json"
+        p.parent.mkdir(parents=True)
+        p.write_text(json.dumps(support))
+        table = tmp_path / f"scores/ji2025_chili/disease/draw{draw}/statistics/per_donor_long.csv"
+        table.parent.mkdir(parents=True)
+        table.write_text("draw,sample_id,donor_id,arm,metric,value\n")
+        (table.parent / "status.json").write_text(json.dumps({"support_sha256": support["sha256"],
+            "bootstrap_replicates": 2000, "disease_deg": {"status": "complete_with_not_estimable"}}))
+        (table.parents[1] / "scoring_support.json").write_text("{}\n")
+        (table.parents[1] / "score").mkdir()
+        (table.parents[1] / "score/summary.json").write_text("{}\n")
+        supports.append(support)
+    def verified(path, current, arms):
+        draw = path.parents[1].name
+        arms = ("lora", "pairedcal", "scsemi", "raw", "refcal")
+        records = [{"draw": f"{draw}_n5", "sample_id": sample, "donor_id": donor,
+                    "arm": arm, "metric": "comp_l1", "value": 0. if arm == "raw" else
+                    (1. if donor == "A" else 3.)}
+                   for sample, donor in (("sA","A"),("sB","B")) for arm in arms]
+        rows = O.pd.DataFrame(records)
+        rows.attrs["unit"] = f"{draw}_n5"
+        rows.attrs["support_sha256"] = supports[int(draw.replace('draw',''))]["sha256"]
+        return rows
+    monkeypatch.setattr(O, "validate_draw_long", verified)
+    with pytest.raises(ValueError, match="five"):
+        O.cohort_draw_ci("ji2025_chili", draws=(0,1,2,3))
+    table, receipt = O.cohort_draw_ci("ji2025_chili", draws=range(5))
+    row = table.loc[(table.arm == "lora") & (table.metric == "comp_l1")].iloc[0]
+    assert row.estimate == 2.0
+    assert row.n_donors == 2
+    assert receipt["draws"] == [f"draw{i}_n5" for i in range(5)]
+    pending = tmp_path / "scores/ji2025_chili/disease/draw3/statistics/status.json"
+    pending.write_text(json.dumps({"support_sha256": supports[3]["sha256"],
+                                   "bootstrap_replicates": 2000, "disease_deg": {"status": "partial_or_pending"}}))
+    with pytest.raises(ValueError, match="corrected donor DEG pending"):
+        O.cohort_draw_ci("ji2025_chili", draws=range(5))
+
+
+def test_frontmatter_refresh_accepts_only_approved_source_changes():
+    import assemble_manuscript as A
+    before = {"sections/abstract.tex": "old", "sections/introduction.tex": "i", "main.tex": "m",
+              "sections/methods_model.tex": "x"}
+    now = {**before, "sections/abstract.tex": "new"}
+    assert A.allowed_frontmatter_refresh(before, now) == {"sections/abstract.tex": {"previous_sha256": "old", "current_sha256": "new"}}
+    with pytest.raises(ValueError, match="outside approved frontmatter"):
+        A.allowed_frontmatter_refresh(before, {**now, "sections/methods_model.tex": "y"})
+    old_main = "\\title{Old}\n\\input{authors}\n"
+    new_main = "\\title{New}\n\\input{authors}\n"
+    A.allowed_frontmatter_refresh(before, {**before, "main.tex": "n"}, old_main=old_main, new_main=new_main)
+    with pytest.raises(ValueError, match="main.tex changed beyond"):
+        A.allowed_frontmatter_refresh(before, {**before, "main.tex": "n"}, old_main=old_main,
+                                      new_main="\\title{New}\n\\input{other}\n")
+
+
+def test_preview_is_preserved_with_runtime_previous_outputs_proof(tmp_path, monkeypatch):
+    import finalize_campaign as F
+    monkeypatch.setattr(F, "ROOT", tmp_path)
+    preview = tmp_path / "manuscript/main.pdf"
+    preview.parent.mkdir()
+    preview.write_bytes(b"%PDF-preview")
+    class RuntimeFake:
+        def receipt_path(self, name):
+            return tmp_path / "receipts" / f"{name}.json"
+    proof = F.preserve_preview_outputs(RuntimeFake(), "compile-final-manuscript-pdfs", [preview])
+    backup = Path(proof[str(preview)]["backup"])
+    assert backup.read_bytes() == preview.read_bytes()
+    assert proof[str(preview)]["backup"] == str(backup)
+    assert proof[str(preview)]["sha256"] == F.sha256(preview)
+
+
+def test_failed_supplement_compile_keeps_both_preview_pdfs(tmp_path, monkeypatch):
+    import finalize_outputs as O
+    import subprocess
+    monkeypatch.setattr(O, "ROOT", tmp_path)
+    monkeypatch.setattr(O, "_require_staged_manuscript", lambda: None)
+    stage = tmp_path / "manuscript"
+    stage.mkdir()
+    (stage / "main.pdf").write_bytes(b"main preview")
+    (stage / "supplementary.pdf").write_bytes(b"supp preview")
+    def fake_run(argv, **kwargs):
+        if "supplementary.tex" in argv:
+            raise subprocess.CalledProcessError(1, argv)
+        target = Path(argv[argv.index("--outdir") + 1]) / "main.pdf"
+        target.write_bytes(b"%PDF-" + b"x" * 1024)
+    monkeypatch.setattr(O.subprocess, "run", fake_run)
+    with pytest.raises(subprocess.CalledProcessError):
+        O.compile_manuscript_pdfs()
+    assert (stage / "main.pdf").read_bytes() == b"main preview"
+    assert (stage / "supplementary.pdf").read_bytes() == b"supp preview"

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

@@ -0,0 +1,254 @@
+"""Exact support and credential-boundary tests for deconvolution adapter."""
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import json
+import shutil
+import subprocess
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+SPEC = importlib.util.spec_from_file_location("deconv_strict", ROOT / "tools/deconv_strict.py")
+assert SPEC and SPEC.loader
+D = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(D)
+
+
+def manifest(tmp_path: Path, *, excluded_in_test: bool = False) -> Path:
+    data = {"schema": "pbisc.paper.strict-support.v1", "cohort": "ji2025_chili",
+            "design": "disease_existing_draw", "unit": "draw0_n5", "n_pairs": 5,
+            "train_sample_ids": [f"P{i}_BC" for i in range(5)],
+            "train_donor_ids": [f"P{i}" for i in range(5)],
+            "test_sample_ids": ["P5_AC", "P5_FU1", "P6_AC"],
+            "test_donor_ids": ["P5", "P5", "P6"],
+            "excluded_sample_ids": ["P0_AC"]}
+    if excluded_in_test:
+        data["test_sample_ids"][0] = "P0_AC"
+    data["sha256"] = hashlib.sha256(json.dumps(data, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
+    p = tmp_path / "support.json"
+    p.write_text(json.dumps(data))
+    return p
+
+
+def test_exact_five_samples_and_excluded_visits(tmp_path: Path) -> None:
+    s = D.validate_support_data(json.loads(manifest(tmp_path).read_text()))
+    split = D.strict_split(s)
+    assert split["reference"] == [f"P{i}_BC" for i in range(5)]
+    assert split["mixture"] == ["P5_AC", "P5_FU1", "P6_AC"]
+    assert split["excluded_samples"] == ["P0_AC"]
+    assert "P0_AC" not in split["reference"] + split["mixture"]
+    with pytest.raises(ValueError, match="excluded visits"):
+        D.validate_support_data(json.loads(manifest(tmp_path, excluded_in_test=True).read_text()))
+
+
+def test_output_isolation_and_binding(tmp_path: Path) -> None:
+    path = manifest(tmp_path)
+    s = D.validate_support_data(json.loads(path.read_text()))
+    out = D.unit_out(s, None)
+    assert out == ROOT / "deconvolution/ji2025_chili/disease/draw0"
+    with pytest.raises(ValueError, match="strict unit output"):
+        D.unit_out(s, tmp_path / "other")
+    with pytest.raises(ValueError, match="canonical protocol file"):
+        D.support(path)
+    hostile = dict(s, unit="../../../../../outside_n5")
+    hostile.pop("sha256")
+    hostile["sha256"] = hashlib.sha256(json.dumps(hostile, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
+    with pytest.raises(ValueError, match="canonical disease draw unit"):
+        D.unit_out(hostile, None)
+
+
+def test_method_output_rejects_extra_or_missing_mixture(tmp_path: Path) -> None:
+    s = D.validate_support_data(json.loads(manifest(tmp_path).read_text()))
+    bp = tmp_path / "inputs/ji2025_chili/fewshot0_full/bp"
+    bp.mkdir(parents=True)
+    (bp / "DONE").write_text("ok\n")
+    rows = s["test_sample_ids"] + ["P0_AC"]
+    pd.DataFrame({"T cell": [0.5] * len(rows)}, index=rows).to_csv(bp / "theta_final.csv")
+    with pytest.raises(ValueError, match="mixtures differ"):
+        D.method_output_hashes(s, tmp_path, "bayesprism")
+    pd.DataFrame({"T cell": [0.5] * len(s["test_sample_ids"])},
+                 index=s["test_sample_ids"]).to_csv(bp / "theta_final.csv")
+    (bp / "theta_first.csv").write_text("sample,T cell\n")
+    (bp / "Z_type_T_cell.tsv.gz").write_bytes(b"fixture")
+    hashes = D.method_output_hashes(s, tmp_path, "bayesprism")
+    assert str(bp / "theta_final.csv") in hashes
+
+
+def test_prepare_never_rewrites_existing_inputs_and_refuses_unreceipted_output(tmp_path: Path, monkeypatch) -> None:
+    s = D.validate_support_data(json.loads(manifest(tmp_path).read_text()))
+    out = tmp_path / "unit"
+    D.bind(s, out)
+    (out / "INPUTS.json").write_text('{"fixture":true}\n')
+    monkeypatch.setattr(D, "require_inputs", lambda *_a: {"verified": True})
+    assert D.prepare(s, out) == {"verified": True}
+    assert (out / "INPUTS.json").read_text() == '{"fixture":true}\n'
+    (out / "INPUTS.json").unlink()
+    bp = out / "inputs/ji2025_chili/fewshot0_full/bp"
+    bp.mkdir(parents=True)
+    (bp / "DONE").write_text("ok\n")
+    with pytest.raises(ValueError, match="refusing to rewrite inputs"):
+        D.prepare(s, out)
+
+
+def test_method_receipt_binds_prepared_inputs_and_outputs(tmp_path: Path, monkeypatch) -> None:
+    s = D.validate_support_data(json.loads(manifest(tmp_path).read_text()))
+    (tmp_path / "INPUTS.json").write_text('{"input":"v1"}\n')
+    monkeypatch.setattr(D, "require_inputs", lambda *_a: {})
+    bp = D.stage_dir(s, tmp_path, "bayesprism")
+    bp.mkdir(parents=True)
+    for name in ("DONE", "theta_final.csv", "theta_first.csv", "genes_used.txt", "Z_type_T_cell.tsv.gz"):
+        (bp / name).write_text("fixture\n")
+    with pytest.raises(ValueError, match="without a support/input-bound receipt"):
+        D.verify_stage_receipt(s, tmp_path, "bayesprism")
+    D.write_stage_receipt(s, tmp_path, "bayesprism")
+    assert D.verify_stage_receipt(s, tmp_path, "bayesprism")["support_sha256"] == s["sha256"]
+    (tmp_path / "INPUTS.json").write_text('{"input":"v2"}\n')
+    with pytest.raises(ValueError, match="receipt differs"):
+        D.verify_stage_receipt(s, tmp_path, "bayesprism")
+
+
+def test_partial_method_output_is_preserved_without_relaunch(tmp_path: Path, monkeypatch) -> None:
+    s = D.validate_support_data(json.loads(manifest(tmp_path).read_text()))
+    bp = D.stage_dir(s, tmp_path, "bayesprism")
+    bp.mkdir(parents=True)
+    (bp / "theta_final.csv").write_text("partial\n")
+    monkeypatch.setattr(D, "require_inputs", lambda *_a: {})
+    monkeypatch.setattr(D.subprocess, "run", lambda *_a, **_k: pytest.fail("method relaunched"))
+    with pytest.raises(ValueError, match="partial BayesPrism output"):
+        D.bayesprism(s, tmp_path, 2)
+    assert (bp / "theta_final.csv").read_text() == "partial\n"
+
+
+def test_missing_required_hires_type_is_an_error(tmp_path: Path) -> None:
+    s = D.support(ROOT / "protocol/splits/ye2026_sepsis/disease/draw0/support.json")
+    assert len(s["test_sample_ids"]) > 8
+    hd = D.stage_dir(s, tmp_path, "hires")
+    hd.mkdir(parents=True)
+    (hd / "CIBERSORTxHiRes_NA_Tcell_Window1.txt").write_text("fixture\n")
+    with pytest.raises(FileNotFoundError, match="required type output missing"):
+        D.stage_outputs(s, tmp_path, "hires")
+
+
+def test_pending_correction_takes_precedence_and_cli_returns_nonzero(monkeypatch, capsys) -> None:
+    methods = {name: {"status": "complete"} for name in ("bayesprism", "cibersortx")}
+    metrics = {"bayesprism": {"corrected_deg": {"status": "pending", "n_types_estimable": 2}},
+               "cibersortx": {"corrected_deg": {"status": "complete"}}}
+    status, reasons = D.score_readiness(methods, metrics)
+    assert status == "pending" and any("bayesprism" in r for r in reasons)
+    metrics["bayesprism"]["corrected_deg"]["status"] = "not_estimable"
+    assert D.score_readiness(methods, metrics) == ("complete", [])
+    path = ROOT / "protocol/splits/ji2025_chili/disease/draw0/support.json"
+    monkeypatch.setattr(D, "host_preflight", lambda: None)
+    monkeypatch.setattr(D, "score", lambda *_a: {"status": "pending", "methods": methods, "metrics": metrics})
+    assert D.main(["--support-manifest", str(path), "--action", "score"]) == 1
+    assert '"status": "pending"' in capsys.readouterr().out
+
+
+def test_pending_score_invalidates_prior_figure_mapping_without_losing_receipt(tmp_path: Path, monkeypatch) -> None:
+    s = D.validate_support_data(json.loads(manifest(tmp_path).read_text()))
+    monkeypatch.setattr(D, "PLAN", tmp_path)
+    path = tmp_path / "deconvolution/deconvolution_manifest.json"
+    path.parent.mkdir()
+    rel = "ji2025_chili/disease/draw0"
+    old = {"csv": "/prior/score.csv", "sha256": "old", "support_sha256": s["sha256"]}
+    path.write_text(json.dumps({"schema": "pbisc.fig4.deconvolution-sources.v1", "units": {rel: old}}))
+    D.invalidate_figure4(s, ["corrected DEG pending"])
+    changed = json.loads(path.read_text())
+    assert rel not in changed["units"]
+    assert changed["inactive_units"][rel]["previous"] == old
+
+
+def test_docker_host_argv_and_redacted_log_contain_no_credentials(tmp_path: Path, monkeypatch) -> None:
+    username, token = "private@example.org", "deadbeef" * 8
+    envfile = tmp_path / "env"
+    argv = D.cx_argv("cibersortx/fractions:latest", "CIBERSORTxFractions", tmp_path,
+                     tmp_path / "out", envfile, 2, ["--mixture", "mixture.txt"])
+    rendered = " ".join(argv)
+    assert username not in rendered and token not in rendered
+    assert '"$CX_USER"' in rendered and '"$CX_TOKEN"' in rendered
+
+    class FakeStdout:
+        def __iter__(self):
+            return iter([f">[Options] username: {username}\n", f">[Options] token: {token}\n",
+                         f"more {username} {token}\n"])
+
+    class FakeProcess:
+        stdout = FakeStdout()
+        def __enter__(self):
+            return self
+        def __exit__(self, *_args):
+            return False
+        def wait(self):
+            return 0
+
+    monkeypatch.setattr(D.subprocess, "Popen", lambda *_a, **_k: FakeProcess())
+    log = tmp_path / "run.log"
+    D.run_cx(argv, log, username, token)
+    saved = log.read_text()
+    assert username not in saved and token not in saved
+    assert saved.count("[REDACTED]") >= 4
+
+
+def test_real_supports_are_exact_and_donor_disjoint() -> None:
+    files = sorted((ROOT / "protocol/splits").glob("*/disease/draw*/support.json"))
+    assert len(files) == 20
+    for path in files:
+        s = D.support(path)
+        assert len(s["train_sample_ids"]) == len(s["train_donor_ids"]) == 5
+        assert not set(s["train_donor_ids"]) & set(s["test_donor_ids"])
+        assert not set(s["excluded_sample_ids"]) & set(s["test_sample_ids"])
+
+
+def test_repeated_visits_collapse_to_one_donor_condition() -> None:
+    s = {"test_donor_ids": ["A", "A", "B", "C"]}
+    case = np.array([True, True, False, False])
+    ctrl = ~case
+    profiles = np.array([[9., 1.], [1., 9.], [2., 8.], [7., 3.]])
+    meta, observed, method, bulk = D._collapse_donor_condition(s, case, ctrl,
+                                                                  profiles, profiles, profiles)
+    assert len(meta) == 3
+    assert meta.to_dict("records") == [
+        {"donor_id": "A", "condition": "case"},
+        {"donor_id": "B", "condition": "control"},
+        {"donor_id": "C", "condition": "control"}]
+    expected = D._log2_cpm(profiles[:2]).mean(axis=0)
+    np.testing.assert_allclose(observed[0], expected)
+    np.testing.assert_allclose(method, observed)
+    np.testing.assert_allclose(bulk, observed)
+
+
+@pytest.mark.skipif(shutil.which("Rscript") is None, reason="Rscript unavailable")
+def test_continuous_limma_fixture(tmp_path: Path) -> None:
+    probe = subprocess.run(["Rscript", "-e", 'quit(status=if (requireNamespace("limma", quietly=TRUE)) 0 else 1)'])
+    if probe.returncode:
+        pytest.skip("limma unavailable")
+    metadata = pd.DataFrame({"donor_id": [f"D{i}" for i in range(8)],
+                             "condition": ["control"] * 4 + ["case"] * 4})
+    metadata.to_csv(tmp_path / "metadata.csv", index=False)
+    genes = [f"G{i}" for i in range(8)]
+    observed = np.array([[1.0, 1.1, 0.9, 1.05, 4.0, 4.1, 3.9, 4.05],
+                         [2.0, 2.1, 1.9, 2.05, 5.0, 5.1, 4.9, 5.05],
+                         *([np.linspace(1.0, 2.0, 8)] * 6)])
+    for name, matrix in (("observed", observed), ("method", observed + 0.01)):
+        pd.DataFrame(matrix, index=genes).to_csv(tmp_path / f"{name}.tsv.gz", sep="\t")
+    script = tmp_path / "limma.R"
+    script.write_text(D.LIMMA_R)
+    subprocess.run(["Rscript", str(script), str(tmp_path / "metadata.csv"),
+                    str(tmp_path / "observed.tsv.gz"), str(tmp_path / "method.tsv.gz"), str(tmp_path / "out")],
+                   check=True, capture_output=True, text=True)
+    obs = pd.read_csv(tmp_path / "out/observed_limma.csv")
+    method = pd.read_csv(tmp_path / "out/method_limma.csv")
+    assert set(obs.gene_id) == set(method.gene_id) == set(genes)
+    assert float(obs.set_index("gene_id").loc["G0", "logFC"]) > 2.0
+    assert D._top50(obs) & D._top50(method)
+    metadata["donor_id"] = [f"D{i}" for i in range(4)] * 2
+    metadata.to_csv(tmp_path / "metadata.csv", index=False)
+    subprocess.run(["Rscript", str(script), str(tmp_path / "metadata.csv"),
+                    str(tmp_path / "observed.tsv.gz"), str(tmp_path / "method.tsv.gz"), str(tmp_path / "paired")],
+                   check=True, capture_output=True, text=True)
+    assert (tmp_path / "paired/method_limma.csv").is_file()