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/10/SOURCE_REUSE.json

@@ -0,0 +1,90 @@
+{
+  "schema": "pbisc.strictpairs.source-reuse.v1",
+  "at": "2026-10-12T14:30:10.806533+00:00",
+  "transitions": [
+    {
+      "operation": "immicro-healthy-fold0-n5-train",
+      "old_signature": "2ca886713c69144fd1ef558468dbeba98e7f9840c0fe183f683af69e065b14e2",
+      "new_signature": "ab97afdd574f8ec532dfade4e716e9ddfccf68dc732848f35932a6f8c15561d8",
+      "original_receipt": {
+        "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/source_reuse_20261012/immicro-healthy-fold0-n5-train.json",
+        "sha256": "a5adc14fe5a2bce4f9aaaaae6a3cfa087e13f91ba8bf7972eb937f1508cf3714"
+      },
+      "evidence": [
+        {
+          "name": "old-source-reproduction",
+          "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/source_reuse_20261012/immicro-healthy-fold0-n5-train-proof.json",
+          "sha256": "32fad796b963affb2e3fcdf1248f22804b0c595678305846477c02e47636c16c"
+        },
+        {
+          "name": "isolated-replay",
+          "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/isolated/immicro/healthy/fold0/n5/REPLAY.json",
+          "sha256": "bdb8576d6558943f4886c3fe063445a129a4c2c04a3adb8d11bfb869f04c8c82"
+        }
+      ]
+    },
+    {
+      "operation": "immicro-healthy-fold0-n5-scinputs",
+      "old_signature": "a77b1b0a1f3a649d1330526615e7ad0c31da2fa815a773e584d9e3e34bf15e0e",
+      "new_signature": "d339898c4f2fc662561acc03749f380e14d0df82dd5b54108f60581c54e312ce",
+      "original_receipt": {
+        "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/source_reuse_20261012/immicro-healthy-fold0-n5-scinputs.json",
+        "sha256": "2888679e086cfd188852113c98c28fba592220a109223c78fba5cf56392a3b8c"
+      },
+      "evidence": [
+        {
+          "name": "old-source-reproduction",
+          "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/source_reuse_20261012/immicro-healthy-fold0-n5-scinputs-proof.json",
+          "sha256": "678c157b9f907b853276212437b95854bc5dfee5a58a29096c8df4c8d0bbb8ca"
+        },
+        {
+          "name": "isolated-replay",
+          "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/isolated/immicro/healthy/fold0/n5/REPLAY.json",
+          "sha256": "bdb8576d6558943f4886c3fe063445a129a4c2c04a3adb8d11bfb869f04c8c82"
+        }
+      ]
+    },
+    {
+      "operation": "immicro-healthy-fold1-n5-train",
+      "old_signature": "1f82de5256dadba1d66d0756684eac3d4373329abe9606684ebb9036cd42618f",
+      "new_signature": "6b102fb7edbdafd80b61c231398bf40bfbf6bec4420c148a9e265b1064a45263",
+      "original_receipt": {
+        "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/source_reuse_20261012/immicro-healthy-fold1-n5-train.json",
+        "sha256": "752d2bf7c1ed36ee224cf8d4ec4a5c36f3ec3258fc0d044c377d151886403b48"
+      },
+      "evidence": [
+        {
+          "name": "old-source-reproduction",
+          "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/source_reuse_20261012/immicro-healthy-fold1-n5-train-proof.json",
+          "sha256": "abc5c91549a18877b3dc9569d67aad489310c4c618c83f4e7dc8f337566e042e"
+        },
+        {
+          "name": "isolated-replay",
+          "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/isolated/immicro/healthy/fold1/n5/REPLAY.json",
+          "sha256": "baa4653814d2a151ab0f55830e57b4a6a30d47edcecebaefb727c968cb495609"
+        }
+      ]
+    },
+    {
+      "operation": "immicro-healthy-fold1-n5-scinputs",
+      "old_signature": "4938632fc0e7110fcd4ee952b42a0c3479d43243d4310527c954eeb42238ca49",
+      "new_signature": "64fc2195127f1e90ad286e2198a8fefcb821a7c4f284cb2b520c060d37ca006d",
+      "original_receipt": {
+        "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/source_reuse_20261012/immicro-healthy-fold1-n5-scinputs.json",
+        "sha256": "feeeef8b6e7a120c879344084e58b646f2c590b693895dba0313d0fadb5cd278"
+      },
+      "evidence": [
+        {
+          "name": "old-source-reproduction",
+          "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/source_reuse_20261012/immicro-healthy-fold1-n5-scinputs-proof.json",
+          "sha256": "482e5417167f4f67b0bc00d4ed1cc1972fa4602757b700767cd1d881485e89e0"
+        },
+        {
+          "name": "isolated-replay",
+          "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/isolated/immicro/healthy/fold1/n5/REPLAY.json",
+          "sha256": "baa4653814d2a151ab0f55830e57b4a6a30d47edcecebaefb727c968cb495609"
+        }
+      ]
+    }
+  ]
+}

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/11/REMOTE_SOURCE_VERIFICATION.json

