Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261012T143729Z-strictpairs-recovery-two-host/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/4/test_campaign.py

@@ -0,0 +1,73 @@
+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))
+        self.assertFalse(mod.is_full_campaign("compute", units))
+
+    def test_disjoint_host_selection_preserves_canonical_order(self):
+        mod = self.module()
+        units = mod.discover_units()
+        names = [mod.name(p) for p in units if "fold2" in str(p)]
+        selected = mod.select_units(units, names=list(reversed(names)))
+        self.assertEqual([mod.name(p) for p in selected], names)
+        self.assertFalse(mod.is_full_campaign("all", selected))
+
+    def test_invalid_partition_names_fail_before_execution(self):
+        mod = self.module()
+        units = mod.discover_units()
+        known = mod.name(units[0])
+        for names in ([], [known, known], ["unknown-unit"]):
+            with self.assertRaises(ValueError):
+                mod.select_units(units, names=names)
+        with self.assertRaises(ValueError):
+            mod.select_units(units, names=[known], only=known)
+
+    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/20261012T143729Z-strictpairs-recovery-two-host/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/5/test_runtime.py

@@ -0,0 +1,237 @@
+"""Safety and resume invariants for the scientific campaign runner."""
+import importlib.util
+import json
+import os
+import socket
+import subprocess
+import sys
+from unittest.mock import patch
+from pathlib import Path
+import tempfile
+import unittest
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+class RuntimeTests(unittest.TestCase):
+    def load(self):
+        self.assertTrue((ROOT / "tools/runtime.py").is_file(), "campaign runtime is not implemented")
+        spec = importlib.util.spec_from_file_location("campaign_runtime", ROOT / "tools/runtime.py")
+        self.assertIsNotNone(spec, "runtime implementation missing")
+        mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(mod)
+        return mod
+
+    def test_changed_scientific_input_cannot_reuse_completed_operation(self):
+        mod = self.load()
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            inp, output = root / "support.json", root / "output.csv"
+            inp.write_text('{"train_sample_ids":["a"]}')
+            output.write_text("value\n1\n")
+            runtime = mod.Runtime(root)
+            signature = runtime.signature(["tool", "--support", str(inp)], [inp])
+            runtime.record_completed("score", signature, [output], 0.1)
+            inp.write_text('{"train_sample_ids":["b"]}')
+            changed = runtime.signature(["tool", "--support", str(inp)], [inp])
+            with self.assertRaises(mod.ReceiptError):
+                runtime.can_skip("score", changed, [output])
+
+    def test_modified_output_is_not_silently_accepted(self):
+        mod = self.load()
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            output = root / "output.csv"
+            output.write_text("value\n1\n")
+            runtime = mod.Runtime(root)
+            sig = runtime.signature(["tool"], [])
+            runtime.record_completed("score", sig, [output], 0.1)
+            self.assertTrue(runtime.can_skip("score", sig, [output]))
+            output.write_text("value\n999\n")
+            with self.assertRaises(mod.ReceiptError):
+                runtime.can_skip("score", sig, [output])
+
+    def test_unreceipted_existing_output_is_preserved_and_rejected(self):
+        mod = self.load()
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            output = root / "output.npz"
+            output.write_bytes(b"partial output must survive")
+            runtime = mod.Runtime(root)
+            with self.assertRaises(mod.ReceiptError):
+                runtime.can_skip("sample", runtime.signature(["tool"], []), [output])
+            self.assertEqual(output.read_bytes(), b"partial output must survive")
+
+    def test_same_size_and_timestamp_do_not_hide_replaced_scientific_output(self):
+        mod = self.load()
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            output = root / "output.csv"
+            output.write_bytes(b"value\n1\n")
+            runtime = mod.Runtime(root)
+            signature = runtime.signature(["score"], [])
+            runtime.record_completed("score", signature, [output], .1)
+            before = output.stat()
+            output.write_bytes(b"value\n9\n")
+            os.utime(output, ns=(before.st_atime_ns, before.st_mtime_ns))
+            with self.assertRaises(mod.ReceiptError):
+                runtime.can_skip("score", signature, [output])
+
+    def test_failed_action_requires_review_before_retry(self):
+        mod = self.load()
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            runtime = mod.Runtime(root)
+            runtime.write_receipt("sample", {"state": "failed", "exit_code": 1})
+            with self.assertRaises(mod.ReceiptError):
+                runtime.can_skip("sample", "new", [])
+
+    def test_preview_replacement_requires_verified_preserved_copy(self):
+        mod = self.load()
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            current = root / "reports/readiness.json"
+            current.parent.mkdir()
+            current.write_text('{"status":"pending"}')
+            backup = root / "preview.json"
+            backup.write_bytes(current.read_bytes())
+            runtime = mod.Runtime(root)
+            proof = {str(current): {"backup": str(backup), "sha256": mod.sha256(current)}}
+            self.assertFalse(runtime.can_skip("render", "new", [current], previous_outputs=proof))
+            backup.write_text("changed")
+            with self.assertRaises(mod.ReceiptError):
+                runtime.can_skip("render", "new", [current], previous_outputs=proof)
+
+    def test_cuda_and_cpu_commands_are_contained(self):
+        mod = self.load()
+        with tempfile.TemporaryDirectory() as td:
+            runtime = mod.Runtime(Path(td))
+            gpu = runtime.wrapped_command("train", ["python", "train.py"], "gpu", 16, 4)
+            cpu = runtime.wrapped_command("score", ["python", "score.py"], "cpu", 16, 4)
+            self.assertEqual(Path(gpu[0]).name, "ml-run")
+            self.assertIn("CUDA_VISIBLE_DEVICES=0", gpu)
+            self.assertIn("MemorySwapMax=0", cpu)
+            self.assertIn("OOMPolicy=kill", cpu)
+            self.assertIn("CUDA_VISIBLE_DEVICES=", cpu)
+
+
+    def execution_map(self, root):
+        launcher, guard = root / "ml-run", root / "ml-memory-guard"
+        for executable in (launcher, guard):
+            executable.write_text("#!/bin/sh\nexit 0\n")
+            executable.chmod(0o700)
+        config = {"host": "server_2", "executables": {"/canonical/python": sys.executable},
+                  "ml_run": str(launcher), "guard_check": str(guard), "path": "/usr/bin:/bin"}
+        config_path = root / "execution.json"
+        config_path.write_text(json.dumps(config))
+        return config_path, config
+
+    def test_native_mapping_changes_only_executed_program_not_scientific_signature(self):
+        mod = self.load()
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            config_path, config = self.execution_map(root)
+            argv = ["/canonical/python", "tool.py", "--source", "/canonical/python"]
+            with patch.dict(os.environ, {"PBISC_STRICT_EXECUTION_MAP": ""}):
+                original = mod.Runtime(root).signature(argv, [])
+            with patch.dict(os.environ, {"PBISC_STRICT_EXECUTION_MAP": str(config_path)}):
+                runtime = mod.Runtime(root)
+                command = runtime.wrapped_command("train", argv, "gpu", 16, 1)
+                self.assertEqual(runtime.signature(argv, []), original)
+                self.assertEqual(command[0], config["ml_run"])
+                self.assertEqual(command[-4:], [sys.executable, *argv[1:]])
+                self.assertIn("CUDA_VISIBLE_DEVICES=0", command)
+                self.assertIn("PATH=/usr/bin:/bin", command)
+                self.assertEqual(argv[0], "/canonical/python")
+                cpu = runtime.wrapped_command("score", argv, "cpu", 16, 1)
+                self.assertIn("MemorySwapMax=0", cpu)
+                self.assertIn("OOMPolicy=kill", cpu)
+                self.assertIn("CUDA_VISIBLE_DEVICES=", cpu)
+                self.assertEqual(cpu[-4:], [sys.executable, *argv[1:]])
+
+    def test_invalid_execution_paths_fail_before_any_command(self):
+        mod = self.load()
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            config_path, config = self.execution_map(root)
+            invalid_configs = [
+                {**config, "executables": {"relative/python": sys.executable}},
+                {**config, "executables": {"/canonical/python": "python -c code"}},
+                {**config, "executables": {"/canonical/python": "/missing/native/python"}},
+                {**config, "ml_run": "ml-run"},
+                {**config, "guard_check": "/bin/true --check"},
+                {**config, "path": "/usr/bin:relative"},
+                {**config, "host": ""},
+            ]
+            with patch.dict(os.environ, {"PBISC_STRICT_EXECUTION_MAP": str(config_path)}):
+                for invalid in invalid_configs:
+                    with self.subTest(config=invalid):
+                        config_path.write_text(json.dumps(invalid))
+                        with self.assertRaises(ValueError):
+                            mod.Runtime(root)
+
+    def test_mapping_provenance_persists_in_running_and_completed_receipts(self):
+        mod = self.load()
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            config_path, config = self.execution_map(root)
+            output = root / "result.txt"
+            with patch.dict(os.environ, {"PBISC_STRICT_EXECUTION_MAP": str(config_path)}):
+                runtime = mod.Runtime(root)
+            seen = []
+            def run(command, **kwargs):
+                seen.append(json.loads(runtime.receipt_path("score").read_text()))
+                output.write_text("completed CPU fixture\n")
+                return subprocess.CompletedProcess(command, 0)
+            with patch.object(runtime, "preflight"), patch.object(mod.subprocess, "run", side_effect=run):
+                self.assertTrue(runtime.execute("score", ["/canonical/python", "tool.py"], outputs=[output]))
+            completed = json.loads(runtime.receipt_path("score").read_text())
+            for receipt in [seen[0], completed]:
+                execution = receipt["execution"]
+                self.assertEqual(execution["host"], socket.gethostname())
+                self.assertEqual(execution["map_host"], "server_2")
+                self.assertEqual(execution["map_sha256"], mod.sha256(config_path))
+                self.assertEqual(execution["argv"], [sys.executable, "tool.py"])
+                self.assertEqual(execution["command"][-2:], [sys.executable, "tool.py"])
+                self.assertEqual(receipt["argv"], ["/canonical/python", "tool.py"])
+            self.assertEqual(seen[0]["state"], "running")
+            self.assertEqual(completed["state"], "completed")
+
+    def test_mapped_guard_preflight_retains_all_host_safety_checks(self):
+        mod = self.load()
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            config_path, config = self.execution_map(root)
+            with patch.dict(os.environ, {"PBISC_STRICT_EXECUTION_MAP": str(config_path)}):
+                runtime = mod.Runtime(root)
+            observed = []
+            def run(command, **kwargs):
+                observed.append(command)
+                return subprocess.CompletedProcess(command, 0, stdout="", stderr="")
+            with patch.object(mod.subprocess, "run", side_effect=run), \
+                    patch.object(mod.shutil, "disk_usage", return_value=type("Disk", (), {"free": 128 * 2**30})()), \
+                    patch.object(Path, "read_text", return_value="MemAvailable: 100663296 kB\n"):
+                runtime.preflight("gpu", 16)
+            self.assertIn([config["guard_check"], "--check"], observed)
+            self.assertIn(["systemctl", "--user", "is-active", "ml-memory-guard.service"], observed)
+            self.assertIn(["nvidia-smi", "--query-compute-apps=pid,process_name,used_memory", "--format=csv,noheader"], observed)
+            self.assertIn(["flock", "--nonblock", "/run/user/1000/ml-gpu0.lock", "true"], observed)
+
+    def test_new_receipts_include_actual_host_without_requiring_it_in_old_receipts(self):
+        mod = self.load()
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            runtime = mod.Runtime(root)
+            output = root / "out"
+            output.write_text("valid")
+            runtime.record_completed("score", "unchanged", [output], .1)
+            record = json.loads(runtime.receipt_path("score").read_text())
+            self.assertEqual(record["execution"]["host"], socket.gethostname())
+            self.assertIsNone(record["execution"]["map_sha256"])
+            del record["execution"]
+            runtime.write_receipt("score", record)
+            self.assertTrue(runtime.can_skip("score", "unchanged", [output]))
+
+
+if __name__ == "__main__":
+    unittest.main()

