# -*- coding: utf-8 -*-
from __future__ import annotations
import argparse, copy, gc, time
from pathlib import Path
import numpy as np
import pandas as pd
import torch
import torch.nn.functional as F
from torch.utils.data import DataLoader, WeightedRandomSampler

from suite24_common import *
from suite24_graph_index import EvidenceIndex, materialize_evidence, MAX_HISTORY_COURSES, MAX_STRUCT_COURSES
from suite24_data import EvidenceDataset, PerturbedEvidenceDataset, same_faculty_permutation, fit_stats, evidence_support_frame
from suite24_model import TargetConditionedStructuralResidual
from suite24_reporting import *

VARIANTS=[('history','suite24_history_residual'),('structural','suite24_structural_residual'),('evidence','suite24_evidence_residual')]

def move_batch(batch,device):return {k:(v.to(device,non_blocking=True) if torch.is_tensor(v) else v) for k,v in batch.items()}

def pairwise_rank_loss(logits,y,faculty,max_pairs=2048):
    losses=[]
    for f in torch.unique(faculty):
        m=faculty==f;pos=torch.where(m&(y>0.5))[0];neg=torch.where(m&(y<=0.5))[0]
        if not len(pos) or not len(neg):continue
        n=min(max_pairs,max(len(pos),len(neg))*4);ip=pos[torch.randint(len(pos),(n,),device=logits.device)];ineg=neg[torch.randint(len(neg),(n,),device=logits.device)];losses.append(F.softplus(-(logits[ip]-logits[ineg])).mean())
    return torch.stack(losses).mean() if losses else logits.sum()*0

def train_epoch(model,loader,opt,device,args):
    model.train();tot=0.;n=0;diag={'bce':0.,'rank':0.,'aux':0.,'corr':0.,'gate':0.}
    for batch in loader:
        b=move_batch(batch,device);opt.zero_grad(set_to_none=True);z,aux=model(b,return_aux=True);y=b['y'];rank=pairwise_rank_loss(z,y,b['faculty_idx']);bce=F.binary_cross_entropy_with_logits(z,y)
        zi=aux['standalone_logit'];auxb=F.binary_cross_entropy_with_logits(zi,y);auxr=pairwise_rank_loss(zi,y,b['faculty_idx']);corr=(aux['correction']**2).mean();gate=(aux['history_gate'].mean()+aux['structural_gate'].mean())/2
        loss=bce+args.rank_weight*rank+args.aux_weight*(auxb+args.aux_rank_weight*auxr)+args.residual_penalty*corr+(args.gate_penalty*gate if model.variant=='evidence' else 0.)
        loss.backward();torch.nn.utils.clip_grad_norm_(model.parameters(),args.grad_clip);opt.step();bs=len(z);tot+=float(loss.detach())*bs;n+=bs
        for k,v in [('bce',bce),('rank',rank),('aux',auxb),('corr',corr),('gate',gate)]:diag[k]+=float(v.detach())*bs
    return tot/max(n,1),{k:v/max(n,1) for k,v in diag.items()}

@torch.no_grad()
def predict_model(model,dataset,device,batch_size=1024,ablate=None,return_aux=False):
    model.eval();loader=DataLoader(dataset,batch_size=batch_size,shuffle=False,num_workers=0,pin_memory=True);p=[];ps=[];idx=[];auxs=[]
    for batch in loader:
        b=move_batch(batch,device);z,a=model(b,return_aux=True,ablate=ablate);p.append(torch.sigmoid(z).cpu().numpy());ps.append(torch.sigmoid(a['standalone_logit']).cpu().numpy());idx.append(batch['bundle_index'].numpy())
        if return_aux:auxs.append({k:v.detach().cpu() for k,v in a.items() if torch.is_tensor(v)})
    p=np.concatenate(p) if p else np.zeros(0);ps=np.concatenate(ps) if ps else np.zeros(0);idx=np.concatenate(idx) if idx else np.zeros(0,int)
    if not return_aux:return p,ps,idx
    merged={k:torch.cat([a[k] for a in auxs],0).numpy() for k in auxs[0]} if auxs else {};return p,ps,idx,merged

def validation_metrics(bundle,mask,score):
    aps=[];f2=[];br=[]
    for fi in range(len(bundle.faculty_names)):
        m=np.asarray(mask)&(bundle.faculty_idx==fi)
        if not m.any():continue
        aps.append(safe_ap(bundle.y[m],score[m]));md=metric_dict(bundle.y[m],score[m]);f2.append(md['fbeta_at_20']);br.append(md['brier'])
    return float(np.nanmean(aps)),float(np.nanmean(f2)),float(np.nanmean(br))

def make_model(variant,stats,args):
    sm,ss,cm,cs=stats;return TargetConditionedStructuralResidual(variant,args.d_model,args.heads,args.dropout,sm,ss,cm,cs,args.delta_cap)