@@ -0,0 +1,139 @@
+{
+  "host": "server_2",
+  "source_host": "server_1",
+  "checks": [
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/runs/f01_6k_1x_seed20260627/checkpoint_epoch_016.pt",
+      "expected": "8c7cd0e83e2bc19fe03dfcbc084919a1e2f61be8cc8bc12f4caf543dfda91633",
+      "actual": "8c7cd0e83e2bc19fe03dfcbc084919a1e2f61be8cc8bc12f4caf543dfda91633",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/scripts/sample_sdd_standalone.py",
+      "expected": "95ace096cdc58a9ca92a18af649c60fe6ac0a55e97f977e7ab9bcb04efa968cb",
+      "actual": "95ace096cdc58a9ca92a18af649c60fe6ac0a55e97f977e7ab9bcb04efa968cb",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/src/pbisc_sdd/__init__.py",
+      "expected": "46c7212b637e67f2b44b616fef47f964a284b576ba56c372f71463ce46ea24ee",
+      "actual": "46c7212b637e67f2b44b616fef47f964a284b576ba56c372f71463ce46ea24ee",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/src/pbisc_sdd/data.py",
+      "expected": "0d959a35175549a263e1b23c2709bfe2699dc293141d5699f01cf70cd7a0ba73",
+      "actual": "0d959a35175549a263e1b23c2709bfe2699dc293141d5699f01cf70cd7a0ba73",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/src/pbisc_sdd/diffusion.py",
+      "expected": "ed97ca9fe56b9328da9ee455d4fbfc4b5102dfcf4f2364363bb715d19610429f",
+      "actual": "ed97ca9fe56b9328da9ee455d4fbfc4b5102dfcf4f2364363bb715d19610429f",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/src/pbisc_sdd/ema.py",
+      "expected": "dcc982725b7f94986b4b13b782c7a587b9efcf06d4fd444e9bf51bca051940c1",
+      "actual": "dcc982725b7f94986b4b13b782c7a587b9efcf06d4fd444e9bf51bca051940c1",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/src/pbisc_sdd/experiment.py",
+      "expected": "5e4f6169410fa165e5b1c39391ab731c38c32b7d3202618da326b2f82131e6de",
+      "actual": "5e4f6169410fa165e5b1c39391ab731c38c32b7d3202618da326b2f82131e6de",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/src/pbisc_sdd/fast_rows.py",
+      "expected": "83cb181499903d20d5aeb58a3e978af5cf132751057561d12f5920ce23378c60",
+      "actual": "83cb181499903d20d5aeb58a3e978af5cf132751057561d12f5920ce23378c60",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/src/pbisc_sdd/gene_selection.py",
+      "expected": "6818525e212b2192e40e7b9f5f879e29f644c17a099aa09a6ab2adb66f1b7e7d",
+      "actual": "6818525e212b2192e40e7b9f5f879e29f644c17a099aa09a6ab2adb66f1b7e7d",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/src/pbisc_sdd/ladder_experiment.py",
+      "expected": "872bf059e14f0042eec64d290cb84685dafd9705ae364125462d1d8e06e14314",
+      "actual": "872bf059e14f0042eec64d290cb84685dafd9705ae364125462d1d8e06e14314",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/src/pbisc_sdd/model.py",
+      "expected": "c3d725b97d003b9b2fb45d5061d5f7daffe89fd37147f9d53753b3ed2da77ffa",
+      "actual": "c3d725b97d003b9b2fb45d5061d5f7daffe89fd37147f9d53753b3ed2da77ffa",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/src/pbisc_sdd/panel_ladder.py",
+      "expected": "45116a496e1f38247dfdaa3d306ab54aa28e13736754dbe9dd75eaa5dc7d518f",
+      "actual": "45116a496e1f38247dfdaa3d306ab54aa28e13736754dbe9dd75eaa5dc7d518f",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/src/pbisc_sdd/proportion_hint.py",
+      "expected": "7a352d73728e78c9d262e29c35628d2437af0bc7743b88c077ba81d911dd2a52",
+      "actual": "7a352d73728e78c9d262e29c35628d2437af0bc7743b88c077ba81d911dd2a52",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/data/immicro/features.npz",
+      "expected": "735255066ce7ebbac13a1fdfd058e26f31edd60314cc02fd589b0a292dbbc838",
+      "actual": "735255066ce7ebbac13a1fdfd058e26f31edd60314cc02fd589b0a292dbbc838",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/data/immicro/cells_panel6k.npz",
+      "expected": "e1168468b621183604038b79280f46961c5819fe2386d9da0b454f7db642742a",
+      "actual": "e1168468b621183604038b79280f46961c5819fe2386d9da0b454f7db642742a",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/data/immicro/conditions_raw_fixed.npz",
+      "expected": "2be5717d19e86bdf38e4838d4bd2886a211ba78bfbfe749c458305a3e0ac2dcc",
+      "actual": "2be5717d19e86bdf38e4838d4bd2886a211ba78bfbfe749c458305a3e0ac2dcc",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/data/immicro/samples.csv",
+      "expected": "9e1e370519910b57528902d7e119a4f5f369f1610779d2bfa1d0ce958953d744",
+      "actual": "9e1e370519910b57528902d7e119a4f5f369f1610779d2bfa1d0ce958953d744",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/data/immicro/folds.csv",
+      "expected": "0adc10f4ac973e5b7558effbea0fd6950a6bf59e5af1d3a376e12eb00bf6a643",
+      "actual": "0adc10f4ac973e5b7558effbea0fd6950a6bf59e5af1d3a376e12eb00bf6a643",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/scsemi/tools/run_scsemi_paired.py",
+      "expected": "24d36efb13500e9d555bcdf19976dea575f9710fd0a25c68fae836f51723fc7f",
+      "actual": "24d36efb13500e9d555bcdf19976dea575f9710fd0a25c68fae836f51723fc7f",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/scsemi/tools/lean_hvset.py",
+      "expected": "3783f6e9728c3ecdb41ec6068f15bc9bf44ff5fc25644ca0e8734c1981486e86",
+      "actual": "3783f6e9728c3ecdb41ec6068f15bc9bf44ff5fc25644ca0e8734c1981486e86",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/scsemi/tools/lean_cellgraph.py",
+      "expected": "0de823e4475786fcd86c0fb83302182ffebafe00a1dad44cdcccc99938430230",
+      "actual": "0de823e4475786fcd86c0fb83302182ffebafe00a1dad44cdcccc99938430230",
+      "match": true
+    },
+    {
+      "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/scsemi/tools/validate_export.py",
+      "expected": "48687cd59bbd3cbba9e07d56a01116a6d9ab46e5a8fb02d9b616cab873ab0f4a",
+      "actual": "48687cd59bbd3cbba9e07d56a01116a6d9ab46e5a8fb02d9b616cab873ab0f4a",
+      "match": true
+    }
+  ],
+  "all_match": true
+}

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/8/test_two_host_resume.py

