"""Walk-forward selection, fresh refitting, frozen protocol, and complete research records."""
from __future__ import annotations
import copy
import hashlib
import json
import os
from pathlib import Path
import platform
import time
from dataclasses import dataclass
import numpy as np
import pandas as pd
import joblib
from .data import (load_inputs,SequenceStore,NumericPreprocessor,student_partition,take_batch,sha256,IndexedHistory)

DEFAULTS={
 'dim':128,'layers':2,'heads':4,'dropout':.1,'hidden_dim':128,
 'ssl_epochs':20,'ssl_patience':4,'ssl_lr':3e-4,'neural_epochs':30,'neural_patience':5,'neural_lr':3e-4,
 'weight_decay':1e-3,'ssl_batch_size':64,'batch_size':256,'mask_rate':.2,'grade_weight':1.,'course_weight':1.,
 'max_semesters':16,'max_courses':32,'seeds':[29,129,229],
 'encoders':['mlp','gru','transformer'],'tasks':['grade','course','joint'],
 'arms':['H0','H1','N0','N1','N2','N3','H2','HR'],
 'hgb_iterations':[50,100,200],'hgb_learning_rate':.05,'hgb_max_leaf_nodes':31,'hgb_min_samples_leaf':20,'hgb_l2':1.,
 'device':'auto','threads':4,'bootstrap':200,'ssl_scope':'pooled','chronology_placebo':False,
 'expected_faculties':None,'expected_folds':[1,2,3,4,5,6,7],
 'output_dir':'/root/disk_3tb/earlywarning/30072026/results/suite35_pace',
 'log_dir':'/root/disk_3tb/earlywarning/30072026/log',
}


def log(msg):print(msg,flush=True)


def dump_json(path,obj):
    def cast(v):
        if isinstance(v,(np.integer,np.floating)):return v.item()
        if isinstance(v,(pd.Timestamp,Path)):return str(v)
        if isinstance(v,np.ndarray):return v.tolist()
        raise TypeError(str(type(v)))
    path=Path(path);path.parent.mkdir(parents=True,exist_ok=True)
    tmp=path.with_suffix(path.suffix+'.tmp');tmp.write_text(json.dumps(obj,indent=2,default=cast,allow_nan=False));tmp.replace(path)


def clean_json(x):
    if isinstance(x,dict):return {str(k):clean_json(v) for k,v in x.items()}
    if isinstance(x,(list,tuple)):return [clean_json(v) for v in x]
    if isinstance(x,(np.integer,np.floating)):x=x.item()
    if isinstance(x,float) and not np.isfinite(x):return None
    return x


def recipe_digest(cfg):
    ignore={'output_dir','log_dir','device','threads','bootstrap','resume','stage','historical_results'}
    recipe={k:v for k,v in cfg.items() if k not in ignore}
    return hashlib.sha256(json.dumps(recipe,sort_keys=True,default=str).encode()).hexdigest()


def source_digest(directory=None):
    directory=Path(directory) if directory is not None else Path(__file__).parent
    h=hashlib.sha256()
    for p in sorted(directory.glob('*.py')):
        h.update(p.name.encode());h.update(p.read_bytes())
    return h.hexdigest()


def validate_resume_cell(cell,target,corpus,device):
    from .inference import predict_checkpoint
    cell=Path(cell);result=json.loads((cell/'complete.json').read_text())
    checkpoint=cell/('checkpoint.joblib' if result['arm'].startswith('H') else 'checkpoint.pt')
    required=[checkpoint,cell/'predictions.csv',cell/'epochs.csv']
    if any(not p.is_file() for p in required):raise ValueError(f'Missing checkpoint/artifact for completed cell {cell.name}')
    hashes=result.get('artifact_hashes',{})
    if any(hashes.get(p.name)!=sha256(p) for p in required):raise ValueError(f'Completed cell artifact integrity mismatch {cell.name}')
    pred=pd.read_csv(cell/'predictions.csv',dtype={'row_id':str,'student_id':str,'faculty':str})
    if pred.row_id.tolist()!=target.row_id.tolist() or not np.array_equal(pred.y.to_numpy(),target.label.to_numpy()):raise ValueError('Resume target row identity/labels mismatch')
    replay=predict_checkpoint(checkpoint,target,corpus,device)
    if not np.allclose(replay,pred.p.to_numpy(),atol=1e-6,rtol=1e-6):raise ValueError('Resume checkpoint replay mismatch')
    return result,pred


