Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20260929T062828Z-manuscript-relocation/diffusion/dataset/server_1/maintenance/26f3248763a2f99b/POLICY.md

@@ -0,0 +1,60 @@
+# PBISC-Diffusion paper archive maintenance
+
+Project ID: **`pbisc-diffusion`**. User standing instruction, 2026-09-28: keep this paper archive updated across **Codex and Claude Code**, and do not mix in any other paper.
+
+## Scope gate — apply this before doing anything
+
+This policy applies only to work explicitly for the PBISC-Diffusion paper:
+
+- Model 8 source, training/fine-tuning, inference, evaluation, figures and reproducibility: `/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/`.
+- Its named manuscript: `/home/sj_server_1/PBISC/paper-release-20260928/manuscript/` (a Git working tree of `junidude/PBISC-diffusion-overleaf`, whose README identifies PBISC-Diffusion). It was moved there from `/home/sj_server_1/PBISC/immun-pbmc-fm/bulk2sc-paper/nature-communications-overleaf/` on 2026-09-29 at the user's request; its superseded drafts are in the sibling `archived-analyses/`, which is not an archive payload root.
+- Exact shared dependencies listed in `SCOPE.json`, with a documented relationship to this paper. A shared dependency does not bring its directory, its other uses, or another paper into scope. New external dependencies require evidence of the Model 8/manuscript relationship and a deliberate exact-path scope addition.
+
+Do **not** treat all PBISC work as this paper. VAE/BIBM papers, independent Model 7 work, historical `model/diffusion` / coalescent, other `bulk2sc-paper` subdirectories, transcriptome/FM papers and unrelated datalake analyses are outside scope. A generic PBISC mention is not enough to infer the paper. The old archived-diffusion wording concerns the historical coalescent branch, not the active Model 8 paper.
+
+## Shared start/end contract for both agents
+
+At the start of an in-scope task, read this policy, `SCOPE.json`, and `../LATEST.json` if present; otherwise use `BASELINE_REFERENCE.json`. Consult `../CURRENT.md` and the current model/inference catalogs before retrieving results. Check source host as well as absolute path: identical paths exist on both servers.
+
+Before finishing an in-scope task that changes paper evidence or reusable assets:
+
+1. Identify exact new or changed checkpoints, data/preprocessing inputs, splits/QC/masks/units, evaluation references, scripts/configs, score tables, figures or manuscript files. Include provenance tying them to this paper. Do not glob the whole workspace.
+2. Write a request using `request.example.json`. Use `project_id: pbisc-diffusion`; name each source host/path, artifact kind and actual state. Register training/inference that is still running as a location/status observation; do not publish actively changing payload files as completed. Immutable stopped/intermediate checkpoints may be archived with that state retained.
+3. Record **new inference output locations**, recorded output/checkpoint/input hashes and receipt paths. Preserve the distinction between presence-only, running, failed and completed evidence. Normally keep large inference arrays in their existing locations; do not rerun inference for bookkeeping or erase/overwrite earlier paper outputs.
+4. Prepare and publish the versioned delta with the shared CLI. This is a standing user-authorized maintenance step for this paper's completed assets. Continue it within the task; do not merely promise a later upload. Keep cohort/sample metadata and paper-support files in private `junidude14/PBISC-data`; eligible Model 8 checkpoint weights use the existing gated `junidude14/PBISC` repository.
+5. Check the verified receipt, refreshed current catalogs and latest pointer before claiming the archive is current. If a file is still changing, a transfer/verification fails, or a dependency is unresolved, retain the pending update and report the exact gap. Never advance latest or claim completion from a dry preflight.
+
+A read-only discussion with no changed assets requires no duplicate upload. Explicitly report “no archive delta” when relevant. Manuscript evidence/figures are not automatically changed merely because a checkpoint was saved; only preserve actually revised, supported content. No automatic GitHub push or Overleaf synchronization is implied.
+
+## One archive, immutable history, current views
+
+- Coordinator and small local records: `spark-fa6b:/home/sj_server_1/PBISC/paper-release-20260928/`.
+- Independent physical archive: `spark-0110:/home/sj_server_2/PBISC/paper-release-20260928/`.
+- Frozen initial snapshot: existing root manifests, receipts, `README.md`, `RELEASE_LOCK.json`, `FINAL_VERIFICATION.json`, and HF tag **`paper-20260928`**. Keep them intact; do not rerun the date-specific preparation/finalization scripts to update the paper.
+- Later versions: `updates/<UTC-id>/`. New HF paths are under **`paper-releases/pbisc-diffusion/updates/<id>/diffusion/`**. Previous objects and tags remain unchanged.
+- `LATEST.json` and current catalogs are live navigation. Latest advances only after independent archive and pinned HF verification. A delta refers back to its parent and the initial baseline; it is not a complete replacement of all earlier payloads.
+
+## Commands and cross-server coordination
+
+Only server_1 publishes; the common writer lock prevents Codex and Claude from publishing simultaneously. Keep credentials on server_1. The request is ordinary JSON without tokens.
+
+On server_1:
+
+```bash
+/home/sj_server_1/miniforge3/bin/python /home/sj_server_1/PBISC/paper-release-20260928/maintenance/update.py status
+/home/sj_server_1/miniforge3/bin/python /home/sj_server_1/PBISC/paper-release-20260928/maintenance/update.py prepare --request /path/to/request.json --id 20260929T010000Z-result-name
+/home/sj_server_1/miniforge3/bin/python /home/sj_server_1/PBISC/paper-release-20260928/maintenance/update.py publish 20260929T010000Z-result-name --execute
+```
+
+For work on server_2, submit the request to the coordinator through standard input:
+
+```bash
+ssh spark-fa6b '/home/sj_server_1/miniforge3/bin/python /home/sj_server_1/PBISC/paper-release-20260928/maintenance/update.py prepare --request - --id 20260929T010000Z-result-name' < request.json
+ssh spark-fa6b '/home/sj_server_1/miniforge3/bin/python /home/sj_server_1/PBISC/paper-release-20260928/maintenance/update.py publish 20260929T010000Z-result-name --execute'
+```
+
+Use an actual UTC timestamp and a descriptive slug, not the example ID. Mark remote sources `host: server_2`; their working tree may still start with `/home/sj_server_1/PBISC/`. The SSH path was verified in both directions when installing this workflow. If connectivity fails, preserve a pending request and report it; do not copy authentication tokens or invent a successful sync.
+
+Hashing/copying is CPU-only. Follow the mandatory host GPU/UMA policy for any substantial-memory launch, and run sustained transfer work with bounded user-systemd memory, zero swap and no automatic restart. Do not initialize CUDA, launch training/inference, interrupt another job, delete originals or replace existing results for archive maintenance.
+
+This is a **task-end maintenance workflow**, not an unattended periodic upload daemon. A future timer may detect candidates, but cannot decide that unrelated or unfinished work belongs to this paper.

