# -*- coding: utf-8 -*-
"""Suite14 — Authority-Safe Collaborative Evidence MoE.

This is the final conservative continuation of the Suite12/13 framework:
1) E0 remains Committee-preserving and is frozen after Phase0.
2) Collaboration is an identity-preserving bounded correction around E0.
3) Phase2 has an exact epoch-0 E0 identity state; Phase3 can preserve it.
4) The learned gate receives no absolute semester ordinal; temporal adaptation is
   handled by chronology-safe authority calibration on historical validation blocks.
5) Phase1 selects specialists using both mechanism fidelity and failure-ranking AP.
6) Deployment authority includes exact zero, broad-success gating, and strong-local fallback.
"""
from __future__ import annotations
import argparse,json,random,math
from pathlib import Path
import numpy as np
import pandas as pd
import joblib
import torch

from suite14_pipeline import discover_faculties,parse_faculties,load_fold_bundle,context_feature_names
from suite14_data import Suite14Standardizers
from suite14_models import AuthoritySafeCollaborativeMoE
from suite14_training import train_phase,train_fixed_phase,predict,safe_ap,safe_auc,robust_committee_selection_stats,mechanism_validation_stats
from suite14_reporting import *
from suite14_structured_cache import build_raw_index,RawEvidenceIndex,ensure_fold_structured,structured_cache_compatible,COMP_TYPES
from suite14_authority import apply_authority_numpy,calibrate_authorities,broad_success_from_rows,deployment_authorities
from suite2_common import equal_budget_metrics
from suite7_common import latest_block_split


def parse_ints(s):return [int(x) for x in str(s).split(',') if x.strip()]
def parse_floats(s,n=None):
    x=[float(v) for v in str(s).split(',') if str(v).strip()]
    if n is not None and len(x)!=n:raise ValueError(f'expected {n} comma-separated floats, got {x}')
    return x
def seed_all(seed):
    random.seed(seed);np.random.seed(seed);torch.manual_seed(seed)
    if torch.cuda.is_available():torch.cuda.manual_seed_all(seed)
def device_of(s):return torch.device('cuda' if s=='auto' and torch.cuda.is_available() else ('cpu' if s=='auto' else s))

def split_rel_sel(bundle,val_mask):
    """Use older held-out validation blocks for epoch/authority fit, newest block for confirmation."""
    val=np.asarray(val_mask,bool);rel=np.zeros(len(val),bool);sel=np.zeros(len(val),bool)
    for fi in np.unique(bundle.faculty_idx[val]):
        m=val&(bundle.faculty_idx==fi)&np.isfinite(bundle.blocks);bs=sorted(pd.unique(bundle.blocks[m]))
        if len(bs)>=2:sel[m&(bundle.blocks==bs[-1])]=1;rel[m&(bundle.blocks!=bs[-1])]=1
        elif len(bs)==1:rel[m]=1;sel[m]=1
    return rel,sel

def model_from_bundle(b,args):
    return AuthoritySafeCollaborativeMoE(
        flat_dim=b.flat.shape[1],e0_context_dim=b.e0_context.shape[1],gate_context_dim=b.gate_context.shape[1],fusion_context_dim=b.fusion_context.shape[1],
        e1_context_dim=b.e1_context.shape[1],e2_context_dim=b.e2_context.shape[1],e3_context_dim=b.e3_context.shape[1],e4_context_dim=b.e4_context.shape[1],
        student_dim=b.student_seq.shape[-1],course_dim=b.course_target.shape[-1],relation_dim=b.relation_events.shape[-1],component_numeric_dim=b.component_events.shape[-1],
        n_faculties=len(b.faculty_names),n_component_types=len(COMP_TYPES),d_model=args.d_model,dropout=args.dropout,e0_dropout=args.e0_dropout,expert_dropout=args.expert_dropout,
        e0_residual_bound=args.e0_residual_bound,gate_faculty_dim=args.gate_faculty_dim,collab_delta_bound=args.collab_delta_bound,authority_bias=args.row_authority_bias)

def phase_epochs(args):return [args.e0_epochs,args.private_epochs,args.fusion_epochs,args.joint_epochs]
def phase_lrs(args):return [args.e0_lr,args.private_lr,args.fusion_lr,args.joint_lr]
def phase_mechanism(args):return [0.,args.mechanism_private_lambda,0.,args.mechanism_joint_lambda]
def phase_preserve(args):return [args.preserve_warmup,0.,0.,0.]
def phase_recon(args):return [args.recon_warmup,0.,0.,0.]
def _robust_str(s):return f'robust={s["score"]:+.5f} medΔAP={s["median_delta_ap"]:+.4f} meanΔAP={s["mean_delta_ap"]:+.4f} APwins={s["ap_wins"]}/{s["faculties"]} medΔF2={s["median_delta_f2"]:+.4f} F2wins={s["f2_wins"]}/{s["faculties"]} q25ΔAP={s["worst_quartile_delta_ap"]:+.4f}'