paper-releases/pbisc-diffusion/updates/20261012T143729Z-strictpairs-recovery-two-host/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/6/test_runtime_recovery.py

@@ -0,0 +1,129 @@
+"""Source reuse requires exact historical provenance and intact replay evidence."""
+import importlib.util
+import json
+from pathlib import Path
+import tempfile
+import unittest
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def load_runtime():
+    spec = importlib.util.spec_from_file_location('runtime_recovery', ROOT / 'tools/runtime.py')
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+class RecoveryTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.tmp.cleanup)
+        self.root = Path(self.tmp.name)
+        self.mod = load_runtime()
+        self.runtime = self.mod.Runtime(self.root)
+        self.source = self.root / 'source.py'
+        self.source.write_text('old source')
+        self.output = self.root / 'score.csv'
+        self.output.write_text('value\n1\n')
+        self.old = self.runtime.signature(['/canonical/python', str(self.source)], [self.source])
+        self.runtime.record_completed('score', self.old, [self.output], .1)
+        self.original = self.runtime.receipt_path('score').read_bytes()
+        self.saved = self.root / 'recoveries/original_score.json'
+        self.saved.parent.mkdir()
+        self.saved.write_bytes(self.original)
+        self.source.write_text('isolated source')
+        self.new = self.runtime.signature(['/canonical/python', str(self.source)], [self.source])
+        self.evidence = self.root / 'recoveries/replay.json'
+        self.evidence.write_text('{"source_reproduced":true,"replay":"equal"}')
+        self.manifest = self.root / 'recoveries/SOURCE_REUSE.json'
+        self.transition = {
+            'operation': 'score', 'old_signature': self.old, 'new_signature': self.new,
+            'original_receipt': {'path': str(self.saved), 'sha256': self.mod.sha256(self.saved)},
+            'evidence': [{'name': 'source-reproduction-and-replay', 'path': str(self.evidence),
+                          'sha256': self.mod.sha256(self.evidence)}],
+        }
+
+    def attest(self):
+        self.manifest.write_text(json.dumps({'schema': 'pbisc.strictpairs.source-reuse.v1',
+                                             'transitions': [self.transition]}))
+
+    def test_exact_attestation_allows_reuse_without_rewriting_receipts(self):
+        self.attest()
+        self.assertTrue(self.runtime.can_skip('score', self.new, [self.output]))
+        self.assertEqual(self.runtime.receipt_path('score').read_bytes(), self.original)
+        self.assertEqual(self.saved.read_bytes(), self.original)
+
+    def test_same_signature_uses_normal_path_without_a_recovery_manifest(self):
+        self.manifest.write_text('malformed unrelated recovery manifest')
+        self.assertTrue(self.runtime.can_skip('score', self.old, [self.output]))
+
+    def test_unapproved_changed_signature_is_rejected(self):
+        with self.assertRaises(self.mod.ReceiptError):
+            self.runtime.can_skip('score', self.new, [self.output])
+
+    def test_attestation_cannot_authorize_future_input_changes(self):
+        self.attest()
+        self.source.write_text('different scientific data')
+        changed = self.runtime.signature(['/canonical/python', str(self.source)], [self.source])
+        with self.assertRaises(self.mod.ReceiptError):
+            self.runtime.can_skip('score', changed, [self.output])
+
+    def test_wrong_operation_or_signature_cannot_match(self):
+        for field, value in [('operation', 'train'), ('old_signature', 'a' * 64),
+                             ('new_signature', 'b' * 64)]:
+            with self.subTest(field=field):
+                original = self.transition[field]
+                self.transition[field] = value
+                self.attest()
+                with self.assertRaises(self.mod.ReceiptError):
+                    self.runtime.can_skip('score', self.new, [self.output])
+                self.transition[field] = original
+
+    def test_missing_or_changed_named_evidence_is_rejected(self):
+        self.attest()
+        self.evidence.write_text('changed replay')
+        with self.assertRaises(self.mod.ReceiptError):
+            self.runtime.can_skip('score', self.new, [self.output])
+        self.evidence.unlink()
+        with self.assertRaises(self.mod.ReceiptError):
+            self.runtime.can_skip('score', self.new, [self.output])
+
+    def test_no_evidence_is_not_an_approval(self):
+        self.transition['evidence'] = []
+        self.attest()
+        with self.assertRaises(self.mod.ReceiptError):
+            self.runtime.can_skip('score', self.new, [self.output])
+
+    def test_changed_original_receipt_is_rejected(self):
+        self.attest()
+        self.saved.write_text('{}')
+        with self.assertRaises(self.mod.ReceiptError):
+            self.runtime.can_skip('score', self.new, [self.output])
+
+    def test_live_receipt_must_match_preserved_original_bytes(self):
+        self.attest()
+        record = json.loads(self.original)
+        record['seconds'] = 99
+        self.runtime.write_receipt('score', record)
+        with self.assertRaises(self.mod.ReceiptError):
+            self.runtime.can_skip('score', self.new, [self.output])
+
+    def test_attestation_never_waives_output_contract_or_hash_checks(self):
+        self.attest()
+        with self.assertRaises(self.mod.ReceiptError):
+            self.runtime.can_skip('score', self.new, [])
+        self.output.write_text('value\n999\n')
+        with self.assertRaises(self.mod.ReceiptError):
+            self.runtime.can_skip('score', self.new, [self.output])
+
+    def test_invalid_manifest_is_fail_closed(self):
+        for content in ['{', '[]', '{"schema":"wrong","transitions":[]}']:
+            with self.subTest(content=content):
+                self.manifest.write_text(content)
+                with self.assertRaises(self.mod.ReceiptError):
+                    self.runtime.can_skip('score', self.new, [self.output])
+
+
+if __name__ == '__main__':
+    unittest.main()

