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_archive_completed.py

@@ -0,0 +1,56 @@
+"""Small negative controls for archive-only snapshot safety."""
+import importlib.util
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import patch
+
+SCRIPT = Path(__file__).resolve().parents[1] / 'tools/archive_completed.py'
+spec = importlib.util.spec_from_file_location('archive_completed', SCRIPT)
+archive = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(archive)
+
+
+class ArchiveSnapshotTests(unittest.TestCase):
+    def test_live_operation_is_not_labeled_planned(self):
+        with tempfile.TemporaryDirectory() as temp:
+            root = Path(temp)
+            (root / 'receipts').mkdir()
+            (root / 'receipts/global-sepsis-raw.json').write_text('{"state":"running"}')
+            with patch.object(archive, 'PLAN', root):
+                self.assertEqual(archive.operation_state('global-sepsis-raw'), 'running')
+                self.assertEqual(archive.operation_state('missing'), 'planned')
+
+    def test_symlink_payload_is_refused(self):
+        with tempfile.TemporaryDirectory() as temp:
+            root = Path(temp)
+            source = root / 'source.txt'
+            source.write_text('private scientific metadata')
+            alias = root / 'alias.txt'
+            alias.symlink_to(source)
+            with self.assertRaisesRegex(ValueError, 'symlink refused'):
+                archive.stable_hash(alias)
+
+    def test_hash_rejects_changed_source(self):
+        with tempfile.TemporaryDirectory() as temp:
+            source = Path(temp) / 'source.txt'
+            source.write_text('old')
+            def changing_hash(path):
+                path.write_text('changed after read')
+                return '0' * 64
+            with patch.object(archive, 'sha', changing_hash):
+                with self.assertRaisesRegex(RuntimeError, 'changed during hash'):
+                    archive.stable_hash(source)
+
+    def test_partial_finalization_cannot_be_archived_as_complete(self):
+        with patch.object(archive, 'json_load', return_value={'stage': 'render', 'state': 'completed'}):
+            with self.assertRaisesRegex(ValueError, 'all-stage'):
+                archive.completion_gate()
+
+    def test_invalid_identifier_does_not_create_snapshot(self):
+        with self.assertRaisesRegex(ValueError, 'invalid update'):
+            archive.build('../escape', 'in-progress')
+
+
+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_score_strict.py