def _score_from_scale(pr,scale):return apply_authority_numpy(pr['e0_logit'],pr['collab_delta'],pr['row_authority'],scale)
def _score_from_map(pr,faculty_idx,faculty_names,authority_map):
    out=np.empty(len(faculty_idx),float);faculty_idx=np.asarray(faculty_idx,int)
    for fi,name in enumerate(faculty_names):
        m=faculty_idx==fi;out[m]=_score_from_scale({k:(v[m] if isinstance(v,np.ndarray) and len(v)==len(faculty_idx) else v) for k,v in pr.items()},authority_map.get(name,0.0))
    return out

def _confirm_authority_rows(h,sel,pr_sel,cal_rows,args):
    idx=np.where(sel)[0];fac=h.faculty_idx[idx];rows=[];by={r['faculty']:dict(r) for r in cal_rows}
    for fi,name in enumerate(h.faculty_names):
        r=by.get(name,{'faculty':name,'authority':0.0,'delta_ap':0.,'delta_f2':0.,'ap_wins':0,'blocks':0});m=fac==fi
        rr=dict(r)
        if np.any(m) and np.unique(h.y[idx][m]).size>1:
            y=h.y[idx][m];e0=pr_sel['private'][m,0];cand=apply_authority_numpy(pr_sel['e0_logit'][m],pr_sel['collab_delta'][m],pr_sel['row_authority'][m],r.get('authority',0.0));
            rr['confirm_delta_ap']=safe_ap(y,cand)-safe_ap(y,e0);rr['confirm_delta_f2']=equal_budget_metrics(y,cand,.20,args.threshold_beta)['fbeta']-equal_budget_metrics(y,e0,.20,args.threshold_beta)['fbeta'];rr['confirm_rows']=int(m.sum());rr['confirm_failures']=int(y.sum())
        else:rr['confirm_delta_ap']=np.nan;rr['confirm_delta_f2']=np.nan;rr['confirm_rows']=int(m.sum());rr['confirm_failures']=int(h.y[idx][m].sum()) if np.any(m) else 0
        rows.append(rr)
    return rows

def _broad_from_confirmation(rows,args):
    cr=[{'faculty':r['faculty'],'delta_ap':r.get('confirm_delta_ap',np.nan),'delta_f2':r.get('confirm_delta_f2',np.nan),'blocks':1,'ap_wins':int(np.isfinite(r.get('confirm_delta_ap',np.nan)) and r.get('confirm_delta_ap',0)>0)} for r in rows if np.isfinite(r.get('confirm_delta_ap',np.nan)) and np.isfinite(r.get('confirm_delta_f2',np.nan))]
    return broad_success_from_rows(cr,args.broad_win_fraction)

