Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261015T121654Z-x1-nine-core40-deck/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/recoveries/x1_priority_completion_20261015/deck_refresh.py

@@ -0,0 +1,69 @@
+"""Refresh complete master from admitted results, atomically update user aliases, archive final evidence."""
+from pathlib import Path
+import os,sys,json,time,subprocess,hashlib,shutil,datetime
+R=Path(__file__).resolve().parent;S=R.parents[1];M=S.parents[1];E=R/'evaluation';D=M/'presentations/2026-09-30--paper-summary--r00';A=D/'data/x1_priority_20261015';X=M/'plans/f01_trunk4x_complete_20261013'
+sys.path.insert(0,str(S/'tools'));from runtime import Runtime,atomic_json,stamp,sha256
+PY='/home/sj_server_1/miniforge3/bin/python';CPU='/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python'
+def refresh():
+ available=next(int(v.split()[1])/1048576 for v in Path('/proc/meminfo').read_text().splitlines() if v.startswith('MemAvailable:'))
+ if available<96:return False
+ rt=Runtime(R/'deck_runtime');rt.preflight('cpu',8)
+ cmd=rt.wrapped_command('refresh-x1-master',[PY,str(D/'tools/build_x1_priority_master_20261015.py'),'--if-changed'],'cpu',8,2)
+ with (R/'deck_refresh.log').open('a') as f:subprocess.run(cmd,stdout=f,stderr=subprocess.STDOUT,check=True)
+ v=json.loads((A/'VERIFIED.json').read_text());assert v['status'] in ['verified','automated_pass_visual_pending']
+ qa=json.loads(Path(v['verification']).read_text());assert not qa['failures'] and not qa['source_rejections'] and qa['parent156_preserved'] and qa['original76_preserved'] and qa['Figure1_parent_pages7to10_preserved'],qa
+ for src,digest in v['outputs'].items():
+  src=Path(src);assert sha256(src)==digest
+  target=D/('PBISC-Diffusion_expanded_master_20261015_figure1_focused'+src.suffix)
+  if target.exists() and sha256(target)==digest:continue
+  temporary=target.with_suffix(target.suffix+'.x1update');shutil.copy2(src,temporary);assert sha256(temporary)==digest;temporary.replace(target)
+ record={'at':stamp(),'build':v['build'],'slides':v['slides'],'verified_output_hashes':v['outputs'],'current_user_pptx':str(D/'PBISC-Diffusion_expanded_master_20261015_figure1_focused.pptx'),'current_user_pdf':str(D/'PBISC-Diffusion_expanded_master_20261015_figure1_focused.pdf'),'original156_preserved':str(A/'base/BASE_VERIFIED.json'),'qa_status':v['status'],'scope':'Completed core and full statistics are distinct; incomplete arms remain explicit.'}
+ atomic_json(R/'DECK_CURRENT.json',record);atomic_json(D/'CURRENT_MASTER.json',record)
+ return True
+
+def archive_final():
+ release=M.parents[1]/'paper-release-20260928';assets=[];seen=set();locations=[]
+ def add(f,kind):
+  if str(f) not in seen:assets.append({'host':'server_1','source':str(f),'kind':kind,'state':'completed'});seen.add(str(f))
+ for unit in json.loads((R/'GPU_UNITS.json').read_text()):
+  from two_host_resume import unit_support
+  _,rel,_=unit_support(S,unit)
+  add(S/'runs'/rel/'lora/checkpoint_ft.pt','checkpoint');add(S/'runs'/rel/'lora/RUN.json','report')
+  for name in ['lora','pairedcal']:
+   f=S/'generated'/rel/f'{name}.npz';rec=json.loads(f.with_suffix('.log').read_text());locations.append({'host':'server_1','path':str(f),'state':'completed','receipt':str(f.with_suffix('.log')),'sha256':rec['output_sha256'],'reason':'Exactly requested x1missing9; newonlyafterzeroexactreuseaudit; server2mirrorverified.'})
+ status=json.loads((E/'STATUS.json').read_text());atomic_json(R/'FINAL_EVALUATION_SNAPSHOT.json',status);add(R/'FINAL_EVALUATION_SNAPSHOT.json','report')
+ for folder in [E/'units',E/'aggregates']:
+  for f in folder.rglob('*'):
+   if f.is_file() and f.suffix in ['.json','.csv'] and f.stat().st_size<4*2**20:add(f,'table' if f.suffix=='.csv' else 'report')
+ v=json.loads((A/'VERIFIED.json').read_text());build=Path(v['build'])
+ for f in build.rglob('*'):
+  if f.is_file() and f.suffix in ['.pptx','.pdf','.png','.svg','.csv','.json'] and ('qa' not in f.parts or f.name in ['VERIFICATION.json','visual_review.json']):add(f,'figure' if f.suffix in ['.pptx','.pdf','.png','.svg'] else 'report')
+ for n in ['GPU_STATUS.json','X4_PAUSE.json','X4_RESUMED.json','MIRROR_VERIFIED.json','DECK_CURRENT.json']:
+  if (R/n).exists():
+   f=R/'final_records'/n;f.parent.mkdir(exist_ok=True);shutil.copy2(R/n,f);add(f,'report')
+ ident=datetime.datetime.now(datetime.timezone.utc).strftime('%Y%m%dT%H%M%SZ')+'-x1-priority-full-deck';request=R/'FINAL_ARCHIVE_REQUEST.json';atomic_json(request,{'project_id':'pbisc-diffusion','summary':'Requestedx1missing9 completed withoutduplicates; fullCPUevaluation ofavailablearms and complete master updated preserving156parents. MissingnewscSemi arms explicit.','assets':assets,'inference_locations':locations})
+ with (R/'final_archive.log').open('x') as log:
+  for args in [['prepare','--request',str(request),'--id',ident],['publish',ident,'--execute']]:subprocess.run([PY,str(release/'maintenance/update.py'),*args],stdout=log,stderr=subprocess.STDOUT,check=True)
+ receipt=release/'maintenance/updates'/ident/'UPDATE_VERIFIED.json';assert json.loads(receipt.read_text())['status']=='PASS';atomic_json(R/'FINAL_ARCHIVE_VERIFIED.json',{'id':ident,'receipt':str(receipt),'sha256':sha256(receipt)})
+
+def main():
+ last=None;last_time=0
+ while True:
+  if (E/'ERROR.json').exists():raise RuntimeError((E/'ERROR.json').read_text())
+  if not (E/'STATUS.json').exists():time.sleep(30);continue
+  j=json.loads((E/'STATUS.json').read_text());states=[(u['unit'],a,v['state']) for u in j['units'] for a,v in u['arms'].items()]
+  fingerprint=hashlib.sha256(json.dumps(states,sort_keys=True).encode()).hexdigest()
+  workers=[E/f'WORKER_{i}.json' for i in [0,1]];done=all(f.exists() and json.loads(f.read_text())['phase']=='assigned_ready_arms_completed' for f in workers)
+  gpu=(R/'GPU_STATUS.json').exists() and json.loads((R/'GPU_STATUS.json').read_text())['phase']=='all_nine_diffusion_completed'
+  if fingerprint!=last and (last is None or time.monotonic()-last_time>900 or done):
+   if refresh():last=fingerprint;last_time=time.monotonic()
+  if done and gpu and (R/'MIRROR_VERIFIED.json').exists():
+   rt=Runtime(R/'deck_runtime');rt.preflight('cpu',4)
+   with (R/'aggregate.log').open('a') as log:subprocess.run(rt.wrapped_command('final-x1-aggregate',[CPU,str(E/'aggregate.py')],'cpu',4,2),stdout=log,stderr=subprocess.STDOUT,check=True)
+   if not refresh():time.sleep(60);continue
+   archive_final();atomic_json(R/'FINAL_STATUS.json',{'phase':'completed_available_evidence_deck_archived','at':stamp(),'x1_full_units':j['x1_full_units'],'missing_scsemi':j['missing_scsemi'],'deck':str(R/'DECK_CURRENT.json')});return
+  atomic_json(R/'DECK_STATUS.json',{'phase':'watching_completed_evidence','at':stamp(),'x1_full_units':j['x1_full_units'],'last_render_fingerprint':last,'missing_scsemi':j['missing_scsemi']})
+  time.sleep(60)
+if __name__=='__main__':
+ try:main()
+ except BaseException as e:atomic_json(R/'DECK_STATUS.json',{'phase':'stopped_needs_inspection','at':stamp(),'error':str(e)});raise