def selection_train(variant,store,bundle,tr_mask,va_mask,args,device,seed):
    tr_idx=np.where(tr_mask)[0];va_idx=np.where(va_mask)[0];stats=fit_stats(store,tr_idx,args.norm_rows,seed);set_seed(seed);model=make_model(variant,stats,args).to(device);opt=torch.optim.AdamW(model.parameters(),lr=args.lr,weight_decay=args.weight_decay)
    ds=EvidenceDataset(store,bundle,tr_idx);weights=faculty_sampling_weights(bundle.faculty_idx[tr_idx],len(bundle.faculty_names));ns=min(args.samples_per_epoch,len(tr_idx)) if args.samples_per_epoch>0 else len(tr_idx);sampler=WeightedRandomSampler(torch.as_tensor(weights,dtype=torch.double),num_samples=max(ns,1),replacement=True);loader=DataLoader(ds,batch_size=args.batch_size,sampler=sampler,num_workers=0,pin_memory=True)
    vds=EvidenceDataset(store,bundle,va_idx);best=None;bad=0;history=[]
    for ep in range(1,args.max_epochs+1):
        loss,diag=train_epoch(model,loader,opt,device,args);pv,psi,ii=predict_model(model,vds,device,args.eval_batch_size);full=np.full(len(bundle.y),np.nan);full[ii]=pv;ap,f2,br=validation_metrics(bundle,va_mask,full);key=(ap,f2,-br)
        row={'epoch':ep,'loss':loss,'macro_ap':ap,'macro_f2_at20':f2,'brier':br,**{f'train_{k}':v for k,v in diag.items()}};history.append(row)
        if best is None or key>best['key']:
            best={'key':key,'epoch':ep,'state':copy.deepcopy({k:v.detach().cpu() for k,v in model.state_dict().items()}),'val_score':full.copy()};bad=0
        elif ep>=args.min_epochs:bad+=1
        print(f'[SELECT {variant.upper()}] epoch={ep:02d}/{args.max_epochs} loss={loss:.5f} macroAP={ap:.4f} F2@20={f2:.4f} Brier={br:.4f} corr={diag["corr"]:.4f} gate={diag["gate"]:.4f} best={best["epoch"]:02d}')
        if ep>=args.min_epochs and bad>=args.patience:break
    model.load_state_dict(best['state']);pv,psi,ii,aux=predict_model(model,vds,device,args.eval_batch_size,return_aux=True);vf=np.full(len(bundle.y),np.nan);sf=np.full(len(bundle.y),np.nan);vf[ii]=pv;sf[ii]=psi;best['val_score']=vf;best['val_standalone']=sf;best['val_aux_indices']=ii;best['val_aux']=aux;best['history']=history;best['stats']=stats;return best

def refit_predict(variant,store_hist,bundle_hist,store_target,bundle_target,epochs,args,device,seed):
    idx=np.arange(len(bundle_hist.y));stats=fit_stats(store_hist,idx,args.norm_rows,seed);set_seed(seed);model=make_model(variant,stats,args).to(device);opt=torch.optim.AdamW(model.parameters(),lr=args.lr,weight_decay=args.weight_decay)
    ds=EvidenceDataset(store_hist,bundle_hist,idx);weights=faculty_sampling_weights(bundle_hist.faculty_idx,len(bundle_hist.faculty_names));ns=min(args.samples_per_epoch,len(idx)) if args.samples_per_epoch>0 else len(idx);sampler=WeightedRandomSampler(torch.as_tensor(weights,dtype=torch.double),num_samples=max(ns,1),replacement=True);loader=DataLoader(ds,batch_size=args.batch_size,sampler=sampler,num_workers=0,pin_memory=True)
    for ep in range(1,int(epochs)+1):
        loss,diag=train_epoch(model,loader,opt,device,args)
        if ep==1 or ep==epochs:print(f'[REFIT {variant.upper()}] epoch={ep:02d}/{epochs} loss={loss:.5f} corr={diag["corr"]:.4f}')
    p,ps,ii,aux=predict_model(model,EvidenceDataset(store_target,bundle_target),device,args.eval_batch_size,return_aux=True);return model,p,ps,aux

def policy_masks(bundle,val_mask):
    cal=np.zeros(len(bundle.y),bool);pol=np.zeros(len(bundle.y),bool)
    for fi in range(len(bundle.faculty_names)):
        m=val_mask&(bundle.faculty_idx==fi);blocks=sorted(pd.unique(bundle.blocks[m]));
        if not blocks:continue
        if len(blocks)==1:cal[m]=True;pol[m]=True
        else:pol[m&(bundle.blocks==blocks[-1])]=True;cal[m&np.isin(bundle.blocks,blocks[:-1])]=True
    return cal,pol

def macro_key(bundle,mask,score):
    ap,f2,br=validation_metrics(bundle,mask,score);return ap,f2,-br