def hgb_validation_score(y,p):
    from .metrics import evaluate
    ap=evaluate(y,p)['ap']
    if np.isfinite(ap):return ap,'AP'
    p=np.clip(p,1e-7,1-1e-7);y=np.asarray(y)
    bce=float(-(y*np.log(p)+(1-y)*np.log1p(-p)).mean())
    return -bce,'BCE (AP undefined: no positives)'


def ssl_key(cutoff,arch,task,seed,scope,fixed_epochs):
    return hashlib.sha256(json.dumps([str(cutoff),arch,task,seed,scope,fixed_epochs]).encode()).hexdigest()[:24]


def chronological_split(frame,target_origin):
    """Selection labels precede validation; final refit labels precede target."""
    t=pd.Timestamp(target_origin)
    refit=frame[frame.label_available_at<t].copy()
    if not len(refit):raise ValueError('No historical labels available before target')
    for order in sorted(refit['_order'].unique(),reverse=True):
        val=refit[refit['_order']==order].copy();v=val.origin_at.iloc[0]
        train=frame[(frame['_order']<order)&(frame.label_available_at<v)].copy()
        if len(train) and len(val):return train,val,refit,v
    raise ValueError('Need at least two observed historical enrollment semesters for chronological selection; no random split fallback')


def history_keys(rows):
    return [json.dumps([str(s),str(t)]) for s,t in zip(rows.student_id,rows.semester)]


def shuffle_semesters(batch,seed,keys=None):
    if isinstance(batch,IndexedHistory):
        keys=list(keys) if keys is not None else [f'prefix_{j}' for j in batch.row_index]
        if len(keys)!=batch.n_rows:raise ValueError('Shuffle identity keys must align with history rows')
        representatives={}
        for i,j in enumerate(batch.row_index):
            if int(j) in representatives and keys[representatives[int(j)]]!=keys[i]:raise ValueError('Shared prefix has inconsistent shuffle identity')
            representatives.setdefault(int(j),i)
        unique_keys=[keys[representatives[j]] if j in representatives else f'unused_{j}' for j in range(len(batch.unique['course']))]
        return IndexedHistory(shuffle_semesters(batch.unique,seed,unique_keys),batch.row_index)
    out={k:v.copy() for k,v in batch.items()}
    keys=list(keys) if keys is not None else list(range(len(batch['semester_mask'])))
    if len(keys)!=len(batch['semester_mask']):raise ValueError('Shuffle identity keys must align with history rows')
    for i,m in enumerate(batch['semester_mask']):
        stable_seed=int.from_bytes(hashlib.sha256(f'{seed}|{keys[i]}'.encode()).digest()[:8],'little')
        rng=np.random.default_rng(stable_seed)
        n=int(m.sum());p=rng.permutation(n)
        for k,a in batch.items():
            if k!='gaps':out[k][i,:n]=a[i,p]
        # Gap/position stays in increasing slot order, intentionally breaking content chronology.
    return out


def encode(encoder,batch,device,batch_size):
    import torch
    if isinstance(batch,IndexedHistory):
        return encode(encoder,batch.unique,device,batch_size)[batch.row_index]
    encoder=encoder.to(device).eval();out=[]
    with torch.no_grad():
        for start in range(0,len(batch['course']),batch_size):
            b={k:torch.as_tensor(v[start:start+batch_size],device=device) for k,v in batch.items()}
            out.append(encoder(b).cpu().numpy())
    return np.concatenate(out).astype(np.float32) if out else np.empty((0,encoder.dim),np.float32)


class ConstantModel:
    def __init__(self,p):self.p=float(p)
    def predict_proba(self,x):return np.tile([1-self.p,self.p],(len(x),1))


def fit_hgb(x,y,cfg,seed,iterations):
    from sklearn.ensemble import HistGradientBoostingClassifier
    if len(np.unique(y))<2:return ConstantModel(np.mean(y))
    m=HistGradientBoostingClassifier(max_iter=int(iterations),learning_rate=cfg['hgb_learning_rate'],max_leaf_nodes=cfg['hgb_max_leaf_nodes'],min_samples_leaf=cfg['hgb_min_samples_leaf'],l2_regularization=cfg['hgb_l2'],early_stopping=False,random_state=seed)
    return m.fit(x,y)