paper-releases/pbisc-diffusion/updates/20260929T062828Z-manuscript-relocation/diffusion/dataset/server_1/maintenance/38e4c628399ccf84/update.py

@@ -0,0 +1,772 @@
+#!/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]]) -> 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 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) -> 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')
+    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')
+        _validate_manifest_rows(root, folder, manifest, scope, already_latest)
+        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), 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), 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/20260929T062828Z-manuscript-relocation/diffusion/dataset/server_1/manuscript/AGENTS.md

@@ -0,0 +1,20 @@
+# PBISC-Diffusion manuscript maintenance
+
+The README names this manuscript as the PBISC-Diffusion Nature Communications
+draft. It is the `pbisc-diffusion` paper covered by
+`../maintenance/POLICY.md`. Read that policy and
+the README at the start of a related task, in addition to parent instructions.
+
+At the end of a task that changes this paper's manuscript, figures, source
+data, references, or evidence, follow the policy's versioned update workflow
+for the exact changed assets. From the release root, use
+`maintenance/update.py prepare --request FILE --id ID`, inspect the prepared
+update, then run `maintenance/update.py publish ID --execute` and
+`maintenance/update.py status` under the policy. Record a no-op or
+pending status when no asset changed or publication failed; never describe
+that as an upload. Preserve the frozen 2026-09-28 release, its root manifests,
+and the HF `paper-20260928` revision. Keep the dataset private.
+
+Do not enroll other papers merely because they are under `bulk2sc-paper/`.
+Manuscript claims must remain tied to their actual evidence, and updating the
+archive does not itself establish scientific validity.