@@ -0,0 +1,260 @@
+"""The strict adapter must bind scored samples and isolate every output tree."""
+import importlib.util
+import json
+import shutil
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pytest
+
+
+PATH = Path(__file__).resolve().parents[1] / "tools/score_strict.py"
+spec = importlib.util.spec_from_file_location("score_strict", PATH)
+adapter = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(adapter)
+
+
+def test_manifest_test_samples_are_scoring_samples(tmp_path):
+    data = {"schema": "pbisc.paper.strict-support.v1", "cohort": "giroux2022",
+            "unit": "draw0_n5", "n_pairs": 1, "test_sample_ids": ["p1_d0", "p1_d7", "p2_d0"],
+            "test_donor_ids": ["p1", "p1", "p2"],
+            "train_sample_ids": ["t1_d0"], "train_donor_ids": ["t1"],
+            "excluded_sample_ids": ["t1_d7"]}
+    data["sha256"] = adapter.manifest_digest(data)
+    p = tmp_path / "support.json"
+    p.write_text(json.dumps(data))
+    got = adapter.read_support(p)
+    assert got["test_sample_ids"] == ["p1_d0", "p1_d7", "p2_d0"]
+    assert adapter.patient_mapping(got).to_dict("records") == [
+        {"sample_id": "p1_d0", "donor_id": "p1"},
+        {"sample_id": "p1_d7", "donor_id": "p1"},
+        {"sample_id": "p2_d0", "donor_id": "p2"}]
+
+
+def test_bad_identity_and_legacy_output_path_fail_closed(tmp_path):
+    data = {"schema": "pbisc.paper.strict-support.v1", "cohort": "immicro",
+            "unit": "fold0_n5", "n_pairs": 1, "test_sample_ids": ["x"], "test_donor_ids": ["A"],
+            "train_sample_ids": ["y"], "train_donor_ids": ["A"], "excluded_sample_ids": []}
+    data["sha256"] = adapter.manifest_digest(data)
+    p = tmp_path / "support.json"
+    p.write_text(json.dumps(data))
+    with pytest.raises(ValueError, match="train/test donor overlap"):
+        adapter.read_support(p)
+    with pytest.raises(ValueError, match="strict-pairs plan"):
+        adapter.safe_out(adapter.LEGACY / "scores/new_run")
+    with pytest.raises(ValueError, match="dedicated result"):
+        adapter.safe_out(adapter.PLAN / "tools")
+
+
+def test_route_scored_extras_to_new_root():
+    out = adapter.PLAN / "scores" / "fixture"
+    assert adapter.extra_root(out) == out / "extras"
+    assert adapter.contrast_root(out) == out / "contrast"
+
+
+def test_score_reuse_requires_exact_support_hash(tmp_path):
+    score = tmp_path / "score"
+    score.mkdir()
+    (score / "summary.json").write_text(json.dumps({"dataset": "immicro", "donors": ["s1"], "arms": ["a"]}))
+    (tmp_path / "scoring_support.json").write_text(json.dumps({"support_sha256": "old"}))
+    with pytest.raises(ValueError, match="support hash"):
+        adapter._existing_score(score, {"cohort": "immicro", "test_sample_ids": ["s1"], "sha256": "new"}, ["a"])
+
+
+def test_score_reuse_rejects_unbound_arm_even_when_test_samples_match(tmp_path):
+    score = tmp_path / "score"
+    score.mkdir()
+    (score / "summary.json").write_text(json.dumps({"dataset": "immicro", "donors": ["s1"],
+                                                    "arms": ["a"], "per_arm": {"a": {"npz": "/x", "npz_sha256": "h"}}}))
+    (tmp_path / "scoring_support.json").write_text(json.dumps({"support_sha256": "strict"}))
+    with pytest.raises(ValueError, match="generation binding"):
+        adapter._existing_score(score, {"cohort": "immicro", "test_sample_ids": ["s1"], "sha256": "strict"}, ["a"])
+
+
+def test_pending_corrected_deg_fails_stats_action():
+    with pytest.raises(ValueError, match="donor-aware DEG pending"):
+        adapter.require_corrected_deg({"status": "partial_or_pending"})
+    adapter.require_corrected_deg({"status": "ok"})
+    adapter.require_corrected_deg({"status": "complete_with_not_estimable", "n_not_estimable": 1})
+
+
+def test_observed_is_reserved_side_name():
+    with pytest.raises(ValueError, match="reserved"):
+        adapter._arms(["observed=/tmp/a.npz"])
+
+
+def test_manifest_cannot_claim_five_pairs_with_six_fit_rows(tmp_path):
+    data = {"schema": "pbisc.paper.strict-support.v1", "cohort": "immicro", "unit": "fold0_n5",
+            "n_pairs": 5, "train_sample_ids": [f"fit{i}" for i in range(6)],
+            "train_donor_ids": [f"p{i}" for i in range(6)],
+            "test_sample_ids": ["held"], "test_donor_ids": ["test"], "excluded_sample_ids": []}
+    data["sha256"] = adapter.manifest_digest(data)
+    p = tmp_path / "support.json"
+    p.write_text(json.dumps(data))
+    with pytest.raises(ValueError, match="n_pairs"):
+        adapter.read_support(p)
+
+
+def test_old_ten_pair_run_cannot_be_relabelled_with_same_heldout_samples():
+    support = {"sha256": "strict5", "train_sample_ids": [f"fit{i}" for i in range(5)],
+               "train_donor_ids": [f"p{i}" for i in range(5)],
+               "test_sample_ids": ["held1", "held2"], "excluded_sample_ids": [],
+               "n_pairs": 5}
+    run = {"support_sha256": "strict5", "train_rows": [f"fit{i}" for i in range(10)],
+           "train_donor_ids": [f"p{i}" for i in range(10)],
+           "test_rows_never_loaded_for_training": ["held1", "held2"],
+           "inner_val_rows": [], "fixed_steps": 3000, "steps_run": 3000,
+           "selected_step": 3000, "mode": "lora", "trainable": {"lora_rank": 16},
+           "source_checkpoint_sha256": adapter.BASE_SHA,
+           "checkpoint_sha256": "a"*64}
+    with pytest.raises(ValueError, match="train_rows"):
+        adapter.validate_lora_run(run, support)
+
+
+def test_current_pilot_lora_run_matches_strict_support_without_running_score():
+    support_path = adapter.PLAN / "protocol/splits/immicro/healthy/fold0/n5/support.json"
+    support = adapter.read_support(support_path)
+    run_path = adapter.PLAN / "runs/immicro/healthy/fold0/n5/lora/RUN.json"
+    adapter.validate_lora_run(json.loads(run_path.read_text()), support)
+
+
+def test_pilot_lora_and_pairedcal_generation_bindings_are_source_bound():
+    support = adapter.read_support(adapter.PLAN / "protocol/splits/immicro/healthy/fold0/n5/support.json")
+    root = adapter.PLAN / "generated/immicro/healthy/fold0/n5"
+    lora = adapter.validate_generation_arm("lora", root / "lora.npz", support)
+    paired = adapter.validate_generation_arm("pairedcal", root / "pairedcal.npz", support)
+    assert lora["support_sha256"] == paired["support_sha256"] == support["sha256"]
+    assert lora["condition_sha256"] != paired["condition_sha256"]
+    assert lora["checkpoint_sha256"] != paired["checkpoint_sha256"]
+
+
+def test_legacy_generated_path_is_rejected_even_with_same_test_ids():
+    support = adapter.read_support(adapter.PLAN / "protocol/splits/giroux2022/disease/draw0/support.json")
+    old = adapter.LEGACY / "generated/giroux2022/fewshot_n5/draw0/lora__raw.npz"
+    with pytest.raises(ValueError, match="canonical strict arm path"):
+        adapter.validate_generation_arm("lora", old, support)
+
+
+def test_global_build_rejects_changed_reference_input(tmp_path):
+    source = tmp_path / "reference.txt"
+    source.write_text("changed")
+    with pytest.raises(ValueError, match="global BUILD input"):
+        adapter.validate_global_build_inputs({"input_hashes": {str(source): "0"*64}})
+
+
+def test_draw_long_requires_canonical_same_cohort_bound_distinct_draw(tmp_path, monkeypatch):
+    monkeypatch.setattr(adapter, "PLAN", tmp_path)
+    def support(draw):
+        obj = {"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"train{draw}_{i}" for i in range(5)],
+               "train_donor_ids": [f"tp{draw}_{i}" for i in range(5)],
+               "test_sample_ids": [f"test{draw}_a", f"test{draw}_b"],
+               "test_donor_ids": ["A", "B"], "excluded_sample_ids": []}
+        obj["sha256"] = adapter.manifest_digest(obj)
+        return obj
+    current, other = support(0), support(1)
+    source = tmp_path / "protocol/splits/ji2025_chili/disease/draw1/support.json"
+    source.parent.mkdir(parents=True)
+    source.write_text(json.dumps(other))
+    base = tmp_path / "scores/ji2025_chili/disease/draw1"
+    (base / "score").mkdir(parents=True)
+    (base / "statistics").mkdir()
+    arm_source = {"npz": "/strict/lora.npz", "npz_sha256": "validhash", "support_sha256": other["sha256"]}
+    (base / "scoring_support.json").write_text(json.dumps({"schema": "pbisc.paper.strict-score-binding.v1",
+        "support_sha256": other["sha256"],
+        "cohort": other["cohort"], "unit": other["unit"],
+        "test_sample_ids": other["test_sample_ids"], "test_donor_ids": other["test_donor_ids"],
+        "arm_bindings": {"lora": arm_source}}))
+    (base / "score/summary.json").write_text(json.dumps({"dataset": other["cohort"],
+        "donors": other["test_sample_ids"], "arms": ["lora"],
+        "per_arm": {"lora": {"npz": arm_source["npz"], "npz_sha256": arm_source["npz_sha256"]}}}))
+    pd.DataFrame({"donor": other["test_sample_ids"], "arm": ["lora"]*2,
+                  "comp_l1": [0.2, 0.3]}).to_csv(base / "score/per_donor.csv", index=False)
+    table = base / "statistics/per_donor_long.csv"
+    pd.DataFrame({"draw": [other["unit"]]*2, "sample_id": other["test_sample_ids"],
+                  "donor_id": other["test_donor_ids"], "arm": ["lora"]*2,
+                  "metric": ["comp_l1"]*2, "value": [0.2, 0.3]}).to_csv(table, index=False)
+    monkeypatch.setattr(adapter, "validate_generation_arm", lambda name, path, manifest: arm_source)
+    assert len(adapter.validate_draw_long(table, current, ["lora"])) == 2
+    monkeypatch.setattr(adapter, "validate_generation_arm", lambda name, path, manifest:
+                        {**arm_source, "npz_sha256": "different"})
+    with pytest.raises(ValueError, match="provenance"):
+        adapter.validate_draw_long(table, current, ["lora"])
+    monkeypatch.setattr(adapter, "validate_generation_arm", lambda name, path, manifest: arm_source)
+    changed = pd.read_csv(table)
+    changed.loc[0, "value"] = 999
+    changed.to_csv(table, index=False)
+    with pytest.raises(ValueError, match="scored metrics"):
+        adapter.validate_draw_long(table, current, ["lora"])
+    changed.loc[0, "value"] = 0.2
+    changed.to_csv(table, index=False)
+    with pytest.raises(ValueError, match="canonical"):
+        adapter.validate_draw_long(tmp_path / "source_data/arbitrary.csv", current, ["lora"])
+    with pytest.raises(ValueError, match="cohort"):
+        adapter.validate_draw_long(table, {**current, "cohort": "giroux2022"}, ["lora"])
+    with pytest.raises(ValueError, match="arms"):
+        adapter.validate_draw_long(table, current, ["lora", "pairedcal"])
+    with pytest.raises(ValueError, match="distinct"):
+        adapter.validate_draw_long(table, {**current, "unit": other["unit"]}, ["lora"])
+    (base / "scoring_support.json").unlink()
+    with pytest.raises(ValueError, match="binding"):
+        adapter.validate_draw_long(table, current, ["lora"])
+
+
+def test_draw_long_list_rejects_same_other_draw_twice(monkeypatch):
+    rows = pd.DataFrame({"draw": ["draw1_n5"], "sample_id": ["s"], "donor_id": ["p"],
+                         "arm": ["lora"], "metric": ["comp_l1"], "value": [0.2]})
+    rows.attrs["unit"] = "draw1_n5"
+    monkeypatch.setattr(adapter, "validate_draw_long", lambda path, support, arms: rows)
+    with pytest.raises(ValueError, match="duplicate draw"):
+        adapter.validate_draw_longs([Path("a"), Path("a")], {"unit": "draw0_n5"}, ["lora"])
+
+
+def test_automatic_deg_uses_scored_readout_and_patient_block(tmp_path, monkeypatch):
+    if not shutil.which("Rscript"):
+        pytest.skip("Rscript unavailable")
+    F = adapter._legacy_module("ft_common")
+    ids = np.array(["A_c", "A_t", "B_c", "B_t", "C_c", "D_t"])
+    patient = np.array(["A", "A", "B", "B", "C", "D"])
+    condition = np.array(["BC", "TOL", "BC", "TOL", "BC", "TOL"])
+    genes = np.array([f"g{i}" for i in range(20)])
+    observed = np.array([[(i+3)*(2 if c == "TOL" else 1)+(i%3) for i in range(20)]
+                         for c in condition], dtype=float)
+    ref = {"donors": ids, "panel_ids": genes, "score_ids": genes, "score_idx": np.arange(20)}
+    man = {"reference_sha256": "fixture-reference"}
+    deg = {"types": ("T cell",), "n": np.ones((6, 1), dtype=int), "sum": observed[:, None, :]}
+    monkeypatch.setattr(F, "load_reference", lambda cache: (ref, man))
+    monkeypatch.setattr(F, "load_deg_reference", lambda cache, manifest, reference: deg)
+    npz = tmp_path / "generated.npz"
+    np.savez(npz, gene_ids=genes, sample_ids=ids, bulk_index=np.arange(6),
+             generated_counts=observed.astype(np.float32), metadata_json="{}")
+    scored_cells = tmp_path / "score/arms/model"
+    scored_cells.mkdir(parents=True)
+    pd.DataFrame({"npz_row": np.arange(6), "donor": ids, "label": "T cell"}).to_parquet(
+        scored_cells / "generated_cells.parquet", index=False)
+    summary = {"reference": {"cache": str(tmp_path), "reference_sha256": "fixture-reference"},
+               "donors": ids.tolist(), "contrast_definition": {"groups": condition.tolist(),
+               "case_groups": ["TOL"], "control_groups": ["BC"]}, "arms": ["model"],
+               "per_arm": {"model": {"npz": str(npz), "npz_sha256": F.sha(npz)}}}
+    support = {"cohort": "ji2025_chili", "test_sample_ids": ids.tolist(),
+               "test_donor_ids": patient.tolist()}
+    result = adapter._automatic_deg(support, tmp_path, summary, 1)
+    assert result["status"] == "ok"
+    row = pd.read_csv(tmp_path / "statistics/donor_deg/donor_deg_summary.csv").iloc[0]
+    assert row.status == "ok"
+    assert row.method_observed.endswith("duplicateCorrelation")
+    assert row.n_case_donors_observed == 3
+    assert row.n_control_donors_observed == 3
+    absent = tmp_path / "absent_type"
+    cells2 = absent / "score/arms/model"
+    cells2.mkdir(parents=True)
+    pd.DataFrame({"npz_row": np.arange(6), "donor": ids, "label": "Other"}).to_parquet(
+        cells2 / "generated_cells.parquet", index=False)
+    missing = adapter._automatic_deg(support, absent, summary, 1)
+    row = pd.read_csv(absent / "statistics/donor_deg/donor_deg_summary.csv").iloc[0]
+    assert missing["status"] == "complete_with_not_estimable"
+    assert row.status == "not_estimable"
+    assert row.generated_status == "no_population"
+    assert pd.isna(row.top50_overlap_count) if "top50_overlap_count" in row else True

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_scsemi_export_strict.py