def select_safe_scale(bundle,cal,pol,val_aux,scale_grid):
    # correction is aligned to validation dataset ordering, which equals np.where(va)[0]
    va_idx=np.where(cal|pol)[0];corr=np.asarray(val_aux['correction']);assert len(corr)==len(va_idx);corr_full=np.full(len(bundle.y),np.nan);corr_full[va_idx]=corr
    rows=[];best=None
    for lam in scale_grid:
        raw=np.full(len(bundle.y),np.nan);m=cal|pol;raw[m]=sigmoid(logit(bundle.committee[m])+float(lam)*corr_full[m]);a,b=fit_platt(bundle.y[cal],raw[cal]);score=np.full(len(bundle.y),np.nan);score[m]=apply_platt(raw[m],a,b);ap,f2,negbr=macro_key(bundle,pol,score);row={'scale':float(lam),'policy_macro_ap':ap,'policy_macro_f2':f2,'policy_brier':-negbr,'platt_a':a,'platt_b':b};rows.append(row);key=(ap,f2,-abs(float(lam)-1.0))
        if best is None or key>best[0]:best=(key,row,corr_full)
    return best[1],pd.DataFrame(rows),best[2]

def select_posthoc_blend(bundle,cal,pol,standalone,alpha_grid):
    a,b=fit_platt(bundle.y[cal],standalone[cal]);stand=np.full(len(bundle.y),np.nan);m=cal|pol;stand[m]=apply_platt(standalone[m],a,b);rows=[];best=None
    for alpha in alpha_grid:
        p=np.full(len(bundle.y),np.nan);p[m]=blend_logits(bundle.committee[m],stand[m],alpha);ap,f2,negbr=macro_key(bundle,pol,p);row={'alpha':float(alpha),'policy_macro_ap':ap,'policy_macro_f2':f2,'policy_brier':-negbr,'standalone_platt_a':a,'standalone_platt_b':b};rows.append(row);key=(ap,f2,-float(alpha))
        if best is None or key>best[0]:best=(key,row)
    return best[1],pd.DataFrame(rows),(a,b)

def perturbation_metrics(model,store,bundle,base_score,platt,device,args,fold):
    rows=[];base=EvidenceDataset(store,bundle);perm_hist=same_faculty_permutation(bundle,args.seed+fold*811,True);perm_struct=same_faculty_permutation(bundle,args.seed+fold*823,True);a,b=platt
    for mode,src in [('zero_history',None),('shuffle_history',perm_hist),('zero_structural',None),('shuffle_structural',perm_struct)]:
        ds=PerturbedEvidenceDataset(base,mode,src);p,_,ii=predict_model(model,ds,device,args.eval_batch_size);full=np.full(len(bundle.y),np.nan);full[ii]=apply_platt(p,a,b)
        for fi,fac in enumerate(bundle.faculty_names):
            m=bundle.faculty_idx==fi;rows.append({'fold':fold,'faculty':fac,'perturbation':mode,'rows':int(m.sum()),'base_ap':safe_ap(bundle.y[m],base_score[m]),'perturbed_ap':safe_ap(bundle.y[m],full[m]),'delta_ap':safe_ap(bundle.y[m],full[m])-safe_ap(bundle.y[m],base_score[m]),'mean_abs_probability_change':float(np.mean(np.abs(full[m]-base_score[m])))})
    return rows

def ablation_metrics(model,store,bundle,base_score,platt,device,args,fold):
    rows=[];ds=EvidenceDataset(store,bundle);a,b=platt
    for name,abl in [('no_history_correction',['history_correction']),('no_structural_correction',['structural_correction']),('fixed_gates',['fixed_gates'])]:
        p,_,ii=predict_model(model,ds,device,args.eval_batch_size,ablate=abl);full=np.full(len(bundle.y),np.nan);full[ii]=apply_platt(p,a,b)
        for fi,fac in enumerate(bundle.faculty_names):
            m=bundle.faculty_idx==fi;rows.append({'fold':fold,'faculty':fac,'ablation':name,'rows':int(m.sum()),'base_ap':safe_ap(bundle.y[m],base_score[m]),'ablated_ap':safe_ap(bundle.y[m],full[m]),'delta_ap':safe_ap(bundle.y[m],full[m])-safe_ap(bundle.y[m],base_score[m])})
    return rows