paper-releases/pbisc-diffusion/updates/20261015T121654Z-x1-nine-core40-deck/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/recoveries/x1_priority_completion_20261015/evaluation/test_readiness.py

@@ -0,0 +1,65 @@
+import hashlib
+import json
+from pathlib import Path
+import tempfile
+import unittest
+from readiness import generation_readiness
+
+
+class ReadinessTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.plan = Path(self.temp.name)
+        self.rel = Path("immicro/healthy/fold0/n20")
+        self.folder = self.plan / "generated" / self.rel
+        self.folder.mkdir(parents=True)
+        (self.plan / "receipts").mkdir()
+        self.receipt = self.plan / "receipts/immicro-healthy-fold0-n20-lora.json"
+        self.npz, self.log = self.folder / "lora.npz", self.folder / "lora.log"
+
+    def tearDown(self):
+        self.temp.cleanup()
+
+    def gate(self):
+        return generation_readiness(self.plan, self.rel, "lora")
+
+    def completed(self):
+        self.npz.write_bytes(b"existing output fixture")
+        digest = hashlib.sha256(self.npz.read_bytes()).hexdigest()
+        self.log.write_text(json.dumps({"output": str(self.npz), "output_sha256": digest}))
+        outputs = [{"path": str(p), "bytes": p.stat().st_size, "sha256": hashlib.sha256(p.read_bytes()).hexdigest()}
+                   for p in (self.npz, self.log)]
+        self.receipt.write_text(json.dumps({"state": "completed", "outputs": outputs}))
+
+    def test_inflight_empty_sampler_waits(self):
+        self.npz.write_bytes(b"partially written")
+        self.log.write_text("")
+        self.receipt.write_text(json.dumps({"state": "running"}))
+        self.assertFalse(self.gate()["ready"])
+        self.assertEqual(self.gate()["state"], "waiting_generation")
+
+    def test_completed_receipt_passes(self):
+        self.completed()
+        self.assertTrue(self.gate()["ready"])
+
+    def test_failed_operation_never_admitted(self):
+        self.completed()
+        operation = json.loads(self.receipt.read_text())
+        operation["state"] = "failed"
+        self.receipt.write_text(json.dumps(operation))
+        self.assertFalse(self.gate()["ready"])
+        self.assertEqual(self.gate()["state"], "generation_failed_needs_inspection")
+
+    def test_missing_operation_never_admitted(self):
+        self.completed()
+        self.receipt.unlink()
+        self.assertFalse(self.gate()["ready"])
+
+    def test_completed_but_truncated_sampler_never_admitted(self):
+        self.completed()
+        self.log.write_text("")
+        self.assertFalse(self.gate()["ready"])
+
+
+if __name__ == "__main__":
+    unittest.main()