def choose_hgb(x,y,xv,yv,cfg,seed,logger):
    from .metrics import evaluate
    best=None;score=-np.inf;rows=[]
    for it in sorted(set(cfg['hgb_iterations'])):
        m=fit_hgb(x,y,cfg,seed,it);p=m.predict_proba(xv)[:,1];ap=evaluate(yv,p)['ap']
        candidate,metric=hgb_validation_score(yv,p)
        rows.append({'epoch':it,'val_ap':ap,'selection_metric':metric,'selection_score':candidate})
        logger(f'HGB selection iterations={it} val_AP={ap} selection_metric={metric} selection_score={candidate}')
        if best is None or candidate>score:best=it;score=candidate
    return int(best),rows


class SSLManager:
    def __init__(self,corpus,cfg,outdir,device,logger):
        self.corpus=corpus;self.cfg=cfg;self.outdir=Path(outdir)/'ssl';self.outdir.mkdir(exist_ok=True,parents=True);self.device=device;self.log=logger
        self.reuse_counts={}
    def get(self,cutoff,arch,task,seed,faculty=None,fixed_epochs=None,shuffle=False):
        import torch
        from .training import train_ssl
        scope=faculty if faculty is not None else 'all';scope=str(scope)+(':shuffle' if shuffle else '')
        key=ssl_key(cutoff,arch,task,seed,scope,fixed_epochs);p=self.outdir/(key+'.pt')
        if p.exists():
            a=torch.load(p,map_location='cpu',weights_only=False)
            self.reuse_counts[key]=self.reuse_counts.get(key,0)+1
            if self.reuse_counts[key]==1:self.log(f'SSL reuse cutoff={self.corpus.describe_origin(cutoff)} arch={arch} task={task} seed={seed} scope={scope} epochs={a["epochs"]}; further identical reuse messages summarized at completion')
            return a
        e=self.corpus.before(cutoff,faculty)
        students=sorted(e.student_id.unique())
        if fixed_epochs is None:
            train_students,val_students=student_partition(students,seed)
        else:train_students=students;val_students=[]
        train_events=e[e.student_id.isin(train_students)]
        vocab={c:i+3 for i,c in enumerate(sorted(train_events.course_id.unique()))}
        if not vocab:raise ValueError(f'Empty admissible SSL corpus before {cutoff} scope={scope}')
        store=SequenceStore(self.corpus,vocab,self.cfg['max_semesters'],self.cfg['max_courses'])
        bt,dt=store.for_students(e,train_students);bv,dv=store.for_students(e,val_students) if val_students else (None,None)
        if shuffle:
            bt=shuffle_semesters(bt,seed,[f'{s}|{cutoff}' for s in train_students])
            if bv is not None:bv=shuffle_semesters(bv,seed,[f'{s}|{cutoff}' for s in val_students])
        self.log(f'SSL START cutoff={self.corpus.describe_origin(cutoff)} arch={arch} task={task} seed={seed} scope={scope} train_students={len(train_students)} val_students={len(val_students)} courses={len(vocab)} events={len(e)} fixed_epochs={fixed_epochs}')
        self.log('SSL truncation '+json.dumps(clean_json(dt.sum(numeric_only=True).to_dict())))
        r=train_ssl(bt,bv,len(vocab)+3,arch,task,self.cfg,seed,self.device,self.log,fixed_epochs=fixed_epochs)
        a={'encoder':r.encoder.cpu(),'epochs':int(r.epochs),'vocab':vocab,'diagnostics':r.diagnostics,'history':r.history,'cutoff':str(cutoff),'cutoff_semester':self.corpus.describe_origin(cutoff),'scope':scope,'arch':arch,'task':task,'seed':seed}
        tmp=p.with_suffix('.tmp');torch.save(a,tmp);tmp.replace(p)
        dump_json(p.with_suffix('.json'),clean_json({k:v for k,v in a.items() if k not in ('encoder','vocab')}))
        dump_json(p.with_name(p.stem+'_vocab.json'),vocab)
        self.log('SSL DIAGNOSTICS '+json.dumps(clean_json(r.diagnostics),default=str))
        return a