def authority_rows(model,store,bundle,device,args,fold):
    _,_,idx,aux=predict_model(model,EvidenceDataset(store,bundle),device,args.eval_batch_size,return_aux=True);rows=[];sup=np.asarray(store.data['support']);hm=np.asarray(store.data['history_mask']);sm=np.asarray(store.data['struct_mask'])
    for fi,fac in enumerate(bundle.faculty_names):
        m=bundle.faculty_idx==fi;y=bundle.y[m];ha=aux['history_attention'][m];sa=aux['structural_attention'][m]
        htop=np.where(hm[m],ha,-1).max(1);stop=np.where(sm[m],sa,-1).max(1);stop=stop[sm[m].any(1)]
        corr=aux['correction'][m]
        rows.append({'fold':fold,'faculty':fac,'rows':int(m.sum()),'history_gate_mean':float(aux['history_gate'][m].mean()),'structural_gate_mean':float(aux['structural_gate'][m].mean()),'abs_history_correction_mean':float(np.abs(aux['history_correction'][m]).mean()),'abs_structural_correction_mean':float(np.abs(aux['structural_correction'][m]).mean()),'abs_total_correction_mean':float(np.abs(corr).mean()),'correction_failure_mean':float(corr[y==1].mean()) if np.any(y==1) else np.nan,'correction_normal_mean':float(corr[y==0].mean()) if np.any(y==0) else np.nan,'history_attention_top1_mean':float(np.mean(htop[htop>=0])) if np.any(htop>=0) else np.nan,'structural_attention_top1_mean':float(np.mean(stop)) if len(stop) else np.nan,'history_support_mean':float(sup[m,0].mean()),'structural_support_mean':float(sup[m,1].mean()),'related_history_mean':float(sup[m,2].mean())})
    return rows

def relation_attention_rows(model,store,bundle,device,args,fold):
    _,_,_,aux=predict_model(model,EvidenceDataset(store,bundle),device,args.eval_batch_size,return_aux=True);rows=[]
    for branch,relkey,maskkey,attkey in [('history','history_rel','history_mask','history_attention'),('structural','struct_rel','struct_mask','structural_attention')]:
        rel=np.asarray(store.data[relkey]);mask=np.asarray(store.data[maskkey]);att=np.asarray(aux[attkey])
        for code in range(14):
            z=mask&(rel==code)
            if z.any():rows.append({'fold':fold,'branch':branch,'relation_code':code,'tokens':int(z.sum()),'mean_attention':float(att[z].mean()),'attention_mass':float(att[z].sum())})
    return rows

def print_support(fold,bundle,store):
    s=np.asarray(store.data['support']);rows=[]
    for fi,fac in enumerate(bundle.faculty_names):
        m=bundle.faculty_idx==fi;rows.append({'faculty':fac,'rows':int(m.sum()),'prevalence':float(bundle.y[m].mean()),'history_courses_mean':float(s[m,0].mean()),'structural_courses_mean':float(s[m,1].mean()),'related_history_mean':float(s[m,2].mean()),'same_course_history_mean':float(s[m,3].mean()),'failed_history_mean':float(s[m,4].mean()),'direct_structural_mean':float(s[m,5].mean()),'history_zero_rate':float(np.mean(s[m,0]==0)),'structural_zero_rate':float(np.mean(s[m,1]==0))})
    print_table(f'FOLD {fold} SUITE24 EVIDENCE SUPPORT — TARGET',rows)