@@ -0,0 +1,170 @@
+import copy
+import importlib.util
+import json
+from pathlib import Path
+import sys
+import tempfile
+import unittest
+from unittest.mock import Mock
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "tools"))
+
+
+class TwoHostTests(unittest.TestCase):
+    def setUp(self):
+        spec = importlib.util.spec_from_file_location("two_host_resume", ROOT / "tools/two_host_resume.py")
+        self.mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(self.mod)
+
+    def test_partition_covers_exactly_authorized_units(self):
+        names = [f"unit-{i}" for i in range(40)]
+        self.mod.verify_partition(names, names[:28], names[28:])
+        for local, remote in ((names[:28], names[27:]), (names[:27], names[28:]),
+                              (names[:28] + [names[0]], names[28:]),
+                              (names[:28], names[28:-1] + ["outside"]), ([], names)):
+            with self.subTest(local=local, remote=remote):
+                with self.assertRaises(ValueError):
+                    self.mod.verify_partition(names, local, remote)
+
+    def fixture(self, directory):
+        root = Path(directory)
+        unit = "immicro-healthy-fold2-n5"
+        relative = Path("immicro/healthy/fold2/n5")
+        support = root / "protocol/splits" / relative / "support.json"
+        support.parent.mkdir(parents=True)
+        support.write_text(json.dumps({"sha256": "support-hash"}))
+        output = root / "generated" / relative / "lora.npz"
+        output.parent.mkdir(parents=True)
+        output.write_bytes(b"immutable-scientific-output")
+        imported = root / "recoveries/two_host/imported" / unit
+        (imported / "receipts").mkdir(parents=True)
+        (imported / "unit_status").mkdir()
+        marker = {"stage": "compute", "state": "completed", "support_sha256": "support-hash"}
+        marker_path = imported / "unit_status" / f"{unit}.json"
+        marker_path.write_text(json.dumps(marker))
+        raw = {"state": "completed", "signature": "canonical-signature",
+               "outputs": [{"path": str(output), "bytes": output.stat().st_size,
+                            "mtime_ns": 3, "sha256": self.mod.sha256(output)}]}
+        for suffix in self.mod.REQUIRED_RECEIPTS:
+            (imported / "receipts" / f"{unit}-{suffix}.json").write_text(json.dumps(raw))
+        files = []
+        for file in [output, marker_path, *sorted((imported / "receipts").glob("*.json"))]:
+            rel = file.relative_to(imported if file.is_relative_to(imported) else root)
+            files.append({"path": str(rel), "bytes": file.stat().st_size, "sha256": self.mod.sha256(file)})
+        snapshot = {"schema": "pbisc.two-host.snapshot.v1", "unit": unit,
+                    "relative": str(relative), "root": str(root), "source_host": "server_2",
+                    "hostname": "spark-0110", "support_sha256": "support-hash",
+                    "support_file_sha256": self.mod.sha256(support), "marker": marker,
+                    "files": files, "directories": [str(Path("generated") / relative)]}
+        self.mod.write_once_json(imported / "source_snapshot.json", snapshot)
+        return root, unit, output, imported, snapshot
+
+    def test_import_preserves_raw_provenance_and_signature(self):
+        with tempfile.TemporaryDirectory() as td:
+            root, unit, output, imported, snapshot = self.fixture(td)
+            raw_path = imported / "receipts" / f"{unit}-train.json"
+            raw_bytes = raw_path.read_bytes()
+            self.mod.publish_import(root, unit, snapshot, imported)
+            record = json.loads((root / "receipts" / raw_path.name).read_text())
+            self.assertEqual(raw_path.read_bytes(), raw_bytes)
+            self.assertEqual(record["signature"], "canonical-signature")
+            self.assertEqual(record["outputs"][0]["mtime_ns"], output.stat().st_mtime_ns)
+            self.assertEqual(record["remote_provenance"]["source_host"], "server_2")
+            self.assertEqual(record["remote_provenance"]["raw_receipt_sha256"], self.mod.sha256(raw_path))
+            self.assertEqual(record["remote_provenance"]["hostname"], "spark-0110")
+            self.mod.verify_import(root, unit, imported)
+            self.mod.publish_import(root, unit, snapshot, imported)
+
+    def test_output_tamper_rejected_before_any_receipt_publish(self):
+        with tempfile.TemporaryDirectory() as td:
+            root, unit, output, imported, snapshot = self.fixture(td)
+            output.write_bytes(b"tampered")
+            with self.assertRaises(self.mod.ReceiptError):
+                self.mod.publish_import(root, unit, snapshot, imported)
+            self.assertFalse((root / "receipts").exists())
+            self.assertEqual(output.read_bytes(), b"tampered")
+
+    def test_post_import_output_tamper_rejected(self):
+        with tempfile.TemporaryDirectory() as td:
+            root, unit, output, imported, snapshot = self.fixture(td)
+            self.mod.publish_import(root, unit, snapshot, imported)
+            output.write_bytes(b"tampered")
+            with self.assertRaises(self.mod.ReceiptError):
+                self.mod.verify_import(root, unit, imported)
+
+    def test_conflicting_existing_receipt_preserved(self):
+        with tempfile.TemporaryDirectory() as td:
+            root, unit, _, imported, snapshot = self.fixture(td)
+            existing = root / "receipts" / f"{unit}-train.json"
+            existing.parent.mkdir()
+            existing.write_bytes(b'{"state":"failed"}')
+            with self.assertRaises(self.mod.ReceiptError):
+                self.mod.publish_import(root, unit, snapshot, imported)
+            self.assertEqual(existing.read_bytes(), b'{"state":"failed"}')
+            self.assertFalse((imported / "IMPORTED.json").exists())
+
+    def test_raw_remote_receipt_tamper_rejected(self):
+        with tempfile.TemporaryDirectory() as td:
+            root, unit, _, imported, snapshot = self.fixture(td)
+            self.mod.publish_import(root, unit, snapshot, imported)
+            raw = imported / "receipts" / f"{unit}-train.json"
+            record = json.loads(raw.read_text())
+            record["signature"] = "altered"
+            raw.write_text(json.dumps(record))
+            with self.assertRaises(self.mod.ReceiptError):
+                self.mod.verify_import(root, unit, imported)
+
+    def test_normalized_receipt_tamper_rejected(self):
+        with tempfile.TemporaryDirectory() as td:
+            root, unit, _, imported, snapshot = self.fixture(td)
+            self.mod.publish_import(root, unit, snapshot, imported)
+            path = root / "receipts" / f"{unit}-train.json"
+            record = json.loads(path.read_text())
+            record["remote_provenance"]["raw_receipt_sha256"] = "0" * 64
+            path.write_text(json.dumps(record))
+            with self.assertRaises(self.mod.ReceiptError):
+                self.mod.verify_import(root, unit, imported)
+
+    def test_failed_and_missing_previous_services_never_restart(self):
+        for properties in ({"LoadState": "not-found"},
+                           {"LoadState": "loaded", "ActiveState": "failed", "Result": "exit-code",
+                            "Description": "PBISC strict two-host binding local"}):
+            controller = self.mod.Controller.__new__(self.mod.Controller)
+            controller.config = {"service_prefix": "test"}
+            controller.config_hash = "binding"
+            controller.state = {"services": {"local": {"state": "launch_intent"}}}
+            controller.properties = Mock(return_value=properties)
+            controller.command = Mock()
+            controller.save = Mock()
+            with self.assertRaises(self.mod.ReceiptError):
+                controller.ensure_service("local", ["python", "campaign.py"])
+            controller.command.assert_not_called()
+
+    def test_snapshot_rejects_other_unit_paths(self):
+        with tempfile.TemporaryDirectory() as td:
+            root, unit, _, imported, snapshot = self.fixture(td)
+            corrupt = copy.deepcopy(snapshot)
+            corrupt["files"][0]["path"] = "generated/other/secret.npz"
+            with self.assertRaises(self.mod.ReceiptError):
+                self.mod.publish_import(root, unit, corrupt, imported)
+
+    def test_service_success_requires_zero_exit_and_retained_completion(self):
+        success = {"LoadState": "loaded", "ActiveState": "active", "SubState": "exited",
+                   "Result": "success", "ExecMainStatus": "0", "ExecMainCode": "1"}
+        self.assertEqual(self.mod.service_phase(success), "completed")
+        self.assertEqual(self.mod.service_phase({**success, "ActiveState": "failed", "Result": "exit-code"}), "failed")
+        self.assertEqual(self.mod.service_phase({**success, "ExecMainStatus": "2"}), "failed")
+        self.assertEqual(self.mod.service_phase({"LoadState": "not-found"}), "missing")
+
+    def test_controller_launch_is_bounded_without_outer_gpu_lock(self):
+        argv = self.mod.service_command("pbisc-test", ["/python", "campaign.py", "run"],
+                                        ROOT, ROOT / "recovery.log", "binding")
+        self.assertNotIn("ml-run", " ".join(argv))
+        for value in ("--slice=app.slice", "MemoryMax=2G", "MemorySwapMax=0", "OOMPolicy=kill",
+                      "OOMScoreAdjust=500", "Restart=no", "RemainAfterExit=yes", "CUDA_VISIBLE_DEVICES="):
+            self.assertIn(value, 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/9/rebind_sources_20261012.py

@@ -0,0 +1,91 @@
+"""Explicitly attest unchanged historical support computations after input isolation.
+
+Original receipts and source bytes remain immutable. This does not reclassify
+historical full-array loading as physically isolated access.
+"""
+from pathlib import Path
+import hashlib
+import json
+import shutil
+import sys
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "tools"))
+import campaign as C
+from runtime import Runtime, atomic_json, sha256, stamp
+
+
+def main():
+    destination = ROOT / "recoveries/source_reuse_20261012"
+    destination.mkdir(exist_ok=True)
+    backups = json.loads((ROOT / "backups/recovery_input_isolation_20261012T142024Z/MANIFEST.json").read_text())
+    lookup = {x["source"]: x for x in backups}
+    for item in backups:
+        assert sha256(Path(item["backup"])) == item["sha256"]
+    cache = {}
+
+    def digest(path):
+        path = str(Path(path).resolve())
+        if path not in cache:
+            cache[path] = sha256(Path(path))
+        return cache[path]
+
+    def old_signature(argv, inputs):
+        rows = [{"path": str(p.resolve()), "sha256": lookup[str(p.resolve())]["sha256"]
+                 if str(p.resolve()) in lookup else digest(p)} for p in inputs]
+        return hashlib.sha256(json.dumps({"argv": argv, "inputs": rows}, sort_keys=True).encode()).hexdigest()
+
+    runtime = Runtime(ROOT)
+    transitions = []
+    for fold in ("fold0", "fold1"):
+        support = ROOT / "protocol/splits/immicro/healthy" / fold / "n5/support.json"
+        replay = ROOT / "isolated/immicro/healthy" / fold / "n5/REPLAY.json"
+        evidence = json.loads(replay.read_text())
+        assert evidence["all_selected_values_exact"] and evidence["training_draws_exact"]
+        assert evidence["support_sha256"] == C.read_support(support)["sha256"]
+        prepare = C.OLD / "scsemi/tools/prepare_draw_inputs.py"
+        work = ROOT / "scsemi" / C.relative(support)
+        commands = [("train", C.train_command(support), C.train_inputs(support)),
+                    ("scinputs", [C.SC_PY, "-u", str(prepare), "--dataset", "immicro",
+                                  "--support-manifest", str(support), "--work", str(work)],
+                     [support, prepare, ROOT / "tools/support_input_isolation.py"])]
+        for suffix, argv, inputs in commands:
+            name = f"{C.name(support)}-{suffix}"
+            receipt_path = runtime.receipt_path(name)
+            receipt = json.loads(receipt_path.read_text())
+            assert receipt["state"] == "completed"
+            prior_inputs = [p for p in inputs if p.name != "support_input_isolation.py"]
+            reproduced = old_signature(argv, prior_inputs)
+            assert reproduced == receipt["signature"], f"old source binding cannot be reproduced: {name}"
+            outputs = [Path(x["path"]) for x in receipt["outputs"]]
+            assert runtime.can_skip(name, reproduced, outputs)
+            preserved = destination / receipt_path.name
+            if preserved.exists():
+                assert preserved.read_bytes() == receipt_path.read_bytes()
+            else:
+                shutil.copy2(receipt_path, preserved)
+            proof = destination / f"{name}-proof.json"
+            new_signature = runtime.signature(argv, inputs)
+            atomic_json(proof, {"operation": name, "old_signature_reproduced": reproduced,
+                                "new_signature": new_signature, "source_backups": backups,
+                                "support_manifest_sha256": digest(support),
+                                "selected_computation_replay": str(replay),
+                                "outputs_unchanged": receipt["outputs"],
+                                "limitation": "Original loaders materialized non-support arrays before selection. Reuse establishes selected-computation equivalence, not historical physical input isolation."})
+            transitions.append({"operation": name, "old_signature": reproduced,
+                                "new_signature": new_signature,
+                                "original_receipt": {"path": str(preserved), "sha256": sha256(preserved)},
+                                "evidence": [{"name": "old-source-reproduction", "path": str(proof), "sha256": sha256(proof)},
+                                             {"name": "isolated-replay", "path": str(replay), "sha256": sha256(replay)}]})
+    manifest = ROOT / "recoveries/SOURCE_REUSE.json"
+    if manifest.exists():
+        raise FileExistsError("source reuse already recorded; do not replace evidence")
+    atomic_json(manifest, {"schema": "pbisc.strictpairs.source-reuse.v1", "at": stamp(), "transitions": transitions})
+    for item in transitions:
+        record = json.loads(runtime.receipt_path(item["operation"]).read_text())
+        assert runtime.can_skip(item["operation"], item["new_signature"], [Path(x["path"]) for x in record["outputs"]])
+    print(json.dumps({"verified_transitions": len(transitions), "manifest": str(manifest)}))
+
+
+if __name__ == "__main__":
+    main()