@@ -0,0 +1,51 @@
+import importlib.util
+import os
+from pathlib import Path
+import sys
+import unittest
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "tools"))
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+
+
+class ExportTests(unittest.TestCase):
+    def function(self):
+        path = ROOT / "tools/export_scsemi_strict.py"
+        self.assertTrue(path.exists(), "strict exporter not implemented")
+        spec = importlib.util.spec_from_file_location("strict_export", path)
+        mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(mod)
+        return mod.strict_arm_metadata
+
+    def fixture(self):
+        support = {"cohort": "immicro", "unit": "fold0_n5", "sha256": "bound",
+                   "n_pairs": 5, "train_sample_ids": [f"s{i}" for i in range(5)],
+                   "train_donor_ids": [f"d{i}" for i in range(5)], "test_sample_ids": ["test"]}
+        man = {"mode": "strict", "dataset": "immicro", "support_sha256": "bound",
+               "representatives": [{"sample_id": s} for s in support["train_sample_ids"]],
+               "train_donors": support["train_donor_ids"], "target_order_test_samples": ["test"]}
+        return support, man
+
+    def test_strict_mode_exports_bound_canonical_arm(self):
+        support, man = self.fixture()
+        result = self.function()(man, support)
+        self.assertEqual(result["arm"], "scsemi")
+        self.assertEqual(result["support_sha256"], "bound")
+        self.assertEqual(result["n_pairs"], 5)
+
+    def test_extra_representative_rejected(self):
+        support, man = self.fixture()
+        man["representatives"].append({"sample_id": "extra_visit"})
+        with self.assertRaises(ValueError):
+            self.function()(man, support)
+
+    def test_legacy_mode_cannot_be_exported_as_strict(self):
+        support, man = self.fixture()
+        man["mode"] = "fewshot"
+        with self.assertRaises(ValueError):
+            self.function()(man, support)
+
+
+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_support_manifest.py