def run(args):
    t0=time.time();out=Path(args.out_dir);out.mkdir(parents=True,exist_ok=True);device=torch.device(args.device if args.device!='auto' else ('cuda' if torch.cuda.is_available() else 'cpu'));faculties=parse_faculties(args.faculties,discover_faculties(args.cache_dir,1));folds=[int(x) for x in args.folds.split(',')];dev=[int(x) for x in args.dev_folds.split(',')];hold=[int(x) for x in args.holdout_folds.split(',')]
    print('='*172);print('SUITE24 — TARGET-CONDITIONED STRUCTURAL RESIDUAL NETWORK (TCSR)');print('student-history paths | direct prerequisite/structural paths | Committee-anchored bounded corrections | row-wise evidence authority | standalone relational head');print('='*172)
    print(f'[ENV] device={device} torch={torch.__version__} faculties={len(faculties)} folds={folds} dev={dev} holdout={hold}')
    print('[SCIENTIFIC CONTRACT] A=history residual; B=history+direct structural residual; C=evidence-conditioned bounded residual (PRIMARY); graph is target-conditioned/local, not global propagation; no cohorts/groups/faculty graph/time module; Committee is an anchor inside C, not a post-hoc fusion. Standalone head and simple blend are ablations. F6/F7 never select model/epoch/calibration/scale/blend.')
    index=EvidenceIndex(Path(args.structured_cache_dir)/'raw_index');print(f'[EVIDENCE INDEX] interactions={len(index.hp):,} students={len(index.by_student):,} courses={len(index.by_course):,} course_relations={len(index.edge_pair):,}')
    all_metrics=[];records=[];reference_meta=[];pert_rows=[];abl_rows=[];auth_rows=[];relatt_rows=[];support_rows=[];novelty_rows=[];support_gain=[];comp_rows=[];scale_rows=[];blend_rows=[]
    ref_dirs={'suite14':args.suite14_dir,'suite16':args.suite16_dir,'suite17':args.suite17_dir,'suite18':args.suite18_dir,'suite20':args.suite20_dir,'suite21':args.suite21_dir,'suite22':args.suite22_dir,'suite22_primary':args.suite22_dir,'suite22_relational':args.suite22_dir,'suite23':args.suite23_dir,'suite23_graph':args.suite23_dir,'council':args.council_dir,'v2':args.v2_dir}
    for fold in folds:
        fd=out/f'fold_{fold}';fd.mkdir(exist_ok=True);print('\n'+'='*172+f'\nSUITE24 TARGET FOLD {fold}\n'+'='*172)
        hist,target=load_query_bundles(args.cache_dir,faculties,fold);tr,va=latest_block_split(hist.faculty_idx,hist.blocks,args.val_blocks);print(f'[DATA] history={len(hist.y):,} fail={hist.y.sum():,} ({hist.y.mean():.2%}) train={tr.sum():,} validation={va.sum():,} target={len(target.y):,} fail={target.y.sum():,} ({target.y.mean():.2%})')
        print('[EVIDENCE CACHE] history...');eh=materialize_evidence(index,hist,args.graph_progress_every);print('[EVIDENCE CACHE] target...');et=materialize_evidence(index,target,args.graph_progress_every);print_support(fold,target,et);viol=int(eh.data['chronology_violation'].sum()+et.data['chronology_violation'].sum());print(f'[CHRONOLOGY AUDIT] violations={viol} / {len(hist.y)+len(target.y):,} | strict historical interaction semester < query semester');assert viol==0
        cal,pol=policy_masks(hist,va);variant_scores={};variant_models={};variant_platt={};variant_best={};target_aux={}
        for vi,(variant,name) in enumerate(VARIANTS):
            print('\n'+'-'*132+f'\n[VARIANT {name}]');best=selection_train(variant,eh,hist,tr,va,args,device,args.seed+fold*1000+vi*100);variant_best[name]=best;a,b=fit_platt(hist.y[cal],best['val_score'][cal]);variant_platt[name]=(a,b);pd.DataFrame(best['history']).to_csv(fd/f'{name}_selection_history.csv',index=False);save_json({'selected_epoch':best['epoch'],'platt_a':a,'platt_b':b},fd/f'{name}_selection.json')
            model,praw,pstand,aux=refit_predict(variant,eh,hist,et,target,best['epoch'],args,device,args.seed+fold*1000+vi*100);variant_models[name]=model;variant_scores[name]=apply_platt(praw,a,b);target_aux[name]=aux;print(f'[VARIANT {name}] selected_epochs={best["epoch"]} target macroAP={np.nanmean([safe_ap(target.y[target.faculty_idx==j],variant_scores[name][target.faculty_idx==j]) for j in range(len(faculties))]):.4f}')
        primary='suite24_evidence_residual';best=variant_best[primary];pmodel=variant_models[primary];pa,pb=variant_platt[primary]
        # Standalone relational head, calibrated on the early validation calibration slice.
        sa,sb=fit_platt(hist.y[cal],best['val_standalone'][cal]);standalone=sigmoid(target_aux[primary]['standalone_logit']);standalone=apply_platt(standalone,sa,sb)
        # Global development-selected residual scale: safety diagnostic/deployment ablation, NOT primary.
        scale_row,scale_grid,corr_full=select_safe_scale(hist,cal,pol,best['val_aux'],tuple(float(x) for x in args.scale_grid.split(',')));scale_row['fold']=fold;scale_rows.extend(scale_grid.assign(fold=fold).to_dict('records'));lam=float(scale_row['scale']);corr_target=np.asarray(target_aux[primary]['correction']);safe_raw=sigmoid(logit(target.committee)+lam*corr_target);safe_scale=apply_platt(safe_raw,float(scale_row['platt_a']),float(scale_row['platt_b']));print(f'[SAFE SCALE] selected lambda={lam:.2f} policyAP={scale_row["policy_macro_ap"]:.4f} policyF2={scale_row["policy_macro_f2"]:.4f}')
        # Old-style post-hoc blend retained only as an ablation.
        blend_row,blend_grid,(bsa,bsb)=select_posthoc_blend(hist,cal,pol,best['val_standalone'],tuple(float(x) for x in args.alpha_grid.split(',')));blend_row['fold']=fold;blend_rows.extend(blend_grid.assign(fold=fold).to_dict('records'));alpha=float(blend_row['alpha']);posthoc=blend_logits(target.committee,standalone,alpha);print(f'[POSTHOC BLEND ABLATION] selected alpha={alpha:.2f} policyAP={blend_row["policy_macro_ap"]:.4f}')
        scores={'committee':target.committee,**variant_scores,'suite24_graph_standalone':standalone,'suite24_safe_scale':safe_scale,'suite24_posthoc_blend':posthoc}
        refs,meta=load_references(ref_dirs,fold,target);reference_meta.extend(meta);scores.update(refs)
        rows=faculty_fold_metric_rows(fold,target,{k:v for k,v in scores.items() if np.isfinite(v).all()});rows=[r for r in rows if not (r['model'] in refs and not np.isfinite(refs[r['model']]).all())]
        for rn,rs in refs.items():
            if np.isfinite(rs).all():continue
            for fi,fac in enumerate(faculties):
                m=target.faculty_idx==fi;z=rs[m]
                if np.isfinite(z).all():rows.append({'fold':fold,'faculty':fac,'model':rn,'rows':int(m.sum()),'failures':int(target.y[m].sum()),'prevalence':float(target.y[m].mean()),**metric_dict(target.y[m],z)})
        all_metrics.extend(rows);print_table(f'SUITE24 TARGET FOLD {fold} — NEW + AVAILABLE REFERENCE RESULTS',pd.DataFrame(rows).sort_values(['faculty','model']))
        for fi,fac in enumerate(faculties):
            m=target.faculty_idx==fi;d={'actual':target.y[m],'committee':target.committee[m],'student_id':target.student_id[m],'course_id':target.course_id[m],'target_semester':target.target_semester[m]}
            for n,s in scores.items():
                z=np.asarray(s)[m]
                if np.isfinite(z).all():d[n]=z
            pd.DataFrame(d).to_csv(fd/f'{fac}_scores.csv',index=False);records.append({'fold':fold,'faculty':fac,'y':target.y[m],'scores':{k:np.asarray(v)[m] for k,v in scores.items() if np.isfinite(np.asarray(v)[m]).all()}})
        pert=perturbation_metrics(pmodel,et,target,variant_scores[primary],(pa,pb),device,args,fold);pert_rows.extend(pert);pd.DataFrame(pert).to_csv(fd/'relational_perturbations.csv',index=False)
        abl=ablation_metrics(pmodel,et,target,variant_scores[primary],(pa,pb),device,args,fold);abl_rows.extend(abl);pd.DataFrame(abl).to_csv(fd/'residual_ablations.csv',index=False)
        ar=authority_rows(pmodel,et,target,device,args,fold);auth_rows.extend(ar);pd.DataFrame(ar).to_csv(fd/'authority_diagnostics.csv',index=False);ra=relation_attention_rows(pmodel,et,target,device,args,fold);relatt_rows.extend(ra);pd.DataFrame(ra).to_csv(fd/'relation_attention.csv',index=False)
        diag={'committee':target.committee,'suite24_graph_standalone':standalone,primary:variant_scores[primary],'suite24_safe_scale':safe_scale};sr=support_strata_rows(fold,target,et,diag);support_rows.extend(sr);pd.DataFrame(sr).to_csv(fd/'support_strata.csv',index=False);nr=novelty_regime_rows(fold,target,et,diag);novelty_rows.extend(nr);pd.DataFrame(nr).to_csv(fd/'novelty_regimes.csv',index=False);sg=support_gain_rows(fold,target,et,target.committee,standalone,variant_scores[primary]);support_gain.extend(sg);pd.DataFrame(sg).to_csv(fd/'support_gain.csv',index=False);cr=complementarity_rows(fold,target,target.committee,standalone,variant_scores[primary]);comp_rows.extend(cr);pd.DataFrame(cr).to_csv(fd/'committee_complementarity.csv',index=False)
        pd.DataFrame(component_uplift(rows,folds=(fold,))).to_csv(fd/'component_uplift.csv',index=False);sf=pd.DataFrame(evidence_support_frame(et,target));sf['faculty']=[faculties[i] for i in target.faculty_idx];sf.to_csv(fd/'evidence_support_and_chronology.csv',index=False)
        del eh,et,variant_models;gc.collect();
        if torch.cuda.is_available():torch.cuda.empty_cache()
    metrics=pd.DataFrame(all_metrics);metrics.to_csv(out/'all_fold_metrics.csv',index=False);pd.DataFrame(reference_meta).to_csv(out/'reference_loading.csv',index=False);pd.DataFrame(pert_rows).to_csv(out/'relational_perturbations_all.csv',index=False);pd.DataFrame(abl_rows).to_csv(out/'residual_ablations_all.csv',index=False);pd.DataFrame(auth_rows).to_csv(out/'authority_diagnostics_all.csv',index=False);pd.DataFrame(relatt_rows).to_csv(out/'relation_attention_all.csv',index=False);pd.DataFrame(support_rows).to_csv(out/'support_strata_all.csv',index=False);pd.DataFrame(novelty_rows).to_csv(out/'novelty_regimes_all.csv',index=False);pd.DataFrame(support_gain).to_csv(out/'support_gain_all.csv',index=False);pd.DataFrame(comp_rows).to_csv(out/'committee_complementarity_all.csv',index=False);pd.DataFrame(scale_rows).to_csv(out/'safe_scale_grid_all.csv',index=False);pd.DataFrame(blend_rows).to_csv(out/'posthoc_blend_grid_all.csv',index=False)
    print_table('SUITE24 ALL-FOLD MACRO SUMMARY — F1..F7',macro_summary(metrics,folds));print_table('SUITE24 HOLDOUT MACRO SUMMARY — F6/F7',macro_summary(metrics,hold));primary='suite24_evidence_residual';comparators=['committee','suite17','suite18','suite21','suite22','suite23','suite22_relational','suite23_graph','council'];ps=[]
    for b in comparators:
        z=paired_summary(metrics,primary,b,hold)
        if z.get('cells',0):ps.append(z)
    print_table('SUITE24 PRIMARY PAIRED HOLDOUT COMPARISON',ps);pd.DataFrame(ps).to_csv(out/'paired_holdout_summary.csv',index=False)
    hh=[]
    for fac in faculties:
        d=metrics[(metrics.faculty==fac)&metrics.fold.isin(hold)];a=d[d.model==primary].ap.mean();row={'faculty':fac,'suite24_ap':a}
        for b in comparators:
            z=d[d.model==b]
            if len(z):row[f'{b}_ap']=z.ap.mean();row[f'delta_vs_{b}']=a-z.ap.mean()
        hh.append(row)
    hh=pd.DataFrame(hh);hh.to_csv(out/'holdout_faculty_head_to_head.csv',index=False);print_table('SUITE24 HOLDOUT FACULTY HEAD-TO-HEAD',hh.sort_values('delta_vs_committee',ascending=False))
    op=operational_metrics(records,dev,hold);op.to_csv(out/'operational_metrics.csv',index=False);piv=op[op.fold.astype(str)=='POOLED'].groupby(['model','policy'],as_index=False).agg(precision=('precision','mean'),recall=('recall','mean'),f2=('fbeta','mean'),flag_rate=('flag_rate','mean'));print_table('SUITE24 OPERATIONAL HOLDOUT SUMMARY',piv.sort_values(['policy','f2'],ascending=[True,False]));op_primary=op[(op.fold.astype(str)=='POOLED')&(op.model.isin([primary,'suite24_graph_standalone','suite24_safe_scale','committee','suite22','suite23','council']))][['faculty','model','policy','tp','fp','fn','tn','precision','recall','fbeta','flag_rate','ap','auc']];op_primary.to_csv(out/'operational_faculty_head_to_head.csv',index=False);print_table('SUITE24 PER-FACULTY OPERATIONAL HEAD-TO-HEAD',op_primary,max_rows=250)
    for model in [primary,'suite24_graph_standalone','suite24_safe_scale','committee','suite22','suite23','council','v2']:
        for pol in ['fixed','drift']:print_confusion('POOLED F6/F7 CONFUSION MATRIX',op,'khoa_cong_nghe_thong_tin',model,pol)
    br=[]
    for fac in faculties:
        rr=[r for r in records if r['faculty']==fac and int(r['fold']) in hold]
        if not rr:continue
        y=np.concatenate([r['y'] for r in rr]);cand=np.concatenate([r['scores'][primary] for r in rr])
        for ref in ['committee','suite18','suite21','suite22','suite23','council']:
            if not all(ref in r['scores'] for r in rr):continue
            s=np.concatenate([r['scores'][ref] for r in rr]);d,lo,hi=bootstrap_ap_delta(y,cand,s,args.bootstrap,args.seed+len(br)*31);br.append({'faculty':fac,'reference':ref,'delta_ap':d,'ci_low':lo,'ci_high':hi,'positive_ci':lo>0,'negative_ci':hi<0})
    br=pd.DataFrame(br);br.to_csv(out/'paired_bootstrap_holdout.csv',index=False);print_table('SUITE24 PAIRED BOOTSTRAP — HOLDOUT',br)
    cu=component_uplift(metrics,hold);cu.to_csv(out/'component_uplift_holdout.csv',index=False);print_table('SUITE24 COMPONENT UPLIFT — HOLDOUT',cu)
    if pert_rows:
        p=pd.DataFrame(pert_rows);print_table('SUITE24 RELATIONAL PERTURBATION SUMMARY — HOLDOUT',p[p.fold.isin(hold)].groupby('perturbation',as_index=False).agg(cells=('delta_ap','size'),mean_delta_ap=('delta_ap','mean'),median_delta_ap=('delta_ap','median'),loss_cells=('delta_ap',lambda x:int((x<0).sum())),mean_abs_prob_change=('mean_abs_probability_change','mean')))
    if abl_rows:
        a=pd.DataFrame(abl_rows);print_table('SUITE24 RESIDUAL ABLATION SUMMARY — HOLDOUT',a[a.fold.isin(hold)].groupby('ablation',as_index=False).agg(cells=('delta_ap','size'),mean_delta_ap=('delta_ap','mean'),median_delta_ap=('delta_ap','median'),loss_cells=('delta_ap',lambda x:int((x<0).sum()))))
    if auth_rows:print_table('SUITE24 EVIDENCE-AUTHORITY DIAGNOSTICS — HOLDOUT',pd.DataFrame(auth_rows)[pd.DataFrame(auth_rows).fold.isin(hold)])
    if relatt_rows:print_table('SUITE24 RELATION ATTENTION SUMMARY — HOLDOUT',pd.DataFrame(relatt_rows)[pd.DataFrame(relatt_rows).fold.isin(hold)].groupby(['branch','relation_code'],as_index=False).agg(tokens=('tokens','sum'),mean_attention=('mean_attention','mean'),attention_mass=('attention_mass','sum')))
    if comp_rows:print_table('SUITE24 COMMITTEE COMPLEMENTARITY — HOLDOUT',pd.DataFrame(comp_rows)[pd.DataFrame(comp_rows).fold.isin(hold)])
    if novelty_rows:print_table('SUITE24 COLD/NEW REGIMES — HOLDOUT',pd.DataFrame(novelty_rows)[pd.DataFrame(novelty_rows).fold.isin(hold)])
    if support_gain:
        sgc=support_gain_correlations(support_gain,hold);sgc.to_csv(out/'support_gain_correlations.csv',index=False);print_table('SUITE24 EVIDENCE-SUPPORT vs GAIN CORRELATIONS — HOLDOUT',sgc)
    audit=premise_audit(metrics,pert_rows,abl_rows,auth_rows,hold);audit.to_csv(out/'premise_audit.csv',index=False);print_table('SUITE24 PREDECLARED PREMISE / SUCCESS AUDIT',audit)
    elapsed=(time.time()-t0)/3600.;save_json({'elapsed_hours':elapsed,'folds':folds,'faculties':faculties,'primary':'suite24_evidence_residual','secondary_deployment':'suite24_safe_scale'},out/'run_summary.json');print(f'\n[DONE] Suite24 complete in {elapsed:.2f} hours | output={out}')