paper-releases/pbisc-diffusion/updates/20261015T121654Z-x1-nine-core40-deck/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/recoveries/x1_priority_completion_20261015/followup.py

@@ -0,0 +1,39 @@
+"""Durable CPU scheduling/mirroring and restore the pre-existing scSemi queue without duplicates."""
+from pathlib import Path
+import json,sys,subprocess,time,shlex
+R=Path(__file__).resolve().parent;S=R.parents[1];M=S.parents[1];E=R/'evaluation';X=M/'plans/f01_trunk4x_complete_20261013'
+sys.path.insert(0,str(S/'tools'));from runtime import atomic_json,stamp
+PY='/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python'
+def state(phase,**kw):atomic_json(R/'FOLLOWUP_STATUS.json',{'phase':phase,'at':stamp(),**kw})
+def launch_worker1():
+ unit='pbisc-x1-full-cpu1-20261015'
+ subprocess.run(['systemd-run','--user',f'--unit={unit}','--slice=app.slice','-p','MemoryMax=4G','-p','MemorySwapMax=0','-p','OOMPolicy=kill','-p','OOMScoreAdjust=500','-p','Restart=no','-p',f'StandardOutput=append:{E}/worker1.log','-p','StandardError=inherit','/usr/bin/env','CUDA_VISIBLE_DEVICES=','PYTHONDONTWRITEBYTECODE=1','OMP_NUM_THREADS=2','OPENBLAS_NUM_THREADS=2',PY,'-u',str(E/'cpu_queue.py'),'--run','--prepare-caches','--workers','2','--worker-index','1','--memory-gib','16'],check=True)
+ atomic_json(R/'CPU1_LAUNCHED.json',{'unit':unit,'at':stamp(),'memory_policy':'Only after16GiB core worker exited; full16+full16+x4score32 <=64GiB CPU caps'})
+def resume_scsemi():
+ assert (R/'mirror/MIRROR_VERIFIED.json').exists() or (R/'MIRROR_VERIFIED.json').exists()
+ old=S/'recoveries/priority_server2_20261014';unit='pbisc-strict-priority-remote-v2-20261015'
+ args=['/usr/bin/env','XDG_RUNTIME_DIR=/run/user/1000','DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/1000/bus','systemd-run','--user',f'--unit={unit}','--slice=app.slice','-p','MemoryMax=2G','-p','MemorySwapMax=0','-p','OOMPolicy=kill','-p','OOMScoreAdjust=500','-p','Restart=no','-p',f'StandardOutput=append:{old}/worker.log','-p','StandardError=inherit','/usr/bin/env','CUDA_VISIBLE_DEVICES=','PYTHONDONTWRITEBYTECODE=1','OMP_NUM_THREADS=1','OPENBLAS_NUM_THREADS=1',f'PBISC_STRICT_EXECUTION_MAP={S}/recoveries/two_host/execution_map_server2.json','/home/sj_server_2/miniforge3/envs/b2sc-infer/bin/python','-u',str(old/'worker.py'),'run','--stage','compute','--unit-list',str(old/'units.json')]
+ subprocess.run(['ssh','spark-0110',shlex.join(args)],check=True)
+ atomic_json(R/'SCSEMI_CONTINUATION.json',{'unit':unit,'at':stamp(),'policy':'New x1diffusion receipts verifiedskip; remaining scSemi work still yields to x4 until HFcoreverified'})
+def main():
+ while True:
+  g=json.loads((R/'GPU_STATUS.json').read_text())
+  if g['phase']=='stopped_needs_inspection':raise RuntimeError(g.get('error'))
+  core=E/'CORE_STATUS.json'
+  if core.exists() and json.loads(core.read_text())['phase']=='complete' and not (R/'CPU1_LAUNCHED.json').exists():
+   # Completionfile iswrittenjustbeforeexit; waituntilthecorecontrollerhasactuallystopped.
+   active=subprocess.run(['systemctl','--user','is-active','--quiet','pbisc-x1-core-cpu-20261015.service']).returncode==0
+   if not active:launch_worker1()
+  if g['phase']=='all_nine_diffusion_completed' and not (R/'SCSEMI_CONTINUATION.json').exists():
+   state('mirroring_completed_x1')
+   subprocess.run([PY,str(R/'mirror_diffusion.py')],check=True)
+   resume_scsemi()
+  hf=X/'HF_CORE_VERIFIED.json';release=X/'payload/priority/LOW_PRIORITY_RELEASE.json'
+  if hf.exists() and json.loads(hf.read_text()).get('state')=='verified' and not release.exists():
+   atomic_json(release,{'reason':'x4corecomputationandHFbackupverified','receipt':str(hf),'at':stamp()})
+  state('watching',x1_gpu_completed=len(g['completed']),cpu1_started=(R/'CPU1_LAUNCHED.json').exists(),scsemi_continuation=(R/'SCSEMI_CONTINUATION.json').exists())
+  if (R/'CPU1_LAUNCHED.json').exists() and (R/'SCSEMI_CONTINUATION.json').exists() and release.exists():return
+  time.sleep(30)
+if __name__=='__main__':
+ try:main()
+ except BaseException as e:state('stopped_needs_inspection',error=str(e));raise

