Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261014T111854Z-strict-server2-priority/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/recoveries/priority_server2_20261014/collect.py

@@ -0,0 +1,92 @@
+"""Collect completed remote units only, keep original receipts, then CPU-score and archive."""
+from pathlib import Path
+import sys,json,subprocess,shlex,threading,time,fcntl,hashlib,copy,os
+R=Path(__file__).resolve().parent;S=R.parents[1];M=S.parents[1]
+sys.path[:0]=[str(R),str(S/'tools')]
+import campaign
+from worker import LowPriorityRuntime,X
+from runtime import atomic_json,sha256,stat_record,stamp
+from two_host_resume import unit_support,validate_snapshot
+PY='/home/sj_server_2/miniforge3/envs/b2sc-infer/bin/python'
+def remote(argv,**kw):return subprocess.run(['ssh','-o','BatchMode=yes','spark-0110',shlex.join(argv)],check=True,**kw)
+def state(phase,**kw):atomic_json(R/'COLLECT_STATUS.json',{'phase':phase,'at':stamp(),**kw})
+def release_watch():
+ while True:
+  p=X/'HF_CORE_VERIFIED.json'
+  if p.exists() and json.loads(p.read_text()).get('state')=='verified':
+   atomic_json(X/'payload/priority/LOW_PRIORITY_RELEASE.json',{'reason':'x4 core computation and HF backup verified','receipt':str(p),'sha256':sha256(p),'at':stamp()});return
+  time.sleep(30)
+def collect(unit):
+ dest=R/'imported'/unit;dest.mkdir(parents=True,exist_ok=True)
+ done=dest/'IMPORTED.json'
+ if done.exists():return
+ snapshot=json.loads(remote([PY,str(S/'tools/two_host_resume.py'),'snapshot','--unit',unit],capture_output=True,text=True).stdout)
+ validate_snapshot(S,unit,snapshot)
+ atomic_json(dest/'snapshot.json',snapshot)
+ for row in snapshot['files']:
+  rel=Path(row['path']);target=dest/rel if rel.parts[0] in ['receipts','unit_status'] else S/rel
+  target.parent.mkdir(parents=True,exist_ok=True)
+  if target.exists() and sha256(target)!=row['sha256']:
+   # Only pre-existing mutable state/logs from the migrated partial unit may advance.
+   allowed=unit=='imperial_eskd-disease-draw3' and rel.parts[0] in ['scsemi','logs']
+   assert allowed,('unexpected conflicting artifact',target)
+   saved=dest/'before_import'/rel;saved.parent.mkdir(parents=True,exist_ok=True)
+   if not saved.exists():subprocess.run(['cp','-p',str(target),str(saved)],check=True)
+  subprocess.run(['rsync','-a','--protect-args','spark-0110:'+str(S/rel),str(target)],check=True)
+  assert target.stat().st_size==row['bytes'] and sha256(target)==row['sha256']
+ for raw in (dest/'receipts').glob('*.json'):
+  record=json.loads(raw.read_text());assert record['state']=='completed'
+  for out in record.get('outputs',[]):
+   f=Path(out['path']);assert sha256(f)==out['sha256'];out.update(stat_record(f))
+  original=S/'receipts'/raw.name
+  if original.exists():
+   old=json.loads(original.read_text());assert old['state']=='completed' and old['signature']==record['signature']
+   assert [o['sha256'] for o in old.get('outputs',[])]==[o['sha256'] for o in record.get('outputs',[])]
+   # Original source receipt remains unchanged; rsync preserved timestamps of immutable outputs.
+   for o in old.get('outputs',[]):assert stat_record(Path(o['path']))=={k:o[k] for k in ['path','bytes','mtime_ns']}
+  else:
+   record['remote_provenance']={'host':'server_2','raw_receipt':str(raw),'sha256':sha256(raw)};atomic_json(original,record)
+ atomic_json(done,{'state':'verified','unit':unit,'snapshot_sha256':sha256(dest/'snapshot.json'),'at':stamp()})
+def main():
+ threading.Thread(target=release_watch,daemon=True).start()
+ units=json.loads((R/'units.json').read_text());rt=LowPriorityRuntime(S)
+ with (S/'.campaign.lock').open('a') as lock:
+  fcntl.flock(lock,fcntl.LOCK_EX|fcntl.LOCK_NB)
+  for unit in units:
+   state('waiting_remote',unit=unit)
+   while True:
+    code='import pathlib,json,sys; p=pathlib.Path(sys.argv[1]); print(p.read_text() if p.exists() else "null")'
+    marker=json.loads(remote(['python3','-c',code,str(S/'unit_status'/f'{unit}.json')],capture_output=True,text=True).stdout)
+    if marker and marker.get('state')=='completed' and marker.get('stage')=='compute':break
+    props=remote(['/usr/bin/env','XDG_RUNTIME_DIR=/run/user/1000','DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/1000/bus','systemctl','--user','show','pbisc-strict-priority-remote-20261014.service','-p','ActiveState','-p','SubState'],capture_output=True,text=True).stdout
+    if 'ActiveState=failed' in props or 'ActiveState=inactive' in props:raise RuntimeError('Remote worker stopped before unit completion: '+props)
+    time.sleep(30)
+   state('collecting',unit=unit);collect(unit)
+   path,_,manifest=unit_support(S,unit)
+   state('scoring',unit=unit);campaign.run_score(rt,path)
+   atomic_json(S/'unit_status'/f'{unit}.json',{'state':'completed','stage':'all','support_sha256':manifest['sha256'],'at':stamp(),'source':'priority server2 migration'})
+   state('unit_completed',unit=unit)
+  state('all_18_completed',units=units)
+  assets=[];locations=[]
+  for unit in units:
+   path,rel,_=unit_support(S,unit)
+   assets.extend([{'host':'server_1','source':str(path),'kind':'metadata','state':'completed'},
+                  {'host':'server_1','source':str(S/'runs'/rel/'lora/checkpoint_ft.pt'),'kind':'checkpoint','state':'completed'}])
+   for f in (S/'scores'/rel).rglob('*'):
+    if f.is_file() and f.suffix in ['.json','.csv'] and f.stat().st_size<4*2**20:
+     assets.append({'host':'server_1','source':str(f),'kind':'report' if f.suffix=='.json' else 'table','state':'completed'})
+   for f in (S/'generated'/rel).glob('*.npz'):
+    locations.append({'host':'server_1','path':str(f),'state':'completed','sha256':sha256(f),'reason':'Completed transferred strict-pair comparator output; source server_2 and imported receipts retained.'})
+  request={'project_id':'pbisc-diffusion','summary':'Completed 18 transferred strict-pair comparator units; original Imperial draw3 120 targets reused; x4 priority preserved.','assets':assets,'inference_locations':locations}
+  atomic_json(R/'FINAL_ARCHIVE_REQUEST.json',request)
+  from datetime import datetime,timezone
+  ident=datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%SZ')+'-strict-priority-results'
+  release=M.parents[1]/'paper-release-20260928';cli=release/'maintenance/update.py'
+  with (R/'final_archive.log').open('x') as log:
+   for args in [['prepare','--request',str(R/'FINAL_ARCHIVE_REQUEST.json'),'--id',ident],['publish',ident,'--execute']]:
+    subprocess.run(['/home/sj_server_1/miniforge3/bin/python',str(cli),*args],check=True,stdout=log,stderr=subprocess.STDOUT)
+  receipt=release/'maintenance/updates'/ident/'UPDATE_VERIFIED.json';assert json.loads(receipt.read_text())['status']=='PASS'
+  state('complete_and_archived',units=units,archive_id=ident,receipt=str(receipt))
+if __name__=='__main__':
+ try:main()
+ except BaseException as e:state('stopped_needs_inspection',error=str(e));raise

