Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261013T005008Z-reuse-audit-results-deck/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/build_results_review_20261013.py

@@ -0,0 +1,278 @@
+"""Reassemble existing PBISC evidence; CPU table plots only, no new experiments."""
+from pathlib import Path
+from datetime import datetime, timezone, timedelta
+import hashlib
+import json
+import os
+
+if os.environ.get('CUDA_VISIBLE_DEVICES') != '':
+    raise SystemExit('Use CUDA_VISIBLE_DEVICES empty for this CPU-only deck builder')
+import fitz
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from pptx import Presentation
+from pptx.util import Pt
+from pptx.dml.color import RGBColor
+from pptx.enum.shapes import MSO_SHAPE
+
+D = Path(__file__).resolve().parents[1]
+M = D.parents[1]
+P = M/'plans/paper_figures_strictpairs_20261012'
+O = M/'plans/paired_finetune_intradataset_20260927'
+U = M/'plans/utility_studies_final6k_20260925'
+FIG = D/'figures'
+DATA = D/'data'
+W,H = 960,540
+INK='#223647'; MUTED='#617184'; TEAL='#087D79'; AMBER='#A66813'
+FONTS=Path('/usr/share/fonts/truetype/dejavu')
+SPEC=json.loads((DATA/'slides_spec.json').read_text())['slides']
+PDF=fitz.open(); PPT=Presentation(); PPT.slide_width=Pt(W); PPT.slide_height=Pt(H)
+PAGE=SLIDE=None
+SOURCES={}; SLIDES=[]
+ASOF=datetime.now(timezone(timedelta(hours=9))).strftime('%Y-%m-%d %H:%M KST')
+
+
+def sha(path):
+    with Path(path).open('rb') as stream:return hashlib.file_digest(stream,'sha256').hexdigest()
+
+
+def source(path,role):
+    path=Path(path).resolve()
+    if not path.is_file():raise FileNotFoundError(path)
+    SOURCES[str(path)]={'sha256':sha(path),'role':role}
+    return path
+
+
+def col(x):return tuple(int(x[i:i+2],16)/255 for i in (1,3,5))
+
+
+def text(x,y,w,h,value,size=17,bold=False,ink=INK):
+    font='DB' if bold else 'DR'
+    result=PAGE.insert_textbox(fitz.Rect(x,y,x+w,y+h),value,fontname=font,fontsize=size,
+                             color=col(ink),lineheight=1.12)
+    if result<0:raise ValueError('Text overflows: '+value[:90])
+    shape=SLIDE.shapes.add_textbox(Pt(x),Pt(y),Pt(w),Pt(h));frame=shape.text_frame
+    frame.word_wrap=True
+    frame.margin_left=frame.margin_right=frame.margin_top=frame.margin_bottom=0
+    for i,line in enumerate(value.split('\n')):
+        para=frame.paragraphs[0] if i==0 else frame.add_paragraph();para.text=line
+        para.font.name='DejaVu Sans';para.font.size=Pt(size);para.font.bold=bold
+        para.font.color.rgb=RGBColor.from_string(ink[1:]);para.space_after=Pt(0);para.line_spacing=1.12
+
+
+def rectangle(x,y,w,h,fill='#F3F6F8'):
+    PAGE.draw_rect(fitz.Rect(x,y,x+w,y+h),color=col(fill),fill=col(fill),width=0)
+    sh=SLIDE.shapes.add_shape(MSO_SHAPE.RECTANGLE,Pt(x),Pt(y),Pt(w),Pt(h))
+    sh.fill.solid();sh.fill.fore_color.rgb=RGBColor.from_string(fill[1:]);sh.line.fill.background()
+
+
+def slide(title,section,protocol,notes='',old_slide=None):
+    global PAGE,SLIDE
+    PAGE=PDF.new_page(width=W,height=H)
+    PAGE.insert_font(fontname='DR',fontfile=str(FONTS/'DejaVuSans.ttf'))
+    PAGE.insert_font(fontname='DB',fontfile=str(FONTS/'DejaVuSans-Bold.ttf'))
+    SLIDE=PPT.slides.add_slide(PPT.slide_layouts[6])
+    text(34,14,850,18,section.upper(),10,True,TEAL)
+    text(34,38,892,44,title,25,True)
+    rectangle(34,490,892,1,'#DCE3E9')
+    text(34,501,850,28,protocol,10,False,MUTED)
+    text(910,506,25,18,str(len(PDF)),9,False,MUTED)
+    SLIDE.notes_slide.notes_text_frame.text=notes+'\nProtocol: '+protocol
+    SLIDES.append({'slide':len(PDF),'section':section,'title':title,'protocol':protocol,
+                   'old_deck_slide':old_slide,'notes':notes,'assets':[]})
+
+
+def picture(path,x=34,y=90,w=892,h=385,clip=None):
+    path=source(path,'figure')
+    ispdf=path.suffix.lower()=='.pdf'
+    if ispdf:
+        doc=fitz.open(path);r=doc[0].rect
+        if clip:r=fitz.Rect(r.x0,r.height*clip[0],r.x1,r.height*clip[1])
+        ratio=r.width/r.height
+    else:
+        pix=fitz.Pixmap(path);ratio=pix.width/pix.height
+    aw=min(w,h*ratio);ah=aw/ratio;xx=x+(w-aw)/2;yy=y+(h-ah)/2
+    if ispdf:
+        PAGE.show_pdf_page(fitz.Rect(xx,yy,xx+aw,yy+ah),doc,0,clip=r)
+        import io
+        blob=doc[0].get_pixmap(matrix=fitz.Matrix(2.5,2.5),clip=r,alpha=False).tobytes('png')
+        SLIDE.shapes.add_picture(io.BytesIO(blob),Pt(xx),Pt(yy),width=Pt(aw),height=Pt(ah))
+    else:
+        PAGE.insert_image(fitz.Rect(xx,yy,xx+aw,yy+ah),filename=str(path))
+        SLIDE.shapes.add_picture(str(path),Pt(xx),Pt(yy),width=Pt(aw),height=Pt(ah))
+    SLIDES[-1]['assets'].append({'path':str(path),'sha256':SOURCES[str(path)]['sha256'],'clip_y_fraction':clip})
+
+
+def old(number,section,title,protocol):
+    s=SPEC[number-1]
+    notes='Original deck slide '+str(number)+'\n'+s.get('footnote_full',s.get('footnote',''))
+    notes+='\nSources: '+s.get('sources','')+'\n'+'\n'.join(s.get('refs_full',[]))
+    slide(title,section,protocol,notes,number)
+    paths=[D/f for f in s['figures']]
+    for i,path in enumerate(paths):
+        vector=path.with_suffix('.pdf');path=vector if vector.is_file() else path
+        if len(paths)==1:picture(path)
+        else:picture(path,34+i*450,90,442,385)
+
+
+def save_plot(fig,name):
+    for ext in ['pdf','svg','png']:
+        fig.savefig(FIG/f'{name}.{ext}',dpi=220,bbox_inches='tight',facecolor='white')
+    plt.close(fig)
+    return FIG/f'{name}.pdf'
+
+
+def table_plots():
+    """Small saved-table redraws; no expression arrays or checkpoints are loaded."""
+    plt.rcParams.update({'font.family':'DejaVu Sans','font.size':10,'axes.spines.top':False,
+                         'axes.spines.right':False,'pdf.fonttype':42,'svg.fonttype':'none'})
+    types=['T cell','B cell','Monocyte','NK cell','DC','Other']
+    frames=[]
+    for draw in range(5):
+        for folder in [f'draw{draw}',f'draw{draw}_scsemi5']:
+            f=source(O/'scores/immicro/fewshot_n5'/folder/'per_donor.csv','existing healthy scores')
+            frame=pd.read_csv(f);frame['draw']=draw;frames.append(frame)
+    t=pd.concat(frames,ignore_index=True)
+    order=['zs_raw','zs_cal','scsemi5','lora5']
+    t=t[t.arm.isin(order)].copy()
+    assert t.groupby('arm').size().to_dict()=={a:510 for a in order}
+    assert not t.duplicated(['arm','draw','donor']).any()
+    keys={a:set(map(tuple,t[t.arm==a][['draw','donor']].to_numpy())) for a in order}
+    assert all(keys[a]==keys['lora5'] for a in order)
+    obs=t[t.arm=='lora5'].set_index(['draw','donor'])[[f'obs_{c}' for c in types]].sort_index()
+    for a in order:
+        got=t[t.arm==a].set_index(['draw','donor'])[obs.columns].sort_index()
+        assert np.allclose(got.to_numpy(),obs.to_numpy(),atol=1e-12,rtol=0)
+    # One descriptive mean per donor across the draws in which it was held out.
+    grouped=t.groupby(['arm','donor'])[[f'{pre}_{c}' for pre in ['obs','gen'] for c in types]].mean()
+    observed=grouped.loc['lora5'][[f'obs_{c}' for c in types]].mean().to_numpy()
+    values=np.vstack([observed]+[grouped.loc[a][[f'gen_{c}' for c in types]].mean().to_numpy() for a in order])
+    assert np.allclose(values.sum(1),1,atol=1e-8)
+    labels=['Observed','Raw','Paired cal.','scSemiProfiler','PBISC LoRA']
+    out=pd.DataFrame(values,columns=types);out.insert(0,'method',labels)
+    out.to_csv(DATA/'review_20261013_healthy_composition.csv',index=False)
+    fig,axs=plt.subplots(1,3,figsize=(13.2,4.0),gridspec_kw={'width_ratios':[1.4,1,1]})
+    colors=['#56B4E9','#E69F00','#009E73','#CC79A7','#0072B2','#B1B7BE'];bottom=np.zeros(5)
+    for j,c in enumerate(types):
+        axs[0].bar(np.arange(5),values[:,j]*100,bottom=bottom,color=colors[j],label=c,width=.7)
+        bottom+=values[:,j]*100
+    axs[0].set_xticks(range(5),labels,rotation=25,ha='right');axs[0].set_ylabel('Mean cell-type share (%)')
+    axs[0].legend(fontsize=8,ncol=3,loc='upper center',bbox_to_anchor=(.5,1.22),frameon=False)
+    for ax,c in zip(axs[1:],['T cell','Monocyte']):
+        for a,label,cmap in [('lora5','PBISC LoRA','#D55E00'),('scsemi5','scSemiProfiler','#009E73')]:
+            z=grouped.loc[a];ax.scatter(100*z[f'obs_{c}'],100*z[f'gen_{c}'],s=13,alpha=.65,c=cmap,label=label)
+        ax.plot([0,100],[0,100],'--',lw=.9,c='#7A8997');ax.set(xlim=(0,100),ylim=(0,100),title=c,xlabel='Observed share (%)',ylabel='Generated share (%)')
+    axs[2].legend(fontsize=8,frameon=False,loc='upper left');fig.tight_layout(w_pad=2)
+    composition=save_plot(fig,'review_20261013_healthy_composition')
+
+    f=source(P/'source_data/rare_all_states.csv','existing corrected rare-state summaries');r=pd.read_csv(f)
+    assert set(r.evidence_tier)=={'diagnostic'} and set(r.design)=={'legacy_5donor'}
+    cohorts=['ye2026_sepsis','imperial_eskd','giroux2022','ji2025_chili'];cn=['Sepsis','Imperial','Giroux','Ji']
+    states=list(dict.fromkeys(r.state))
+    z=r[r.arm=='lora5'].groupby(['state','cohort']).obs_pct.median().unstack().reindex(index=states,columns=cohorts)
+    z.to_csv(DATA/'review_20261013_rare_observed.csv')
+    fig,ax=plt.subplots(figsize=(12.2,6.1));im=ax.imshow(z.to_numpy(),cmap='YlGnBu',aspect='auto',vmin=0,vmax=np.nanmax(z.to_numpy()))
+    ax.set_xticks(range(4),cn);ax.set_yticks(range(len(states)),states);ax.tick_params(axis='both',length=0)
+    for i in range(len(states)):
+        for j in range(4):
+            v=z.iloc[i,j];ax.text(j,i,'NA' if pd.isna(v) else f'{v:.2g}',ha='center',va='center',fontsize=9,color='white' if pd.notna(v) and v>20 else '#223647')
+    fig.colorbar(im,ax=ax,label='Observed state share within parent (%)',fraction=.035,pad=.03)
+    fig.tight_layout();observed_plot=save_plot(fig,'review_20261013_rare_observed')
+    f=source(P/'source_data/rare_all_states_aggregate.csv','existing zero-aware rare-state metrics');a=pd.read_csv(f)
+    e=a.pivot(index=['cohort','state'],columns='arm',values='abundance_error')
+    rank=a.pivot(index=['cohort','state'],columns='arm',values='ranking')
+    assert len(e)==59
+    fig,axs=plt.subplots(1,2,figsize=(12.4,4.6));palette=['#0072B2','#D55E00','#009E73','#CC79A7']
+    for cohort,name,c in zip(cohorts,cn,palette):
+        x=e.loc[cohort];axs[0].scatter(x.scsemi5,x.lora5,c=c,s=31,alpha=.8,label=name)
+        x=rank.loc[cohort];axs[1].scatter(x.scsemi5,x.lora5,c=c,s=31,alpha=.8,label=name)
+    lim=float(np.nanmax(e[['scsemi5','lora5']].to_numpy()))*1.05
+    axs[0].plot([0,lim],[0,lim],'--',color='#6B7A89',lw=1)
+    axs[0].set(xlabel='scSemiProfiler abundance error (pp)',ylabel='PBISC LoRA abundance error (pp)',xlim=(0,lim),ylim=(0,lim),title='Abundance error: below diagonal favors LoRA')
+    axs[1].plot([-1,1],[-1,1],'--',color='#6B7A89',lw=1)
+    axs[1].set(xlabel='scSemiProfiler donor rank correlation',ylabel='PBISC LoRA donor rank correlation',xlim=(-1,1),ylim=(-1,1),title='Patient ranking: above diagonal favors LoRA')
+    axs[1].legend(fontsize=9,frameon=False);fig.tight_layout(w_pad=2.8)
+    rare_compare=save_plot(fig,'review_20261013_rare_corrected_comparison')
+    return composition,observed_plot,rare_compare
+
+
+def main():
+    source(DATA/'slides_spec.json','original 76-slide deck specification')
+    comp,rareobs,rarecompare=table_plots()
+    slide('PBISC-Diffusion: results available now','Results review',ASOF+' | Existing evidence reused; protocol updates are identified separately.')
+    text(55,122,850,80,'Pretraining → settings → healthy cells → disease signals → rare states',29,True)
+    text(55,231,845,116,'Completed figures and saved outputs form the main deck.\nStrict-budget replacements, CPU-only visual work and new-data waiting are separate statuses.',22)
+    text(55,406,845,45,'No training or cell generation was performed to assemble this deck.',16,False,TEAL)
+
+    slide('What is already supported?','Figure roadmap','Figure 6 remains reserved for user-prepared reproduction data.')
+    rows=[('1','Training and inference','Complete concept + corpus'),('2','Settings and data budget','Ablations/rank complete; strict-n update running'),('3','Healthy reconstruction','Exact-five draw results complete; OOF scoring update'),('4','Disease signals','Five-donor and five-fold results; corrected exact-five update'),('5','Rare-state reproduction','Existing outputs reanalyzed; descriptive Behcet'),('6','Bulk-only reproduction','Awaiting new dataset')]
+    for i,(n,title,state) in enumerate(rows):
+        y=92+i*61;rectangle(34,y,892,52);text(49,y+10,28,28,n,20,True,TEAL);text(98,y+9,354,30,title,17,True);text(459,y+11,451,30,state,13,False,MUTED)
+
+    for title,clip in [('From pretraining to five-pair adaptation',(0,.395)),('Condition, depth and independent cell draws',(.395,.65)),('Corpus composition and training exposure',(.65,1))]:
+        slide(title,'Figure 1','Complete existing concept: K_cond, depth and N_gen are distinct; corpus labels are descriptive.')
+        picture(P/'figures/fig1_overview.pdf',clip=clip)
+
+    slide('Native-pseudobulk model comparisons','Figure 2','Completed held-out rescoring. Architecture 1% floor and gene-panel 0.1% floor are separate sweeps.')
+    picture(P/'figures/fig2_ablation_and_support.pdf',clip=(.035,.35))
+    old(12,'Figure 2','Gene-panel performance and gene coverage','Existing panel benchmark; 6k has five sampling seeds, other panels one. Do not claim universal 6k superiority.')
+    slide('Healthy real bulk: full fine-tuning and LoRA rank','Figure 2','Completed original donor-level five-fold comparison; r16 is a quality/parameter compromise.')
+    picture(P/'figures/fig2_ablation_and_support.pdf',clip=(.35,.68))
+    old(31,'Figure 2','Existing learning curve: matched data access','Historical curve: n training + 7 validation pairs; early stopping. These are not the new total-n budgets.')
+    old(26,'Figure 2','Additional pairs improve donor-level information','Historical n + 7 validation design. The fixed-3000-step strict curve is a separate protocol update.')
+
+    old(17,'Figure 3','Measured bulk differs from pseudobulk input','Existing paired-input diagnostic; mean-shift removal uses paired pseudobulks and is not a deployment method.')
+    old(30,'Figure 3','Healthy donors: completed exact-five comparison','ImMicro: exactly 5 pairs, no extra validation, 3000-step LoRA; five draws, remaining 102 donors per draw.')
+    slide('Healthy cell-type composition from saved scores','Figure 3','CPU redraw of completed exact-five draws. Each donor is averaged over held-out draws; descriptive, no new p-values.')
+    picture(comp)
+    old(32,'Figure 3','Representative-dependent composition errors','Existing healthy five-draw diagnostic. This evaluates composition dependence, not literal copying of every cell.')
+    old(34,'Figure 3','Operational cost after supplied pretraining','Existing measurements: adaptation + target generation; pretraining, GPU wait and scoring excluded.')
+
+    old(37,'Figure 4','Paired cohorts and their evaluation units','Existing paired-cohort map. Five donors means 5 pairs in Sepsis, 12-15 Imperial, 12-14 Giroux, 7-9 Ji.')
+    old(38,'Figure 4','Disease signal: completed five-donor draws','Existing five-donor protocol; sample counts differ by cohort. Original sample-level estimator; corrected update separate.')
+    old(39,'Figure 4','Disease signal: completed five-fold validation','Original donor-level split and original signal estimator. These results are distinct from the exact-five update.')
+    old(40,'Figure 4','Disease-gene agreement across list lengths','Existing CAT curves; ranking agreement and chance line. Patient-aware reanalysis reuses the same predictions.')
+    old(41,'Figure 4','Cell-type expression against deconvolution','Completed BayesPrism/CIBERSORTx comparisons; same five-donor support, method-supported expression metrics.')
+    old(46,'Figure 4','Composition against deconvolution','Completed deconvolution outputs already exist. Verified identical Sepsis supports use adoption instead of method reruns.')
+
+    slide('Rare-state frequencies in the observed cells','Figure 5','Saved corrected analysis of original five-donor outputs; median across draws, state share within parent population.')
+    picture(rareobs)
+    slide('Rare-state fidelity after zero-aware reanalysis','Figure 5','Original five-donor predictions; zero draws retained and actual donor IDs. 59 state/cohort combinations, including controls.')
+    picture(rarecompare)
+    slide('Behcet: one-gene and multi-gene C1Q rules','Figure 5','Descriptive unmatched reference includes training donors. Same-three-pair calibration; 2 identity-pass + 1 uncertain pair.')
+    picture(P/'figures/fig5_behcet_rules_diagnostic.pdf')
+
+    slide('Remaining work has three different meanings','Work status','Existing evidence stays visible; incomplete replacements are not presented as completed new results.')
+    items=[('Protocol update running','Total n=5/10/20/40 without extra validation; exact-five samples in multi-visit disease cohorts.'),('CPU scoring / visual assembly','Healthy OOF outputs already generated; shared UMAP, canonical marker dot plots, patient-aware contrasts and strict rare caches.'),('New data waiting','Figure 6: reproduce a published finding using the user-prepared bulk-only cohort.')]
+    for i,(title,body) in enumerate(items):
+        y=110+i*116;rectangle(34,y,892,101,'#FFF6E7' if i==2 else '#F3F6F8')
+        text(52,y+12,850,29,title,19,True,AMBER if i==2 else TEAL);text(52,y+48,850,43,body,15)
+
+    # Completed controls and limitations are retained without repeating new runs.
+    old(19,'Supporting evidence','Existing control-cell embedding diagnostic','Existing same-noise input diagnostic; not the new LoRA/scSemi OOF embedding. UMAP overlap is not a quantitative score.')
+    old(58,'Supporting evidence','Generated-cell quality across all cohorts','Completed five-donor comparisons. Multi-visit cohorts used more than five paired samples.')
+    old(60,'Supporting evidence','Precision and coverage across neighbourhood sizes','Completed sensitivity at k=3,5,10; no new sensitivity campaign required.')
+    old(62,'Supporting evidence','Same training pairs: five-fold method comparison','Completed original five-fold LoRA/scSemi comparison; not the new total-n curve.')
+    old(68,'Supporting evidence','Pairs from other cohorts do not replace local pairs','Completed leave-one-cohort-out test at K=1000; target-cohort sc was excluded from training.')
+    old(69,'Supporting evidence','Longer cross-cohort training leaves a gap','Existing saturation experiment; no additional saturation run introduced here.')
+    old(70,'Supporting evidence','From-scratch control: current evidence and limits','Completed Sepsis fold0 pilot, not all folds. Pretraining supports speed/few-pair adaptation, not universal superiority.')
+    old(74,'Supporting evidence','scSemiProfiler readout sensitivity','Completed modified-readout check; main results use official output. Models were not retrained for the sensitivity.')
+    old(42,'Supporting evidence','SLE pseudobulk development benchmark','Completed pseudobulk benchmark; separate from external paired real-bulk validation. PBISC five seeds, scSemi one run.')
+
+    stem=D/'PBISC-Diffusion_results_review_20261013'
+    PDF.set_metadata({'title':'PBISC-Diffusion — existing results review','subject':'Existing evidence reused; protocol-specific updates labelled'})
+    PDF.save(stem.with_suffix('.pdf'),garbage=4,deflate=True);PPT.save(stem.with_suffix('.pptx'))
+    for i,s in enumerate(PPT.slides):
+        for sh in s.shapes:assert sh.left>=0 and sh.top>=0 and sh.left+sh.width<=PPT.slide_width+2 and sh.top+sh.height<=PPT.slide_height+2,(i,sh.name)
+    manifest={'schema':'pbisc.results-review.reuse.v1','as_of_kst':ASOF,'slides':SLIDES,'sources':SOURCES,
+              'new_training':False,'new_generation':False,'cpu_work':'saved-table redraws only',
+              'pdf_sha256':sha(stem.with_suffix('.pdf')),'pptx_sha256':sha(stem.with_suffix('.pptx'))}
+    (DATA/'results_review_20261013_provenance.json').write_text(json.dumps(manifest,indent=2)+'\n')
+    pd.DataFrame([{k:s[k] for k in ['slide','section','title','protocol','old_deck_slide']} for s in SLIDES]).to_csv(DATA/'results_review_20261013_slide_map.csv',index=False)
+    print(json.dumps({'slides':len(SLIDES),'sources':len(SOURCES),'pdf':str(stem.with_suffix('.pdf')),'pptx':str(stem.with_suffix('.pptx'))},indent=2))
+
+
+if __name__=='__main__':main()