paper-releases/pbisc-diffusion/updates/20261015T121654Z-x1-nine-core40-deck/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/recoveries/x1_priority_completion_20261015/transport.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+import sys,json,subprocess,shlex,hashlib
+r=json.loads(Path(sys.argv[1]).read_text())
+subprocess.run(r['command'],check=True)
+files=r['outputs']
+code='import pathlib,hashlib,json,sys; print(json.dumps({p:hashlib.file_digest(pathlib.Path(p).open("rb"),"sha256").hexdigest() for p in json.load(sys.stdin)}))'
+hashes=json.loads(subprocess.check_output(['ssh','spark-0110',shlex.join(['python3','-c',code])],input=json.dumps(files).encode()))
+for f,h in hashes.items():
+ p=Path(f);p.parent.mkdir(parents=True,exist_ok=True)
+ if p.exists():assert hashlib.file_digest(p.open('rb'),'sha256').hexdigest()==h,'Conflicting local result preserved'
+ else:subprocess.run(['rsync','-a','--protect-args','spark-0110:'+f,str(p)],check=True)
+ assert hashlib.file_digest(p.open('rb'),'sha256').hexdigest()==h
+Path(r['receipt']).write_text(json.dumps({'host':'server_2','sha256':hashes,'state':'verified'},indent=2)+'\n')