Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261007T185408Z-scsemi-cleanup-recovery/diffusion/dataset/server_1/maintenance/207d2460f5aa644b/test_update.py

@@ -0,0 +1,362 @@
+"""Offline contract tests for the incremental release gate."""
+from __future__ import annotations
+
+import fcntl
+import hashlib
+import json
+from pathlib import Path
+import sys
+import tempfile
+from types import SimpleNamespace
+import unittest
+from unittest.mock import patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import update
+
+
+class UpdateTests(unittest.TestCase):
+    def setUp(self):
+        self.temporary = tempfile.TemporaryDirectory(dir='/home/sj_server_1')
+        self.addCleanup(self.temporary.cleanup)
+        self.root = Path(self.temporary.name) / 'release'
+        self.root.mkdir()
+        self.maintenance = self.root / 'maintenance'
+        self.maintenance.mkdir()
+        self.model = Path(self.temporary.name) / 'model8'
+        self.paper = Path(self.temporary.name) / 'paper'
+        self.other = Path(self.temporary.name) / 'other-paper'
+        for path in (self.model, self.paper, self.other):
+            path.mkdir()
+        (self.maintenance / 'SCOPE.json').write_text(json.dumps({
+            'project_id': 'pbisc-diffusion',
+            'core_roots': {'model8': str(self.model), 'manuscript': str(self.paper)},
+            'maintenance_root': str(self.maintenance),
+            'external_dependencies': [],
+            'forbidden_components': ['.git', '.venv', 'venv', 'runtime_env', '__pycache__',
+                                     'node_modules', 'Rlib', '.cache'],
+        }))
+        self.source = self.model / 'weights.pt'
+        self.source.write_bytes(b'first')
+        self.identifier = '20260928T120000Z-a'
+        self.request = {'project_id': 'pbisc-diffusion', 'summary': 'new experiment',
+                        'assets': [{'host': 'server_1', 'source': str(self.source),
+                                    'kind': 'checkpoint', 'state': 'completed'}],
+                        'inference_locations': []}
+        self.patch_roots = patch.object(update, 'CORE_ROOTS',
+                                        {'model8': self.model, 'manuscript': self.paper})
+        self.patch_roots.start()
+        self.addCleanup(self.patch_roots.stop)
+
+    def prepare(self, request=None, identifier=None):
+        return update.prepare(self.root, request or self.request, identifier or self.identifier)
+
+    def test_rejects_other_paper_and_symlink_escape(self):
+        bad = json.loads(json.dumps(self.request))
+        bad['assets'][0]['source'] = str(self.other / 'weights.bin')
+        (self.other / 'weights.bin').write_bytes(b'bad')
+        with self.assertRaises(update.UpdateError):
+            self.prepare(bad)
+        bad['project_id'] = 'another-paper'
+        with self.assertRaisesRegex(update.UpdateError, 'wrong_request_project'):
+            self.prepare(bad)
+        link = self.model / 'escape.bin'
+        link.symlink_to(self.other / 'weights.bin')
+        bad['assets'][0]['source'] = str(link)
+        with self.assertRaises(update.UpdateError):
+            self.prepare(bad)
+        self.assertFalse((self.root / 'LATEST.json').exists())
+
+    def test_hash_change_is_incremental_and_old_paths_untouched(self):
+        baseline = {'assets': [{'host': 'server_1', 'source': str(self.source),
+                                'sha256': hashlib.sha256(b'first').hexdigest()}]}
+        (self.root / 'COMBINED_ASSET_INDEX.json').write_text(json.dumps(baseline))
+        frozen = self.root / 'RELEASE_LOCK.json'
+        frozen.write_bytes(b'{"immutable":true}\n')
+        with self.assertRaisesRegex(update.UpdateError, 'no_changed_assets'):
+            self.prepare()
+        self.source.write_bytes(b'second')
+        output = self.prepare()
+        rows = json.loads((output / 'manifest.json').read_text())['assets']
+        payload = [r for r in rows if r['source'] == str(self.source)][0]
+        self.assertEqual(payload['repo_type'], 'model')
+        self.assertTrue(payload['bundle_path'].startswith('updates/' + self.identifier + '/'))
+        self.assertEqual(baseline, json.loads((self.root / 'COMBINED_ASSET_INDEX.json').read_text()))
+        self.assertEqual(frozen.read_bytes(), b'{"immutable":true}\n')
+        self.assertFalse((self.root / 'LATEST.json').exists())
+
+    def test_rejects_running_payload_and_external_checkpoint(self):
+        bad = json.loads(json.dumps(self.request))
+        bad['assets'][0]['state'] = 'running'
+        with self.assertRaises(update.UpdateError):
+            self.prepare(bad)
+        external = self.other / 'checkpoint.pt'
+        external.write_bytes(b'checkpoint')
+        scope = json.loads((self.maintenance / 'SCOPE.json').read_text())
+        scope['external_dependencies'] = [{'host': 'server_1', 'source': str(external),
+                                           'reason': 'evaluation'}]
+        (self.maintenance / 'SCOPE.json').write_text(json.dumps(scope))
+        bad['assets'][0].update(source=str(external), state='completed')
+        with self.assertRaises(update.UpdateError):
+            self.prepare(bad)
+
+    def test_parent_conflict_and_lock_refuse_before_publisher(self):
+        output = self.prepare()
+        (self.root / 'LATEST.json').write_text(json.dumps({'id': 'different'}))
+        called = []
+        with self.assertRaisesRegex(update.UpdateError, 'parent_changed'):
+            update.publish(self.root, self.identifier, execute=True,
+                           publisher=lambda *_: called.append(1))
+        self.assertEqual(called, [])
+        (self.root / 'LATEST.json').unlink()
+        lock = self.maintenance / '.writer.lock'
+        with lock.open('a') as stream:
+            fcntl.flock(stream, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            with self.assertRaisesRegex(update.UpdateError, 'writer_busy'):
+                update.publish(self.root, self.identifier, execute=True,
+                               publisher=lambda *_: called.append(1))
+        self.assertEqual(called, [])
+        self.assertTrue(output.exists())
+
+    def test_latest_never_advances_on_publisher_failure(self):
+        self.prepare()
+        with self.assertRaisesRegex(update.UpdateError, 'publisher_failed'):
+            update.publish(self.root, self.identifier, execute=True,
+                           publisher=lambda *_: 1)
+        self.assertFalse((self.root / 'LATEST.json').exists())
+        self.assertFalse((self.maintenance / 'updates' / self.identifier / 'UPDATE_VERIFIED.json').exists())
+
+    def test_resumes_after_pointer_was_already_committed(self):
+        folder = self.prepare()
+        manifest_bytes = (folder / 'manifest.json').read_bytes()
+        manifest = json.loads(manifest_bytes)
+        verified_rows = [dict(row, archive_stat={}, hf_revision='a' * 40)
+                         for row in manifest['assets']]
+        receipt = json.dumps({'status': 'PASS', 'project_id': 'pbisc-diffusion',
+                              'update_id': self.identifier,
+                              'parent_latest': None,
+                              'manifest_sha256': hashlib.sha256(manifest_bytes).hexdigest(),
+                              'assets': verified_rows})
+        (folder / 'UPDATE_VERIFIED.json').write_text(receipt)
+        pointer = {'id': self.identifier, 'project_id': 'pbisc-diffusion',
+                   'verified_receipt_sha256': hashlib.sha256(receipt.encode()).hexdigest()}
+        (self.root / 'LATEST.json').write_text(json.dumps(pointer))
+        with patch.object(update, '_refresh_catalog') as refresh, \
+             patch.object(update, '_remote_latest', return_value=pointer), \
+             patch.object(update, '_hf_latest', return_value=pointer), \
+             patch.object(update, '_hf_api', return_value=object()), \
+             patch.object(update, '_verify_rows', return_value=verified_rows), \
+             patch.object(update, '_check_publisher_receipts'):
+            result = update.publish(self.root, self.identifier, execute=True,
+                                    publisher=lambda *_: self.fail('publisher reran'))
+        self.assertEqual(result, pointer)
+        refresh.assert_called_once_with(self.root)
+        self.assertEqual(json.loads((folder / 'STATUS.json').read_text())['phase'], 'verified')
+
+    def test_verified_replay_uses_frozen_assets_after_source_changes(self):
+        folder = self.prepare()
+        manifest = json.loads((folder / 'manifest.json').read_text())
+        scope = update._scope(self.root)
+        self.source.write_bytes(b'changed after publication')
+        with self.assertRaisesRegex(update.UpdateError, 'manifest_row_scope_mismatch'):
+            update._validate_manifest_rows(self.root, folder, manifest, scope, False)
+        update._validate_manifest_rows(self.root, folder, manifest, scope, False, True)
+        row = manifest['assets'][0]
+        paper = update._publisher()
+
+        class API:
+            def repo_info(self, **_):
+                return SimpleNamespace(sha='a' * 40)
+
+        info = {'size': row['bytes'], 'lfs': {'sha256': row['sha256']}}
+        with patch.object(update, '_hf_api', return_value=API()), \
+             patch.object(paper, 'check_visibility'), \
+             patch.object(paper, 'source_digest', return_value='0' * 64) as source_digest, \
+             patch.object(paper, 'remote_call', return_value={'event': 'verified_existing', 'stat': {}}), \
+             patch.object(paper.base, 'remote_file', return_value=info):
+            with self.assertRaisesRegex(update.UpdateError, 'source_changed'):
+                update._verify_rows(self.root, self.identifier, [row])
+            source_digest.reset_mock()
+            verified = update._verify_rows(self.root, self.identifier, [row], True)
+            source_digest.assert_not_called()
+        self.assertEqual(verified[0]['sha256'], row['sha256'])
+
+    def test_completed_pointer_replay_survives_source_change(self):
+        folder = self.prepare()
+        manifest_bytes = (folder / 'manifest.json').read_bytes()
+        manifest = json.loads(manifest_bytes)
+        rows = [dict(row, archive_stat={}, hf_revision='a' * 40)
+                for row in manifest['assets']]
+        receipt = {'status': 'PASS', 'project_id': 'pbisc-diffusion',
+                   'update_id': self.identifier, 'parent_latest': None,
+                   'manifest_sha256': hashlib.sha256(manifest_bytes).hexdigest(),
+                   'assets': rows}
+        verified_path = folder / 'UPDATE_VERIFIED.json'
+        verified_path.write_text(json.dumps(receipt))
+        pointer = {'id': self.identifier, 'project_id': 'pbisc-diffusion',
+                   'receipt_revision': 'a' * 40,
+                   'verified_receipt_sha256': hashlib.sha256(verified_path.read_bytes()).hexdigest()}
+        (folder / 'LATEST.json').write_text(json.dumps(pointer))
+        (self.root / 'LATEST.json').write_text(json.dumps(pointer))
+        self.source.write_bytes(b'changed after publication')
+        with patch.object(update, '_remote_latest', return_value=pointer), \
+             patch.object(update, '_hf_latest', return_value=pointer), \
+             patch.object(update, '_hf_api', return_value=object()), \
+             patch.object(update, '_verify_rows', return_value=rows), \
+             patch.object(update, '_check_publisher_receipts'), \
+             patch.object(update, '_refresh_catalog'), \
+             patch('huggingface_hub.hf_hub_download', return_value=str(verified_path)):
+            result = update.publish(self.root, self.identifier, execute=True,
+                                    publisher=lambda *_: self.fail('publisher reran'))
+        self.assertEqual(result, pointer)
+
+    def test_wrong_pinned_hf_digest_cannot_verify(self):
+        folder = self.prepare()
+        row = json.loads((folder / 'manifest.json').read_text())['assets'][0]
+        paper = update._publisher()
+
+        class API:
+            def repo_info(self, **_):
+                return SimpleNamespace(sha='a' * 40)
+
+        info = {'path': row['remote_path'], 'size': row['bytes'],
+                'lfs': {'sha256': '0' * 64}}
+        with patch.object(update, '_hf_api', return_value=API()), \
+             patch.object(paper, 'check_visibility'), \
+             patch.object(paper, 'remote_call', return_value={'event': 'verified_existing', 'stat': {}}), \
+             patch.object(paper.base, 'remote_file', return_value=info):
+            with self.assertRaisesRegex(update.UpdateError, 'hf_payload_digest_mismatch'):
+                update._verify_rows(self.root, self.identifier, [row])
+
+    def test_remote_model8_path_and_host_namespace(self):
+        request = json.loads(json.dumps(self.request))
+        request['assets'][0]['host'] = 'server_2'
+        paper = update._publisher()
+        with patch.object(update, '_remote_stat', return_value={
+            'dev': 1, 'ino': 2, 'size': 5, 'mtime_ns': 3,
+        }), patch.object(paper, 'source_digest', return_value='a' * 64):
+            folder = self.prepare(request)
+        row = json.loads((folder / 'manifest.json').read_text())['assets'][0]
+        self.assertEqual(row['host'], 'server_2')
+        self.assertIn('/server_2/model8/', row['bundle_path'])
+        self.assertEqual(row['repo_type'], 'model')
+
+    def test_maintenance_requires_explicit_kind_and_checkpoint_extension(self):
+        policy = self.maintenance / 'POLICY.md'
+        policy.write_text('policy\n')
+        request = json.loads(json.dumps(self.request))
+        request['assets'][0].update(source=str(policy), kind='code')
+        with self.assertRaisesRegex(update.UpdateError, 'maintenance_kind_scope'):
+            self.prepare(request)
+        request['assets'][0]['kind'] = 'maintenance'
+        folder = self.prepare(request)
+        row = json.loads((folder / 'manifest.json').read_text())['assets'][0]
+        self.assertEqual(row['repo_type'], 'dataset')
+        self.assertIn('/maintenance/', row['bundle_path'])
+        other = json.loads(json.dumps(self.request))
+        other['assets'][0]['source'] = str(self.model / 'condition.npz')
+        (self.model / 'condition.npz').write_bytes(b'npz')
+        with self.assertRaisesRegex(update.UpdateError, 'checkpoint_extension_refused'):
+            self.prepare(other, '20260928T120001Z-b')
+
+    def test_locator_requires_evidence_for_completion_and_refuses_symlinks(self):
+        output = self.model / 'prediction.txt'
+        request = {'project_id': 'pbisc-diffusion', 'summary': 'inference pointer',
+                   'assets': [], 'inference_locations': [{
+                       'host': 'server_1', 'path': str(output), 'state': 'completed',
+                   }]}
+        with self.assertRaisesRegex(update.UpdateError, 'completed_locator_evidence_missing'):
+            self.prepare(request)
+        receipt = self.model / 'receipt.json'
+        output.write_text('prediction')
+        receipt.write_text('{}')
+        request['inference_locations'][0]['receipt'] = str(receipt)
+        folder = self.prepare(request)
+        location = json.loads((folder / 'inference_locations.json').read_text())['locations'][0]
+        self.assertEqual(location['sha_basis'], 'existing_receipt')
+        self.assertEqual(location['observed_output']['kind'], 'file')
+        link = self.model / 'linked.txt'
+        link.symlink_to(output)
+        request['inference_locations'][0].update(path=str(link), state='running')
+        with self.assertRaisesRegex(update.UpdateError, 'locator_symlink_refused'):
+            self.prepare(request, '20260928T120001Z-b')
+
+    def test_planned_locator_can_be_missing_with_explicit_presence(self):
+        request = {'project_id': 'pbisc-diffusion', 'summary': 'planned inference',
+                   'assets': [], 'inference_locations': [{
+                       'host': 'server_1', 'path': str(self.model / 'future.txt'),
+                       'state': 'planned',
+                   }]}
+        folder = self.prepare(request)
+        location = json.loads((folder / 'inference_locations.json').read_text())['locations'][0]
+        self.assertEqual(location['sha_basis'], 'presence_unverified')
+        self.assertEqual(location['observed_output']['presence'], 'missing_unverified')
+
+    def test_hf_record_conflict_and_latest_parent_cas(self):
+        record = self.root / 'record.json'
+        record.write_text('{"id":"ours"}\n')
+        old = self.root / 'old.json'
+        old.write_text('{"id":"theirs"}\n')
+
+        class API:
+            def repo_info(self, **_):
+                return SimpleNamespace(sha='a' * 40)
+
+            def create_commit(self, **_):
+                raise AssertionError('commit must not run')
+
+        paper = update._publisher()
+        with patch.object(paper.base, 'remote_file', return_value={'path': 'exists'}), \
+             patch('huggingface_hub.hf_hub_download', return_value=str(old)):
+            with self.assertRaisesRegex(update.UpdateError, 'immutable_hf_record_conflict'):
+                update._hf_upload_verified(API(), record, 'remote/immutable.json')
+            with self.assertRaisesRegex(update.UpdateError, 'hf_latest_parent_changed'):
+                update._hf_upload_verified(API(), record, 'remote/LATEST.json',
+                                           mutable=True, expected_parent=None)
+
+    def test_edited_prepared_manifest_cannot_change_asset_classification(self):
+        folder = self.prepare()
+        path = folder / 'manifest.json'
+        manifest = json.loads(path.read_text())
+        manifest['assets'][0]['repo_type'] = 'dataset'
+        manifest['assets'][0]['repo_id'] = 'junidude14/PBISC-data'
+        path.write_text(json.dumps(manifest))
+        with self.assertRaisesRegex(update.UpdateError, 'manifest_row_scope_mismatch'):
+            update.publish(self.root, self.identifier, execute=True,
+                           publisher=lambda *_: self.fail('publisher must not run'))
+        self.assertFalse((self.root / 'LATEST.json').exists())
+
+    def test_history_uses_only_reachable_verified_receipt(self):
+        folder = self.prepare()
+        manifest = json.loads((folder / 'manifest.json').read_text())
+        receipt = {'status': 'PASS', 'project_id': 'pbisc-diffusion',
+                   'update_id': self.identifier, 'parent_latest': None,
+                   'assets': manifest['assets']}
+        receipt_path = folder / 'UPDATE_VERIFIED.json'
+        receipt_path.write_text(json.dumps(receipt))
+        orphan = self.maintenance / 'updates' / '20260928T120002Z-orphan'
+        orphan.mkdir()
+        (orphan / 'UPDATE_VERIFIED.json').write_text(json.dumps({
+            'status': 'PASS', 'assets': [{'host': 'server_1', 'source': str(self.source),
+                                         'sha256': '0' * 64}],
+        }))
+        pointer = {'id': self.identifier,
+                   'verified_receipt_sha256': hashlib.sha256(receipt_path.read_bytes()).hexdigest(),
+                   'receipt_revision': 'a' * 40,
+                   'parent': None}
+        (self.root / 'LATEST.json').write_text(json.dumps(pointer))
+        with self.assertRaisesRegex(update.UpdateError, 'no_changed_assets'):
+            self.prepare(identifier='20260928T120003Z-next')
+        self.source.write_bytes(b'new content')
+        next_folder = self.prepare(identifier='20260928T120003Z-next')
+        next_manifest = json.loads((next_folder / 'manifest.json').read_text())
+        self.assertEqual(next_manifest['parent_latest'], pointer)
+        self.assertEqual(update._parent_ref(pointer), {
+            'id': self.identifier,
+            'verified_receipt_sha256': pointer['verified_receipt_sha256'],
+            'receipt_revision': 'a' * 40,
+        })
+
+
+if __name__ == '__main__':
+    unittest.main()

paper-releases/pbisc-diffusion/updates/20261007T185408Z-scsemi-cleanup-recovery/diffusion/dataset/server_1/maintenance/38e4c628399ccf84/update.py

@@ -0,0 +1,799 @@
+#!/usr/bin/env python3
+"""Scoped, CPU-only incremental PBISC-diffusion publication.
+
+Prepare is local (server_2 source metadata requires SSH). Publish is explicit and
+uses the frozen paper publisher in a fresh process. No GPU work is started.
+"""
+from __future__ import annotations
+
+import argparse
+import fcntl
+import hashlib
+import json
+import os
+from pathlib import Path, PurePosixPath
+import re
+import shlex
+import stat
+import subprocess
+import sys
+import tempfile
+from typing import Any, Callable
+
+ROOT = Path(__file__).resolve().parent.parent
+CORE_ROOTS = {
+    'model8': Path('/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion'),
+    'manuscript': Path('/home/sj_server_1/PBISC/paper-release-20260928/manuscript'),
+}
+REMOTE = 'spark-0110'
+REMOTE_ROOT = '/home/sj_server_2/PBISC/paper-release-20260928'
+PREFIX = 'paper-releases/pbisc-diffusion'
+ID_RE = re.compile(r'[0-9]{8}T[0-9]{6}Z-[a-z0-9-]+\Z')
+SHA_RE = re.compile(r'[0-9a-f]{64}\Z')
+STATES = {'completed', 'final', 'intermediate', 'stopped'}
+LOCATOR_STATES = STATES | {'running', 'planned', 'failed', 'presence_only'}
+FORBIDDEN = {'.git', '.venv', 'venv', 'runtime_env', '__pycache__', 'node_modules', 'Rlib', '.cache'}
+NON_PAYLOAD_KINDS = {'output', 'outputs', 'generated', 'inference', 'sample', 'samples', 'prediction', 'predictions'}
+ALLOWED_KINDS = {'checkpoint', 'condition', 'code', 'manuscript', 'data', 'metadata',
+                 'report', 'figure', 'table', 'log', 'provenance', 'maintenance',
+                 'policy', 'config', 'test', 'document'}
+MAINTENANCE_FILES = {'POLICY.md', 'SCOPE.json', 'update.py', 'test_update.py',
+                     'catalog.py', 'test_catalog.py', 'CURRENT.md', 'request.example.json'}
+
+
+class UpdateError(Exception):
+    pass
+
+
+def _json(path: Path) -> Any:
+    return json.loads(path.read_text(encoding='utf-8'))
+
+
+def _bytes(value: Any) -> bytes:
+    return (json.dumps(value, sort_keys=True, indent=2, ensure_ascii=False) + '\n').encode()
+
+
+def _atomic(path: Path, data: bytes) -> None:
+    if path.is_symlink() or path.parent.is_symlink():
+        raise UpdateError('unsafe_output_path')
+    path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    with tempfile.NamedTemporaryFile(dir=path.parent, prefix='.owned-', delete=False) as stream:
+        temporary = Path(stream.name)
+        stream.write(data)
+        stream.flush()
+        os.fsync(stream.fileno())
+    try:
+        os.replace(temporary, path)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def _path(value: Any, host: str) -> Path:
+    if not isinstance(value, str) or not value.startswith('/') or '\\' in value or any(ord(c) < 32 for c in value):
+        raise UpdateError('invalid_source_path')
+    path = PurePosixPath(value)
+    if str(path) != value or any(part in ('.', '..') for part in path.parts):
+        raise UpdateError('invalid_source_path')
+    allowed_homes = ('/home/sj_server_1/',) if host == 'server_1' else ('/home/sj_server_1/', '/home/sj_server_2/')
+    if not value.startswith(allowed_homes):
+        raise UpdateError('wrong_source_host')
+    return Path(value)
+
+
+def _safe_local(path: Path) -> None:
+    current = Path('/')
+    for part in path.parts[1:]:
+        current /= part
+        if current.is_symlink():
+            raise UpdateError('source_symlink_refused')
+    st = path.lstat()
+    if not stat.S_ISREG(st.st_mode):
+        raise UpdateError('source_not_regular')
+
+
+def _scope(root: Path) -> dict[str, Any]:
+    maintenance = root / 'maintenance'
+    if maintenance.is_symlink() or maintenance.resolve() != maintenance:
+        raise UpdateError('unsafe_maintenance_root')
+    if (maintenance / 'SCOPE.json').is_symlink():
+        raise UpdateError('unsafe_scope_file')
+    scope = _json(maintenance / 'SCOPE.json')
+    if not isinstance(scope, dict) or scope.get('project_id') != 'pbisc-diffusion':
+        raise UpdateError('wrong_project_scope')
+    if scope.get('core_roots') != {k: str(v) for k, v in CORE_ROOTS.items()}:
+        raise UpdateError('wrong_core_roots')
+    if scope.get('maintenance_root') != str(maintenance):
+        raise UpdateError('wrong_maintenance_root')
+    forbidden = scope.get('forbidden_components')
+    if not isinstance(forbidden, list) or not FORBIDDEN.issubset(set(forbidden)):
+        raise UpdateError('missing_forbidden_components')
+    dependencies = scope.get('external_dependencies')
+    if not isinstance(dependencies, list):
+        raise UpdateError('invalid_dependencies')
+    for item in dependencies:
+        if (not isinstance(item, dict) or item.get('host') not in ('server_1', 'server_2')
+                or not isinstance(item.get('reason'), str) or not item['reason'].strip()):
+            raise UpdateError('invalid_dependency')
+        _path(item.get('source'), item['host'])
+    return scope
+
+
+def _allow(path: Path, host: str, scope: dict[str, Any], *, internal: Path | None = None) -> str:
+    if any(part in set(scope['forbidden_components']) for part in path.parts):
+        raise UpdateError('forbidden_component')
+    if internal is not None and host == 'server_1' and path.is_relative_to(internal):
+        return 'internal'
+    if host == 'server_1' and path.parent == Path(scope['maintenance_root']) and path.name in MAINTENANCE_FILES:
+        return 'maintenance'
+    for name, root in CORE_ROOTS.items():
+        if path.is_relative_to(root) and path != root:
+            return name
+    if any(item['host'] == host and item['source'] == str(path)
+           for item in scope['external_dependencies']):
+        return 'dependency'
+    raise UpdateError('source_outside_project_scope')
+
+
+def _publisher():
+    sys.path.insert(0, str(ROOT / 'tools'))
+    import publish_paper_assets as paper
+    return paper
+
+
+def _remote_stat(path: Path) -> dict[str, int]:
+    code = '''import json,os,stat,sys
+p=sys.argv[1]; q='/'
+for part in p.strip('/').split('/'):
+ q=os.path.join(q,part)
+ if os.path.islink(q): raise SystemExit(2)
+s=os.lstat(p)
+if not stat.S_ISREG(s.st_mode): raise SystemExit(2)
+print(json.dumps(dict(dev=s.st_dev,ino=s.st_ino,size=s.st_size,mtime_ns=s.st_mtime_ns)))'''
+    result = subprocess.run(['ssh', '-o', 'BatchMode=yes', REMOTE,
+                             shlex.join(['python3', '-B', '-c', code, str(path)])],
+                            capture_output=True, text=True, check=False)
+    if result.returncode:
+        raise UpdateError('remote_source_unavailable')
+    return json.loads(result.stdout)
+
+
+def _locator_stat(path: Path, host: str) -> dict[str, Any]:
+    """Observe a locator without hashing large generated outputs."""
+    if host == 'server_1':
+        current = Path('/')
+        for part in path.parts[1:]:
+            current /= part
+            if current.is_symlink():
+                raise UpdateError('locator_symlink_refused')
+            if not current.exists():
+                return {'presence': 'missing_unverified'}
+        st = path.lstat()
+        return {'presence': 'observed', 'kind': 'file' if stat.S_ISREG(st.st_mode) else 'directory' if stat.S_ISDIR(st.st_mode) else 'other',
+                'stat': {'dev': st.st_dev, 'ino': st.st_ino, 'size': st.st_size, 'mtime_ns': st.st_mtime_ns}}
+    code = '''import json,os,stat,sys
+p=sys.argv[1]; q='/'
+for part in p.strip('/').split('/'):
+ q=os.path.join(q,part)
+ if os.path.islink(q): raise SystemExit(2)
+ if not os.path.exists(q):
+  print(json.dumps({'presence':'missing_unverified'})); raise SystemExit(0)
+s=os.lstat(p)
+k='file' if stat.S_ISREG(s.st_mode) else 'directory' if stat.S_ISDIR(s.st_mode) else 'other'
+print(json.dumps({'presence':'observed','kind':k,'stat':dict(dev=s.st_dev,ino=s.st_ino,size=s.st_size,mtime_ns=s.st_mtime_ns)}))'''
+    result = subprocess.run(['ssh', '-o', 'BatchMode=yes', REMOTE,
+                             shlex.join(['python3', '-B', '-c', code, str(path)])],
+                            capture_output=True, text=True, check=False)
+    if result.returncode:
+        raise UpdateError('remote_locator_unavailable')
+    return json.loads(result.stdout)
+
+
+def _row(host: str, path: Path, kind: str, identifier: str, scope: dict[str, Any]) -> dict[str, Any]:
+    area = _allow(path, host, scope)
+    if host == 'server_1':
+        _safe_local(path)
+    snap = _publisher().base.snapshot(path.lstat()) if host == 'server_1' else _remote_stat(path)
+    if kind == 'checkpoint' and area != 'model8':
+        raise UpdateError('checkpoint_outside_model8')
+    if kind == 'checkpoint' and path.suffix.lower() not in {'.pt', '.pth', '.safetensors'}:
+        raise UpdateError('checkpoint_extension_refused')
+    if kind == 'condition' and path.suffix.lower() != '.npz':
+        raise UpdateError('condition_requires_npz')
+    if kind not in ALLOWED_KINDS:
+        raise UpdateError('generated_payload_refused')
+    if (area == 'maintenance') != (kind == 'maintenance'):
+        raise UpdateError('maintenance_kind_scope')
+    if kind not in {'checkpoint', 'condition'} and any(part.lower() in NON_PAYLOAD_KINDS for part in path.parts):
+        raise UpdateError('generated_payload_refused')
+    root = CORE_ROOTS.get(area)
+    relative = path.relative_to(root) if root is not None else Path(hashlib.sha256(str(path).encode()).hexdigest()[:16]) / path.name
+    bundle = PurePosixPath('updates') / identifier / 'diffusion' / ('model' if kind == 'checkpoint' else 'dataset') / host / area / PurePosixPath(*relative.parts)
+    repo_type = 'model' if kind == 'checkpoint' else 'dataset'
+    repo_id = 'junidude14/PBISC' if repo_type == 'model' else 'junidude14/PBISC-data'
+    row = {'host': host, 'source': str(path), 'bundle_path': str(bundle), 'repo_type': repo_type,
+           'repo_id': repo_id, 'remote_path': str(PurePosixPath(PREFIX) / bundle),
+           'bytes': snap['size'], 'expected_stat': snap, 'category': kind}
+    row['sha256'] = _publisher().source_digest(row)
+    return row
+
+
+def _history(root: Path) -> dict[tuple[str, str], str]:
+    seen = {}
+    baseline = root / 'COMBINED_ASSET_INDEX.json'
+    if baseline.exists():
+        for row in _json(baseline).get('assets', []):
+            seen[row['host'], row['source']] = row['sha256']
+    pointer = _latest(root)
+    chain = []
+    visited = set()
+    while pointer is not None:
+        identifier = pointer.get('id') if isinstance(pointer, dict) else None
+        if not isinstance(identifier, str) or not ID_RE.fullmatch(identifier) or identifier in visited:
+            raise UpdateError('invalid_latest_chain')
+        visited.add(identifier)
+        path = root / 'maintenance' / 'updates' / identifier / 'UPDATE_VERIFIED.json'
+        if path.is_symlink():
+            raise UpdateError('unsafe_verified_receipt')
+        verified = _json(path)
+        if (verified.get('status') != 'PASS' or verified.get('update_id') != identifier
+                or pointer.get('verified_receipt_sha256') != hashlib.sha256(path.read_bytes()).hexdigest()):
+            raise UpdateError('invalid_latest_chain')
+        chain.append(verified)
+        pointer = verified.get('parent_latest')
+    for verified in reversed(chain):
+        for row in verified.get('assets', []):
+            seen[row['host'], row['source']] = row['sha256']
+    return seen
+
+
+def _latest(root: Path) -> dict[str, Any] | None:
+    path = root / 'LATEST.json'
+    if path.is_symlink():
+        raise UpdateError('unsafe_latest_pointer')
+    return _json(path) if path.exists() else None
+
+
+def _metadata_row(path: Path, identifier: str, name: str) -> dict[str, Any]:
+    _safe_local(path)
+    paper = _publisher()
+    snap = paper.base.snapshot(path.lstat())
+    with paper.base.open_source(path, snap) as stream:
+        digest = paper.base.hash_source(path, stream, snap)
+    bundle = str(PurePosixPath('updates') / identifier / 'diffusion' / 'metadata' / name)
+    return dict(host='server_1', source=str(path), bundle_path=bundle,
+                repo_type='dataset', repo_id='junidude14/PBISC-data',
+                remote_path=str(PurePosixPath(PREFIX) / bundle), bytes=snap['size'],
+                expected_stat=snap, sha256=digest['sha256'], category='update_metadata')
+
+
+def prepare(root: Path, request: dict[str, Any], identifier: str) -> Path:
+    root = root.absolute()
+    if not ID_RE.fullmatch(identifier):
+        raise UpdateError('invalid_update_id')
+    scope = _scope(root)
+    if not isinstance(request, dict) or request.get('project_id') != 'pbisc-diffusion':
+        raise UpdateError('wrong_request_project')
+    summary = request.get('summary')
+    if not isinstance(summary, str) or not summary.strip():
+        raise UpdateError('summary_required')
+    assets, locations = request.get('assets'), request.get('inference_locations')
+    if not isinstance(assets, list) or not isinstance(locations, list):
+        raise UpdateError('invalid_request_lists')
+    parent = _latest(root)
+    rows = []
+    observed = _history(root)
+    seen_sources = set()
+    for item in assets:
+        if not isinstance(item, dict) or item.get('host') not in ('server_1', 'server_2'):
+            raise UpdateError('invalid_asset')
+        if item.get('state') not in STATES:
+            raise UpdateError('payload_state_refused')
+        host, kind = item['host'], item.get('kind')
+        if not isinstance(kind, str):
+            raise UpdateError('invalid_kind')
+        path = _path(item.get('source'), host)
+        if (host, str(path)) in seen_sources:
+            raise UpdateError('duplicate_source')
+        seen_sources.add((host, str(path)))
+        row = _row(host, path, kind, identifier, scope)
+        if observed.get((host, str(path))) != row['sha256']:
+            row['state'] = item['state']
+            rows.append(row)
+    checked_locations = []
+    for item in locations:
+        if not isinstance(item, dict) or item.get('host') not in ('server_1', 'server_2'):
+            raise UpdateError('invalid_inference_location')
+        if item.get('state') not in LOCATOR_STATES:
+            raise UpdateError('invalid_inference_state')
+        host = item['host']
+        path = _path(item.get('path'), host)
+        _allow(path, host, scope)
+        receipt = item.get('receipt')
+        output_observation = _locator_stat(path, host)
+        receipt_observation = None
+        if receipt is not None:
+            receipt_path = _path(receipt, host)
+            _allow(receipt_path, host, scope)
+            receipt_observation = _locator_stat(receipt_path, host)
+        if item['state'] in {'completed', 'final'}:
+            if (output_observation.get('kind') != 'file' or receipt_observation is None
+                    or receipt_observation.get('kind') != 'file'):
+                raise UpdateError('completed_locator_evidence_missing')
+        sha = item.get('sha256')
+        if sha is not None and (not isinstance(sha, str) or not SHA_RE.fullmatch(sha)):
+            raise UpdateError('invalid_locator_sha256')
+        basis = 'existing_receipt' if receipt_observation and receipt_observation.get('kind') == 'file' else 'presence_unverified'
+        checked_locations.append(dict(item, observed_output=output_observation,
+                                      observed_receipt=receipt_observation,
+                                      sha_basis=basis, sha256_basis=basis))
+    if not rows and not checked_locations:
+        raise UpdateError('no_changed_assets')
+    updates_root = root / 'maintenance' / 'updates'
+    if updates_root.is_symlink():
+        raise UpdateError('unsafe_updates_root')
+    folder = updates_root / identifier
+    if folder.exists():
+        raise UpdateError('update_id_exists')
+    folder.mkdir(mode=0o700, parents=True)
+    _atomic(folder / 'request.json', _bytes(request))
+    _atomic(folder / 'inference_locations.json', _bytes({'project_id': 'pbisc-diffusion',
+                                                       'update_id': identifier, 'locations': checked_locations}))
+    note = f'# PBISC-diffusion update {identifier}\n\n{summary.strip()}\n\nPayload states are recorded as supplied. Inference locations are pointers, not archived generated outputs.\n'
+    _atomic(folder / 'NOTE.md', note.encode())
+    rows.extend([_metadata_row(folder / 'request.json', identifier, 'request.json'),
+                 _metadata_row(folder / 'inference_locations.json', identifier, 'inference_locations.json'),
+                 _metadata_row(folder / 'NOTE.md', identifier, 'NOTE.md')])
+    if len({r['bundle_path'] for r in rows}) != len(rows):
+        raise UpdateError('duplicate_bundle_path')
+    manifest = {'schema': 'pbisc.diffusion.update-manifest.v1', 'project_id': 'pbisc-diffusion',
+                'update_id': identifier, 'parent_latest': parent, 'assets': rows}
+    _atomic(folder / 'manifest.json', _bytes(manifest))
+    _atomic(folder / 'STATUS.json', _bytes({'phase': 'prepared', 'update_id': identifier}))
+    return folder
+
+
+def _run_publisher(root: Path, identifier: str, manifest: Path, work: Path) -> int:
+    code = ("import sys; from pathlib import Path; "
+            "sys.path.insert(0,str(Path(sys.argv[1]))); import publish_paper_assets as p; "
+            "p.PREFIX=sys.argv[2]; sys.exit(p.main([sys.argv[3],'--phase','all',"
+            "'--work-dir',sys.argv[4],'--execute']))")
+    prefix = str(PurePosixPath(PREFIX) / 'updates' / identifier)
+    result = subprocess.run([sys.executable, '-B', '-c', code, str(root / 'tools'), prefix,
+                             str(manifest), str(work)], check=False)
+    return result.returncode
+
+
+def _remote_latest(value: dict[str, Any] | None = None,
+                   expected: dict[str, Any] | None = None) -> dict[str, Any] | None:
+    code = '''import fcntl,json,os,sys,tempfile
+from pathlib import Path
+p=Path('/home/sj_server_2/PBISC/paper-release-20260928/LATEST.json')
+if len(sys.argv)==1:
+ print(p.read_text() if p.exists() else 'null')
+else:
+ if p.is_symlink() or not p.parent.is_dir(): raise SystemExit(2)
+ request=json.load(sys.stdin)
+ lock=p.parent/'.latest.writer.lock'
+ if lock.is_symlink(): raise SystemExit(2)
+ with lock.open('a') as guard:
+  fcntl.flock(guard,fcntl.LOCK_EX)
+  current=json.loads(p.read_text()) if p.exists() else None
+  if current!=request['expected'] and current!=request['value']: raise SystemExit(3)
+  if current!=request['value']:
+   with tempfile.NamedTemporaryFile(mode='w',dir=p.parent,prefix='.latest-',delete=False) as f:
+    json.dump(request['value'],f,sort_keys=True); f.write('\\n'); f.flush(); os.fsync(f.fileno()); name=f.name
+   os.replace(name,p)
+  print('ok')'''
+    command = shlex.join(['python3', '-B', '-c', code] + (['write'] if value is not None else []))
+    result = subprocess.run(['ssh', '-o', 'BatchMode=yes', REMOTE, command],
+                            input=_bytes({'expected': expected, 'value': value}).decode() if value is not None else None,
+                            capture_output=True, text=True, check=False)
+    if result.returncode:
+        raise UpdateError('remote_latest_failed')
+    return None if value is not None else json.loads(result.stdout)
+
+
+def _hf_api():
+    os.environ['HF_HUB_ENABLE_HF_TRANSFER'] = '0'
+    os.environ['HF_HUB_DISABLE_XET'] = '1'
+    from huggingface_hub import HfApi, get_token
+    from huggingface_hub import constants
+    constants.HF_HUB_ENABLE_HF_TRANSFER = False
+    constants.HF_HUB_DISABLE_XET = True
+    if not get_token():
+        raise UpdateError('existing_hf_auth_missing')
+    return HfApi(token=True)
+
+
+def _hf_latest(api: Any) -> dict[str, Any] | None:
+    from huggingface_hub import hf_hub_download
+    path = PREFIX + '/LATEST.json'
+    head = api.repo_info(repo_id='junidude14/PBISC-data', repo_type='dataset', revision='main').sha
+    try:
+        file = hf_hub_download(repo_id='junidude14/PBISC-data', repo_type='dataset',
+                               filename=path, revision=head, token=True)
+    except Exception as exc:
+        # Absence is allowed only when the path is absent in the pinned tree.
+        if _publisher().base.remote_file(api, 'junidude14/PBISC-data', 'dataset', path, head) is None:
+            return None
+        raise UpdateError('hf_latest_read_failed') from exc
+    return json.loads(Path(file).read_text(encoding='utf-8'))
+
+
+def _hf_upload_verified(api: Any, path: Path, remote_path: str, *,
+                        mutable: bool = False, expected_parent: dict[str, Any] | None = None) -> str:
+    digest = hashlib.sha256(path.read_bytes()).hexdigest()
+    from huggingface_hub import CommitOperationAdd, hf_hub_download
+    repo = 'junidude14/PBISC-data'
+    head = api.repo_info(repo_id=repo, repo_type='dataset', revision='main').sha
+    found = _publisher().base.remote_file(api, repo, 'dataset', remote_path, head)
+    if found is not None:
+        existing = hf_hub_download(repo_id=repo, repo_type='dataset', filename=remote_path,
+                                   revision=head, token=True)
+        existing_bytes = Path(existing).read_bytes()
+        if hashlib.sha256(existing_bytes).hexdigest() == digest:
+            return head
+        if not mutable:
+            raise UpdateError('immutable_hf_record_conflict')
+        if json.loads(existing_bytes) != expected_parent:
+            raise UpdateError('hf_latest_parent_changed')
+    elif mutable and expected_parent is not None:
+        raise UpdateError('hf_latest_parent_changed')
+    result = api.create_commit(repo_id=repo, repo_type='dataset',
+                               operations=[CommitOperationAdd(path_in_repo=remote_path,
+                                                              path_or_fileobj=str(path))],
+                               commit_message='Publish PBISC-diffusion maintenance record',
+                               parent_commit=head)
+    revision = result.oid
+    downloaded = hf_hub_download(repo_id='junidude14/PBISC-data', repo_type='dataset',
+                                 filename=remote_path, revision=revision, token=True)
+    if hashlib.sha256(Path(downloaded).read_bytes()).hexdigest() != digest:
+        raise UpdateError('hf_record_digest_mismatch')
+    return revision
+
+
+def _verify_rows(root: Path, identifier: str, rows: list[dict[str, Any]],
+                 frozen_replay: bool = False) -> list[dict[str, Any]]:
+    paper = _publisher()
+    api = _hf_api()
+    revisions = {}
+    for repo_type, repo_id in {(r['repo_type'], r['repo_id']) for r in rows}:
+        paper.check_visibility(api, repo_id, repo_type)
+        revisions[repo_type] = api.repo_info(repo_id=repo_id, repo_type=repo_type, revision='main').sha
+    verified = []
+    from huggingface_hub import hf_hub_download
+    for row in rows:
+        if not row['bundle_path'].startswith('updates/' + identifier + '/'):
+            raise UpdateError('bundle_outside_update')
+        if not frozen_replay and paper.source_digest(row) != row['sha256']:
+            raise UpdateError('source_changed')
+        inspected = paper.remote_call(paper.archive_request(row, row['sha256'], 'inspect'))
+        if inspected.get('event') != 'verified_existing' or not isinstance(inspected.get('stat'), dict):
+            raise UpdateError('archive_not_verified')
+        revision = revisions[row['repo_type']]
+        info = paper.base.remote_file(api, row['repo_id'], row['repo_type'], row['remote_path'], revision)
+        if info is None or paper.base.attr(info, 'size') != row['bytes']:
+            raise UpdateError('hf_payload_missing')
+        lfs = paper.base.attr(info, 'lfs')
+        if lfs is not None:
+            if paper.base.attr(lfs, 'sha256') != row['sha256']:
+                raise UpdateError('hf_payload_digest_mismatch')
+        else:
+            local = hf_hub_download(repo_id=row['repo_id'], repo_type=row['repo_type'],
+                                    filename=row['remote_path'], revision=revision, token=True)
+            if hashlib.sha256(Path(local).read_bytes()).hexdigest() != row['sha256']:
+                raise UpdateError('hf_payload_digest_mismatch')
+        verified.append(dict(row, archive_stat=inspected['stat'], hf_revision=revision))
+    return verified
+
+
+def _refresh_catalog(root: Path) -> None:
+    import importlib.util
+    module_path = root / 'maintenance' / 'catalog.py'
+    if not module_path.is_file():
+        raise UpdateError('catalog_module_missing')
+    spec = importlib.util.spec_from_file_location('pbisc_diffusion_catalog', module_path)
+    if spec is None or spec.loader is None:
+        raise UpdateError('catalog_module_invalid')
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    module.refresh(root)
+
+
+def _archive_control(root: Path, identifier: str, folder: Path) -> list[dict[str, Any]]:
+    """Keep independent server_2 copies of the post-publish proof and receipts."""
+    paper = _publisher()
+    required = [folder / 'manifest.json', folder / 'work' / 'receipts.jsonl',
+                folder / 'work' / 'status.json', folder / 'UPDATE_VERIFIED.json']
+    archived = []
+    for source in required:
+        _safe_local(source)
+        snap = paper.base.snapshot(source.lstat())
+        with paper.base.open_source(source, snap) as stream:
+            digest = paper.base.hash_source(source, stream, snap)
+        bundle = str(PurePosixPath('updates') / identifier / 'control' / source.name)
+        row = {'host': 'server_1', 'source': str(source), 'bundle_path': bundle,
+               'bytes': snap['size'], 'expected_stat': snap, 'sha256': digest['sha256'],
+               'repo_type': None, 'repo_id': None, 'remote_path': None}
+        result = paper.archive_asset(row, digest['sha256'], True)
+        if result.get('event') not in ('verified_existing', 'archived'):
+            raise UpdateError('control_archive_failed')
+        inspection = paper.remote_call(paper.archive_request(row, digest['sha256'], 'inspect'))
+        if inspection.get('event') != 'verified_existing':
+            raise UpdateError('control_archive_failed')
+        archived.append({'bundle_path': bundle, 'sha256': digest['sha256'],
+                         'bytes': snap['size'], 'archive_stat': inspection.get('stat')})
+    return archived
+
+
+def _check_publisher_receipts(folder: Path, rows: list[dict[str, Any]]) -> None:
+    receipts = folder / 'work' / 'receipts.jsonl'
+    state = folder / 'work' / 'status.json'
+    _safe_local(receipts)
+    _safe_local(state)
+    if _json(state).get('phase') != 'complete' or _json(state).get('execute') is not True:
+        raise UpdateError('publisher_status_incomplete')
+    events = [json.loads(line) for line in receipts.read_text(encoding='utf-8').splitlines() if line.strip()]
+    for row in rows:
+        archived = any(event.get('event') in ('archived', 'verified_existing')
+                       and event.get('bundle_path') == row['bundle_path']
+                       and event.get('source') == row['source']
+                       and event.get('sha256') == row['sha256'] for event in events)
+        uploaded = any(event.get('event') in ('verified_uploaded', 'verified_existing')
+                       and event.get('remote_path') == row['remote_path']
+                       and event.get('repo_id') == row['repo_id']
+                       and (event.get('sha256') == row['sha256']
+                            or event.get('digest', {}).get('sha256') == row['sha256'])
+                       for event in events)
+        if not archived or not uploaded:
+            raise UpdateError('publisher_receipt_missing')
+
+
+def _compare_receipt(manifest: dict[str, Any], receipt: dict[str, Any],
+                     current_rows: list[dict[str, Any]], manifest_bytes: bytes) -> None:
+    if (receipt.get('status') != 'PASS' or receipt.get('project_id') != 'pbisc-diffusion'
+            or receipt.get('update_id') != manifest.get('update_id')
+            or receipt.get('parent_latest') != manifest.get('parent_latest')
+            or receipt.get('manifest_sha256') != hashlib.sha256(manifest_bytes).hexdigest()
+            or len(receipt.get('assets', [])) != len(current_rows)):
+        raise UpdateError('verified_receipt_mismatch')
+    for declared, verified, current in zip(manifest['assets'], receipt['assets'], current_rows):
+        if (any(verified.get(key) != value for key, value in declared.items())
+                or any(verified.get(key) != value for key, value in current.items() if key != 'hf_revision')):
+            raise UpdateError('verified_receipt_mismatch')
+
+
+def _parent_ref(parent: dict[str, Any] | None) -> dict[str, Any] | None:
+    if parent is None:
+        return None
+    return {key: parent[key] for key in ('id', 'verified_receipt_sha256', 'receipt_revision')}
+
+
+def _validate_manifest_rows(root: Path, folder: Path, manifest: dict[str, Any],
+                            scope: dict[str, Any], already_latest: bool,
+                            frozen_replay: bool = False) -> None:
+    request = _json(folder / 'request.json')
+    if request.get('project_id') != 'pbisc-diffusion' or not isinstance(request.get('assets'), list):
+        raise UpdateError('prepared_request_invalid')
+    identifier = manifest['update_id']
+    declared = manifest['assets']
+    selected = {(row['host'], row['source']) for row in declared
+                if row.get('category') != 'update_metadata'}
+    if len(selected) != len([row for row in declared if row.get('category') != 'update_metadata']):
+        raise UpdateError('manifest_duplicate_source')
+    if frozen_replay:
+        requested = {(item.get('host'), item.get('source'), item.get('kind'), item.get('state'))
+                     for item in request['assets'] if isinstance(item, dict)}
+        payload = [row for row in declared if row.get('category') != 'update_metadata']
+        metadata = [_metadata_row(folder / name, identifier, name)
+                    for name in ('request.json', 'inference_locations.json', 'NOTE.md')]
+        if (len(requested) != len(request['assets']) or
+                any((row['host'], row['source'], row['category'], row['state']) not in requested
+                    for row in payload) or declared[-3:] != metadata):
+            raise UpdateError('manifest_row_scope_mismatch')
+        return
+    history = {} if already_latest else _history(root)
+    expected = []
+    seen = set()
+    for item in request['assets']:
+        if not isinstance(item, dict) or item.get('host') not in ('server_1', 'server_2') or item.get('state') not in STATES:
+            raise UpdateError('prepared_request_invalid')
+        host = item['host']
+        path = _path(item.get('source'), host)
+        key = (host, str(path))
+        if key in seen:
+            raise UpdateError('prepared_request_duplicate')
+        seen.add(key)
+        kind = item.get('kind')
+        if not isinstance(kind, str):
+            raise UpdateError('prepared_request_invalid')
+        row = _row(host, path, kind, identifier, scope)
+        include = key in selected if already_latest else history.get(key) != row['sha256']
+        if include:
+            row['state'] = item['state']
+            expected.append(row)
+    expected.extend([_metadata_row(folder / 'request.json', identifier, 'request.json'),
+                     _metadata_row(folder / 'inference_locations.json', identifier, 'inference_locations.json'),
+                     _metadata_row(folder / 'NOTE.md', identifier, 'NOTE.md')])
+    if declared != expected:
+        raise UpdateError('manifest_row_scope_mismatch')
+
+
+def publish(root: Path, identifier: str, *, execute: bool,
+            publisher: Callable[[Path, str, Path, Path], int] = _run_publisher) -> dict[str, Any]:
+    root = root.absolute()
+    if not ID_RE.fullmatch(identifier):
+        raise UpdateError('invalid_update_id')
+    if not execute:
+        raise UpdateError('publish_requires_execute')
+    scope = _scope(root)
+    folder = root / 'maintenance' / 'updates' / identifier
+    if (folder.parent.is_symlink() or folder.is_symlink()
+            or (folder / 'manifest.json').is_symlink()):
+        raise UpdateError('unsafe_update_folder')
+    manifest = _json(folder / 'manifest.json')
+    manifest_bytes = (folder / 'manifest.json').read_bytes()
+    if manifest.get('project_id') != 'pbisc-diffusion' or manifest.get('update_id') != identifier:
+        raise UpdateError('manifest_identity_mismatch')
+    rows = manifest['assets']
+    if not rows or any(not r.get('bundle_path', '').startswith('updates/' + identifier + '/diffusion/') for r in rows):
+        raise UpdateError('manifest_bundle_scope')
+    # Revalidate every source and repository mapping before calling the broad frozen publisher.
+    for row in rows:
+        host, path = row['host'], _path(row['source'], row['host'])
+        area = _allow(path, host, scope, internal=folder)
+        if area == 'internal' and path not in {folder / 'request.json', folder / 'inference_locations.json', folder / 'NOTE.md'}:
+            raise UpdateError('unsafe_internal_source')
+        if area != 'internal' and row['repo_type'] == 'model' and area != 'model8':
+            raise UpdateError('checkpoint_outside_model8')
+        expected_repo = 'junidude14/PBISC' if row['repo_type'] == 'model' else 'junidude14/PBISC-data'
+        if row['repo_id'] != expected_repo or row['remote_path'] != PREFIX + '/' + row['bundle_path']:
+            raise UpdateError('manifest_repository_scope')
+        if host == 'server_1':
+            _safe_local(path)
+    lock_path = root / 'maintenance' / '.writer.lock'
+    if lock_path.is_symlink():
+        raise UpdateError('unsafe_writer_lock')
+    with lock_path.open('a', encoding='utf-8') as lock:
+        try:
+            fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except BlockingIOError as exc:
+            raise UpdateError('writer_busy') from exc
+        verified_path = folder / 'UPDATE_VERIFIED.json'
+        current = _latest(root)
+        already_latest = isinstance(current, dict) and current.get('id') == identifier
+        if current != manifest.get('parent_latest') and not already_latest:
+            raise UpdateError('parent_changed')
+        candidate_path = folder / 'LATEST.json'
+        frozen_replay = False
+        if verified_path.exists() and candidate_path.exists():
+            candidate = _json(candidate_path)
+            if candidate.get('id') == identifier and _remote_latest() == candidate:
+                digest = hashlib.sha256(verified_path.read_bytes()).hexdigest()
+                from huggingface_hub import hf_hub_download
+                pinned = hf_hub_download(repo_id='junidude14/PBISC-data', repo_type='dataset',
+                                         filename=PREFIX + '/updates/' + identifier + '/UPDATE_VERIFIED.json',
+                                         revision=candidate['receipt_revision'], token=True)
+                if candidate.get('verified_receipt_sha256') != digest or hashlib.sha256(Path(pinned).read_bytes()).hexdigest() != digest:
+                    raise UpdateError('frozen_receipt_mismatch')
+                frozen_replay = True
+        _validate_manifest_rows(root, folder, manifest, scope, already_latest, frozen_replay)
+        status = folder / 'STATUS.json'
+        if already_latest:
+            if (not verified_path.exists()
+                    or current.get('verified_receipt_sha256') != hashlib.sha256(verified_path.read_bytes()).hexdigest()):
+                raise UpdateError('latest_without_verified_receipt')
+            _check_publisher_receipts(folder, rows)
+            _compare_receipt(manifest, _json(verified_path),
+                             _verify_rows(root, identifier, rows, frozen_replay), manifest_bytes)
+            api = _hf_api()
+            if _remote_latest() != current or _hf_latest(api) != current:
+                raise UpdateError('latest_replica_disagreement')
+            try:
+                _refresh_catalog(root)
+            except Exception as exc:
+                _atomic(status, _bytes({'phase': 'catalog_pending', 'update_id': identifier}))
+                raise UpdateError('catalog_refresh_failed') from exc
+            _atomic(status, _bytes({'phase': 'verified', 'update_id': identifier}))
+            return current
+        _atomic(status, _bytes({'phase': 'publishing', 'update_id': identifier}))
+        try:
+            if not verified_path.exists():
+                if publisher(root, identifier, folder / 'manifest.json', folder / 'work') != 0:
+                    raise UpdateError('publisher_failed')
+                _check_publisher_receipts(folder, rows)
+                verified_rows = _verify_rows(root, identifier, rows)
+                receipt = {'schema': 'pbisc.diffusion.update-verified.v1', 'status': 'PASS',
+                           'project_id': 'pbisc-diffusion', 'update_id': identifier,
+                           'parent_latest': manifest.get('parent_latest'),
+                           'manifest_sha256': hashlib.sha256(manifest_bytes).hexdigest(),
+                           'assets': verified_rows}
+                _atomic(verified_path, _bytes(receipt))
+            else:
+                _check_publisher_receipts(folder, rows)
+                _compare_receipt(manifest, _json(verified_path),
+                                 _verify_rows(root, identifier, rows, frozen_replay), manifest_bytes)
+            archived_control = _archive_control(root, identifier, folder)
+            api = _hf_api()
+            remote_latest, hf_latest = _remote_latest(), _hf_latest(api)
+            if (remote_latest not in (manifest.get('parent_latest'), _json(folder / 'LATEST.json') if (folder / 'LATEST.json').exists() else None)
+                    or hf_latest not in (manifest.get('parent_latest'), _json(folder / 'LATEST.json') if (folder / 'LATEST.json').exists() else None)):
+                raise UpdateError('parent_changed_remote')
+            pointer_path = folder / 'LATEST.json'
+            if pointer_path.exists():
+                pointer = _json(pointer_path)
+                if (pointer.get('id') != identifier or pointer.get('parent') != _parent_ref(manifest.get('parent_latest'))
+                        or pointer.get('verified_receipt_sha256') != hashlib.sha256(verified_path.read_bytes()).hexdigest()):
+                    raise UpdateError('prepared_pointer_conflict')
+            else:
+                receipt_revision = _hf_upload_verified(api, verified_path,
+                               PREFIX + '/updates/' + identifier + '/UPDATE_VERIFIED.json')
+                pointer = {'schema': 'pbisc.diffusion.latest.v1', 'project_id': 'pbisc-diffusion',
+                           'id': identifier, 'parent': _parent_ref(manifest.get('parent_latest')),
+                           'verified_receipt_path': PREFIX + '/updates/' + identifier + '/UPDATE_VERIFIED.json',
+                           'verified_receipt_sha256': hashlib.sha256(verified_path.read_bytes()).hexdigest(),
+                           'receipt_revision': receipt_revision, 'control_archive': archived_control}
+                _atomic(pointer_path, _bytes(pointer))
+            _remote_latest(pointer, expected=manifest.get('parent_latest'))
+            _hf_upload_verified(api, pointer_path, PREFIX + '/LATEST.json',
+                                mutable=True, expected_parent=manifest.get('parent_latest'))
+            if _remote_latest() != pointer or _hf_latest(api) != pointer:
+                raise UpdateError('latest_replica_disagreement')
+            _atomic(root / 'LATEST.json', _bytes(pointer))
+            try:
+                _refresh_catalog(root)
+            except Exception as exc:
+                _atomic(status, _bytes({'phase': 'catalog_pending', 'update_id': identifier}))
+                raise UpdateError('catalog_refresh_failed') from exc
+            _atomic(status, _bytes({'phase': 'verified', 'update_id': identifier}))
+            return pointer
+        except Exception as exc:
+            if not status.exists() or _json(status).get('phase') != 'catalog_pending':
+                _atomic(status, _bytes({'phase': 'error', 'update_id': identifier,
+                                        'error_code': str(exc) if isinstance(exc, UpdateError) else 'update_failed'}))
+            raise
+
+
+def status(root: Path) -> dict[str, Any]:
+    _scope(root.absolute())
+    updates = []
+    updates_root = root / 'maintenance' / 'updates'
+    if updates_root.is_symlink():
+        raise UpdateError('unsafe_updates_root')
+    for folder in sorted(updates_root.glob('*')) if updates_root.exists() else []:
+        if folder.is_dir() and not folder.is_symlink() and ID_RE.fullmatch(folder.name):
+            state = _json(folder / 'STATUS.json') if (folder / 'STATUS.json').exists() else {'phase': 'unknown'}
+            updates.append({'id': folder.name, 'phase': state['phase']})
+    baseline = root / 'maintenance' / 'BASELINE_REFERENCE.json'
+    return {'project_id': 'pbisc-diffusion', 'latest': _latest(root),
+            'baseline': _json(baseline) if baseline.exists() else None, 'updates': updates}
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    sub = parser.add_subparsers(dest='command', required=True)
+    prep = sub.add_parser('prepare')
+    prep.add_argument('--request', required=True, type=Path)
+    prep.add_argument('--id', required=True)
+    pub = sub.add_parser('publish')
+    pub.add_argument('id')
+    pub.add_argument('--execute', action='store_true')
+    sub.add_parser('status')
+    args = parser.parse_args(argv)
+    try:
+        if args.command == 'prepare':
+            request = json.load(sys.stdin) if str(args.request) == '-' else _json(args.request)
+            result = {'prepared': str(prepare(ROOT, request, args.id))}
+        elif args.command == 'publish':
+            result = publish(ROOT, args.id, execute=args.execute)
+        else:
+            result = status(ROOT)
+        print(json.dumps(result, sort_keys=True))
+        return 0
+    except Exception as exc:
+        print(json.dumps({'error_code': str(exc) if isinstance(exc, UpdateError) else 'update_failed'}), file=sys.stderr)
+        return 1
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261007T185408Z-scsemi-cleanup-recovery/diffusion/metadata/inference_locations.json

@@ -0,0 +1,5 @@
+{
+  "locations": [],
+  "project_id": "pbisc-diffusion",
+  "update_id": "20261007T185408Z-scsemi-cleanup-recovery"
+}

paper-releases/pbisc-diffusion/updates/20261007T185408Z-scsemi-cleanup-recovery/diffusion/metadata/request.json

@@ -0,0 +1,25 @@
+{
+  "assets": [
+    {
+      "host": "server_2",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/scsemi/README.md",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "maintenance",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/maintenance/update.py",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "maintenance",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/maintenance/test_update.py",
+      "state": "completed"
+    }
+  ],
+  "inference_locations": [],
+  "project_id": "pbisc-diffusion",
+  "summary": "Document verified SCSEMI disk cleanup and repair safe replay of a partially committed PBISC-Diffusion archive update"
+}