paper-releases/pbisc-diffusion/updates/20261014T111854Z-strict-server2-priority/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/recoveries/priority_server2_20261014/probe.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+import sys
+R=Path(__file__).resolve().parent;S=R.parents[1];sys.path.insert(0,str(S/'tools'))
+import campaign
+from runtime import Runtime
+from two_host_resume import unit_support
+class Probe(Runtime):
+ def execute(self,name,argv,**kw):
+  sig=self.signature(argv,kw.get('inputs',[]))
+  if self.can_skip(name,sig,kw.get('outputs',[])):print('VERIFIED_REUSE',name,flush=True);return False
+  print('NEXT_OPERATION',name,flush=True)
+  assert name=='imperial_eskd-disease-draw3-scinfer-120';raise SystemExit(0)
+p,_,_=unit_support(S,'imperial_eskd-disease-draw3');r=Probe(S)
+campaign.run_diffusion(r,p);campaign.run_scsemi(r,p)
+raise RuntimeError('Expected remaining inference was not reached')

paper-releases/pbisc-diffusion/updates/20261014T111854Z-strict-server2-priority/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/recoveries/priority_server2_20261014/stage.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+import sys,json,subprocess,shlex,hashlib
+R=Path(__file__).resolve().parent;S=R.parents[1];M=S.parents[1]
+sys.path.insert(0,str(S/'tools'));from two_host_resume import unit_support
+units=json.loads((R/'units.json').read_text());files=set()
+for directory in [S/'tools',S/'data',S/'protocol']:
+ files.update(f for f in directory.rglob('*') if f.is_file() and '__pycache__' not in str(f))
+for unit in units:
+ _,rel,_=unit_support(S,unit)
+ for tree in ['runs','generated','scsemi','isolated']:
+  files.update(f for f in (S/tree/rel).rglob('*') if f.is_file())
+ files.update((S/'receipts').glob(unit+'-*.json'))
+files.update([R/'worker.py',R/'units.json'])
+# These two unexecuted presentation/deconvolution helpers differ in the historical remote replica.
+# The remote worker runs compute only; CPU scoring stays local. Preserve both remote originals.
+files.difference_update([S/'tools/deconv_strict.py',S/'tools/finalize_campaign.py'])
+assert all(not f.is_symlink() for f in files),'explicit symlink handling required'
+# --ignore-existing prevents changing any pre-existing completed remote results.
+subprocess.run(['rsync','-aR','--no-implied-dirs','--omit-dir-times','--ignore-existing',*[str(f) for f in sorted(files)],'spark-0110:/'],check=True)
+bindings={str(f):hashlib.file_digest(f.open('rb'),'sha256').hexdigest() for f in sorted(files)}
+code='import sys,json,pathlib,hashlib; b=json.load(sys.stdin); bad=[p for p,h in b.items() if hashlib.file_digest(pathlib.Path(p).open("rb"),"sha256").hexdigest()!=h];print(json.dumps({"files":len(b),"mismatches":bad}));sys.exit(bool(bad))'
+r=subprocess.run(['ssh','spark-0110',shlex.join(['python3','-c',code])],input=json.dumps(bindings),text=True,capture_output=True);print(r.stdout);r.check_returncode()
+(R/'STAGED.json').write_text(json.dumps({'files':bindings,'verified':True},indent=2)+'\n')
+# Preserve raw imported receipts, normalize only output stat metadata on the destination.
+code='''import pathlib,json,shutil,hashlib
+S=pathlib.Path("'''+str(S)+'''"); R=pathlib.Path("'''+str(R)+'''")
+for u in json.loads((R/'units.json').read_text()):
+ for p in (S/'receipts').glob(u+'-*.json'):
+  j=json.loads(p.read_text());assert j['state']=='completed',str(p)
+  raw=R/'source_receipts'/p.name;raw.parent.mkdir(exist_ok=True)
+  assert not raw.exists();shutil.copy2(p,raw)
+  for o in j.get('outputs',[]):
+   f=pathlib.Path(o['path']);assert hashlib.file_digest(f.open('rb'),'sha256').hexdigest()==o['sha256'];o['mtime_ns']=f.stat().st_mtime_ns;o['bytes']=f.stat().st_size
+  j['migration']={'source_host':'server_1','raw_receipt':str(raw),'raw_sha256':hashlib.file_digest(raw.open('rb'),'sha256').hexdigest()}
+  p.write_text(json.dumps(j,indent=2)+'\\n')
+print('Receipt hashes verified and destination stat metadata normalized')
+'''
+subprocess.run(['ssh','spark-0110',shlex.join(['python3','-c',code])],check=True)