def select_epochs(hist,args,seed,device):
    tr,va=latest_block_split(hist.faculty_idx,hist.blocks,args.val_blocks);rel,sel=split_rel_sel(hist,va)
    if rel.sum()==0:rel=va.copy()
    if sel.sum()==0:sel=rel.copy()
    std=Suite14Standardizers.fit(hist,tr);h=std.transform(hist);seed_all(seed);model=model_from_bundle(h,args).to(device);selected=[];histories=[];direct_weights=parse_floats(args.specialist_direct_weights,4)
    for phase,(epochs,lr,ml,pl,rl) in enumerate(zip(phase_epochs(args),phase_lrs(args),phase_mechanism(args),phase_preserve(args),phase_recon(args))):
        be,hh=train_phase(model,h,tr,rel,phase,epochs,lr,args.weight_decay,args.batch_size,args.sampling_beta,seed+phase*701,device,args.aux_lambda,ml,pl,rl,direct_weights,args.joint_e0_lr_scale,args.selection_f2_weight,args.selection_mean_weight,args.phase1_predictive_weight,args.patience,args.samples_per_epoch,args.predict_batch_size);selected.append(be);histories.append(hh)
    # Independent newest-block audit + authority calibration. Model never trains on rel/sel rows.
    pr_rel=predict(model,h,rel,args.predict_batch_size,device);rid=np.where(rel)[0]
    grid=parse_floats(args.authority_grid)
    cal_rows=calibrate_authorities(h.y[rid],pr_rel['e0_logit'],pr_rel['collab_delta'],pr_rel['row_authority'],h.faculty_idx[rid],h.faculty_names,h.blocks[rid],grid,args.threshold_beta,args.authority_f2_weight,args.authority_mean_weight)
    pr_sel=predict(model,h,sel,args.predict_batch_size,device);confirm_rows=_confirm_authority_rows(h,sel,pr_sel,cal_rows,args);broad,broad_stats=_broad_from_confirmation(confirm_rows,args)
    authority_map,deploy_info=deployment_authorities(confirm_rows,h.faculty_names,broad,args.local_min_ap,args.local_min_f2,args.local_min_win_fraction)
    sid=np.where(sel)[0];q=h.teacher[sid].mean(1);e0_stats=robust_committee_selection_stats(h.y[sid],pr_sel['private'][:,0],q,h.faculty_idx[sid],h.faculty_names,args.selection_f2_weight,args.selection_mean_weight,args.threshold_beta)
    full_stats=robust_committee_selection_stats(h.y[sid],pr_sel['score'],pr_sel['private'][:,0],h.faculty_idx[sid],h.faculty_names,args.selection_f2_weight,args.selection_mean_weight,args.threshold_beta)
    final_sel=_score_from_map(pr_sel,h.faculty_idx[sid],h.faculty_names,authority_map);final_stats=robust_committee_selection_stats(h.y[sid],final_sel,pr_sel['private'][:,0],h.faculty_idx[sid],h.faculty_names,args.selection_f2_weight,args.selection_mean_weight,args.threshold_beta)
    mech_stats=mechanism_validation_stats(h.mechanism_targets[sid],pr_sel['mechanism'],h.faculty_idx[sid],h.faculty_names)
    print(f'[HISTORICAL AUTHORITY AUDIT] phase_epochs={selected} full-vs-E0 {_robust_str(full_stats)} | final-vs-E0 {_robust_str(final_stats)} | E0-vs-C medΔAP={e0_stats["median_delta_ap"]:+.4f} | broad_success={broad} mode={deploy_info["mode"]}')
    print('[AUTHORITY PLAN] '+' '.join(f'{r["faculty"]}:cal={r.get("authority",0):.2f}/confirmAP={r.get("confirm_delta_ap",np.nan):+.3f}/deploy={authority_map.get(r["faculty"],0):.2f}' for r in confirm_rows))
    allh=pd.concat(histories,ignore_index=True) if histories else pd.DataFrame()
    audit=pd.DataFrame([{'phase_epochs':str(selected),'broad_success':broad,'deployment_mode':deploy_info['mode'],**{f'broad_{k}':v for k,v in broad_stats.items() if np.isscalar(v)},**{f'full_{k}':v for k,v in full_stats.items() if np.isscalar(v)},**{f'final_{k}':v for k,v in final_stats.items() if np.isscalar(v)},**{f'e0_{k}':v for k,v in e0_stats.items() if np.isscalar(v)},**{f'mechanism_{k}':v for k,v in mech_stats.items() if np.isscalar(v)}}])
    auth_df=pd.DataFrame([{**r,'deploy_authority':authority_map.get(r['faculty'],0.0),'deploy_reason':deploy_info['reasons'].get(r['faculty'],'')} for r in confirm_rows])
    return selected,allh,audit,auth_df,authority_map,deploy_info

def refit(hist,target,args,selected,seed,device):
    std=Suite14Standardizers.fit(hist,np.ones(len(hist.y),bool));h=std.transform(hist);t=std.transform(target);seed_all(seed);model=model_from_bundle(h,args).to(device);allm=np.ones(len(h.y),bool);direct_weights=parse_floats(args.specialist_direct_weights,4)
    for phase,(epochs,lr,ml,pl,rl) in enumerate(zip(selected,phase_lrs(args),phase_mechanism(args),phase_preserve(args),phase_recon(args))):
        train_fixed_phase(model,h,allm,phase,epochs,lr,args.weight_decay,args.batch_size,args.sampling_beta,seed+phase*1709,device,args.aux_lambda,ml,pl,rl,direct_weights,args.joint_e0_lr_scale,args.samples_per_epoch)
    return model,std,h,t

def availability_report(bundle):
    return {'E1_student_history':float(bundle.student_mask.any(1).mean()),'E2_course_target':1.0,'E2_course_neighbors':float(bundle.course_neighbor_mask.any(1).mean()),'E3_relation_history':float(bundle.relation_mask.any(1).mean()),'E4_component_history':float(bundle.component_mask.any(1).mean()),'E1_tokens_mean':float(bundle.student_mask.sum(1).mean()),'E2_neighbors_mean':float(bundle.course_neighbor_mask.sum(1).mean()),'E3_events_mean':float(bundle.relation_mask.sum(1).mean()),'E4_events_mean':float(bundle.component_mask.sum(1).mean())}