paper-releases/pbisc-diffusion/updates/20261012T143729Z-strictpairs-recovery-two-host/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/7/test_support_input_isolation.py

@@ -0,0 +1,289 @@
+"""Small CPU fixtures: excluded expression is poison, selected values are exact."""
+from __future__ import annotations
+
+import importlib.util
+import json
+from pathlib import Path
+import sys
+from types import SimpleNamespace
+
+import numpy as np
+import pandas as pd
+import pytest
+import scipy.sparse as sp
+
+ROOT = Path(__file__).resolve().parents[1]
+OLD = ROOT.parent / "paired_finetune_intradataset_20260927"
+sys.path.insert(0, str(ROOT / "tools"))
+import support_input_isolation as isolation
+import support_manifest as manifests
+
+
+def module_from_path(name: str, path: Path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+@pytest.fixture
+def cohort(tmp_path, monkeypatch):
+    m8 = tmp_path / "model8"
+    plan = m8 / "plans" / ROOT.name
+    old = m8 / "plans" / OLD.name
+    dataset = old / "data/immicro"
+    dataset.mkdir(parents=True)
+    folds = pd.DataFrame({"sample_id": ["s0", "s1", "s2", "s3"],
+                          "donor_id": ["d0", "d1", "d2", "d3"],
+                          "group": ["healthy"] * 4, "fold": [0, 1, 0, 2],
+                          "inner_val_f0": [False] * 4})
+    folds.to_csv(dataset / "folds.csv", index=False)
+    samples = folds.assign(n_cells=[2, 3, 1, 2])
+    samples.to_csv(dataset / "samples.csv", index=False)
+    panel = np.asarray([f"g{i}" for i in range(1001)])
+    genes = np.asarray([f"g{i}" for i in range(20097)])
+    row_sample = np.asarray([0, 0, 1, 1, 1, 2, 3, 3], dtype=np.int64)
+    dense = np.zeros((len(row_sample), len(panel)), dtype=np.float32)
+    dense[:, 0] = np.arange(1, len(row_sample) + 1)
+    dense[:, 3] = 2 * dense[:, 0]
+    csr = sp.csr_matrix(dense)
+    arrays = {"data": csr.data.copy(), "indices": csr.indices.copy(), "indptr": csr.indptr,
+              "row_sample": row_sample, "shape": np.asarray(csr.shape),
+              "panel_gene_ids": panel, "panel_measured": np.ones((4, len(panel)), bool)}
+    clean = dataset / "clean.npz"
+    np.savez_compressed(clean, **arrays)
+    for cell in np.flatnonzero(~np.isin(row_sample, [1, 3])):
+        section = slice(csr.indptr[cell], csr.indptr[cell + 1])
+        arrays["data"][section] = np.nan
+        arrays["indices"][section] = -999
+    source = dataset / "cells_panel6k.npz"
+    np.savez_compressed(source, **arrays)
+    bulk = np.arange(4 * len(genes), dtype=np.float32).reshape(4, -1) + 1
+    bulk_valid = np.ones(bulk.shape, dtype=bool)
+    bulk_valid[0, -1] = False
+    bulk[0, -1] = np.nan
+    np.savez_compressed(dataset / "features.npz", sample_ids=folds.sample_id.to_numpy(str),
+                        donor_ids=folds.donor_id.to_numpy(str), groups=folds.group.to_numpy(str),
+                        qc_cell_counts=samples.n_cells.to_numpy(), gene_ids=genes,
+                        bulk_valid=bulk_valid, sc_valid=np.ones_like(bulk_valid), bulk_raw=bulk,
+                        identity_pass=np.ones(4, bool),
+                        pseudo_raw_sum=np.asarray(["must never load"], dtype=object))
+    support = manifests.build_healthy(folds, 0, 2, seed=3)
+    support_path = plan / "protocol/splits/immicro/healthy/fold0/n2/support.json"
+    support_path.parent.mkdir(parents=True)
+    manifests.write_manifest(support_path, support)
+    condition = plan / "data/immicro/healthy/fold0/n2/test_raw.npz"
+    condition.parent.mkdir(parents=True)
+    np.savez_compressed(condition, sample_ids=np.asarray(support["test_sample_ids"]))
+    symbols = m8 / "artifacts/panel_ladder_floor01_1m_20260923/tiers/6k/selected_genes.csv"
+    symbols.parent.mkdir(parents=True)
+    pd.DataFrame({"gene_id": panel, "gene_symbol": panel}).to_csv(symbols, index=False)
+    monkeypatch.setattr(isolation, "PLAN", plan)
+    monkeypatch.setattr(isolation, "OLD", old)
+    monkeypatch.setenv("CUDA_VISIBLE_DEVICES", "")
+    return SimpleNamespace(plan=plan, old=old, dataset=dataset, support=support,
+                           support_path=support_path, source=source, clean=clean,
+                           dense=dense, arrays=arrays, folds=folds, panel=panel,
+                           row_sample=row_sample, bulk=bulk)
+
+
+def forbid_full_expression(monkeypatch, source: Path):
+    """Catch np.load expression access, while permitting streamed source ranges."""
+    original = np.lib.npyio.NpzFile.__getitem__
+    accessed = []
+
+    def guarded(archive, key):
+        name = Path(archive.zip.filename)
+        accessed.append((name, key))
+        if name == source and key in {"data", "indices"}:
+            pytest.fail(f"full source expression member accessed: {key}")
+        if key in {"pseudo_raw_sum", "pseudo", "sc_raw_sum"}:
+            pytest.fail(f"single-cell aggregate accessed: {key}")
+        return original(archive, key)
+
+    monkeypatch.setattr(np.lib.npyio.NpzFile, "__getitem__", guarded)
+    return accessed
+
+
+def test_isolation_discards_poison_and_preserves_original_cell_rows(cohort, monkeypatch):
+    forbid_full_expression(monkeypatch, cohort.source)
+    got, audit = isolation.isolated_arrays(cohort.source, np.asarray([3, 1]))
+    clean, _ = isolation.isolated_arrays(cohort.clean, np.asarray([1, 3]))
+    for key in got:
+        np.testing.assert_array_equal(got[key], clean[key])
+    selected = np.isin(cohort.row_sample, [1, 3])
+    expected = cohort.dense.copy()
+    expected[~selected] = 0
+    matrix = sp.csr_matrix((got["data"], got["indices"], got["indptr"]), shape=got["shape"])
+    np.testing.assert_array_equal(matrix.toarray(), expected)
+    np.testing.assert_array_equal(got["row_sample"], cohort.row_sample)
+    assert np.all(np.diff(got["indptr"])[~selected] == 0)
+    assert audit["selected_sample_rows"] == [1, 3]
+    assert audit["selected_cells"] == 5
+
+
+@pytest.mark.parametrize("rows", [[], [-1], [0.9], ["1"], [[1]], [9]])
+def test_rejects_invalid_support_rows_without_coercion(cohort, rows):
+    with pytest.raises(ValueError):
+        isolation.isolated_arrays(cohort.source, np.asarray(rows))
+
+
+@pytest.mark.parametrize("key,value", [
+    ("row_sample", np.asarray([0., 0., 1., 1., 1., 2., 3., 3.])),
+    ("shape", np.asarray([8, 1001, 1])),
+    ("indices", np.full(16, -1, dtype=np.int64)),
+    ("data", np.asarray(["bad"] * 16)),
+    ("data", np.ones(15)),
+])
+def test_rejects_malformed_csr_members(cohort, key, value, tmp_path):
+    arrays = dict(cohort.arrays)
+    arrays[key] = value
+    path = tmp_path / "malformed.npz"
+    np.savez_compressed(path, **arrays)
+    with pytest.raises(ValueError):
+        isolation.isolated_arrays(path, np.asarray([1, 3]))
+
+
+def test_stream_ranges_boundaries_and_validation(tmp_path):
+    path = tmp_path / "ranges.npz"
+    values = np.arange(20, dtype="<i4")
+    np.savez_compressed(path, data=values)
+    np.testing.assert_array_equal(isolation.read_ranges(path, "data", [(1, 3), (10, 14), (20, 20)]),
+                                  np.r_[values[1:3], values[10:14]])
+    assert isolation.read_ranges(path, "data", []).size == 0
+    for ranges in [[(3, 4), (2, 3)], [(-1, 1)], [(19, 21)], [(0.5, 1)]]:
+        with pytest.raises(ValueError):
+            isolation.read_ranges(path, "data", ranges)
+    with pytest.raises(ValueError, match="length"):
+        isolation.read_ranges(path, "data", [(1, 3)], expected_length=21)
+
+
+def test_materialize_receipt_is_immutable_and_replay_has_limited_scope(cohort, monkeypatch):
+    forbid_full_expression(monkeypatch, cohort.source)
+    path, receipt = isolation.materialize(cohort.support_path, dataset_dir=cohort.dataset)
+    before = path.stat().st_mtime_ns
+    assert isolation.materialize(cohort.support_path) == (path, receipt)
+    assert path.stat().st_mtime_ns == before
+    result = isolation.validate_replay(cohort.support_path)
+    assert result["all_selected_values_exact"] and result["training_draws_exact"]
+    assert "no training" in result["validation_scope"]
+    assert "does not change historical access claims" in result["legacy_access_limitation"]
+    assert receipt["target_sc_aggregate_keys_accessed"] == []
+    with pytest.raises(ValueError, match="dataset directory"):
+        isolation.materialize(cohort.support_path, dataset_dir=cohort.dataset.parent)
+    changed = dict(receipt, builder_sha256="stale")
+    (path.parent / "ISOLATION.json").write_text(json.dumps(changed))
+    with pytest.raises(ValueError, match="immutable"):
+        isolation.materialize(cohort.support_path)
+
+
+def test_bulk_loader_does_not_open_pseudobulk_and_matches_legacy_nan_conversion(cohort, monkeypatch):
+    accessed = forbid_full_expression(monkeypatch, cohort.source)
+    d = isolation.bulk_only_load(cohort.dataset)
+    expected = np.where(np.isnan(cohort.bulk), 0, cohort.bulk).astype(np.float64)
+    np.testing.assert_array_equal(d["bulk"], expected)
+    assert d["bulk"].dtype == np.float64
+    assert "pseudo" not in d
+    assert not d["use"].any()  # Same 200-cell metadata eligibility floor as legacy loader.
+    assert all(key != "pseudo_raw_sum" for _, key in accessed)
+    (cohort.dataset / "samples.csv").unlink()
+    fallback = isolation.bulk_only_load(cohort.dataset)
+    np.testing.assert_array_equal(fallback["sample_ids"], d["sample_ids"])
+    assert not (cohort.dataset / "samples.csv").exists()
+
+
+def test_actual_trainer_seeded_draws_and_selected_dense_values_are_identical(cohort):
+    pytest.importorskip("torch")
+    trainer = module_from_path("isolation_test_trainer_draws", OLD / "tools/ft_sdd.py")
+    path, _ = isolation.materialize(cohort.support_path)
+    old = trainer.Cells(cohort.clean, cohort.panel)
+    strict = trainer.Cells(path, cohort.panel)
+    rng_old, rng_strict = np.random.default_rng(20260927), np.random.default_rng(20260927)
+    for _ in range(3000):
+        rows_a, cells_a = trainer.draw_batch(old, np.asarray([1, 3]), 256, rng_old)
+        rows_b, cells_b = trainer.draw_batch(strict, np.asarray([1, 3]), 256, rng_strict)
+        np.testing.assert_array_equal(rows_a, rows_b)
+        np.testing.assert_array_equal(cells_a, cells_b)
+    np.testing.assert_array_equal(strict.dense(cells_b), cohort.dense[cells_b])
+    np.testing.assert_array_equal(old.dense(cells_a), strict.dense(cells_b))
+
+
+@pytest.mark.parametrize("strict", [False, True])
+def test_trainer_main_routes_only_opt_in_to_isolated_cells(cohort, monkeypatch, strict):
+    pytest.importorskip("torch")
+    trainer = module_from_path(f"isolation_test_trainer_main_{strict}", OLD / "tools/ft_sdd.py")
+    checkpoint = cohort.plan / "fake-checkpoint.pt"
+    checkpoint.write_bytes(b"metadata-only test checkpoint")
+    condition = cohort.plan / "fake-condition.npz"
+    np.savez(condition, sample_ids=cohort.folds.sample_id.to_numpy(str))
+    monkeypatch.setattr(trainer.SS, "restore_standalone", lambda *args, **kw:
+                        SimpleNamespace(diffusion=object(), scaler=object(), gene_ids=cohort.panel))
+    monkeypatch.setattr(trainer.SS, "load_conditions", lambda *args, **kw:
+                        SimpleNamespace(sample_ids=cohort.folds.sample_id.to_numpy(str)))
+    captured = []
+
+    class ReachedCellLoader(Exception):
+        pass
+
+    cells_class = trainer.Cells
+
+    def capture(path, panel):
+        captured.append((path, cells_class(path, panel)))
+        raise ReachedCellLoader
+
+    monkeypatch.setattr(trainer, "Cells", capture)
+    argv = ["--checkpoint", str(checkpoint), "--checkpoint-sha", trainer.sha256_file(checkpoint),
+            "--dataset-dir", str(cohort.dataset), "--condition-npz", str(condition), "--fold", "0",
+            "--mode", "lora", "--lr", "0.0001", "--device", "cpu", "--min-system-gib", "0",
+            "--out-dir", str(cohort.plan / "trainer-output")]
+    if strict:
+        argv += ["--support-manifest", str(cohort.support_path), "--fixed-steps", "3000"]
+        forbid_full_expression(monkeypatch, cohort.source)
+    with pytest.raises(ReachedCellLoader):
+        trainer.main(argv)
+    assert len(captured) == 1
+    if strict:
+        assert captured[0][0].name == "cells_support_only.npz"
+        assert np.isfinite(captured[0][1].data).all()
+    else:
+        assert captured[0][0] == cohort.source
+
+
+def test_scsemi_preparation_uses_support_only_expression_and_no_pseudo(cohort, monkeypatch):
+    ad = pytest.importorskip("anndata")
+    prep = module_from_path("isolation_test_scsemi", OLD / "scsemi/tools/prepare_draw_inputs.py")
+    monkeypatch.setattr(prep, "TASK", cohort.old)
+    monkeypatch.setattr(prep.PD, "load", lambda *_: pytest.fail("strict called legacy pseudo loader"))
+    forbid_full_expression(monkeypatch, cohort.source)
+    work = cohort.plan / "scsemi-fixture"
+    assert prep.main(["--dataset", "immicro", "--support-manifest", str(cohort.support_path),
+                      "--work", str(work)]) == 0
+    man = json.loads((work / "inputs/inputs_manifest.json").read_text())
+    out = ad.read_h5ad(work / "inputs/rep_sc.h5ad")
+    expected_cells = np.concatenate([np.flatnonzero(cohort.row_sample == int(s[1:]))
+                                     for s in cohort.support["train_sample_ids"]])
+    np.testing.assert_array_equal(out.obs.source_cell_row.to_numpy(), expected_cells)
+    np.testing.assert_array_equal(out.X.toarray(), cohort.dense[expected_cells])
+    assert out.obs.sample_ids.unique().tolist() == cohort.support["train_sample_ids"]
+    assert man["depth"]["value"] == float(np.median(cohort.dense[expected_cells].sum(1)))
+    assert man["support_expression_isolation"]["audit"]["selected_cells"] == 5
+    assert man["support_expression_isolation"]["target_sc_aggregate_keys_accessed"] == []
+    assert "cells_support_only.npz" in man["sources"]
+    assert man["targets"] == cohort.support["test_sample_ids"]
+
+
+def test_scsemi_without_manifest_keeps_legacy_loader(cohort, monkeypatch):
+    prep = module_from_path("isolation_test_scsemi_legacy", OLD / "scsemi/tools/prepare_draw_inputs.py")
+    monkeypatch.setattr(prep, "TASK", cohort.old)
+
+    class LegacyLoaderReached(Exception):
+        pass
+
+    def legacy_loader(path):
+        assert path == cohort.dataset
+        raise LegacyLoaderReached
+
+    monkeypatch.setattr(prep.PD, "load", legacy_loader)
+    monkeypatch.setattr(isolation, "bulk_only_load", lambda *_: pytest.fail("legacy used strict loader"))
+    with pytest.raises(LegacyLoaderReached):
+        prep.main(["--dataset", "immicro", "--draw", "0", "--check-only", "--work", str(cohort.plan / "legacy")])