paper-releases/pbisc-diffusion/updates/20261014T111854Z-strict-server2-priority/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/recoveries/priority_server2_20261014/worker.py

@@ -0,0 +1,24 @@
+"""Resume only transferred units; checkpoint-bound x4 priority at operation boundaries."""
+from pathlib import Path
+import sys,json,os,time
+R=Path(__file__).resolve().parent;S=R.parents[1];M=S.parents[1]
+sys.path.insert(0,str(S/'tools'))
+import campaign
+from runtime import Runtime,atomic_json,stamp
+X=M/'plans/f01_trunk4x_complete_20261013'
+def priority(payload):
+ # Fail closed if NAS disappears. The marker is shared by both hosts.
+ if not (payload/'pretrain').is_dir():return True
+ return (payload/'pretrain/f01_6k_trunk4x_seed20260627/checkpoint_epoch_016.pt').exists() and not (payload/'priority/LOW_PRIORITY_RELEASE.json').exists()
+class LowPriorityRuntime(Runtime):
+ def preflight(self,resource,memory_gib):
+  if priority(X/'payload'):
+   atomic_json(R/'PRIORITY_STATUS.json',{'state':'yielding_to_x4','at':stamp(),'policy':'no new operations until verified x4 core completion'})
+   raise BlockingIOError('x4 downstream has priority')
+  super().preflight(resource,memory_gib)
+ def execute(self,*args,**kwargs):
+  kwargs.setdefault('wait_seconds',14*86400)
+  return super().execute(*args,**kwargs)
+if __name__=='__main__':
+ campaign.Runtime=LowPriorityRuntime
+ campaign.main()