def ensure_structured(args,faculties,folds):
    sd=Path(args.structured_cache_dir);missing=[sd/f'{f}_fold_{fold}.joblib' for fold in folds for f in faculties if not structured_cache_compatible(sd/f'{f}_fold_{fold}.joblib')]
    if not missing:return
    if not args.database_dir and (not args.data1_zip or not args.data2_zip):raise FileNotFoundError(f'{len(missing)} structured caches missing. Provide --database_dir or both ZIPs; first={missing[0]}')
    raw=sd/'raw_index';build_raw_index(args.cache_dir,args.data1_zip,args.data2_zip,faculties,folds,raw,args.force_raw,args.raw_chunksize,database_dir=args.database_dir,strict_alignment=not args.skip_alignment_audit);idx=RawEvidenceIndex(raw)
    for fold in folds:
      for fac in faculties:
        p=sd/f'{fac}_fold_{fold}.joblib'
        if structured_cache_compatible(p) and not args.force_structured:continue
        d=joblib.load(Path(args.cache_dir)/f'{fac}_fold_{fold}.joblib');x=ensure_fold_structured(d,idx,p,args.max_semesters,args.max_course_neighbors,args.max_relation_events,args.max_component_events,args.force_structured);print(f'[STRUCTURED F{fold} {fac}] OOF={len(x["train_row_index"]):,} target={len(x["target_row_index"]):,}')

def _mean_attention(pr,mask):
    aa=pr['attention'][mask]
    if len(aa)==0:return np.full((5,5),np.nan)
    return aa.mean(axis=(0,1)) if aa.ndim==4 else aa.mean(0)