def _runtime(cfg):
    import torch
    import sklearn
    from threadpoolctl import threadpool_limits
    torch.set_num_threads(cfg['threads']);threadpool_limits(limits=cfg['threads'])
    device=cfg['device']
    if device=='auto':device='cuda' if torch.cuda.is_available() else 'cpu'
    if device.startswith('cuda') and not torch.cuda.is_available():raise ValueError('CUDA requested but unavailable; install CUDA-enabled PyTorch')
    os.environ.setdefault('CUBLAS_WORKSPACE_CONFIG',':4096:8')
    torch.use_deterministic_algorithms(True)
    torch.backends.cudnn.benchmark=False
    info={'python':platform.python_version(),'numpy':np.__version__,'pandas':pd.__version__,'sklearn':sklearn.__version__,'torch':torch.__version__,'device':device,'cuda_available':torch.cuda.is_available(),'cuda_name':torch.cuda.get_device_name() if torch.cuda.is_available() else None,'threads':cfg['threads']}
    return device,info


def run(config_path,stage='all',resume=False):
    import torch
    from .models import HistoryEncoder
    from .training import fit_neural,predict_neural
    from .metrics import evaluate,tune_thresholds,report_results
    config_path=Path(config_path).resolve();raw=json.loads(config_path.read_text());cfg={**DEFAULTS,**raw}
    for key in ('dim','max_semesters','max_courses','batch_size','ssl_epochs','neural_epochs','threads'):
        if not isinstance(cfg[key],int) or cfg[key]<1:raise ValueError(f'{key} must be positive integer')
    if set(cfg['encoders'])-{'mlp','gru','transformer'}:raise ValueError('Unknown encoder')
    if set(cfg['tasks'])-{'grade','course','joint'}:raise ValueError('Unknown SSL task')
    if set(cfg['arms'])-{'H0','H1','N0','N1','N2','N3','H2','HR','HS'}:raise ValueError('Unknown research arm')
    if cfg['ssl_scope'] not in ('pooled','local'):raise ValueError('ssl_scope must be pooled/local')
    if cfg['chronology_placebo'] and 'HS' not in cfg['arms']:cfg['arms']=cfg['arms']+['HS']
    corpus,entries,fingerprints=load_inputs(cfg,config_path.parent)
    folds={e['fold'] for e in entries};faculties={e['faculty'] for e in entries}
    if set(cfg['expected_folds'])!=folds:raise ValueError(f'Fold coverage mismatch expected {cfg["expected_folds"]} found {sorted(folds)}')
    if cfg['expected_faculties'] is not None and len(faculties)!=cfg['expected_faculties']:raise ValueError('Faculty coverage mismatch')
    # Every faculty must have every declared fold; failures never silently shrink macro support.
    if any({e['fold'] for e in entries if e['faculty']==f}!=folds for f in faculties):raise ValueError('Incomplete faculty x fold matrix')
    out=Path(cfg['output_dir']).expanduser().resolve();out.mkdir(parents=True,exist_ok=True)
    identity={'recipe_digest':recipe_digest(cfg),'data_fingerprints':fingerprints,'source_digest':source_digest()}
    ip=out/'run_identity.json'
    if ip.exists():
        if json.loads(ip.read_text())!=identity:raise ValueError('Existing output belongs to different recipe/data; use a new output_dir')
        if not resume:raise ValueError('Output already initialized; use --resume to reuse verified artifacts')
    else:dump_json(ip,identity)
    device,runtime=_runtime(cfg);dump_json(out/'runtime.json',runtime);dump_json(out/'resolved_config.json',cfg)
    log('SUITE35 PACE runtime '+json.dumps(runtime))
    if cfg.get('input_mode')=='aq_native':
        from .native_cli import print_audit
        print_audit(corpus,entries,fingerprints)
        dump_json(out/'aq_source_audit.json',corpus.audit);dump_json(out/'aq_source_fingerprints.json',fingerprints)
    else:log('SOURCE AUDIT '+json.dumps(corpus.audit))
    log(f'SUPPORT faculties={sorted(faculties)} folds={sorted(folds)} cells={len(entries)}')
    manager=SSLManager(corpus,cfg,out,device,log)
    fp=out/'protocol_freeze.json';freeze=None
    if stage=='retrospective':
        if not fp.exists():raise ValueError('Retrospective requires protocol_freeze.json from development in same output directory')
        freeze=json.loads(fp.read_text())
        if freeze['identity']!=identity:raise ValueError('Frozen protocol recipe/data identity mismatch')
    all_results=[];all_predictions=[]
    phases=['development','retrospective'] if stage=='all' else [stage]
    for phase in phases:
        if phase=='retrospective' and freeze is None:freeze=json.loads(fp.read_text())
        phase_results=[];phase_predictions=[]
        for en in entries:
            fold=en['fold']
            if (phase=='development')!=(fold<=5):continue
            fac=en['faculty'];te=en['test'];features=en['features'];t=te.origin_at.iloc[0]
            tr,val,refit,v=chronological_split(en['train'],t)
            if set(tr.row_id)&set(val.row_id):raise ValueError('Selection training/validation identity overlap')
            log(f'COHORT phase={phase} faculty={fac} F{fold} selection_cutoff={corpus.describe_origin(v)} target_cutoff={corpus.describe_origin(t)} n_train={len(tr)} n_validation={len(val)} n_refit={len(refit)} n_target={len(te)} target_prevalence={te.label.mean():.6f} excluded_late_training_labels={len(en["train"])-len(refit)}')
            psel=NumericPreprocessor().fit(tr[features].to_numpy(float));pfin=NumericPreprocessor().fit(refit[features].to_numpy(float))
            xtr=psel.transform(tr[features]);xv=psel.transform(val[features]);xr=pfin.transform(refit[features]);xt=pfin.transform(te[features])
            ys=tr.label.to_numpy(int);yv=val.label.to_numpy(int);yr=refit.label.to_numpy(int);yt=te.label.to_numpy(int)
            blank=SequenceStore(corpus,{},cfg['max_semesters'],cfg['max_courses'])
            summary_tr,summary_names=blank.summaries(tr);summary_v,_=blank.summaries(val);summary_r,_=blank.summaries(refit);summary_t,_=blank.summaries(te)
            _,target_diag=blank.for_rows(te)
            for seed in cfg['seeds']:
                sequence_cache={}
                specs=[(a,'none','none') for a in ('H0','H1','N0') if a in cfg['arms']]
                for arch in cfg['encoders']:
                    specs += [(a,arch,'none') for a in ('N1','HR') if a in cfg['arms']]
                    specs += [(a,arch,task) for task in cfg['tasks'] for a in ('N2','N3','H2','HS') if a in cfg['arms']]
                for arm,arch,task in specs:
                    key=f'{fac}_F{fold}_s{seed}_{arm}_{arch}_{task}'
                    cell=out/'cells'/key;cell.mkdir(parents=True,exist_ok=True);done=cell/'complete.json'
                    if resume and done.exists():
                        result,pred=validate_resume_cell(cell,te,corpus,device)
                        phase_results.append(result);phase_predictions.append(pred);log('RESUME '+key);continue
                    start=time.monotonic();log('ARM START '+key)
                    btr=bv=br=bt=None;sel_encoder=fin_encoder=None;diag=target_diag;ssl_epochs=0
                    sx,xsv,fx,ft=xtr,xv,xr,xt
                    if arm=='H1':
                        sx=np.c_[xtr,summary_tr];xsv=np.c_[xv,summary_v];fx=np.c_[xr,summary_r];ft=np.c_[xt,summary_t]
                    if arch!='none':
                        local=fac if cfg['ssl_scope']=='local' else None
                        if arm in ('N2','N3','H2','HS'):
                            selected=manager.get(v,arch,task,seed,local,shuffle=arm=='HS');ssl_epochs=selected['epochs']
                            sel=manager.get(v,arch,task,seed,local,fixed_epochs=ssl_epochs,shuffle=arm=='HS')
                            final=manager.get(t,arch,task,seed,local,fixed_epochs=ssl_epochs,shuffle=arm=='HS')
                            svocab=sel['vocab'];fvocab=final['vocab'];sel_encoder=copy.deepcopy(sel['encoder']);fin_encoder=copy.deepcopy(final['encoder'])
                        else:
                            se=corpus.before(v,local);fe=corpus.before(t,local)
                            svocab={c:i+3 for i,c in enumerate(sorted(se.course_id.unique()))};fvocab={c:i+3 for i,c in enumerate(sorted(fe.course_id.unique()))}
                            torch.manual_seed(seed);sel_encoder=HistoryEncoder(len(svocab)+3,arch,cfg['dim'],cfg['layers'],cfg['heads'],cfg['dropout'])
                            torch.manual_seed(seed);fin_encoder=HistoryEncoder(len(fvocab)+3,arch,cfg['dim'],cfg['layers'],cfg['heads'],cfg['dropout'])
                        sequence_key=hashlib.sha256(json.dumps([svocab,fvocab,arm=='HS'],sort_keys=True).encode()).hexdigest()
                        if sequence_key not in sequence_cache:
                            ss=SequenceStore(corpus,svocab,cfg['max_semesters'],cfg['max_courses']);fs=SequenceStore(corpus,fvocab,cfg['max_semesters'],cfg['max_courses'])
                            bs,_=ss.for_rows(tr);bvs,_=ss.for_rows(val);bf,_=fs.for_rows(refit);bts,ds=fs.for_rows(te)
                            if arm=='HS':
                                bs=shuffle_semesters(bs,seed,history_keys(tr));bvs=shuffle_semesters(bvs,seed,history_keys(val));bf=shuffle_semesters(bf,seed,history_keys(refit));bts=shuffle_semesters(bts,seed,history_keys(te))
                            sequence_cache[sequence_key]=(bs,bvs,bf,bts,ds)
                        btr,bv,br,bt,diag=sequence_cache[sequence_key]
                        if arm in ('H2','HR','HS'):
                            sx=np.c_[xtr,encode(sel_encoder,btr,device,cfg['batch_size'])];xsv=np.c_[xv,encode(sel_encoder,bv,device,cfg['batch_size'])]
                            fx=np.c_[xr,encode(fin_encoder,br,device,cfg['batch_size'])];ft=np.c_[xt,encode(fin_encoder,bt,device,cfg['batch_size'])]
                    if arm.startswith('H'):
                        epochs,curves=choose_hgb(sx,ys,xsv,yv,cfg,seed,log)
                        final_model=fit_hgb(fx,yr,cfg,seed,epochs);p=final_model.predict_proba(ft)[:,1];p_train=final_model.predict_proba(fx)[:,1]
                        joblib.dump({'model':final_model,'preprocessor':pfin,'encoder':fin_encoder.cpu() if fin_encoder is not None else None,'vocab':fvocab if arch!='none' else None,'summary_names':summary_names if arm=='H1' else None,'features':features,'config':cfg,'arm':arm,'seed':seed},cell/'checkpoint.joblib')
                        from .inference import predict_checkpoint
                        replay=predict_checkpoint(cell/'checkpoint.joblib',te,corpus,device)
                    else:
                        mode={'N0':'none','N1':'scratch','N2':'frozen','N3':'finetune'}[arm]
                        sel_fit=fit_neural(xtr,ys,btr,xv,yv,bv,sel_encoder,mode,cfg,seed,device,log)
                        epochs=sel_fit.epochs;curves=sel_fit.history
                        fit=fit_neural(xr,yr,br,None,None,None,fin_encoder,mode,cfg,seed,device,log,fixed_epochs=epochs)
                        curves=[{**r,'phase':'selection'} for r in curves]+[{**r,'phase':'refit'} for r in fit.history]
                        final_model=fit.model;p=predict_neural(final_model,xt,bt,device,cfg['batch_size']);p_train=predict_neural(final_model,xr,br,device,cfg['batch_size'])
                        torch.save({'model':final_model.cpu(),'preprocessor':pfin,'features':features,'config':cfg,'vocab':fvocab if arch!='none' else None,'arm':arm},cell/'checkpoint.pt')
                        from .inference import predict_checkpoint
                        replay=predict_checkpoint(cell/'checkpoint.pt',te,corpus,device)
                    if not np.allclose(p,replay,atol=1e-6,rtol=1e-6):raise RuntimeError('Checkpoint replay mismatch '+key)
                    if not np.isfinite(p).all():raise FloatingPointError('Nonfinite final probability '+key)
                    tag=f'{arm}|{arch}|{task}'
                    thresholds=freeze['thresholds'][tag] if phase=='retrospective' else {'f1':.5,'f2':.5}
                    met=evaluate(yt,p,thresholds,row_ids=te.row_id.to_numpy());train_ap=evaluate(yr,p_train)['ap']
                    result={'faculty':fac,'fold':fold,'seed':seed,'arm':arm,'arch':arch,'task':task,'stage':phase,'epochs':int(epochs),'ssl_epochs':ssl_epochs,'train_ap':train_ap,'seconds':time.monotonic()-start,'checkpoint_replay':True,**met}
                    pred=te[['row_id','student_id','faculty']].reset_index(drop=True).copy();pred['fold']=fold;pred['seed']=seed;pred['arm']=arm;pred['arch']=arch;pred['task']=task;pred['y']=yt;pred['p']=p
                    for c in diag:pred[c]=diag[c].to_numpy()
                    pd.DataFrame(curves).to_csv(cell/'epochs.csv',index=False);pred.to_csv(cell/'predictions.csv',index=False)
                    artifact_paths=[cell/'epochs.csv',cell/'predictions.csv',cell/('checkpoint.joblib' if arm.startswith('H') else 'checkpoint.pt')]
                    result['artifact_hashes']={p.name:sha256(p) for p in artifact_paths}
                    dump_json(done,clean_json(result))
                    phase_results.append(result);phase_predictions.append(pred)
                    log(f'ARM END {key} AP={met["ap"]} AUC={met["auc"]} train_AP={train_ap} selected_epochs={epochs} SSL_epochs={ssl_epochs} seconds={result["seconds"]:.2f} replay=PASS history_none={int(diag.no_history.sum())} mean_OOV={diag.oov_rate.mean():.4f}')
                    del final_model
                    if torch.cuda.is_available():torch.cuda.empty_cache()
        if not phase_results:raise ValueError('No cohorts in requested stage '+phase)
        results=pd.DataFrame(phase_results);preds=pd.concat(phase_predictions,ignore_index=True)
        if phase=='development':
            thresholds={}
            for (arm,arch,task),g in preds.groupby(['arm','arch','task'],sort=True):
                # Average seeds for each held-out enrollment before threshold fitting.
                gg=g.groupby(['faculty','fold','row_id'],sort=False).agg(y=('y','first'),p=('p','mean'))
                thresholds[f'{arm}|{arch}|{task}']=tune_thresholds(gg.y.to_numpy(),gg.p.to_numpy())
            for i,r in results.iterrows():
                g=preds[(preds.faculty==r.faculty)&(preds.fold==r.fold)&(preds.seed==r.seed)&(preds.arm==r.arm)&(preds.arch==r.arch)&(preds.task==r.task)]
                met=evaluate(g.y.to_numpy(),g.p.to_numpy(),thresholds[f'{r.arm}|{r.arch}|{r.task}'],row_ids=g.row_id.to_numpy())
                for k,value in met.items():results.loc[i,k]=value
            results.to_csv(out/'development_results.csv',index=False);preds.to_csv(out/'development_predictions.csv',index=False)
            decision=report_results(results,preds,out/'development_reports',lambda message:None,cfg['bootstrap'])
            freeze={'version':1,'identity':identity,'thresholds':thresholds,'decision':clean_json(decision),'development_folds':sorted(folds&{1,2,3,4,5}),'threshold_note':'F1/F2 chosen on development predictions; development threshold metrics are policy fitting diagnostics. Retrospective applies them unchanged.'}
            dump_json(fp,freeze);log('PROTOCOL FROZEN '+json.dumps(freeze['decision'],default=str))
        else:
            results.to_csv(out/'retrospective_results.csv',index=False);preds.to_csv(out/'retrospective_predictions.csv',index=False)
            report_results(results,preds,out/'retrospective_reports',lambda message:None,cfg['bootstrap'])
            log('DEVELOPMENT DECISION RETAINED '+json.dumps(freeze['decision'],default=str))
        all_results.append(results);all_predictions.append(preds)
    # Preserve the earlier phase when retrospective is invoked as a separate process.
    combined=[];combined_pred=[]
    for ph in ('development','retrospective'):
        if (out/f'{ph}_results.csv').exists():combined.append(pd.read_csv(out/f'{ph}_results.csv'))
        if (out/f'{ph}_predictions.csv').exists():combined_pred.append(pd.read_csv(out/f'{ph}_predictions.csv',dtype={'row_id':str,'student_id':str}))
    results=pd.concat(combined,ignore_index=True);preds=pd.concat(combined_pred,ignore_index=True)
    results.to_csv(out/'all_results.csv',index=False)
    report_results(results,preds,out/'reports',log,cfg['bootstrap'])
    if cfg.get('historical_results'):
        hp=Path(cfg['historical_results']);hp=hp if hp.is_absolute() else config_path.parent/hp
        from .archival import report as archival_report
        archival_report(results,hp,out/'reports',log)
    dump_json(out/'ssl_reuse_summary.json',manager.reuse_counts)
    log(f'SSL SHARING reused_artifacts={len(manager.reuse_counts)} reuse_requests={sum(manager.reuse_counts.values())}')
    log(f'SUITE35 COMPLETE results={out} research performance remains to be assessed on real AQ data')
    return out