def parser():
    root='/root/disk_3tb/earlywarning/30072026';p=argparse.ArgumentParser();p.add_argument('--cache_dir',default=f'{root}/results/cross_faculty_residual_moe/cache');p.add_argument('--structured_cache_dir',default=f'{root}/results/suite12_structured_cache');p.add_argument('--out_dir',default=f'{root}/results/suite24_target_conditioned_structural_residual');p.add_argument('--faculties',default='all');p.add_argument('--folds',default='1,2,3,4,5,6,7');p.add_argument('--dev_folds',default='1,2,3,4,5');p.add_argument('--holdout_folds',default='6,7');p.add_argument('--seed',type=int,default=20260925);p.add_argument('--device',default='auto');p.add_argument('--d_model',type=int,default=64);p.add_argument('--heads',type=int,default=4);p.add_argument('--dropout',type=float,default=.10);p.add_argument('--delta_cap',type=float,default=.75);p.add_argument('--lr',type=float,default=1e-3);p.add_argument('--weight_decay',type=float,default=1e-4);p.add_argument('--rank_weight',type=float,default=.15);p.add_argument('--aux_weight',type=float,default=.25);p.add_argument('--aux_rank_weight',type=float,default=.05);p.add_argument('--residual_penalty',type=float,default=.01);p.add_argument('--gate_penalty',type=float,default=.002);p.add_argument('--grad_clip',type=float,default=5.);p.add_argument('--batch_size',type=int,default=1024);p.add_argument('--eval_batch_size',type=int,default=2048);p.add_argument('--max_epochs',type=int,default=10);p.add_argument('--min_epochs',type=int,default=3);p.add_argument('--patience',type=int,default=3);p.add_argument('--samples_per_epoch',type=int,default=240000);p.add_argument('--norm_rows',type=int,default=50000);p.add_argument('--val_blocks',type=int,default=3);p.add_argument('--scale_grid',default='0,.25,.50,.75,1.0');p.add_argument('--alpha_grid',default='0,.10,.25,.50,.75');p.add_argument('--bootstrap',type=int,default=500);p.add_argument('--graph_progress_every',type=int,default=25000)
    p.add_argument('--suite14_dir',default=f'{root}/results/suite14_authority_safe_collaborative_moe');p.add_argument('--suite16_dir',default=f'{root}/results/suite16_conditional_tree_boosting');p.add_argument('--suite17_dir',default=f'{root}/results/suite17_robust_forward_specialist_boosting');p.add_argument('--suite18_dir',default=f'{root}/results/suite18_fmm_forward_specialist_boosting');p.add_argument('--suite20_dir',default=f'{root}/results/suite20_semester_target_transformer');p.add_argument('--suite21_dir',default=f'{root}/results/suite21_guarded_temporal_residual');p.add_argument('--suite22_dir',default=f'{root}/results/suite22_sftr_tabm');p.add_argument('--suite23_dir',default=f'{root}/results/suite23_cs_hagt');p.add_argument('--council_dir',default=f'{root}/results/suite4/2_competence_council');p.add_argument('--v2_dir',default=f'{root}/results/final_train_v2');return p

if __name__=='__main__':run(parser().parse_args())