def run_fold(args,faculties,fold,out,device):
    print('\n'+'='*180);print(f'SUITE14 AUTHORITY-SAFE COLLABORATIVE EVIDENCE MoE | TARGET FOLD {fold}');print('='*180)
    hist,target,common=load_fold_bundle(args.cache_dir,args.structured_cache_dir,faculties,fold)
    print(f'[DATA] raw_common={len(common)} flat={hist.flat.shape[1]} contexts(e0/gate/fusion/e1/e2/e3/e4)={hist.e0_context.shape[1]}/{hist.gate_context.shape[1]}/{hist.fusion_context.shape[1]}/{hist.e1_context.shape[1]}/{hist.e2_context.shape[1]}/{hist.e3_context.shape[1]}/{hist.e4_context.shape[1]} OOF={len(hist.y):,} fail={hist.y.sum():,} ({hist.y.mean():.2%}) target={len(target.y):,}')
    print(f'[EVIDENCE OOF] {availability_report(hist)}');print(f'[EVIDENCE TARGET] {availability_report(target)}');print('[MECHANISM TARGET OOF] '+' '.join(f'E{k+1} mean/std={hist.mechanism_targets[:,k].mean():.3f}/{hist.mechanism_targets[:,k].std():.3f}' for k in range(4)))
    selected,history,audit,auth_df,authority_map,deploy_info=select_epochs(hist,args,args.seed+fold*100003,device);fd=out/f'fold_{fold}';fd.mkdir(parents=True,exist_ok=True);history.to_csv(fd/'training_history.csv',index=False);audit.to_csv(fd/'historical_selection_audit.csv',index=False);auth_df.to_csv(fd/'authority_calibration.csv',index=False)
    model,std,h,t=refit(hist,target,args,selected,args.seed+fold*200003,device);mask=np.ones(len(t.y),bool);pr=predict(model,t,mask,args.predict_batch_size,device)
    full_score=pr['score'];cal_map={r.faculty:float(r.authority) for _,r in auth_df.iterrows()};cal_score=_score_from_map(pr,t.faculty_idx,t.faculty_names,cal_map);final_score=_score_from_map(pr,t.faculty_idx,t.faculty_names,authority_map)
    abl={}
    for k in range(5):
        ap=predict(model,t,mask,args.predict_batch_size,device,ablate=k);abl[k]=_score_from_map(ap,t.faculty_idx,t.faculty_names,authority_map)
    joblib.dump(std,fd/'suite14_standardizers.joblib',compress=3);torch.save({'state_dict':model.state_dict(),'selected_phase_epochs':selected,'authority_map':authority_map,'deployment_info':deploy_info,'args':vars(args),'faculty_names':list(h.faculty_names),'common_raw_features':common,'context_features':context_feature_names(),'component_types':COMP_TYPES},fd/'suite14_model.pt')
    records=[];metrics=[];diag=[];rep=[];mech_rows=[]
    for fi,fac in enumerate(faculties):
        m=t.faculty_idx==fi;y=t.y[m];q=t.teacher[m].mean(1);scores=reference_for_faculty(args,fold,fac,y,q);scores[E0]=pr['private'][m,0];scores[FULL]=full_score[m];scores[CAL]=cal_score[m];scores[MODEL]=final_score[m]
        for k in range(1,5):scores[f'suite14_private_e{k}']=pr['private'][m,k]
        sf=pd.DataFrame({'actual':y,'committee':q,E0:scores[E0],FULL:scores[FULL],CAL:scores[CAL],MODEL:scores[MODEL],'row_authority':pr['row_authority'][m],'collab_delta_logit':pr['collab_delta'][m],'deploy_authority':authority_map.get(fac,0.0),'calibrated_authority':cal_map.get(fac,0.0)})
        for k in range(1,5):sf[f'suite14_private_e{k}']=scores[f'suite14_private_e{k}'];sf[f'mechanism_e{k}_target']=t.mechanism_targets[m,k-1];sf[f'mechanism_e{k}_pred']=pr['mechanism'][m,k-1]
        for k,v in scores.items():
            if k not in sf:sf[k]=v
        for k in range(5):sf[f'gate_e{k}']=pr['gate'][m,k];sf[f'ablate_e{k}']=abl[k][m]
        sf['e0_logit_delta']=pr['e0_delta'][m];sf.to_csv(fd/f'{fac}_scores.csv',index=False);records.append({'fold':fold,'faculty':fac,'y':y,'scores':scores})
        for name,s in scores.items():metrics.append(metric_row(fold,fac,name,y,s,args.threshold_beta))
        ret=e0_retention_diagnostics(y,q,scores[E0],pr['e0_delta'][m]);trans=top20_transitions(y,scores[E0],scores[MODEL]);trans_full=top20_transitions(y,scores[E0],scores[FULL]);trans_cal=top20_transitions(y,scores[E0],scores[CAL])
        row={'fold':fold,'faculty':fac,'rows':int(m.sum()),'failures':int(y.sum()),'ap_committee':safe_ap(y,q),'ap_e0':safe_ap(y,scores[E0]),'ap_full':safe_ap(y,scores[FULL]),'ap_calibrated':safe_ap(y,scores[CAL]),'ap_suite14':safe_ap(y,scores[MODEL]),'auc_suite14':safe_auc(y,scores[MODEL]),'full_delta_vs_e0_ap':safe_ap(y,scores[FULL])-safe_ap(y,scores[E0]),'calibrated_delta_vs_e0_ap':safe_ap(y,scores[CAL])-safe_ap(y,scores[E0]),'final_delta_vs_e0_ap':safe_ap(y,scores[MODEL])-safe_ap(y,scores[E0]),'calibrated_authority':cal_map.get(fac,0.0),'deploy_authority':authority_map.get(fac,0.0),'deploy_reason':deploy_info['reasons'].get(fac,''),**ret,**{f'final_{k}':v for k,v in trans.items()},**{f'full_{k}':v for k,v in trans_full.items()},**{f'cal_{k}':v for k,v in trans_cal.items()}}
        private_aps=[]
        for k in range(1,5):ap=safe_ap(y,scores[f'suite14_private_e{k}']);private_aps.append(ap);row[f'private_e{k}_ap']=ap
        row['best_private_ap']=float(np.nanmax(private_aps));gm=pr['gate'][m];row['gate_entropy_norm']=float(np.mean(-np.sum(gm*np.log(np.clip(gm,1e-12,1.)),1)/np.log(5.)));row['gate_max_mean']=float(gm.max(1).mean());ra=pr['row_authority'][m];row['row_authority_mean']=float(np.mean(ra));row['row_authority_p10']=float(np.quantile(ra,.10));row['row_authority_p50']=float(np.quantile(ra,.50));row['row_authority_p90']=float(np.quantile(ra,.90));row['collab_delta_abs_mean']=float(np.mean(np.abs(pr['collab_delta'][m])));row['collab_delta_abs_p95']=float(np.quantile(np.abs(pr['collab_delta'][m]),.95))
        teacher_hat=pr['teacher_pred'][m];teacher_true=t.teacher[m];row['teacher_head_mae']=float(np.mean(np.abs(teacher_hat-teacher_true)))
        for k,nm in enumerate(['rf','et','hgb']):row[f'teacher_{nm}_mae']=float(np.mean(np.abs(teacher_hat[:,k]-teacher_true[:,k])))
        md=mechanism_diagnostics(t.mechanism_targets[m],pr['mechanism'][m])
        for k,z in enumerate(md,1):row[f'mechanism_e{k}_bce']=z['bce'];row[f'mechanism_e{k}_mae']=z['mae'];row[f'mechanism_e{k}_corr']=z['corr'];mech_rows.append({'fold':fold,'faculty':fac,'expert':k,**z})
        av=pr['availability'][m]
        for k in range(5):
            row[f'expert_e{k}_availability']=float(av[:,k].mean());row[f'gate_e{k}_mean']=float(gm[:,k].mean());row[f'ablate_e{k}_delta_ap']=safe_ap(y,abl[k][m])-safe_ap(y,scores[MODEL]);z=metric_row(fold,fac,'ablation',y,abl[k][m],args.threshold_beta);bz=metric_row(fold,fac,'suite14',y,scores[MODEL],args.threshold_beta);row[f'ablate_e{k}_delta_f2_at_20']=z['f2_at_20']-bz['f2_at_20'];fm=m&(t.y==1);nm=m&(t.y==0);row[f'gate_e{k}_failure_mean']=float(pr['gate'][fm,k].mean()) if np.any(fm) else np.nan;row[f'gate_e{k}_normal_mean']=float(pr['gate'][nm,k].mean()) if np.any(nm) else np.nan
        row['row_authority_failure_mean']=float(pr['row_authority'][m&(t.y==1)].mean()) if np.any(m&(t.y==1)) else np.nan;row['row_authority_normal_mean']=float(pr['row_authority'][m&(t.y==0)].mean()) if np.any(m&(t.y==0)) else np.nan
        for k in range(5):
            a=pr['tokens'][m,k];b=pr['collab_tokens'][m,k];den=np.linalg.norm(a,axis=1)*np.linalg.norm(b,axis=1)+1e-12;row[f'e{k}_private_to_collab_cosine']=float(np.mean(np.sum(a*b,1)/den))
        diag.append(row)
        for rr in representation_cosine(pr['tokens'][m]):rep.append({'fold':fold,'faculty':fac,'stage':'private',**rr})
        for rr in representation_cosine(pr['collab_tokens'][m]):rep.append({'fold':fold,'faculty':fac,'stage':'collaborative',**rr})
        pap=' '.join(f'E{k}:{row[f"private_e{k}_ap"]:.3f}' for k in range(1,5));ab=' '.join(f'E{k}:{row[f"ablate_e{k}_delta_ap"]:+.3f}' for k in range(1,5))
        print(f'[TARGET {fac}] AP C/E0/full/cal/14={row["ap_committee"]:.4f}/{row["ap_e0"]:.4f}/{row["ap_full"]:.4f}/{row["ap_calibrated"]:.4f}/{row["ap_suite14"]:.4f} | authority cal/deploy={row["calibrated_authority"]:.2f}/{row["deploy_authority"]:.2f} ({row["deploy_reason"]}) rowα={row["row_authority_mean"]:.2f} | privateAP {pap} | gateH={row["gate_entropy_norm"]:.3f} gate='+' '.join(f'E{k}:{row[f"gate_e{k}_mean"]:.2f}' for k in range(5))+f' | specialist ablateΔAP {ab} | final rescue/lost={trans["rescued_failures"]}/{trans["lost_failures"]}')
    pd.DataFrame(diag).to_csv(fd/'suite14_diagnostics.csv',index=False);pd.DataFrame(rep).to_csv(fd/'representation_cosine.csv',index=False);pd.DataFrame(mech_rows).to_csv(fd/'mechanism_diagnostics.csv',index=False)
    labels=[f'E{i}' for i in range(5)];att=_mean_attention(pr,np.ones(len(t.y),bool));attf=_mean_attention(pr,t.y==1);attn=_mean_attention(pr,t.y==0);pd.DataFrame(att,index=labels,columns=labels).to_csv(fd/'mean_expert_attention.csv');pd.DataFrame(attf,index=labels,columns=labels).to_csv(fd/'mean_expert_attention_failures.csv');pd.DataFrame(attn,index=labels,columns=labels).to_csv(fd/'mean_expert_attention_normals.csv');print('[EXPERT ATTENTION] target mean rows=query, cols=source');print(pd.DataFrame(att,index=labels,columns=labels).to_string(float_format=lambda x:f'{x:.3f}'));print('[EXPERT ATTENTION Δ failure-normal]');print(pd.DataFrame(attf-attn,index=labels,columns=labels).to_string(float_format=lambda x:f'{x:+.3f}'))
    summary={'fold':fold,'selected_phase_epochs':selected,'authority_map':authority_map,'deployment_info':deploy_info,'target_evidence_availability':availability_report(t),'mean_gate':[float(x) for x in pr['gate'].mean(0)],'row_authority_mean':float(pr['row_authority'].mean()),'collab_delta_abs_mean':float(np.mean(np.abs(pr['collab_delta']))),'mean_attention':att.tolist(),'mean_attention_failures':attf.tolist(),'mean_attention_normals':attn.tolist(),'mean_e0_probability_mae':float(np.mean(np.abs(pr['private'][:,0]-pr['committee']))),'mean_e0_logit_delta_abs':float(np.mean(np.abs(pr['e0_delta']))),'context_features':context_feature_names()};(fd/'suite14_fold_summary.json').write_text(json.dumps(summary,indent=2,default=str))
    return records,metrics,diag,rep,mech_rows