@@ -0,0 +1,223 @@
+"""Contract tests for exact paired support (CPU only)."""
+import copy
+import hashlib
+import importlib.util
+import json
+import os
+from pathlib import Path
+
+import pandas as pd
+import pytest
+
+
+ROOT = Path(__file__).resolve().parents[1]
+spec = importlib.util.spec_from_file_location("support_manifest", ROOT / "tools/support_manifest.py")
+support = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(support)
+
+
+@pytest.fixture
+def folds():
+    return pd.DataFrame([
+        ("a0", "a", "case", 0), ("a1", "a", "case", 0),
+        ("b0", "b", "case", 1), ("c0", "c", "case", 1),
+        ("d0", "d", "control", 2), ("e0", "e", "control", 2),
+        ("f0", "f", "case", 3), ("g0", "g", "control", 4),
+        ("bad", "z", "case", -1),
+    ], columns=["sample_id", "donor_id", "group", "fold"])
+
+
+def test_healthy_deterministic_nested_exact_budget(folds):
+    small = support.build_healthy(folds, 0, 2, seed=20261012)
+    large = support.build_healthy(folds, 0, 4, seed=20261012)
+    assert small == support.build_healthy(folds, 0, 2, seed=20261012)
+    assert len(small["train_sample_ids"]) == len(small["train_donor_ids"]) == 2
+    assert set(small["train_sample_ids"]) <= set(large["train_sample_ids"])
+    assert "a0" in small["test_sample_ids"] and "a1" in small["test_sample_ids"]
+    assert "bad" not in small["test_sample_ids"]
+
+
+def test_rejects_duplicate_donor_and_test_leakage(folds):
+    m = support.build_healthy(folds, 0, 2, seed=3)
+    m["train_sample_ids"].append(m["train_sample_ids"][0])
+    with pytest.raises(ValueError): support.validate_manifest(m, folds)
+    m = support.build_healthy(folds, 0, 2, seed=3)
+    m["test_sample_ids"].append(m["train_sample_ids"][0])
+    with pytest.raises(ValueError): support.validate_manifest(m, folds)
+
+
+def test_rejects_malicious_sample_donor_mismatch_and_hash(folds):
+    m = support.build_healthy(folds, 0, 2, seed=3)
+    m["train_donor_ids"][0] = "a"
+    with pytest.raises(ValueError): support.validate_manifest(m, folds)
+    m = support.build_healthy(folds, 0, 2, seed=3)
+    m["train_sample_ids"].reverse()
+    with pytest.raises(ValueError): support.validate_manifest(m, folds)
+
+
+def test_disease_earliest_same_stratum_and_excludes_other_visits(folds):
+    pairs = pd.DataFrame([
+        ("a0", 14, True), ("a1", 0, True),
+        ("b0", 1, True), ("c0", 0, True), ("d0", 0, True), ("e0", 0, True),
+    ], columns=["sample_id", "timepoint", "identity_pass"])
+    m = support.build_disease(folds, pairs, ["a", "b", "c", "d", "e"], "toy", 0)
+    assert m["train_sample_ids"][:2] == ["a1", "b0"]
+    assert "a0" in m["excluded_sample_ids"]
+    assert "a0" not in m["test_sample_ids"]
+    assert m["selection_audit"][0]["candidates"][0]["sample_id"] == "a1"
+    support.validate_manifest(m, folds)
+
+
+def test_disease_requires_stratum_match_and_parseable_time(folds):
+    pairs = pd.DataFrame([("a0", "nonsense", True), ("a1", "nonsense", True),
+                          ("b0", 0, True), ("c0", 0, True), ("d0", 0, True), ("e0", 0, True)],
+                         columns=["sample_id", "timepoint", "identity_pass"])
+    with pytest.raises(ValueError): support.build_disease(folds, pairs, ["a", "b", "c", "d", "e"], "toy", 0)
+    with pytest.raises(ValueError): support.build_disease(folds, pairs, ["a", "b"], "toy", 0)
+
+
+def test_disease_rejects_missing_identity_or_mismatched_pair_metadata(folds):
+    pairs = pd.DataFrame([("a0", "a", "case", 0, None), ("a1", "a", "case", 1, False),
+                          ("b0", "b", "case", 0, True), ("c0", "c", "case", 0, True),
+                          ("d0", "d", "control", 0, True), ("e0", "e", "control", 0, True)],
+                         columns=["sample_id", "donor_id", "group", "timepoint", "identity_pass"])
+    with pytest.raises(ValueError):
+        support.build_disease(folds, pairs, ["a", "b", "c", "d", "e"], "toy", 0)
+    pairs.loc[pairs.sample_id == "a0", "identity_pass"] = True
+    pairs.loc[pairs.sample_id == "a0", "donor_id"] = "b"
+    with pytest.raises(ValueError):
+        support.build_disease(folds, pairs, ["a", "b", "c", "d", "e"], "toy", 0)
+
+
+def test_imperial_dates_share_one_calendar_axis(folds):
+    f = folds.copy()
+    f.loc[f.donor_id == "a", "group"] = "covid_positive"
+    pairs = pd.DataFrame([
+        ("a0", 1.0, "25/02/2021", True), ("a1", None, "30/04/2020", True),
+        ("b0", 1.0, "01/01/2021", True), ("c0", 1.0, "01/01/2021", True),
+        ("d0", 1.0, "01/01/2021", True), ("e0", 1.0, "01/01/2021", True),
+    ], columns=["sample_id", "timepoint", "sample_date", "identity_pass"])
+    m = support.build_disease(f, pairs, ["a", "b", "c", "d", "e"], "imperial_eskd", 4)
+    assert m["train_sample_ids"][0] == "a1"
+    assert {c["time_field"] for c in m["selection_audit"][0]["candidates"]} == {"sample_date"}
+
+
+def test_exclusion_includes_identity_failed_other_visit(folds):
+    f = folds.copy()
+    f.loc[f.sample_id == "bad", "donor_id"] = "a"
+    pairs = pd.DataFrame([("a0", 14, True), ("a1", 0, True),
+                          ("b0", 0, True), ("c0", 0, True),
+                          ("d0", 0, True), ("e0", 0, True)],
+                         columns=["sample_id", "timepoint", "identity_pass"])
+    m = support.build_disease(f, pairs, ["a", "b", "c", "d", "e"], "toy", 0)
+    assert set(m["excluded_sample_ids"]) == {"a0", "bad"}
+    support.validate_manifest(m, f)
+
+
+def test_immutable_write(tmp_path, folds):
+    m = support.build_healthy(folds, 0, 2, seed=3)
+    p = tmp_path / "SUPPORT.json"
+    support.write_manifest(p, m)
+    assert support.load_manifest(p, folds) == m
+    with pytest.raises(FileExistsError): support.write_manifest(p, copy.deepcopy(m))
+
+
+def test_selector_never_reads_inner_validation_or_other_visits(folds):
+    pairs = pd.DataFrame([("a0", 14, True), ("a1", 0, True), ("b0", 1, True),
+                          ("c0", 0, True), ("d0", 0, True), ("e0", 0, True)],
+                         columns=["sample_id", "timepoint", "identity_pass"])
+    m = support.build_disease(folds, pairs, ["a", "b", "c", "d", "e"], "toy", 0)
+    train, test = support.select_rows(m, folds)
+    assert folds.loc[train, "sample_id"].tolist()[:2] == ["a1", "b0"]
+    assert "a0" not in folds.loc[test, "sample_id"].tolist()
+
+
+def test_rejects_missing_and_empty_ids(folds):
+    broken = folds.copy()
+    broken.loc[0, "sample_id"] = None
+    with pytest.raises(ValueError): support.build_healthy(broken, 0, 2, seed=3)
+    broken.loc[0, "sample_id"] = "  "
+    with pytest.raises(ValueError): support.build_healthy(broken, 0, 2, seed=3)
+
+
+def test_rejects_stale_existing_trainer_run(folds):
+    m = support.build_healthy(folds, 0, 2, seed=3)
+    run = {"support_sha256": m["sha256"], "train_rows": m["train_sample_ids"],
+           "train_donor_ids": m["train_donor_ids"],
+           "test_rows_never_loaded_for_training": m["test_sample_ids"],
+           "inner_val_rows": [], "fixed_steps": 3000, "steps_run": 3000,
+           "selected_step": 3000, "mode": "lora", "trainable": {"lora_rank": 16},
+           "source_checkpoint_sha256": "sourcehash"}
+    run.update(condition_npz_sha256="conditionhash", lr=1e-4, warmup=200, batch_size=256,
+               ema_decay=0.999, seed=123)
+    run["trainable"]["lora_alpha"] = 16.0
+    support.validate_existing_run(m, run, fixed_steps=3000, lora_rank=16,
+                                  source_checkpoint_sha256="sourcehash", condition_npz_sha256="conditionhash",
+                                  lr=1e-4, lora_alpha=16.0, warmup=200, batch_size=256,
+                                  ema_decay=0.999, seed=123)
+    for key, val in (("support_sha256", "wrong"), ("train_rows", []),
+                     ("fixed_steps", 2000), ("steps_run", 2000),
+                     ("source_checkpoint_sha256", "wrong"), ("condition_npz_sha256", "wrong"),
+                     ("lr", 1e-3), ("warmup", 100), ("batch_size", 128),
+                     ("ema_decay", 0.9), ("seed", 234)):
+        bad = copy.deepcopy(run)
+        bad[key] = val
+        with pytest.raises(ValueError):
+            support.validate_existing_run(m, bad, fixed_steps=3000, lora_rank=16,
+                                          source_checkpoint_sha256="sourcehash", condition_npz_sha256="conditionhash",
+                                          lr=1e-4, lora_alpha=16.0, warmup=200, batch_size=256,
+                                          ema_decay=0.999, seed=123)
+    bad = copy.deepcopy(run)
+    bad["trainable"]["lora_alpha"] = 8.0
+    with pytest.raises(ValueError):
+        support.validate_existing_run(m, bad, fixed_steps=3000, lora_rank=16,
+                                      source_checkpoint_sha256="sourcehash", condition_npz_sha256="conditionhash",
+                                      lr=1e-4, lora_alpha=16.0, warmup=200, batch_size=256,
+                                      ema_decay=0.999, seed=123)
+
+
+def test_scsemi_opt_in_keeps_legacy_fewshot_behavior(monkeypatch):
+    monkeypatch.setenv("CUDA_VISIBLE_DEVICES", "")
+    old = ROOT.parent / "paired_finetune_intradataset_20260927"
+    source = old / "scsemi/tools/prepare_draw_inputs.py"
+    module_spec = importlib.util.spec_from_file_location("strict_scsemi_inputs", source)
+    module = importlib.util.module_from_spec(module_spec)
+    module_spec.loader.exec_module(module)
+    ds = old / "data/giroux2022"
+    f = pd.read_csv(ds / "folds.csv", dtype={"sample_id": str, "donor_id": str})
+    ids = f.sample_id.to_numpy(str)
+    legacy = module.split_rows("giroux2022", "fewshot", 0, ids, f)
+    support_path = ROOT / "protocol/splits/giroux2022/disease/draw0/support.json"
+    strict = module.split_rows("giroux2022", "strict", 0, ids, f, support_manifest=support_path)
+    assert len(strict["rep"]) == 5
+    assert len(legacy["rep"]) > len(strict["rep"])
+    assert [ids[i] for i in strict["rep"]] == support.load_manifest(support_path, f)["train_sample_ids"]
+    assert strict["support_sha256"] == support.load_manifest(support_path, f)["sha256"]
+    assert legacy["condition"].name == "test_raw.npz"
+
+
+def test_scsemi_strict_wrapper_validates_support_and_legacy_runner_is_unchanged(tmp_path):
+    wrapper_path = ROOT / "tools/run_scsemi_strict.py"
+    wrapper_spec = importlib.util.spec_from_file_location("scsemi_strict_wrapper", wrapper_path)
+    wrapper = importlib.util.module_from_spec(wrapper_spec)
+    wrapper_spec.loader.exec_module(wrapper)
+    old = ROOT.parent / "paired_finetune_intradataset_20260927"
+    original = ROOT / "backups/plans/paired_finetune_intradataset_20260927/scsemi/tools/run_scsemi_paired.py"
+    assert hashlib.sha256((old / "scsemi/tools/run_scsemi_paired.py").read_bytes()).digest() == \
+           hashlib.sha256(original.read_bytes()).digest()
+    path = ROOT / "protocol/splits/giroux2022/disease/draw0/support.json"
+    f = pd.read_csv(old / "data/giroux2022/folds.csv", dtype={"sample_id": str, "donor_id": str})
+    m = support.load_manifest(path, f)
+    inp = tmp_path / "inputs"
+    inp.mkdir()
+    man = {"mode": "strict", "dataset": "giroux2022", "support_sha256": m["sha256"],
+           "representatives": [{"sample_id": s} for s in m["train_sample_ids"]],
+           "targets": m["test_sample_ids"], "train_donors": m["train_donor_ids"],
+           "sources": {"support.json": hashlib.sha256(path.read_bytes()).hexdigest()}}
+    (inp / "inputs_manifest.json").write_text(json.dumps(man))
+    wrapper.validate_strict_inputs(path, tmp_path, phase="prepare", reuse_from=None)
+    with pytest.raises(ValueError): wrapper.validate_strict_inputs(path, tmp_path, phase="prepare", reuse_from=tmp_path)
+    with pytest.raises(ValueError): wrapper.validate_strict_inputs(path, tmp_path, phase="link", reuse_from=None)
+    man["representatives"][0]["sample_id"] = "wrong"
+    (inp / "inputs_manifest.json").write_text(json.dumps(man))
+    with pytest.raises(ValueError): wrapper.validate_strict_inputs(path, tmp_path, phase="pretrain", reuse_from=None)