paper-releases/pbisc-diffusion/updates/20261013T005008Z-reuse-audit-results-deck/diffusion/dataset/server_1/model8/scripts/audit_experiment_reuse.py

@@ -0,0 +1,741 @@
+#!/usr/bin/env python3
+"""Inventory Model 8 evidence without loading arrays, importing ML, or launching jobs.
+
+The JSONL is an observed filesystem/evidence registry, not a claim that every
+experiment succeeded. JSON documents are parsed one at a time under a size cap;
+CSV/JSONL/log/text files receive bounded inspection. Scientific matches are
+candidates for human review, never permission to reuse or delete a result.
+"""
+from __future__ import annotations
+
+import argparse
+import collections
+import csv
+import hashlib
+import json
+import math
+import os
+import re
+import socket
+import stat
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterator
+
+SCHEMA = "pbisc.experiment-reuse-index.v1"
+OUTPUTS = {"EXPERIMENT_INDEX.md", "EXPERIMENT_REUSE_INDEX.jsonl", "EXPERIMENT_REUSE_COVERAGE.json"}
+EXCLUDED_DIRS = {".git", ".venv", "venv", "env", "envs", "runtime_env", "node_modules",
+                 "__pycache__", ".pytest_cache", ".cache", ".mypy_cache", ".ruff_cache",
+                 "site-packages", "Rlib", ".staging", ".incoming"}
+ARRAY_SUFFIXES = {".npz", ".npy", ".pt", ".pth", ".ckpt", ".safetensors", ".h5ad", ".h5",
+                  ".hdf5", ".parquet", ".feather", ".zarr", ".rds", ".rda", ".rdata"}
+DOCUMENT_SUFFIXES = {".md", ".txt", ".log", ".yaml", ".yml", ".toml"}
+STATE_KEYS = {"state", "status", "phase", "completed", "complete", "success", "finished", "outcome"}
+# Only these explicit scientific fields are retained; commands and arbitrary
+# configuration values (which could contain credentials) are not copied.
+FIELD_ALIASES = {
+    "checkpoint_sha256": {"source_checkpoint_sha256", "checkpoint_sha256", "model_pt_sha256", "model_sha256"},
+    "checkpoint_path": {"source_checkpoint", "checkpoint", "source_model"},
+    "support_sha256": {"support_sha256", "support_manifest_sha256"},
+    "condition_sha256": {"condition_npz_sha256", "condition_sha256", "input_condition_sha256"},
+    "reference_sha256": {"reference_sha256", "scoring_reference_sha256"},
+    "feature_sha256": {"features_sha256", "feature_sha256", "gene_axis_sha256", "panel_sha256"},
+    "training_data_sha256": {"training_data_sha256", "cells_panel_sha256", "cells_sha256", "dataset_sha256"},
+    "training_code_sha256": {"training_code_sha256", "train_script_sha256", "trainer_sha256", "source_code_sha256", "code_sha256"},
+    "effective_config_sha256": {"effective_config_sha256", "config_sha256"},
+    "output_sha256": {"output_sha256", "npz_sha256", "generated_sha256"},
+    "train_samples": {"train_rows", "train_sample_ids", "train_samples"},
+    "validation_samples": {"inner_val_rows", "validation_sample_ids", "val_rows", "inner_val_sample_ids"},
+    "test_samples": {"test_rows_never_loaded_for_training", "test_sample_ids", "test_rows", "test_samples"},
+    "gene_order": {"gene_ids", "panel_gene_ids", "scoring_gene_ids"},
+    "mode": {"mode", "arm", "method"},
+    "cohort": {"cohort", "dataset"},
+    "design": {"design", "protocol"},
+    "lora_rank": {"lora_rank", "rank"},
+    "learning_rate": {"lr", "learning_rate"},
+    "batch_size": {"batch_size"},
+    "warmup": {"warmup", "warmup_steps"},
+    "ema_decay": {"ema_decay"},
+    "fixed_steps": {"fixed_steps", "lora_fixed_steps"},
+    "selected_step": {"selected_step"},
+    "max_steps": {"max_steps"},
+    "steps_run": {"steps_run"},
+    "sampling_steps": {"sampling_steps", "ddim_steps"},
+    "seed": {"seed", "generation_seed"},
+    "training_seed": {"training_seed", "train_seed"},
+    "K_cond": {"k_cond", "k_train", "k_fixed"},
+    "rho_reference": {"rho_reference", "rho_ref"},
+    "N_gen": {"n_gen", "cells_per_donor", "n_cells_per_donor", "cells_per_sample"},
+    "support_readout": {"support_readout"},
+    "weights": {"weights"},
+    "scsemi_hvset_sha256": {"hvset_sha256"},
+}
+ALIASES = {alias.lower(): field for field, aliases in FIELD_ALIASES.items() for alias in aliases | {field}}
+REQUIRED_MATCH_FIELDS = ["checkpoint_sha256", "train_samples", "validation_samples", "test_samples",
+                         "condition_sha256", "gene_order", "fixed_steps", "sampling_steps",
+                         "seed", "K_cond", "rho_reference", "N_gen", "support_readout", "weights"]
+KNOWN_FAMILIES = [
+    ("Pretraining and checkpoint parents", ["runs", "plans/full_recipe_allcells_6k_broad_20260909", "plans/floor01_campaign_20260923"],
+     "Use RUN_STATUS/history/config and checkpoint receipts together; payload presence alone is not completion."),
+    ("Architecture and gene-panel ablations", ["plans/arch_ablation_6k_20260913", "plans/gene_panel_scaling_20260908", "analysis/floor01_benchmark_20260923",
+      "presentations/2026-09-30--paper-summary--r00/data/sec03_width_bench.csv",
+      "presentations/2026-09-30--paper-summary--r00/data/sec03_panel_bench.csv"],
+     "Existing width/context/gene-panel results precede the strict-pair campaign."),
+    ("Canonical paired training, exact-five historical draws and learning curves", ["plans/paired_finetune_intradataset_20260927"],
+     "ImMicro fewshot_n5: five samples, no inner validation, fixed3000, five draws. Historical lora_n curves: n+7 validation samples and early stopping. Do not conflate these."),
+    ("scSemiProfiler and matched-budget comparisons", ["plans/paired_finetune_intradataset_20260927/scsemi",
+      "plans/immicro_scsemi_comparison_20260927", "analysis/scsemi_benchmark_diffusion_20260913"],
+     "Check representative IDs, gene axis, hvset, seed index, assignment and exports before reusing training."),
+    ("Cross-cohort transfer and from-scratch controls", ["plans/paired_crosscohort_20261002"],
+     "LOCO and same-cohort adaptation are different estimands; retain support-cohort lineage."),
+    ("Real-reference UMAP, external calibration and composition", ["plans/utility_studies_final6k_20260925"],
+     "Existing ImMicro real-reference UMAP, AIFI reference-calibration output and composition tables are reusable inputs; LoRA/scSemi panels require method-specific projection."),
+    ("Deconvolution", ["plans/bayesprism_paired_20261006", "plans/utility_studies_final6k_20260925/deconv"],
+     "Match support pairs and supported endpoints; deconvolution is not cell generation."),
+    ("Rare-state screen and Behcet diagnostic", ["plans/rare_states_paired_20261008", "plans/rare_states_screen_20261004", "plans/behcet_c1q_lora3_20261004"],
+     "Retain zero draws, donor dependence, marker rules and the descriptive status of Behcet."),
+    ("Bulk-only generation and research", ["plans/bulkonly_lora5_20261006", "plans/bulkonly_lora5_k4000_20261006"],
+     "Existing generated arrays and analyses are candidates for CPU reanalysis, not grounds to repeat inference."),
+    ("76-slide evidence deck", ["presentations/2026-09-30--paper-summary--r00"],
+     "slides_spec.json maps each slide to figures, source CSV and full provenance notes. Slides23–34 contain healthy metrics/curves/runtime."),
+    ("Strict-pair protocol and new manuscript layouts", ["plans/paper_figures_strictpairs_20261012"],
+     "New fold support sets differ from historical draws/curves. Check generated outputs and receipts before considering missing scoring a reason to regenerate."),
+    ("Current cross-host archive catalogs", ["../../paper-release-20260928/CURRENT_MODEL_INDEX.csv",
+      "../../paper-release-20260928/CURRENT_INFERENCE_LOCATIONS.csv"],
+     "Resolve canonical host and location from these catalogs; identical paths can exist on both hosts. Catalog observations are not a live process check."),
+    ("Separately verified duplicate-training evidence", ["plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/CONFIRMED_DUPLICATE_TRAINING.json"],
+     "Read the coordinator's exact scoped payload comparison and provenance. This audit links that evidence; generic metadata signatures do not inherit its confirmed status."),
+]
+
+
+def now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def digest(value: Any) -> str:
+    return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False).encode()).hexdigest()
+
+
+def family_of(relative: Path) -> str:
+    parts = relative.parts
+    if len(parts) == 2 and relative.suffix:
+        return parts[0]
+    if parts and parts[0] in {"plans", "runs", "analysis", "presentations", "artifacts"} and len(parts) > 1:
+        return "/".join(parts[:2])
+    return parts[0] if len(parts) > 1 else "root"
+
+
+def lineage_role(relative: Path) -> str:
+    copies = {"archive", "_archive", "archived", "backups", "backup", "snapshot", "snapshots", "previews", "mirror", "mirrors"}
+    if any(part.lower() in copies or "snapshot" in part.lower() or part.lower().startswith(("backup", "pause_")) for part in relative.parts[:-1]):
+        return "inherited_snapshot_or_backup_not_independent_experiment"
+    return "primary_working_tree_observation_not_proof_of_independent_run"
+
+
+def kind_of(path: Path) -> str:
+    suffix = path.suffix.lower()
+    if suffix in ARRAY_SUFFIXES:
+        return "checkpoint_payload" if suffix in {".pt", ".pth", ".ckpt", ".safetensors"} else "array_payload"
+    if suffix in {".png", ".pdf", ".svg", ".jpg", ".jpeg", ".pptx", ".html"}:
+        return "figure_or_presentation"
+    if suffix in {".csv", ".tsv"}:
+        return "table"
+    if suffix in {".json", ".jsonl"}:
+        return "metadata"
+    if suffix in DOCUMENT_SUFFIXES:
+        return "document_or_log"
+    if suffix in {".py", ".sh", ".r", ".js", ".tex"}:
+        return "source"
+    return "other"
+
+
+def extract_scientific(document: Any) -> dict[str, Any]:
+    """Retain explicit evidence paths; conflicting nested values never collapse."""
+    values: dict[str, list[dict[str, Any]]] = collections.defaultdict(list)
+
+    def visit(value: Any, keypath: str, depth: int) -> None:
+        if depth > 7:
+            return
+        if isinstance(value, dict):
+            for key, child in value.items():
+                field = ALIASES.get(str(key).lower())
+                location = f"{keypath}.{key}".lstrip(".")
+                if field:
+                    normalized: Any = None
+                    if field in {"train_samples", "validation_samples", "test_samples", "gene_order"}:
+                        if isinstance(child, list) and all(isinstance(v, (str, int)) for v in child):
+                            sequence = [str(v) for v in child]
+                            normalized = {"count": len(sequence), "sha256": digest(sequence if field == "gene_order" else sorted(sequence)),
+                                          "ordering": "ordered" if field == "gene_order" else "sorted_sample_ids"}
+                    elif isinstance(child, (str, int, bool)) or child is None:
+                        normalized = child if not isinstance(child, str) else child[:1000]
+                    elif isinstance(child, float) and child == child and abs(child) != float("inf"):
+                        normalized = child
+                    if normalized is not None and len(values[field]) < 12:
+                        candidate = {"source_key": location, "value": normalized}
+                        if candidate not in values[field]:
+                            values[field].append(candidate)
+                if isinstance(child, dict):
+                    visit(child, location, depth + 1)
+                # A list of arm/donor records may contain independent runs; do
+                # not flatten them into a single experiment signature.
+    visit(document, "", 0)
+    unambiguous: dict[str, Any] = {}
+    ambiguous = []
+    for field, evidence in values.items():
+        distinct = {json.dumps(item["value"], sort_keys=True) for item in evidence}
+        if len(distinct) == 1:
+            unambiguous[field] = evidence[0]["value"]
+        else:
+            ambiguous.append(field)
+    scientific = {k: v for k, v in unambiguous.items() if k not in {"output_sha256", "checkpoint_path", "steps_run"}}
+    unknown = [field for field in REQUIRED_MATCH_FIELDS if field not in scientific]
+    return {"fields": dict(values), "unambiguous": unambiguous, "ambiguous_fields": sorted(ambiguous),
+            "unknown_required_fields": unknown, "signature_sha256": digest(scientific) if scientific else None,
+            "known_field_count": len(scientific), "automatic_reuse_allowed": False}
+
+
+def recorded_status(path: Path, document: Any) -> dict[str, Any]:
+    signals = []
+    if isinstance(document, dict):
+        for key in STATE_KEYS:
+            value = document.get(key)
+            if isinstance(value, (str, bool)):
+                signals.append({"key": key, "value": value if isinstance(value, bool) else value[:160]})
+    words = " ".join(str(item["value"]).lower() for item in signals)
+    if re.search(r"fail|error|interrupted|aborted|killed|incomplete|stopped", words):
+        state = "recorded_failed_or_incomplete"
+    elif re.search(r"running|progress|training|sampling|queued|pending|waiting", words):
+        state = "recorded_running_or_pending"
+    elif re.search(r"complet|success|verified|finished|done", words) or any(v["key"] in {"completed", "complete", "success", "finished"} and v["value"] is True for v in signals):
+        state = "recorded_completed_or_verified"
+    elif isinstance(document, dict) and isinstance(document.get("steps_run"), int) and isinstance(document.get("fixed_steps"), int) and document["steps_run"] >= document["fixed_steps"] > 0:
+        state = "recorded_fixed_training_budget_reached"
+    elif path.name.lower() in {"summary.json", "metrics.json", "results.json", "repro.json"}:
+        state = "result_record_present"
+    elif path.name.lower() in {"run.json", "run_status.json"}:
+        state = "run_record_present_status_unknown"
+    else:
+        state = "unknown"
+    return {"classification": state, "signals": signals, "live_process_verified": False}
+
+
+def inspect_content(path: Path, size: int, cap: int) -> dict[str, Any]:
+    suffix = path.suffix.lower()
+    if suffix in ARRAY_SUFFIXES:
+        return {"inspection": "payload_metadata_only"}
+    if suffix == ".json":
+        if size > cap:
+            return {"inspection": "json_over_size_cap_not_parsed"}
+        try:
+            with path.open("rb") as handle:
+                raw = handle.read(cap + 1)
+            if len(raw) > cap:
+                return {"inspection": "json_grew_over_cap_not_parsed"}
+            doc = json.loads(raw)
+            record: dict[str, Any] = {"inspection": "json_parsed", "metadata_sha256": hashlib.sha256(raw).hexdigest(),
+                "json_type": type(doc).__name__, "recorded_status": recorded_status(path, doc), "scientific": extract_scientific(doc)}
+            record["schema_handling"] = "known_scientific_fields_extracted" if record["scientific"]["known_field_count"] else "unrecognized_schema_or_no_scientific_fields"
+            if isinstance(doc, dict):
+                record["top_level_keys"] = sorted(str(k) for k in doc)[:80]
+                record["declared_schema"] = doc.get("schema") if isinstance(doc.get("schema"), str) else None
+                record["declared_host"] = next((doc[k] for k in ["host", "source_host", "hostname"] if isinstance(doc.get(k), str)), None)
+                record["declared_source_locations"] = {key: doc[key] for key in ["source", "source_path", "source_root", "original_path", "copied_from", "source_checkpoint"]
+                                                       if isinstance(doc.get(key), str) and doc[key].startswith("/")}
+            return record
+        except (OSError, ValueError, UnicodeError, RecursionError) as error:
+            return {"inspection": "json_unreadable_or_invalid", "error_type": type(error).__name__, "error": str(error)[:240]}
+    if suffix in {".csv", ".tsv"}:
+        try:
+            with path.open("r", encoding="utf-8-sig", errors="replace") as handle:
+                prefix = handle.read(min(cap, 65536))
+            rows = list(csv.reader(prefix.splitlines(), delimiter="\t" if suffix == ".tsv" else ","))
+            return {"inspection": "table_prefix_only", "header": rows[0][:100] if rows else [],
+                    "prefix_bytes_limit": min(cap, 65536), "rows_in_prefix_including_header": len(rows),
+                    "complete_row_count": None}
+        except (OSError, csv.Error) as error:
+            return {"inspection": "table_unreadable", "error_type": type(error).__name__}
+    if suffix == ".jsonl":
+        parsed = invalid = 0
+        last_status: dict[str, Any] | None = None
+        try:
+            with path.open("rb") as handle:
+                # Read first and last bounded blocks; never claim exhaustive
+                # event/log contents or infer a process is currently running.
+                prefix = handle.read(min(cap, 65536))
+                offset = max(0, size - min(cap, 65536))
+                handle.seek(offset)
+                tail = handle.read(min(cap, 65536))
+            lines = prefix.splitlines()[:-1] if size > len(prefix) else prefix.splitlines()
+            if offset:
+                lines += tail.splitlines()[1:]
+            for line in lines:
+                try:
+                    doc = json.loads(line)
+                    parsed += 1
+                    status = recorded_status(path, doc)
+                    if status["classification"] != "unknown":
+                        last_status = status
+                except (ValueError, UnicodeError):
+                    invalid += 1
+            return {"inspection": "jsonl_prefix_tail_only", "sampled_records": parsed, "sampled_invalid_records": invalid,
+                    "sampled_last_status": last_status, "complete_row_count": None}
+        except OSError as error:
+            return {"inspection": "jsonl_unreadable", "error_type": type(error).__name__}
+    if suffix in DOCUMENT_SUFFIXES or path.name.upper().startswith("README"):
+        try:
+            with path.open("rb") as handle:
+                raw = handle.read(min(cap, 65536))
+            text = raw.decode("utf-8", errors="replace")
+            headings = [line.strip()[:180] for line in text.splitlines() if line.startswith("#")][:12]
+            # Excerpts intentionally limited to headings, never arbitrary log lines.
+            return {"inspection": "text_prefix_only", "bytes_read": len(raw), "headings": headings,
+                    "full_text_inspected": size <= len(raw)}
+        except OSError as error:
+            return {"inspection": "text_unreadable", "error_type": type(error).__name__}
+    return {"inspection": "filesystem_metadata_only"}
+
+
+def traverse(root: Path, errors: list[dict[str, str]]) -> Iterator[tuple[Path, os.stat_result | None, str | None]]:
+    def onerror(error: OSError) -> None:
+        errors.append({"path": str(error.filename), "error": str(error)})
+    for base, directories, files in os.walk(root, followlinks=False, onerror=onerror):
+        directories.sort()
+        files.sort()
+        for name in list(directories):
+            path = Path(base) / name
+            if name in EXCLUDED_DIRS or path.is_symlink():
+                directories.remove(name)
+                try:
+                    metadata = path.lstat()
+                except OSError:
+                    metadata = None
+                yield path, metadata, "excluded_subtree" if name in EXCLUDED_DIRS else "symlink_directory_not_traversed"
+        for name in files:
+            path = Path(base) / name
+            if path.parent == root and (name in OUTPUTS or any(name.startswith(output + ".tmp") for output in OUTPUTS)):
+                continue
+            try:
+                yield path, path.lstat(), None
+            except OSError as error:
+                errors.append({"path": str(path), "error": str(error)})
+                yield path, None, "stat_failed"
+
+
+def load_confirmed_aliases(root: Path) -> dict[str, Any]:
+    """Validate the coordinator's scoped proof structure; never reload tensors.
+
+    All records fail closed together if any required proof field is malformed.
+    The original and duplicate serialized file hashes remain distinct.
+    """
+    proof = root / "plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/CONFIRMED_DUPLICATE_TRAINING.json"
+    result: dict[str, Any] = {"proof_path": str(proof), "proof_status": "absent", "aliases": [],
+                             "errors": [], "payloads_rechecked_by_this_auditor": False}
+    if not proof.exists():
+        return result
+    sha_pattern = re.compile(r"[0-9a-f]{64}")
+    try:
+        with proof.open("rb") as handle:
+            raw = handle.read(1_048_577)
+        if len(raw) > 1_048_576:
+            raise ValueError("confirmed-proof file exceeds its 1MiB dedicated cap")
+        document = json.loads(raw)
+        if not isinstance(document, dict) or document.get("schema") != "pbisc.confirmed-duplicate-training.v1":
+            raise ValueError("unrecognized confirmed-proof schema")
+        rows = document.get("records")
+        if not isinstance(rows, list) or not rows or type(document.get("confirmed_duplicate_training_runs")) is not int or document["confirmed_duplicate_training_runs"] != len(rows):
+            raise ValueError("missing records or inconsistent confirmed record count")
+        aliases = []
+        seen_duplicates: set[str] = set()
+        seen_draws: set[int] = set()
+        seconds_sum = 0.0
+        for row in rows:
+            if not isinstance(row, dict) or row.get("all_tensor_storage_bytes_identical") is not True:
+                raise ValueError("record does not explicitly attest identical tensor storage bytes")
+            draw = row.get("draw")
+            if type(draw) is not int or draw < 0 or draw in seen_draws:
+                raise ValueError("invalid or duplicate draw identifier")
+            seen_draws.add(draw)
+            original = Path(row.get("original_checkpoint", ""))
+            duplicate = Path(row.get("duplicate_execution_checkpoint", ""))
+            if not original.is_absolute() or not duplicate.is_absolute() or original == duplicate:
+                raise ValueError("checkpoint paths must be distinct absolute paths")
+            for path in (original, duplicate):
+                path.relative_to(root)
+                if path.suffix != ".pt" or ".." in path.parts:
+                    raise ValueError("invalid checkpoint path")
+            if str(duplicate) in seen_duplicates:
+                raise ValueError("duplicate checkpoint alias is repeated")
+            seen_duplicates.add(str(duplicate))
+            for key in ("original_sha256", "duplicate_serialized_sha256"):
+                if not isinstance(row.get(key), str) or not sha_pattern.fullmatch(row[key]):
+                    raise ValueError(f"invalid {key}")
+            payloads = row.get("tensor_payloads")
+            count = row.get("tensor_storage_count")
+            if type(count) is not int or count <= 0 or not isinstance(payloads, dict) or len(payloads) != count:
+                raise ValueError("tensor storage count does not match per-storage evidence")
+            if set(payloads) != {str(i) for i in range(count)}:
+                raise ValueError("tensor storage identifiers are incomplete")
+            for tensor in payloads.values():
+                if not isinstance(tensor, dict) or type(tensor.get("bytes")) is not int or tensor["bytes"] < 0:
+                    raise ValueError("invalid tensor storage size")
+                if not isinstance(tensor.get("sha256"), str) or not sha_pattern.fullmatch(tensor["sha256"]):
+                    raise ValueError("invalid tensor storage SHA")
+            seconds = row.get("duplicate_execution_seconds")
+            if type(seconds) not in (float, int) or not math.isfinite(seconds) or seconds < 0:
+                raise ValueError("invalid duplicate execution time")
+            if "not_an_independent_model_result" not in str(row.get("disposition", "")):
+                raise ValueError("missing explicit non-independent-model disposition")
+            seconds_sum += seconds
+            aliases.append({"record_type": "confirmed_duplicate_training_alias", "draw": draw,
+                "path": str(duplicate.relative_to(root)), "canonical_checkpoint": str(original),
+                "canonical_checkpoint_sha256": row["original_sha256"], "duplicate_checkpoint": str(duplicate),
+                "duplicate_serialized_sha256": row["duplicate_serialized_sha256"],
+                "duplicate_run_record": str(duplicate.with_name("RUN.json")), "canonical_run_record": str(original.with_name("RUN.json")),
+                "tensor_storage_count": count, "tensor_storage_bytes_identical_reported": True,
+                "independent_model_evidence": False, "retain_serialization_for_existing_receipts": True,
+                "generated_outputs_classified_duplicate": False,
+                "proof_path": str(proof), "proof_sha256": hashlib.sha256(raw).hexdigest(),
+                "proof_declared_host": document.get("host", document.get("source_host")),
+                "alias_scope": "exact local paths under this audit root; identical paths on other hosts require separate verification",
+                "proof_validation_scope": "schema_integrity_checked; scoped payload comparison supplied by coordinating-agent report",
+                "payloads_rechecked_by_this_auditor": False, "duplicate_execution_seconds": seconds})
+        total = document.get("total_duplicate_execution_seconds")
+        if type(total) not in (float, int) or not math.isfinite(total) or not math.isclose(total, seconds_sum, abs_tol=1e-6):
+            raise ValueError("duplicate execution total does not match records")
+        result.update({"proof_status": "validated_report_structure", "proof_sha256": hashlib.sha256(raw).hexdigest(),
+                       "aliases": aliases, "total_duplicate_execution_seconds": seconds_sum})
+    except (OSError, ValueError, TypeError, KeyError) as error:
+        result.update({"proof_status": "rejected", "errors": [f"{type(error).__name__}: {error}"], "aliases": []})
+    return result
+
+
+def run_audit(root: Path, output: Path, cap: int) -> dict[str, Any]:
+    root = root.resolve()
+    output.mkdir(parents=True, exist_ok=True)
+    started = now()
+    confirmed = load_confirmed_aliases(root)
+    duplicate_aliases = {path: alias for alias in confirmed["aliases"]
+                         for path in (alias["duplicate_checkpoint"], alias["duplicate_run_record"])}
+    counts: collections.Counter[str] = collections.Counter()
+    kind_counts: collections.Counter[str] = collections.Counter()
+    inspection_counts: collections.Counter[str] = collections.Counter()
+    status_counts: collections.Counter[str] = collections.Counter()
+    lineage_counts: collections.Counter[str] = collections.Counter()
+    families: dict[str, dict[str, Any]] = {}
+    errors: list[dict[str, str]] = []
+    exclusions = []
+    signatures: dict[str, list[str]] = collections.defaultdict(list)
+    copies: dict[str, list[str]] = collections.defaultdict(list)
+    total_bytes = 0
+    target = output / "EXPERIMENT_REUSE_INDEX.jsonl"
+    tmp = target.with_name(target.name + ".tmp")
+    with tmp.open("w", encoding="utf-8") as handle:
+        handle.write(json.dumps({"record_type": "audit_header", "schema": SCHEMA, "root": str(root), "observed_host": socket.gethostname(),
+            "started_utc": started, "json_size_cap_bytes": cap, "payloads_loaded": False,
+            "caution": "Filesystem and recorded evidence only; no remote-host or live-process verification; unknown fields block exact-reuse claims."}) + "\n")
+        for path, metadata, special in traverse(root, errors):
+            relative = path.relative_to(root)
+            family = family_of(relative)
+            group = families.setdefault(family, {"path": str(root / family) if family != "root" else str(root),
+                "files": 0, "bytes": 0, "kinds": collections.Counter(), "inspections": collections.Counter(),
+                "recorded_statuses": collections.Counter(), "lineage_counts": collections.Counter(), "evidence_examples": [], "latest_mtime_utc": None})
+            record: dict[str, Any] = {"record_type": "file", "path": str(relative), "family": family,
+                                      "observed_host": socket.gethostname(), "lineage_role": lineage_role(relative)}
+            if str(path) in duplicate_aliases:
+                alias = duplicate_aliases[str(path)]
+                record.update({"model_evidence_role": "confirmed_duplicate_execution_not_independent_model",
+                    "canonical_model_checkpoint": alias["canonical_checkpoint"], "independent_model_evidence": False,
+                    "confirmed_alias_proof": alias["proof_path"], "confirmed_alias_proof_sha256": alias["proof_sha256"],
+                    "retain_serialization_for_existing_receipts": True})
+                counts["confirmed_duplicate_execution_file_records"] += 1
+            if special:
+                record.update({"record_type": "excluded_or_unreadable", "inspection": special})
+                if path.is_symlink():
+                    record["link_target"] = os.readlink(path)
+                if metadata is not None:
+                    record["directory_entry_bytes"] = metadata.st_size
+                    record["directory_entry_mtime_utc"] = datetime.fromtimestamp(metadata.st_mtime, timezone.utc).isoformat()
+                    counts["excluded_or_link_directory_entries_statted"] += 1
+                counts[special] += 1
+                exclusions.append({"path": str(relative), "reason": special, "descendant_file_count": "not_traversed_unknown"})
+            elif metadata is not None:
+                counts["files_statted"] += 1
+                group["files"] += 1
+                lineage_counts[record["lineage_role"]] += 1
+                group["lineage_counts"][record["lineage_role"]] += 1
+                group["bytes"] += metadata.st_size
+                total_bytes += metadata.st_size
+                stamp = datetime.fromtimestamp(metadata.st_mtime, timezone.utc).isoformat()
+                group["latest_mtime_utc"] = max(group["latest_mtime_utc"] or stamp, stamp)
+                record.update({"bytes": metadata.st_size, "mtime_utc": stamp, "kind": kind_of(path)})
+                kind_counts[record["kind"]] += 1
+                group["kinds"][record["kind"]] += 1
+                if stat.S_ISLNK(metadata.st_mode):
+                    record.update({"inspection": "symlink_file_not_read", "link_target": os.readlink(path)})
+                elif not stat.S_ISREG(metadata.st_mode):
+                    record["inspection"] = "nonregular_file_not_read"
+                else:
+                    record.update(inspect_content(path, metadata.st_size, cap))
+                inspection_counts[record["inspection"]] += 1
+                group["inspections"][record["inspection"]] += 1
+                status = record.get("recorded_status", {}).get("classification", "unknown")
+                status_counts[status] += 1
+                group["recorded_statuses"][status] += 1
+                if record.get("schema_handling") == "unrecognized_schema_or_no_scientific_fields":
+                    counts["json_unknown_schema_or_no_scientific_fields"] += 1
+                scientific = record.get("scientific", {})
+                if scientific.get("known_field_count", 0) >= 4 and scientific.get("signature_sha256") and any(k in scientific.get("unambiguous", {}) for k in ["train_samples", "condition_sha256", "support_sha256"]):
+                    signatures[scientific["signature_sha256"]].append(str(relative))
+                if record.get("metadata_sha256") and scientific.get("known_field_count", 0) >= 3:
+                    copies[record["metadata_sha256"]].append(str(relative))
+                if len(group["evidence_examples"]) < 6 and (path.name.lower() in {"run.json", "run_status.json", "protocol.json", "summary.json", "readme.md"} or "receipt" in path.name.lower()):
+                    group["evidence_examples"].append(str(relative))
+            handle.write(json.dumps(record, separators=(",", ":"), ensure_ascii=False) + "\n")
+        for alias in confirmed["aliases"]:
+            handle.write(json.dumps(alias, separators=(",", ":")) + "\n")
+        for catalog_name in ["CURRENT_MODEL_INDEX.csv", "CURRENT_INFERENCE_LOCATIONS.csv"]:
+            catalog = root.parent.parent / "paper-release-20260928" / catalog_name
+            if not catalog.is_file():
+                continue
+            try:
+                with catalog.open(encoding="utf-8-sig", newline="") as source:
+                    for row in csv.DictReader(source):
+                        keep = {key: row[key] for key in ["category", "cohort", "experiment", "protocol", "mode", "state", "status", "host", "source", "path",
+                            "checkpoint_current_host", "checkpoint_current_path", "condition_current_host", "condition_current_path", "receipt", "generation_log",
+                            "sha256", "output_sha256", "checkpoint_sha256", "condition_sha256", "catalog_version", "artifact_role", "draw", "fold", "seed", "steps", "weights"] if row.get(key)}
+                        catalog_record = {"record_type": "external_catalog_entry", "catalog": str(catalog),
+                            "path": keep.get("source", keep.get("path", "")), "declared_location": keep,
+                            "inspection": "existing_archive_catalog_record_not_live_verified"}
+                        if catalog_record["path"] in duplicate_aliases:
+                            # An identical absolute path can exist on server_2.
+                            # The local proof alone must not silently establish
+                            # payload equivalence for a remote catalog entry.
+                            catalog_record.update({"local_same_path_alias_proof": duplicate_aliases[catalog_record["path"]]["proof_path"],
+                                                   "alias_requires_declared_host_verification": True})
+                        handle.write(json.dumps(catalog_record, separators=(",", ":")) + "\n")
+                        counts["external_catalog_entries"] += 1
+            except (OSError, csv.Error) as error:
+                errors.append({"path": str(catalog), "error": str(error)})
+    os.replace(tmp, target)
+    candidates = [{"signature_sha256": key, "count": len(paths), "paths": paths,
+                   "decision": "candidate_only_compare_unknown_fields_and_scientific_provenance"}
+                  for key, paths in signatures.items() if len(paths) > 1]
+    copy_groups = [{"metadata_sha256": key, "count": len(paths), "paths": paths,
+                    "decision": "identical_small_metadata_not_proof_of_duplicate_payload_or_deletion_permission"}
+                   for key, paths in copies.items() if len(paths) > 1]
+    summary: dict[str, Any] = {"schema": SCHEMA, "root": str(root), "observed_host": socket.gethostname(),
+        "started_utc": started, "finished_utc": now(), "json_size_cap_bytes": cap, "counts": dict(counts),
+        "apparent_bytes_metadata_only": total_bytes, "kind_counts": dict(kind_counts),
+        "lineage_counts": dict(lineage_counts),
+        "inspection_counts": dict(inspection_counts), "recorded_status_counts": dict(status_counts),
+        "families": families, "excluded_or_unreadable_paths": exclusions, "traversal_errors": errors,
+        "candidate_signature_groups": candidates, "identical_small_metadata_groups": copy_groups,
+        "confirmed_duplicate_training": confirmed,
+        "scientific_payload_contents_inspected": False, "live_or_remote_process_status_verified": False,
+        "automatic_reuse_or_deletion_authorized": False,
+        "limitations": ["Excluded subtrees were not traversed; descendant counts are unknown.",
+            "Every remaining directory entry was enumerated; every accessible file was lstat-ed.",
+            "Arrays/checkpoints were not loaded or hashed. JSON above the cap was not parsed.",
+            "CSV headers and bounded text/JSONL samples are navigation evidence, not exhaustive content validation.",
+            "Recorded running/completed fields may be stale; family status is intentionally mixed evidence counts.",
+            "Scientific signatures contain explicit fields only. Missing, ambiguous or unrecognized fields require source review.",
+            "This is a point-in-time scan, not an atomic snapshot of actively changing files."]}
+    write_json(output / "EXPERIMENT_REUSE_COVERAGE.json", summary)
+    write_navigation(root, output, summary)
+    return summary
+
+
+def write_json(path: Path, value: Any) -> None:
+    tmp = path.with_name(path.name + ".tmp")
+    tmp.write_text(json.dumps(value, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    os.replace(tmp, path)
+
+
+def write_navigation(root: Path, output: Path, summary: dict[str, Any]) -> None:
+    lines = ["# Model 8 experiment and reuse index", "",
+        f"Observed on `{summary['observed_host']}` at {summary['finished_utc']}.", "",
+        "Before any training, inference, annotation, scoring or figure rebuild, search this index and the JSONL registry. "
+        "An absent file under a new plan is not evidence that the result does not exist elsewhere.", "",
+        "## Required reuse lookup", "",
+        "1. Find the experiment family below; read its existing README/protocol, run records, generation receipts, score tables and deck source map.",
+        "2. Check the current cross-host model/inference catalogs. Resolve actual host and path; inspect completed outputs before scheduling compute.",
+        "3. Compare checkpoint, exact train/validation/test sample IDs, gene order/masks, conditioning/depth, selected/fixed steps, seed, generated cell budget, sampling/readout, scSemi HVG/assignment, and scoring reference.",
+        "4. Classify the request: existing figure; CPU redraw/reanalysis; existing generated output awaiting scoring; or scientifically different new GPU work. Record the exact mismatch that requires new work.",
+        "5. Unknown fields block an exact-match claim, not historical display with an accurate protocol label. Candidate matches never authorize deleting or overwriting outputs.",
+        "6. Follow host memory/GPU policies for any later launch. This audit does not launch anything or verify live process state.", "",
+        "```bash", "python scripts/audit_experiment_reuse.py --query 'immicro/fewshot_n5' --limit 20",
+        "python scripts/audit_experiment_reuse.py --query 'refcal' --kind array_payload --limit 20",
+        "python scripts/audit_experiment_reuse.py --check-training-request /path/to/training-request.json",
+        "python scripts/audit_experiment_reuse.py --refresh", "```", "",
+        "The training-request JSON uses `checkpoint_sha256`, `train_samples` (ID list), `validation_samples` (ID list, empty when none), `mode`, `lora_rank`, `learning_rate`, `fixed_steps`, `training_seed`, `condition_sha256`, `training_data_sha256`, `gene_order` (ordered gene-ID list), `batch_size`, `warmup`, `ema_decay`, `training_code_sha256`, and `effective_config_sha256`; `cohort` is an optional filter. "
+        "The check reports `reuse_candidate`, unknown fields, or a different protocol. A complete match has `metadata_match=true`, never an exact-reuse verdict. "
+        "A generation/sampling seed is ignored for checkpoint-training comparison. Verified adoption still requires all scientifically relevant inputs/configuration/code, current checkpoint/output receipts, and payload identity or equivalence; fields outside this schema also require review.", "",
+        "## Evidence already available", ""]
+    for title, paths, note in KNOWN_FAMILIES:
+        available = [f"[{path}]({path})" for path in paths if (root / path).exists()]
+        if available:
+            lines += [f"- **{title}:** " + "; ".join(available) + f". {note}"]
+    lines += ["", "## Coverage and limits", "", f"- Files with filesystem metadata: **{summary['counts'].get('files_statted', 0):,}** across **{len(summary['families']):,}** families.",
+        f"- JSON documents parsed under {summary['json_size_cap_bytes']:,} bytes: **{summary['inspection_counts'].get('json_parsed', 0):,}**.",
+        f"- JSON over the cap: **{summary['inspection_counts'].get('json_over_size_cap_not_parsed', 0):,}**; invalid/unreadable JSON: **{summary['inspection_counts'].get('json_unreadable_or_invalid', 0):,}**.",
+        f"- JSON with unrecognized schema or no extracted scientific fields: **{summary['counts'].get('json_unknown_schema_or_no_scientific_fields', 0):,}**. These remain indexed with top-level keys.",
+        f"- Excluded subtrees: **{summary['counts'].get('excluded_subtree', 0):,}**; directory symlinks not followed: **{summary['counts'].get('symlink_directory_not_traversed', 0):,}**; traversal errors: **{len(summary['traversal_errors']):,}**.",
+        f"- Candidate signature groups: **{len(summary['candidate_signature_groups']):,}**; identical small scientific-metadata groups: **{len(summary['identical_small_metadata_groups']):,}**. Neither is a deletion list.",
+        f"- Primary working-tree file observations: **{summary['lineage_counts'].get('primary_working_tree_observation_not_proof_of_independent_run', 0):,}**; inherited archive/backup/snapshot files: **{summary['lineage_counts'].get('inherited_snapshot_or_backup_not_independent_experiment', 0):,}**. File or metadata counts are not independent experiment counts.",
+        f"- Existing cross-host archive location records indexed: **{summary['counts'].get('external_catalog_entries', 0):,}**; these preserve declared source host/path and receipt pointers without claiming live verification.",
+        f"- Separately confirmed duplicate-training aliases: **{len(summary['confirmed_duplicate_training']['aliases'])}**; proof status `{summary['confirmed_duplicate_training']['proof_status']}`. Their RUN/checkpoint records map to the original model, retain distinct serialization hashes, and are not independent model evidence. Generated outputs are not classified as duplicates.",
+        "- Large array/checkpoint contents were not inspected, loaded or hashed. Apparent bytes can double-count hardlinks and copies.",
+        "- No remote host or live process query is performed. `recorded_running_or_pending` is historical evidence, not current GPU status.",
+        "- CSV headers and JSONL/log/text prefixes are bounded samples. JSON records over the cap and excluded subtree descendants are explicitly uninspected.",
+        "- Files may change during this point-in-time inventory. Refresh before a new execution decision.",
+        "", "Detailed machine-readable records: [EXPERIMENT_REUSE_INDEX.jsonl](EXPERIMENT_REUSE_INDEX.jsonl). "
+        "Counts, exclusions, family evidence, and candidate groups: [EXPERIMENT_REUSE_COVERAGE.json](EXPERIMENT_REUSE_COVERAGE.json).", "",
+        "## Every inventoried family", "",
+        "State columns count records, not completed experiments; multiple states within one family are expected.", "",
+        "| Family | Files | Inherited copies | Figures | Tables | Arrays/checkpoints | Recorded completed/budget reached | Recorded running/pending | Recorded failed/incomplete |", "|---|---:|---:|---:|---:|---:|---:|---:|---:|"]
+    for name, group in sorted(summary["families"].items()):
+        kinds, states = group["kinds"], group["recorded_statuses"]
+        inherited = group['lineage_counts'].get('inherited_snapshot_or_backup_not_independent_experiment', 0)
+        lines.append(f"| [{name}]({'.' if name == 'root' else name}) | {group['files']} | {inherited} | {kinds.get('figure_or_presentation', 0)} | {kinds.get('table', 0)} | {kinds.get('array_payload', 0) + kinds.get('checkpoint_payload', 0)} | {states.get('recorded_completed_or_verified', 0) + states.get('recorded_fixed_training_budget_reached', 0)} | {states.get('recorded_running_or_pending', 0)} | {states.get('recorded_failed_or_incomplete', 0)} |")
+    path = output / "EXPERIMENT_INDEX.md"
+    tmp = path.with_name(path.name + ".tmp")
+    tmp.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    os.replace(tmp, path)
+
+
+def query(index: Path, term: str, kind: str | None, limit: int) -> int:
+    found = 0
+    with index.open(encoding="utf-8") as handle:
+        for line in handle:
+            record = json.loads(line)
+            if record.get("record_type") not in {"file", "external_catalog_entry", "confirmed_duplicate_training_alias"} or term.lower() not in record.get("path", "").lower():
+                continue
+            if kind and record.get("kind") != kind:
+                continue
+            print(json.dumps(record, ensure_ascii=False))
+            found += 1
+            if found >= limit:
+                break
+    return found
+
+
+TRAINING_FIELDS = ["checkpoint_sha256", "train_samples", "validation_samples", "mode",
+                   "lora_rank", "learning_rate", "fixed_steps", "training_seed",
+                   "condition_sha256", "training_data_sha256", "gene_order", "batch_size",
+                   "warmup", "ema_decay", "training_code_sha256", "effective_config_sha256"]
+
+
+def check_training_request(index: Path, request: dict[str, Any], limit: int = 10) -> dict[str, Any]:
+    """Read-only training comparison. Sampling seeds do not change checkpoints.
+
+    Request keys are TRAINING_FIELDS; sample fields accept ID lists. Optional
+    cohort restricts candidates. Missing fields never prove a new protocol.
+    """
+    wanted = dict(request)
+    for key in ("train_samples", "validation_samples", "gene_order"):
+        if isinstance(wanted.get(key), list):
+            ids = [str(value) for value in wanted[key]]
+            wanted[key] = {"count": len(ids), "sha256": digest(ids if key == "gene_order" else sorted(ids)),
+                           "ordering": "ordered" if key == "gene_order" else "sorted_sample_ids"}
+    request_unknown = [key for key in TRAINING_FIELDS if key not in wanted or wanted[key] is None]
+    candidates = []
+    inspected = 0
+    incomplete_run_records = 0
+    with index.open(encoding="utf-8") as handle:
+        for line in handle:
+            record = json.loads(line)
+            if Path(record.get("path", "")).name.lower() != "run.json":
+                continue
+            scientific = record.get("scientific", {})
+            actual = dict(scientific.get("unambiguous", {}))
+            # RUN.json commonly has both source/base SHA and newly written
+            # fine-tuned checkpoint SHA. Only the former identifies training
+            # initialization; do not confuse their intentional difference.
+            base_sha = [entry["value"] for entry in scientific.get("fields", {}).get("checkpoint_sha256", [])
+                        if entry["source_key"] == "source_checkpoint_sha256"]
+            if len(base_sha) == 1:
+                actual["checkpoint_sha256"] = base_sha[0]
+            if "training_seed" not in actual:
+                top_seed = [entry["value"] for entry in scientific.get("fields", {}).get("seed", []) if entry["source_key"] == "seed"]
+                if len(top_seed) == 1:
+                    actual["training_seed"] = top_seed[0]
+            if request.get("cohort") and request["cohort"] != actual.get("cohort") and f"/{request['cohort']}/" not in f"/{record['path']}/":
+                continue
+            inspected += 1
+            same, different, unknown = [], [], []
+            for key in TRAINING_FIELDS:
+                if key not in actual or key in request_unknown:
+                    unknown.append(key)
+                elif actual[key] == wanted[key]:
+                    same.append(key)
+                else:
+                    different.append(key)
+            incomplete_run_records += bool(unknown)
+            # Keep protocol neighbours only. A different pretrained model or
+            # unrelated cohort must not swamp partial same-support evidence.
+            if len(same) < 2:
+                continue
+            status = "reuse_candidate" if not different else "different_protocol"
+            candidates.append({"path": record["path"], "classification": status, "matched_fields": same,
+                               "mismatched_fields": different, "unknown_fields": unknown,
+                               "metadata_match": not different and not unknown,
+                               "recorded_status": record.get("recorded_status", {}),
+                               "canonical_model_checkpoint": record.get("canonical_model_checkpoint"),
+                               "independent_model_evidence": record.get("independent_model_evidence", "not_assessed"),
+                               "confirmed_alias_proof": record.get("confirmed_alias_proof"),
+                               "payload_verified": False})
+    candidates.sort(key=lambda row: (-int(row["metadata_match"]),
+                     -int(row["classification"] == "reuse_candidate"), -len(row["matched_fields"]), len(row["mismatched_fields"]), row["path"]))
+    if any(row["classification"] == "reuse_candidate" for row in candidates):
+        classification = "reuse_candidate"
+    elif candidates and not request_unknown and incomplete_run_records == 0:
+        classification = "new_protocol"
+    else:
+        classification = "unknown"
+    return {"classification": classification, "request_unknown_fields": request_unknown,
+            "metadata_match": any(row["metadata_match"] for row in candidates),
+            "run_records_considered": inspected, "candidate_count": len(candidates), "candidates": candidates[:limit],
+            "run_records_with_unknown_fields": incomplete_run_records,
+            "scope": "recorded training specifications only; output/checkpoint availability and receipts require verification",
+            "sampling_settings_ignored_for_training_match": True,
+            "automatic_launch_reuse_or_deletion_authorized": False,
+            "verified_adoption_required": ["all scientifically relevant preprocessing, input data, gene order and masks",
+                "effective training configuration and source code, including fields not represented by this schema",
+                "checkpoint/output availability, current receipts and payload identity or scientific equivalence"],
+            "warning": "A missing field or uninspected schema is unknown, never proof that new training is necessary."}
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--root", type=Path, default=Path(__file__).resolve().parents[1])
+    parser.add_argument("--output", type=Path)
+    parser.add_argument("--refresh", action="store_true")
+    parser.add_argument("--json-cap-bytes", type=int, default=16_777_216)
+    parser.add_argument("--query")
+    parser.add_argument("--check-training-request", type=Path,
+                        help="read-only JSON spec comparison; sample IDs are lists; training_seed is distinct from generation seed")
+    parser.add_argument("--kind")
+    parser.add_argument("--limit", type=int, default=20)
+    args = parser.parse_args()
+    if args.json_cap_bytes <= 0 or args.limit <= 0:
+        parser.error("caps and limits must be positive")
+    output = args.output or args.root
+    if args.check_training_request is not None:
+        request = json.loads(args.check_training_request.read_text())
+        if not isinstance(request, dict):
+            parser.error("training request must be a JSON object")
+        print(json.dumps(check_training_request(output / "EXPERIMENT_REUSE_INDEX.jsonl", request, args.limit), indent=2))
+    elif args.query is not None:
+        count = query(output / "EXPERIMENT_REUSE_INDEX.jsonl", args.query, args.kind, args.limit)
+        print(json.dumps({"matches_shown": count, "limit": args.limit}))
+    elif args.refresh:
+        summary = run_audit(args.root, output, args.json_cap_bytes)
+        print(json.dumps({"files_statted": summary["counts"].get("files_statted"), "families": len(summary["families"]),
+                          "inspection_counts": summary["inspection_counts"], "traversal_errors": len(summary["traversal_errors"])}))
+    else:
+        parser.error("choose --refresh, --query TERM, or --check-training-request FILE")
+
+
+if __name__ == "__main__":
+    main()

paper-releases/pbisc-diffusion/updates/20261013T005008Z-reuse-audit-results-deck/diffusion/metadata/request.json

@@ -0,0 +1,313 @@
+{
+  "assets": [
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/AGENTS.md",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/EXPERIMENT_INDEX.md",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/EXPERIMENT_REUSE_COVERAGE.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/EXPERIMENT_REUSE_INDEX.jsonl",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/PROGRESS.md",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/CLEANUP.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/CONFIRMED_DUPLICATE_TRAINING.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/FINAL_VERIFICATION.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/REPORT.md",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/RUNNING_OBSERVATION.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/backups/deconvolution/MANIFEST.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "code",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/backups/deconvolution/tools/deconv_strict.py",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "code",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/backups/deconvolution/tools/finalize_campaign.py",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/backups/navigation/AGENTS.md",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/backups/navigation/deck_README.md",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/backups/navigation/deconv_strict.md",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/deconvolution_tests.xml",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/deconvolution_tests_final.xml",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/deconvolution_verification.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "code",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/audit_reuse_20261013/test_audit_experiment_reuse.py",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/deck/README.md",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/deconvolution/ye2026_sepsis/disease/draw0/ADOPTION.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/deconvolution/ye2026_sepsis/disease/draw1/ADOPTION.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/deconvolution/ye2026_sepsis/disease/draw2/ADOPTION.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/deconvolution/ye2026_sepsis/disease/draw3/ADOPTION.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/deconvolution/ye2026_sepsis/disease/draw4/ADOPTION.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/layout_preview_20261013/README.md",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/layout_preview_20261013/SUPERSEDED.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/reports/deconv_strict.md",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "code",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/tests/test_deconv_adoption.py",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "code",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/tools/adopt_deconv_legacy.py",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "code",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/tools/deconv_strict.py",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "code",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/tools/finalize_campaign.py",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00/PBISC-Diffusion_results_review_20261013.pdf",
+      "state": "intermediate"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00/PBISC-Diffusion_results_review_20261013.pptx",
+      "state": "intermediate"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00/README.md",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00/data/results_review_20261013_provenance.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00/data/results_review_20261013_slide_map.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00/data/review_20261013_healthy_composition.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00/data/review_20261013_rare_observed.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00/figures/review_20261013_healthy_composition.pdf",
+      "state": "intermediate"
+    },
+    {
+      "host": "server_1",
+      "kind": "figure",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00/figures/review_20261013_healthy_composition.png",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "figure",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00/figures/review_20261013_healthy_composition.svg",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00/figures/review_20261013_rare_corrected_comparison.pdf",
+      "state": "intermediate"
+    },
+    {
+      "host": "server_1",
+      "kind": "figure",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00/figures/review_20261013_rare_corrected_comparison.png",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "figure",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00/figures/review_20261013_rare_corrected_comparison.svg",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "report",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00/figures/review_20261013_rare_observed.pdf",
+      "state": "intermediate"
+    },
+    {
+      "host": "server_1",
+      "kind": "figure",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00/figures/review_20261013_rare_observed.png",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "figure",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00/figures/review_20261013_rare_observed.svg",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "code",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00/tools/build_results_review_20261013.py",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "code",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/scripts/audit_experiment_reuse.py",
+      "state": "completed"
+    }
+  ],
+  "inference_locations": [],
+  "project_id": "pbisc-diffusion",
+  "summary": "User authorized whole-Model8 reuse audit, repeat prevention, available-results deck rebuild and discard assistant duplicate work. Metadata inventory66,604files/138families,17,919JSON parsed, explicit unread payload/exclusion limits;5confirmed tensor-identical Sepsis training aliases. All5old SepsisBP/CIB outputs adopted with original draw sampling and fail-closed no-method-rerun;193tests1dependency skip18subtests plus5registrytests4subtests. New34slide available-resultsPDF/PPTX uses42verified sources and saved-table CPUredraws; no newtraining/generation.45superseded generatedpreview workingfiles removed after36independent archivalreadbacks,20,002,296logicalbytes; immutablearchives/originals/logs/manifests preserved.5distinct serialized duplicate-training checkpoints retained for existing SHAprovenance and excluded as independentmodel evidence. Active exact-pair campaign remains running; Figure6waiting user data. No canonicalmanuscriptedit/GitHubpush/Overleafsync."
+}