def parse_args():
    p=argparse.ArgumentParser(description='Suite14 Authority-Safe Collaborative Evidence MoE')
    p.add_argument('--cache_dir',required=True);p.add_argument('--structured_cache_dir',required=True);p.add_argument('--models_dir',required=True);p.add_argument('--database_dir',default=None);p.add_argument('--data1_zip',default=None);p.add_argument('--data2_zip',default=None);p.add_argument('--faculties',default='all');p.add_argument('--dev_folds',default='1,2,3,4,5');p.add_argument('--holdout_folds',default='6,7');p.add_argument('--primary_faculty',default='khoa_cong_nghe_thong_tin')
    p.add_argument('--shared_results_dir',default=None);p.add_argument('--suite7_results_dir',default=None);p.add_argument('--suite8_results_dir',default=None);p.add_argument('--suite9_results_dir',default=None);p.add_argument('--suite10_results_dir',default=None);p.add_argument('--suite11_results_dir',default=None);p.add_argument('--suite12_results_dir',default=None);p.add_argument('--suite13_results_dir',default=None);p.add_argument('--v2_results_dir',default=None);p.add_argument('--council_results_dir',default=None)
    p.add_argument('--seed',type=int,default=42);p.add_argument('--device',choices=['auto','cpu','cuda'],default='auto');p.add_argument('--d_model',type=int,default=64);p.add_argument('--dropout',type=float,default=.10);p.add_argument('--e0_dropout',type=float,default=.10);p.add_argument('--expert_dropout',type=float,default=.05);p.add_argument('--e0_residual_bound',type=float,default=2.5);p.add_argument('--gate_faculty_dim',type=int,default=8);p.add_argument('--collab_delta_bound',type=float,default=2.0);p.add_argument('--row_authority_bias',type=float,default=-1.5)
    p.add_argument('--e0_epochs',type=int,default=8);p.add_argument('--private_epochs',type=int,default=8);p.add_argument('--fusion_epochs',type=int,default=8);p.add_argument('--joint_epochs',type=int,default=8);p.add_argument('--e0_lr',type=float,default=5e-4);p.add_argument('--private_lr',type=float,default=8e-4);p.add_argument('--fusion_lr',type=float,default=7e-4);p.add_argument('--joint_lr',type=float,default=2e-4);p.add_argument('--joint_e0_lr_scale',type=float,default=0.0);p.add_argument('--weight_decay',type=float,default=1e-4)
    p.add_argument('--aux_lambda',type=float,default=.25);p.add_argument('--mechanism_private_lambda',type=float,default=.40);p.add_argument('--mechanism_joint_lambda',type=float,default=.12);p.add_argument('--preserve_warmup',type=float,default=1.0);p.add_argument('--recon_warmup',type=float,default=.25);p.add_argument('--specialist_direct_weights',default='.50,.10,1.00,.35');p.add_argument('--phase1_predictive_weight',type=float,default=.75)
    p.add_argument('--selection_f2_weight',type=float,default=.50);p.add_argument('--selection_mean_weight',type=float,default=.25);p.add_argument('--broad_win_fraction',type=float,default=.60);p.add_argument('--authority_grid',default='0,.25,.5,.75,1');p.add_argument('--authority_f2_weight',type=float,default=.50);p.add_argument('--authority_mean_weight',type=float,default=.25);p.add_argument('--local_min_ap',type=float,default=.01);p.add_argument('--local_min_f2',type=float,default=0.0);p.add_argument('--local_min_win_fraction',type=float,default=.67)
    p.add_argument('--patience',type=int,default=3);p.add_argument('--val_blocks',type=int,default=3);p.add_argument('--batch_size',type=int,default=512);p.add_argument('--predict_batch_size',type=int,default=2048);p.add_argument('--sampling_beta',type=float,default=.9999);p.add_argument('--samples_per_epoch',type=int,default=250000)
    p.add_argument('--max_semesters',type=int,default=6);p.add_argument('--max_course_neighbors',type=int,default=8);p.add_argument('--max_relation_events',type=int,default=16);p.add_argument('--max_component_events',type=int,default=24);p.add_argument('--raw_chunksize',type=int,default=250000);p.add_argument('--force_raw',action='store_true');p.add_argument('--force_structured',action='store_true');p.add_argument('--skip_alignment_audit',action='store_true')
    p.add_argument('--threshold_beta',type=float,default=2.0);p.add_argument('--min_precision',type=float,default=.15);p.add_argument('--max_warning_ratio',type=float,default=2.5);p.add_argument('--min_flags',type=int,default=5);p.add_argument('--verbose_operational',action='store_true')
    a=p.parse_args();a.dev_folds=parse_ints(a.dev_folds);a.holdout_folds=parse_ints(a.holdout_folds);parse_floats(a.specialist_direct_weights,4);parse_floats(a.authority_grid);return a

def main():
    args=parse_args();folds=args.dev_folds+args.holdout_folds;available=discover_faculties(args.cache_dir,folds[0]);faculties=parse_faculties(args.faculties,available);out=Path(args.models_dir);out.mkdir(parents=True,exist_ok=True);device=device_of(args.device)
    print('='*180);print('SUITE14 — AUTHORITY-SAFE COLLABORATIVE EVIDENCE MoE');print('E0 identity anchor | optional bounded collaboration | no absolute-time gate | temporal authority calibration | E0 frozen after Phase0');print('='*180);print(f'faculties={len(faculties)} folds={folds} device={device} d_model={args.d_model} phases={phase_epochs(args)} authority_grid={args.authority_grid}')
    ensure_structured(args,faculties,folds);records=[];metrics=[];diag=[];rep=[];mech=[]
    for fold in folds:
        rr,mm,dd,rp,mr=run_fold(args,faculties,fold,out,device);records.extend(rr);metrics.extend(mm);diag.extend(dd);rep.extend(rp);mech.extend(mr)
    pd.DataFrame(metrics).to_csv(out/'suite14_fold_metrics.csv',index=False);pd.DataFrame(diag).to_csv(out/'suite14_diagnostics.csv',index=False);pd.DataFrame(rep).to_csv(out/'suite14_representation_cosine.csv',index=False);pd.DataFrame(mech).to_csv(out/'suite14_mechanism_diagnostics.csv',index=False)
    meanf=mean_fold_summary(metrics,args.holdout_folds);meanf.to_csv(out/'suite14_holdout_mean_fold.csv',index=False);warning=operational(records,faculties,args);warning.to_csv(out/'suite14_warning_metrics.csv',index=False);macro=macro_summary(meanf,warning);macro.to_csv(out/'suite14_macro_model_comparison.csv',index=False)
    cols=['model','faculties','mean_fold_ap','mean_fold_auc','mean_fold_precision_at_20','mean_fold_recall_at_20','mean_fold_f1_at_20','mean_fold_f2_at_20','fixed_precision','fixed_recall','fixed_f1','fixed_fbeta','drift_precision','drift_recall','drift_f1','drift_fbeta','drift_tp_total','drift_fn_total','drift_fp_total','drift_tn_total'];print('\nSUITE14 PRIMARY HOLDOUT COMPARISON — SAME EVALUATOR');print(macro[[c for c in cols if c in macro]].to_string(index=False,float_format=lambda x:f'{x:.4f}'))
    pf=args.primary_faculty;mf=meanf[meanf.faculty==pf];po=warning[(warning.faculty==pf)&(warning.fold.astype(str)=='POOLED')]
    if len(mf):
        rows=[]
        for model in sorted(mf.model.unique()):
            r=mf[mf.model==model].iloc[0];z={'model':model,'AP':r.mean_fold_ap,'AUC':r.mean_fold_auc,'P@20':r.mean_fold_precision_at_20,'R@20':r.mean_fold_recall_at_20,'F1@20':r.mean_fold_f1_at_20,'F2@20':r.mean_fold_f2_at_20}
            for pol in ['fixed','drift']:
                d=po[(po.model==model)&(po.policy==pol)]
                if len(d):
                    x=d.iloc[0]
                    for c in ['precision','recall','f1','fbeta','tp','fn','fp','tn']:z[f'{pol}_{c}']=x[c]
            rows.append(z)
        print(f'\nPRIMARY FACULTY COMPARISON — {pf}');print(pd.DataFrame(rows).to_string(index=False,float_format=lambda x:f'{x:.4f}'))
    print_win_rates(meanf,warning,MODEL);(out/'suite14_run_config.json').write_text(json.dumps({'args':vars(args),'faculties':faculties,'architecture':'E0-identity authority-safe collaborative evidence MoE','context_features':context_feature_names()},indent=2,default=str));print(f'\nCompleted. Results: {out}')
if __name__=='__main__':main()
