# -*- coding: utf-8 -*-
"""Suite9 — competitive responsibility residual MoE.

Controlled Experiment D1:
  1) reproduce Suite7 on the chronological training side;
  2) discover residual specialists using sparse detached responsibilities;
  3) freeze specialists and distill those responsibilities into the router;
  4) optionally perform gentle responsibility-based joint refinement;
  5) deploy Suite9 only when temporal validation beats the exact Suite7 baseline;
     otherwise use the exact Suite7 score for that fold.

Committee caches and prior Suite5/7/8 score files are read-only.
"""
from __future__ import annotations

import argparse
import copy
from pathlib import Path

import numpy as np
import pandas as pd
import torch
from torch.utils.data import DataLoader,TensorDataset,WeightedRandomSampler

from suite2_common import safe_ap,safe_auc,equal_budget_metrics
from suite7_common import (
    FeatureStandardizer,load_fold_caches,build_historical_bundle,build_target_bundle,
    faculty_class_sampling_weights,latest_block_split,per_faculty_validation_rows,
    model_selection_score,parse_faculties,save_json,
)
from suite7_eval import evaluate_faculty
from suite7_reporting import (
    load_shared_feature_schema,load_shared_fold_frame,merge_external_references,
)
from suite8_reporting import load_suite7_fold_frame
from suite7_shared_private_moe import SharedPrivateResidualMoE,residual_moe_loss
from suite9_competitive_responsibility_moe import (
    CompetitiveResponsibilityResidualMoE,load_suite7_initialization,
    sparse_competitive_responsibilities,competitive_specialist_loss,
    router_distillation_loss,set_trainable_phase,ownership_diagnostics,
    expert_view_cosine_diagnostics,top_ownership_summary,router_diagnostics,
    adapter_parameter_rows,seed_everything,choose_device,
)
from suite9_diagnostics import (
    responsibility_summary,expert_region_diagnostics,router_responsibility_agreement,
    oracle_responsibility_score,top_budget_transition_counts,
)

BUDGETS=(.10,.15,.20,.25)
COMMITTEE_MODEL='committee'
SHARED_MODEL='residual_moe_shared'
ADAPTER_MODEL='residual_moe_shared_private'
SUITE8_MODEL='residual_moe_true_specialist'
CANDIDATE_MODEL='residual_moe_competitive_candidate'
ORACLE_MODEL='residual_moe_competitive_oracle'
FINAL_MODEL='residual_moe_competitive_final'


def _tensor_loader(bundle,scaler,mask,args,seed,sampled=True):
    mask=np.asarray(mask,bool);X=scaler.transform(bundle.X[mask]);y=bundle.y[mask].astype(np.float32);q=bundle.q[mask].astype(np.float32);f=bundle.faculty_idx[mask].astype(np.int64)
    ds=TensorDataset(torch.from_numpy(X),torch.from_numpy(f),torch.from_numpy(q),torch.from_numpy(y))
    if not sampled:return DataLoader(ds,batch_size=args.predict_batch_size,shuffle=False,num_workers=0)
    w,diag=faculty_class_sampling_weights(bundle.y[mask],bundle.faculty_idx[mask],bundle.faculty_names,args.sampling_beta)
    gen=torch.Generator();gen.manual_seed(int(seed));n=len(ds) if args.samples_per_epoch<=0 else int(args.samples_per_epoch)
    sampler=WeightedRandomSampler(torch.as_tensor(w,dtype=torch.double),num_samples=n,replacement=True,generator=gen)
    return DataLoader(ds,batch_size=args.batch_size,sampler=sampler,num_workers=0),diag


def _checkpoint_info(path):
    return torch.load(Path(path),map_location='cpu',weights_only=False)


def _base_cfg(checkpoint,args):
    c=dict(checkpoint.get('model_config',{}))
    def g(name,default):return c.get(name,getattr(args,name,default))
    return {
        'n_experts':int(g('n_experts',args.n_experts)),
        'faculty_dim':int(g('faculty_dim',args.faculty_dim)),
        'encoder_hidden':int(g('encoder_hidden',args.encoder_hidden)),
        'representation_dim':int(g('representation_dim',args.representation_dim)),
        'expert_hidden':int(g('expert_hidden',args.expert_hidden)),
        'delta_max':float(g('delta_max',args.delta_max)),
        'dropout':float(g('dropout',args.dropout)),
        'router_temperature':float(g('router_temperature',args.router_temperature)),
        'adapter_dim':int(g('adapter_dim',args.adapter_dim)),
        'adapter_dropout':float(g('adapter_dropout',args.adapter_dropout)),
        'adapter_scale':float(g('adapter_scale',args.adapter_scale)),
    }


def _make_suite7_model(input_dim,n_faculties,cfg):
    return SharedPrivateResidualMoE(input_dim=input_dim,n_faculties=n_faculties,**cfg)


def _make_suite9_model(input_dim,n_faculties,cfg,args):
    return CompetitiveResponsibilityResidualMoE(
        input_dim=input_dim,n_faculties=n_faculties,**cfg,
        view_temperature=args.view_temperature,view_strength=args.view_strength,
        view_init_std=args.view_init_std,
    )


def _train_suite7_epoch(model,loader,opt,device,args):
    model.train();acc=0.;n=0
    for X,f,q,y in loader:
        X=X.to(device);f=f.to(device);q=q.to(device);y=y.to(device);opt.zero_grad(set_to_none=True);out=model(X,f,q)
        ls=residual_moe_loss(out,y,q,router_lambda=args.baseline_router_lambda,
            specialization_lambda=args.baseline_specialization_lambda,
            magnitude_lambda=args.baseline_magnitude_lambda,
            utility_temperature=args.baseline_utility_temperature)
        ls['total'].backward();torch.nn.utils.clip_grad_norm_(model.parameters(),args.grad_clip);opt.step();b=len(y);n+=b;acc+=float(ls['total'].detach().cpu())*b
    return acc/max(n,1)


def _reproduce_suite7_train_state(bundle,tr,scaler,args,seed,epochs,cfg,device,label):
    seed_everything(seed);model=_make_suite7_model(bundle.X.shape[1],len(bundle.faculty_names),cfg).to(device)
    opt=torch.optim.AdamW(model.parameters(),lr=args.lr,weight_decay=args.weight_decay)
    for ep in range(1,max(int(epochs),1)+1):
        loader,_=_tensor_loader(bundle,scaler,tr,args,seed+ep*997,sampled=True);loss=_train_suite7_epoch(model,loader,opt,device,args)
        if ep==1 or ep==epochs:print(f'[{label}] reproduced Suite7 epoch={ep}/{epochs} loss={loss:.5f}')
    return model


def _suite9_from_base_model(base,bundle,args,seed,cfg,device):
    # New view parameters are deterministic but do not perturb the already-fitted Suite7 state.
    seed_everything(seed+9109);m=_make_suite9_model(bundle.X.shape[1],len(bundle.faculty_names),cfg,args).to(device)
    result=m.load_state_dict(base.state_dict(),strict=False)
    if set(result.missing_keys)!={'view_logits'} or result.unexpected_keys:
        raise RuntimeError(f'could not initialize Suite9 from reproduced Suite7: missing={result.missing_keys} unexpected={result.unexpected_keys}')
    return m


def _phase_train_mode(model,phase):
    if phase=='discovery':
        # Keep the fitted Suite7 representation and expert utilities deterministic.
        # Gradients still flow in eval mode; only stochastic dropout is disabled.
        model.eval()
    elif phase=='router':
        model.eval();model.router.train()
    elif phase=='joint':model.train()
    else:raise ValueError(phase)


def _discovery_epoch(model,loader,opt,device,args):
    _phase_train_mode(model,'discovery');acc={'total':0.,'expert_prediction':0.,'magnitude':0.,'view_entropy':0.,'view_balance':0.};n=0
    for X,f,q,y in loader:
        X=X.to(device);f=f.to(device);q=q.to(device);y=y.to(device);opt.zero_grad(set_to_none=True);out=model(X,f,q)
        ls=competitive_specialist_loss(out,y,q,responsibility_temperature=args.responsibility_temperature,
            responsibility_top_k=args.responsibility_top_k,min_expert_utility=args.min_expert_utility,
            magnitude_lambda=args.magnitude_lambda,view_entropy_lambda=args.view_entropy_lambda,
            view_balance_lambda=args.view_balance_lambda)
        ls['total'].backward();torch.nn.utils.clip_grad_norm_(set_trainable_phase(model,'discovery'),args.grad_clip);opt.step();b=len(y);n+=b
        for k in acc:acc[k]+=float(ls[k].detach().cpu())*b
    return {k:v/max(n,1) for k,v in acc.items()}


def _router_epoch(model,loader,opt,device,args):
    _phase_train_mode(model,'router');acc=0.;n=0
    for X,f,q,y in loader:
        X=X.to(device);f=f.to(device);q=q.to(device);y=y.to(device);opt.zero_grad(set_to_none=True);out=model(X,f,q)
        ls=router_distillation_loss(out,y,q,args.responsibility_temperature,args.responsibility_top_k,args.min_expert_utility)
        ls['total'].backward();torch.nn.utils.clip_grad_norm_(set_trainable_phase(model,'router'),args.grad_clip);opt.step();b=len(y);n+=b;acc+=float(ls['total'].detach().cpu())*b
    return acc/max(n,1)


def _joint_epoch(model,loader,opt,device,args):
    _phase_train_mode(model,'joint');acc=0.;n=0
    for X,f,q,y in loader:
        X=X.to(device);f=f.to(device);q=q.to(device);y=y.to(device);opt.zero_grad(set_to_none=True);out=model(X,f,q)
        a=competitive_specialist_loss(out,y,q,responsibility_temperature=args.responsibility_temperature,
            responsibility_top_k=args.responsibility_top_k,min_expert_utility=args.min_expert_utility,
            magnitude_lambda=args.magnitude_lambda,view_entropy_lambda=args.view_entropy_lambda,
            view_balance_lambda=args.view_balance_lambda)
        b=router_distillation_loss(out,y,q,args.responsibility_temperature,args.responsibility_top_k,args.min_expert_utility)
        total=a['total']+args.joint_router_lambda*b['total'];total.backward();torch.nn.utils.clip_grad_norm_(set_trainable_phase(model,'joint'),args.grad_clip);opt.step();bs=len(y);n+=bs;acc+=float(total.detach().cpu())*bs
    return acc/max(n,1)


@torch.no_grad()
def predict_bundle(model,bundle,scaler,mask,device,args,with_labels=True):
    model.eval();loader=_tensor_loader(bundle,scaler,mask,args,0,sampled=False)
    ps=[];ws=[];rs=[];cfs=[];cs=[];views=[];shared=[];adapt=[];aout=[]
    for X,f,q,y in loader:
        out=model(X.to(device),f.to(device),q.to(device));ps.append(out['final_prob'].cpu().numpy());ws.append(out['weights'].cpu().numpy());rs.append(out['residuals'].cpu().numpy());cfs.append(out['counterfactual_prob'].cpu().numpy());cs.append(out['correction'].cpu().numpy());views.append(out['expert_views'].cpu().numpy());shared.append(out['shared_representation'].cpu().numpy());adapt.append(out['adapted_representation'].cpu().numpy());aout.append(out['adapter_output'].cpu().numpy())
    if not ps:return {'p':np.array([]),'weights':np.empty((0,args.n_experts+1)),'residuals':np.empty((0,args.n_experts)),'counterfactual_prob':np.empty((0,args.n_experts)),'correction':np.array([])}
    p=np.concatenate(ps);w=np.concatenate(ws);r=np.concatenate(rs);cf=np.concatenate(cfs);v=np.concatenate(views);h=np.concatenate(shared);hf=np.concatenate(adapt);ao=np.concatenate(aout)
    own=model.view_ownership().detach().cpu().numpy();od=ownership_diagnostics(own);vd=expert_view_cosine_diagnostics(v)
    return {'p':p,'weights':w,'residuals':r,'counterfactual_prob':cf,'correction':np.concatenate(cs),'expert_views':v,'view_ownership':own,**od,**vd,
            'shared_representation':h,'adapted_representation':hf,'adapter_output':ao}


def _np_responsibilities(y,q,cf,args):
    with torch.no_grad():
        r,u,_=sparse_competitive_responsibilities(torch.as_tensor(y,dtype=torch.float32),torch.as_tensor(q,dtype=torch.float32),torch.as_tensor(cf,dtype=torch.float32),args.responsibility_temperature,args.responsibility_top_k,args.min_expert_utility)
    return r.cpu().numpy(),u.cpu().numpy()


def _mean_residual_corr(r):
    r=np.asarray(r,float)
    if r.ndim!=2 or len(r)<3 or r.shape[1]<2:return np.nan
    c=np.corrcoef(r,rowvar=False);v=c[np.triu_indices(c.shape[0],1)];v=v[np.isfinite(v)]
    return float(v.mean()) if len(v) else np.nan


def _selection_vs_baseline(y,baseline,candidate,faculty_idx,faculty_names,args):
    rows=per_faculty_validation_rows(y,baseline,candidate,faculty_idx,faculty_names,args.threshold_beta,.20)
    score,macro=model_selection_score(rows,args.macro_f2_weight)
    return float(score),macro,rows


def _discovery_diagnostics(bundle,mask,pred,args):
    y=bundle.y[mask];q=bundle.q[mask];resp,util=_np_responsibilities(y,q,pred['counterfactual_prob'],args);oracle=oracle_responsibility_score(q,pred['residuals'],resp)
    rd=responsibility_summary(resp,y,bundle.support_history_semesters[mask]);rc=_mean_residual_corr(pred['residuals'])
    return resp,util,oracle,rd,rc


def _fit_phases_validation(bundle,tr,va,args,seed,cfg,suite7_epochs,device,label):
    scaler=FeatureStandardizer.fit(bundle.X[tr])
    base=_reproduce_suite7_train_state(bundle,tr,scaler,args,seed,suite7_epochs,cfg,device,label+'-base')
    base_pred=predict_suite7(base,bundle,scaler,va,device,args)
    model=_suite9_from_base_model(base,bundle,args,seed,cfg,device)

    # Phase 1: discover experts; selection is based only on diagnostic oracle potential.
    set_trainable_phase(model,'discovery');opt=torch.optim.AdamW([p for p in model.parameters() if p.requires_grad],lr=args.discovery_lr,weight_decay=args.weight_decay)
    best_disc_score=-np.inf;best_disc_epoch=1;best_disc_state=copy.deepcopy(model.state_dict());disc_hist=[];pat=0
    for ep in range(1,args.discovery_epochs+1):
        loader,_=_tensor_loader(bundle,scaler,tr,args,seed+20000+ep*977,sampled=True);loss=_discovery_epoch(model,loader,opt,device,args);pred=predict_bundle(model,bundle,scaler,va,device,args);resp,util,oracle,rd,rc=_discovery_diagnostics(bundle,va,pred,args);score,macro,_=_selection_vs_baseline(bundle.y[va],base_pred['p'],oracle,bundle.faculty_idx[va],bundle.faculty_names,args)
        row={'phase':'discovery','epoch':ep,'selection_score':score,**loss,**macro,**rd,'residual_correlation':rc,'ownership_entropy':pred['normalized_ownership_entropy'],'ownership_cosine':pred['mean_pairwise_ownership_cosine'],'view_cosine':pred['mean_pairwise_view_cosine']};disc_hist.append(row)
        if ep==1 or ep%args.print_every==0:print(f'[{label} DISC] ep={ep:02d} loss={loss["total"]:.5f} oracle_sel={score:+.5f} medΔAP={macro["median_delta_ap"]:+.4f} medΔF2={macro["median_delta_f2_20"]:+.4f} NULLresp={rd["responsibility_mass_null"]:.3f} RespH={rd["normalized_responsibility_entropy"]:.3f} Rcorr={rc:.3f} OwnH={pred["normalized_ownership_entropy"]:.3f} ViewCos={pred["mean_pairwise_view_cosine"]:.3f}')
        if np.isfinite(score) and score>best_disc_score+args.discovery_min_improvement:
            best_disc_score=score;best_disc_epoch=ep;best_disc_state=copy.deepcopy(model.state_dict());pat=0
        else:pat+=1
        if ep>=args.discovery_min_epochs and pat>=args.discovery_patience:break
    model.load_state_dict(best_disc_state)

    # Phase 2: distill frozen responsibilities into router. Selection is deployable vs Suite7.
    set_trainable_phase(model,'router');opt=torch.optim.AdamW([p for p in model.parameters() if p.requires_grad],lr=args.router_lr,weight_decay=args.weight_decay)
    best_router_score=-np.inf;best_router_epoch=0;best_router_state=copy.deepcopy(model.state_dict());router_hist=[];pat=0
    # Evaluate epoch 0 as a legitimate candidate.
    for ep in range(0,args.router_epochs+1):
        if ep>0:
            loader,_=_tensor_loader(bundle,scaler,tr,args,seed+40000+ep*991,sampled=True);rkl=_router_epoch(model,loader,opt,device,args)
        else:rkl=np.nan
        pred=predict_bundle(model,bundle,scaler,va,device,args);resp,util,oracle,rd,rc=_discovery_diagnostics(bundle,va,pred,args);agree=router_responsibility_agreement(pred['weights'],resp);score,macro,_=_selection_vs_baseline(bundle.y[va],base_pred['p'],pred['p'],bundle.faculty_idx[va],bundle.faculty_names,args)
        row={'phase':'router','epoch':ep,'router_kl_loss':rkl,'selection_score':score,**macro,**agree,**rd,'residual_correlation':rc,'oracle_ap':safe_ap(bundle.y[va],oracle),'learned_ap':safe_ap(bundle.y[va],pred['p'])};router_hist.append(row)
        if ep==0 or ep==1 or ep%args.print_every==0:print(f'[{label} ROUTER] ep={ep:02d} KL={rkl if np.isfinite(rkl) else float("nan"):.5f} deploy_sel={score:+.5f} medΔAP={macro["median_delta_ap"]:+.4f} medΔF2={macro["median_delta_f2_20"]:+.4f} Acc={agree["router_target_top1_accuracy"]:.3f} targetKL={agree["router_target_kl"]:.3f} NULLresp={rd["responsibility_mass_null"]:.3f}')
        if np.isfinite(score) and score>best_router_score+args.router_min_improvement:
            best_router_score=score;best_router_epoch=ep;best_router_state=copy.deepcopy(model.state_dict());pat=0
        else:pat+=1
        if ep>=args.router_min_epochs and pat>=args.router_patience:break
    model.load_state_dict(best_router_state)
    best_joint_epoch=0;best_final_score=best_router_score;best_final_state=copy.deepcopy(best_router_state);joint_hist=[]

    if args.joint_refine_epochs>0:
        set_trainable_phase(model,'joint');opt=torch.optim.AdamW([p for p in model.parameters() if p.requires_grad],lr=args.joint_lr,weight_decay=args.weight_decay)
        for ep in range(1,args.joint_refine_epochs+1):
            loader,_=_tensor_loader(bundle,scaler,tr,args,seed+60000+ep*997,sampled=True);loss=_joint_epoch(model,loader,opt,device,args);pred=predict_bundle(model,bundle,scaler,va,device,args);resp,_,_,rd,rc=_discovery_diagnostics(bundle,va,pred,args);agree=router_responsibility_agreement(pred['weights'],resp);score,macro,_=_selection_vs_baseline(bundle.y[va],base_pred['p'],pred['p'],bundle.faculty_idx[va],bundle.faculty_names,args);joint_hist.append({'phase':'joint','epoch':ep,'loss':loss,'selection_score':score,**macro,**agree,**rd,'residual_correlation':rc})
            if ep==1 or ep%args.print_every==0:print(f'[{label} JOINT] ep={ep:02d} loss={loss:.5f} deploy_sel={score:+.5f} medΔAP={macro["median_delta_ap"]:+.4f} medΔF2={macro["median_delta_f2_20"]:+.4f}')
            if np.isfinite(score) and score>best_final_score+args.joint_min_improvement:
                best_final_score=score;best_joint_epoch=ep;best_final_state=copy.deepcopy(model.state_dict())
        model.load_state_dict(best_final_state)

    deploy=bool(np.isfinite(best_final_score) and best_final_score>args.min_selection_improvement)
    print(f'[{label}] selected discovery={best_disc_epoch} router={best_router_epoch} joint={best_joint_epoch} deploy_sel={best_final_score:+.5f} -> {"SUITE9" if deploy else "EXACT SUITE7 FALLBACK"}')
    history=pd.DataFrame(disc_hist+router_hist+joint_hist)
    return {'discovery_epoch':best_disc_epoch,'router_epoch':best_router_epoch,'joint_epoch':best_joint_epoch,'deploy':deploy,'selection_score':best_final_score,'history':history,'scaler':scaler}


@torch.no_grad()
def predict_suite7(model,bundle,scaler,mask,device,args):
    model.eval();loader=_tensor_loader(bundle,scaler,mask,args,0,sampled=False);ps=[]
    for X,f,q,_ in loader:ps.append(model(X.to(device),f.to(device),q.to(device))['final_prob'].cpu().numpy())
    return {'p':np.concatenate(ps) if ps else np.array([])}


def _full_refit(bundle,args,seed,cfg,suite7_checkpoint,selected,device,label):
    scaler=FeatureStandardizer.fit(bundle.X);seed_everything(seed+9109);model=_make_suite9_model(bundle.X.shape[1],len(bundle.faculty_names),cfg,args).to(device);load_suite7_initialization(model,suite7_checkpoint,bundle.faculty_names)
    mask=np.ones(len(bundle.y),bool)
    set_trainable_phase(model,'discovery');opt=torch.optim.AdamW([p for p in model.parameters() if p.requires_grad],lr=args.discovery_lr,weight_decay=args.weight_decay)
    for ep in range(1,selected['discovery_epoch']+1):
        loader,_=_tensor_loader(bundle,scaler,mask,args,seed+20000+ep*977,sampled=True);loss=_discovery_epoch(model,loader,opt,device,args)
        if ep==1 or ep==selected['discovery_epoch']:print(f'[{label} REFIT-DISC] ep={ep}/{selected["discovery_epoch"]} loss={loss["total"]:.5f}')
    set_trainable_phase(model,'router');opt=torch.optim.AdamW([p for p in model.parameters() if p.requires_grad],lr=args.router_lr,weight_decay=args.weight_decay)
    for ep in range(1,selected['router_epoch']+1):
        loader,_=_tensor_loader(bundle,scaler,mask,args,seed+40000+ep*991,sampled=True);loss=_router_epoch(model,loader,opt,device,args)
        if ep==1 or ep==selected['router_epoch']:print(f'[{label} REFIT-ROUTER] ep={ep}/{selected["router_epoch"]} KL={loss:.5f}')
    if selected['joint_epoch']>0:
        set_trainable_phase(model,'joint');opt=torch.optim.AdamW([p for p in model.parameters() if p.requires_grad],lr=args.joint_lr,weight_decay=args.weight_decay)
        for ep in range(1,selected['joint_epoch']+1):
            loader,_=_tensor_loader(bundle,scaler,mask,args,seed+60000+ep*997,sampled=True);loss=_joint_epoch(model,loader,opt,device,args)
            if ep==1 or ep==selected['joint_epoch']:print(f'[{label} REFIT-JOINT] ep={ep}/{selected["joint_epoch"]} loss={loss:.5f}')
    return model,scaler



def apply_deployment_fallback(candidate,adapter,deploy:bool):
    candidate=np.asarray(candidate,float);adapter=np.asarray(adapter,float)
    if candidate.shape!=adapter.shape:raise ValueError('candidate and adapter scores must align')
    return candidate.copy() if bool(deploy) else adapter.copy()


def _load_suite8_score(suite8_results_dir,fold,faculty,y,q,atol):
    if not suite8_results_dir:return None
    p=Path(suite8_results_dir)/f'fold_{fold}'/f'{faculty}_scores.csv'
    if not p.exists():return None
    df=pd.read_csv(p)
    if SUITE8_MODEL not in df:return None
    if len(df)!=len(y) or not np.array_equal(df.actual.to_numpy(int),np.asarray(y,int)):raise ValueError(f'Suite8 alignment mismatch {faculty} fold {fold}')
    if not np.allclose(df.committee.to_numpy(float),np.asarray(q,float),atol=atol,rtol=1e-5):raise ValueError(f'Suite8 committee alignment mismatch {faculty} fold {fold}')
    return df[SUITE8_MODEL].to_numpy(float)


def _load_reference_scores(shared_dir,s7_dir,s8_dir,fold,target,args):
    shared=[];adapter=[];s8=[];has8=True
    for fi,faculty in enumerate(target.faculty_names):
        m=target.faculty_idx==fi
        sf=load_shared_fold_frame(shared_dir,fold,faculty,target.y[m],target.q[m],args.reference_alignment_atol)
        af=load_suite7_fold_frame(s7_dir,fold,faculty,target.y[m],target.q[m],args.reference_alignment_atol)
        shared.append(sf[SHARED_MODEL].to_numpy(float));adapter.append(af[ADAPTER_MODEL].to_numpy(float))
        z=_load_suite8_score(s8_dir,fold,faculty,target.y[m],target.q[m],args.reference_alignment_atol)
        if z is None:has8=False
        else:s8.append(z)
    return np.concatenate(shared),np.concatenate(adapter),(np.concatenate(s8) if has8 else None)


def _metric_rows(fold,target,scores,args):
    rows=[]
    for fi,faculty in enumerate(target.faculty_names):
        m=target.faculty_idx==fi;y=target.y[m]
        for model,s in scores.items():
            if s is None:continue
            ss=np.asarray(s)[m];row={'fold':fold,'faculty':faculty,'model':model,'rows':int(m.sum()),'failures':int(y.sum()),'prevalence':float(y.mean()),'ap':safe_ap(y,ss),'auc':safe_auc(y,ss)}
            for b in BUDGETS:
                z=equal_budget_metrics(y,ss,b,args.threshold_beta);tag=int(b*100);row[f'precision_at_{tag}']=z['precision'];row[f'recall_at_{tag}']=z['recall'];row[f'f1_at_{tag}']=z['f1'];row[f'f2_at_{tag}']=z['fbeta']
            rows.append(row)
    return rows


def _residual_corr_rows(fold,target,res):
    rows=[]
    for fi,faculty in enumerate(target.faculty_names):
        m=target.faculty_idx==fi
        if m.sum()<3:continue
        c=np.corrcoef(res[m],rowvar=False)
        for i in range(c.shape[0]):
            for j in range(i+1,c.shape[1]):rows.append({'fold':fold,'faculty':faculty,'expert_i':i+1,'expert_j':j+1,'correlation':float(c[i,j]) if np.isfinite(c[i,j]) else np.nan})
    return rows


def run_fold(args,faculties,fold,out):
    print('\n'+'='*170);print(f'SUITE9 COMPETITIVE RESPONSIBILITY | TARGET FOLD {fold}');print('='*170)
    schema=load_shared_feature_schema(args.shared_results_dir,fold);common=list(schema['common_raw_features']);caches=load_fold_caches(args.cache_dir,faculties,fold);hist=build_historical_bundle(caches,faculties,common);target=build_target_bundle(caches,faculties,common)
    if schema.get('shared_feature_names') and list(schema['shared_feature_names'])!=list(hist.feature_names):raise ValueError(f'fold {fold}: feature schema mismatch')
    shared_score,adapter_score,suite8_score=_load_reference_scores(args.shared_results_dir,args.suite7_results_dir,args.suite8_results_dir,fold,target,args)
    ckpt_path=Path(args.suite7_results_dir)/f'fold_{fold}'/'shared_private_model.pt'
    if not ckpt_path.exists():raise FileNotFoundError(f'missing Suite7 checkpoint required for Suite9: {ckpt_path}')
    ckpt=_checkpoint_info(ckpt_path);cfg=_base_cfg(ckpt,args);suite7_epochs=max(int(ckpt.get('selected_epoch') or 1),1);seed=args.seed+fold*100003;device=choose_device(args.device)
    tr,va=latest_block_split(hist.faculty_idx,hist.blocks,args.val_blocks)
    if tr.sum()<args.min_train_rows:raise RuntimeError(f'fold {fold}: only {tr.sum()} chronological train rows')
    print(f'[DATA] common={len(common)} inputs={hist.X.shape[1]} OOF={len(hist.y):,} failures={int(hist.y.sum()):,} ({hist.y.mean():.2%}) target={len(target.y):,} | Suite7 init epoch={suite7_epochs} train={tr.sum():,} val={va.sum():,}')
    fold_dir=out/f'fold_{fold}';fold_dir.mkdir(parents=True,exist_ok=True);save_json({'fold':fold,'faculties':faculties,'common_raw_features':common,'shared_feature_names':hist.feature_names,'suite7_checkpoint':str(ckpt_path),'suite7_selected_epoch':suite7_epochs,'base_model_config':cfg,'responsibility_top_k':args.responsibility_top_k,'responsibility_temperature':args.responsibility_temperature,'min_expert_utility':args.min_expert_utility},fold_dir/'feature_schema.json')
    if va.sum()>=args.min_val_rows:
        selected=_fit_phases_validation(hist,tr,va,args,seed,cfg,suite7_epochs,device,f'F{fold}')
    else:
        print(f'[F{fold}] insufficient validation ({va.sum():,}); candidate will be trained for fixed epochs but deployment falls back to Suite7')
        selected={'discovery_epoch':args.fallback_discovery_epochs,'router_epoch':args.fallback_router_epochs,'joint_epoch':0,'deploy':False,'selection_score':np.nan,'history':pd.DataFrame([{'phase':'fallback','epoch':0,'selection_score':np.nan}])}
    selected['history'].to_csv(fold_dir/'phase_training_history.csv',index=False)
    model,scaler=_full_refit(hist,args,seed,cfg,ckpt_path,selected,device,f'F{fold}');scaler.save(fold_dir/'suite9_scaler.npz')
    torch.save({'state_dict':model.state_dict(),'selected':{k:selected[k] for k in ['discovery_epoch','router_epoch','joint_epoch','deploy','selection_score']},'model_config':cfg|{'view_temperature':args.view_temperature,'view_strength':args.view_strength,'view_init_std':args.view_init_std},'faculties':faculties,'common_raw_features':common},fold_dir/'competitive_responsibility_model.pt')
    pred=predict_bundle(model,target,scaler,np.ones(len(target.y),bool),device,args);resp,util=_np_responsibilities(target.y,target.q,pred['counterfactual_prob'],args);oracle=oracle_responsibility_score(target.q,pred['residuals'],resp);candidate=pred['p'];final=apply_deployment_fallback(candidate,adapter_score,selected['deploy'])
    scores={COMMITTEE_MODEL:target.q,SHARED_MODEL:shared_score,ADAPTER_MODEL:adapter_score,CANDIDATE_MODEL:candidate,ORACLE_MODEL:oracle,FINAL_MODEL:final}
    if suite8_score is not None:scores[SUITE8_MODEL]=suite8_score
    metrics=_metric_rows(fold,target,scores,args);records=[];resp_rows=[];region_rows=[];agree_rows=[];gap_rows=[];trans_rows=[]
    for fi,faculty in enumerate(faculties):
        m=target.faculty_idx==fi;y=target.y[m];r=resp[m];w=pred['weights'][m];cf=pred['counterfactual_prob'][m];q=target.q[m]
        rs=responsibility_summary(r,y,target.support_history_semesters[m]);agree=router_responsibility_agreement(w,r);rs.update({'fold':fold,'faculty':faculty,'rows':int(m.sum()),'failures':int(y.sum()),'deploy':selected['deploy']});resp_rows.append(rs);agree_rows.append({'fold':fold,'faculty':faculty,**agree})
        for z in expert_region_diagnostics(y,q,cf,r):z.update({'fold':fold,'faculty':faculty});region_rows.append(z)
        om=equal_budget_metrics(y,oracle[m],.20,args.threshold_beta);lm=equal_budget_metrics(y,candidate[m],.20,args.threshold_beta);am=equal_budget_metrics(y,adapter_score[m],.20,args.threshold_beta)
        gap_rows.append({'fold':fold,'faculty':faculty,'oracle_ap':safe_ap(y,oracle[m]),'learned_ap':safe_ap(y,candidate[m]),'adapter_ap':safe_ap(y,adapter_score[m]),'oracle_auc':safe_auc(y,oracle[m]),'learned_auc':safe_auc(y,candidate[m]),'oracle_f2_20':om['fbeta'],'learned_f2_20':lm['fbeta'],'adapter_f2_20':am['fbeta'],'oracle_minus_learned_ap':safe_ap(y,oracle[m])-safe_ap(y,candidate[m]),'oracle_minus_learned_f2_20':om['fbeta']-lm['fbeta'],**agree})
        trn=top_budget_transition_counts(y,adapter_score[m],candidate[m],.20);trn.update({'fold':fold,'faculty':faculty,'comparison':'candidate_vs_suite7'});trans_rows.append(trn);trf=top_budget_transition_counts(y,adapter_score[m],final[m],.20);trf.update({'fold':fold,'faculty':faculty,'comparison':'final_vs_suite7'});trans_rows.append(trf)
        frame=pd.DataFrame({'actual':y,'committee':q,SHARED_MODEL:shared_score[m],ADAPTER_MODEL:adapter_score[m],CANDIDATE_MODEL:candidate[m],ORACLE_MODEL:oracle[m],FINAL_MODEL:final[m],'suite9_deployed':int(selected['deploy']),'history_semesters':target.support_history_semesters[m],'correction_logit':pred['correction'][m]})
        if suite8_score is not None:frame[SUITE8_MODEL]=suite8_score[m]
        for j in range(w.shape[1]):frame[f'weight_{"null" if j==0 else f"expert_{j}"}']=w[:,j];frame[f'responsibility_{"null" if j==0 else f"expert_{j}"}']=r[:,j]
        for j in range(pred['residuals'].shape[1]):frame[f'residual_expert_{j+1}']=pred['residuals'][m,j];frame[f'utility_expert_{j+1}']=util[m,j]
        frame.to_csv(fold_dir/f'{faculty}_scores.csv',index=False);records.append({'faculty':faculty,'fold':fold,'y':y,'scores':{k:np.asarray(v)[m] for k,v in scores.items() if k!=ORACLE_MODEL},'fallback':not selected['deploy']})
        mm={x['model']:x for x in metrics if x['faculty']==faculty};s8ap=mm[SUITE8_MODEL]['ap'] if SUITE8_MODEL in mm else np.nan
        print(f'[TARGET {faculty}] AP C/S/A/8/9c/9f={mm[COMMITTEE_MODEL]["ap"]:.4f}/{mm[SHARED_MODEL]["ap"]:.4f}/{mm[ADAPTER_MODEL]["ap"]:.4f}/{s8ap:.4f}/{mm[CANDIDATE_MODEL]["ap"]:.4f}/{mm[FINAL_MODEL]["ap"]:.4f} | F2@20 A/9c/9f={mm[ADAPTER_MODEL]["f2_at_20"]:.4f}/{mm[CANDIDATE_MODEL]["f2_at_20"]:.4f}/{mm[FINAL_MODEL]["f2_at_20"]:.4f} | OracleAP={mm[ORACLE_MODEL]["ap"]:.4f} RespNULL={rs["responsibility_mass_null"]:.3f} RouterAcc={agree["router_target_top1_accuracy"]:.3f} Rcorr={_mean_residual_corr(pred["residuals"][m]):.3f} deploy={selected["deploy"]}')
    own=ownership_diagnostics(pred['view_ownership']);print(f'[F{fold} OWNERSHIP] OwnH={own["normalized_ownership_entropy"]:.3f} OwnCos={own["mean_pairwise_ownership_cosine"]:.3f} ViewCos={pred["mean_pairwise_view_cosine"]:.3f} Rcorr={_mean_residual_corr(pred["residuals"]):.3f} | {top_ownership_summary(model,args.top_owned_dims)}')
    pd.DataFrame(metrics).to_csv(fold_dir/'fold_metrics.csv',index=False);pd.DataFrame(resp_rows).to_csv(fold_dir/'responsibility_diagnostics.csv',index=False);pd.DataFrame(region_rows).to_csv(fold_dir/'expert_region_diagnostics.csv',index=False);pd.DataFrame(agree_rows).to_csv(fold_dir/'router_agreement.csv',index=False);pd.DataFrame(gap_rows).to_csv(fold_dir/'oracle_gap.csv',index=False);pd.DataFrame(trans_rows).to_csv(fold_dir/'transfer_at20.csv',index=False);pd.DataFrame(_residual_corr_rows(fold,target,pred['residuals'])).to_csv(fold_dir/'residual_correlations.csv',index=False);pd.DataFrame(adapter_parameter_rows(model,faculties)).to_csv(fold_dir/'adapter_parameter_norms.csv',index=False)
    summary={'fold':fold,'discovery_epoch':selected['discovery_epoch'],'router_epoch':selected['router_epoch'],'joint_epoch':selected['joint_epoch'],'deploy':selected['deploy'],'selection_score':selected['selection_score'],'suite7_selected_epoch':suite7_epochs,**own,'mean_pairwise_view_cosine':pred['mean_pairwise_view_cosine'],'mean_residual_correlation':_mean_residual_corr(pred['residuals'])}
    return records,metrics,resp_rows,region_rows,agree_rows,gap_rows,trans_rows,_residual_corr_rows(fold,target,pred['residuals']),summary


def pooled_ranking_rows(records,holdout_folds,args):
    rows=[]
    for faculty in sorted({r['faculty'] for r in records}):
        rr=[r for r in records if r['faculty']==faculty and r['fold'] in holdout_folds]
        if not rr:continue
        y=np.concatenate([r['y'] for r in rr]);models=set.intersection(*[set(r['scores']) for r in rr])
        for model in sorted(models):
            s=np.concatenate([r['scores'][model] for r in rr]);row={'faculty':faculty,'model':model,'rows':len(y),'failures':int(y.sum()),'prevalence':float(y.mean()),'ap':safe_ap(y,s),'auc':safe_auc(y,s)}
            for b in BUDGETS:
                z=equal_budget_metrics(y,s,b,args.threshold_beta);tag=int(b*100);row[f'precision_at_{tag}']=z['precision'];row[f'recall_at_{tag}']=z['recall'];row[f'f1_at_{tag}']=z['f1'];row[f'f2_at_{tag}']=z['fbeta']
            rows.append(row)
    return pd.DataFrame(rows)


def operational_summary(records,faculties,args,out):
    all_rows=[];policies=[];models=[COMMITTEE_MODEL,SHARED_MODEL,ADAPTER_MODEL]
    if any(SUITE8_MODEL in r['scores'] for r in records):models.append(SUITE8_MODEL)
    models += [CANDIDATE_MODEL,FINAL_MODEL]
    print('\n'+'='*170);print('SUITE9 OFFICIAL OPERATIONAL EVALUATION — DEVELOPMENT POLICIES FROZEN BEFORE HOLDOUT');print('='*170)
    for faculty in faculties:
        for model in models:
            pol,rows=evaluate_faculty(records,faculty,model,args.dev_folds,args.holdout_folds,args.threshold_beta,args.min_precision,args.max_warning_ratio,args.min_flags,verbose=True)
            policies.append({'faculty':faculty,'model':model,'threshold':pol.threshold,'warning_ratio':pol.warning_ratio,'development_ap':pol.development_ap,'development_auc':pol.development_auc,'development_prevalence':pol.development_prevalence,'development_flag_rate':pol.flag_rate,'development_precision':pol.precision,'development_recall':pol.recall,'development_f1':pol.f1,'development_f2':pol.fbeta,'constraints_relaxed':pol.constraints_relaxed});all_rows.extend(rows)
    w=pd.DataFrame(all_rows);p=pd.DataFrame(policies);w.to_csv(out/'suite9_warning_metrics.csv',index=False);p.to_csv(out/'suite9_threshold_policies.csv',index=False);return w,p


def _get(df,faculty,model,col):
    d=df[(df.faculty==faculty)&(df.model==model)]
    return float(d.iloc[0][col]) if len(d) and col in d else np.nan


def build_comparison(pooled,warning,records,holdout_folds):
    po=warning[warning.fold.astype(str)=='POOLED'];fixed=po[po.policy=='fixed'];drift=po[po.policy=='drift'];rows=[]
    for f in sorted(pooled.faculty.unique()):
        row={'faculty':f}
        for model,short in [(COMMITTEE_MODEL,'committee'),(SHARED_MODEL,'shared'),(ADAPTER_MODEL,'adapter'),(SUITE8_MODEL,'suite8'),(CANDIDATE_MODEL,'suite9_candidate'),(FINAL_MODEL,'suite9_final')]:
            row[f'{short}_ap']=_get(pooled,f,model,'ap');row[f'{short}_auc']=_get(pooled,f,model,'auc');row[f'{short}_f2_20']=_get(pooled,f,model,'f2_at_20');row[f'{short}_fixed_f2']=_get(fixed,f,model,'fbeta');row[f'{short}_drift_f2']=_get(drift,f,model,'fbeta')
        row['candidate_minus_adapter_ap']=row['suite9_candidate_ap']-row['adapter_ap'];row['suite9_minus_adapter_ap']=row['suite9_final_ap']-row['adapter_ap'];row['suite9_minus_adapter_f2_20']=row['suite9_final_f2_20']-row['adapter_f2_20'];row['suite9_minus_adapter_fixed_f2']=row['suite9_final_fixed_f2']-row['adapter_fixed_f2'];row['suite9_minus_adapter_drift_f2']=row['suite9_final_drift_f2']-row['adapter_drift_f2']
        rr=[r for r in records if r['faculty']==f and r['fold'] in holdout_folds];row['fallback_rate']=float(np.mean([r['fallback'] for r in rr])) if rr else np.nan
        votes=[row['suite9_minus_adapter_ap'],row['suite9_minus_adapter_f2_20'],row['suite9_minus_adapter_drift_f2']];nw=sum(x>1e-6 for x in votes if np.isfinite(x));aw=sum(x<-1e-6 for x in votes if np.isfinite(x));row['evidence_pattern']='SUITE9_STRONGER' if nw>=2 else ('SUITE7_STRONGER' if aw>=2 else 'MIXED')
        rows.append(row)
    return pd.DataFrame(rows)


def print_comparison(cmp):
    print('\n'+'='*170);print('SUITE9 HOLDOUT — COMMITTEE / SHARED / SUITE7 / SUITE8 / SUITE9');print('='*170)
    cols=['faculty','committee_ap','adapter_ap','suite8_ap','suite9_candidate_ap','suite9_final_ap','suite9_minus_adapter_ap','adapter_f2_20','suite9_final_f2_20','suite9_minus_adapter_f2_20','suite9_minus_adapter_drift_f2','fallback_rate','evidence_pattern'];print(cmp[cols].to_string(index=False,float_format=lambda x:f'{x:.4f}'))
    for c in ['suite9_minus_adapter_ap','suite9_minus_adapter_f2_20','suite9_minus_adapter_fixed_f2','suite9_minus_adapter_drift_f2']:
        v=cmp[c].to_numpy(float);v=v[np.isfinite(v)]
        if len(v):print(f'{c:38s} mean={v.mean():+.4f} median={np.median(v):+.4f} worst={v.min():+.4f} win_rate={(v>0).mean():.1%}')


def parse_args():
    p=argparse.ArgumentParser(description='Suite9 competitive responsibility residual MoE')
    p.add_argument('--cache_dir',required=True);p.add_argument('--shared_results_dir',required=True);p.add_argument('--suite7_results_dir',required=True);p.add_argument('--suite8_results_dir',default=None);p.add_argument('--models_dir',required=True);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('--reference_metrics',default=None)
    p.add_argument('--seed',type=int,default=42);p.add_argument('--device',choices=['auto','cpu','cuda'],default='auto');p.add_argument('--n_experts',type=int,default=4);p.add_argument('--faculty_dim',type=int,default=8);p.add_argument('--encoder_hidden',type=int,default=256);p.add_argument('--representation_dim',type=int,default=128);p.add_argument('--expert_hidden',type=int,default=64);p.add_argument('--delta_max',type=float,default=2.0);p.add_argument('--dropout',type=float,default=.10);p.add_argument('--router_temperature',type=float,default=1.0);p.add_argument('--adapter_dim',type=int,default=16);p.add_argument('--adapter_dropout',type=float,default=0.0);p.add_argument('--adapter_scale',type=float,default=1.0)
    p.add_argument('--view_temperature',type=float,default=1.0);p.add_argument('--view_strength',type=float,default=.5);p.add_argument('--view_init_std',type=float,default=.01);p.add_argument('--view_entropy_lambda',type=float,default=.002);p.add_argument('--view_balance_lambda',type=float,default=.01);p.add_argument('--top_owned_dims',type=int,default=8)
    p.add_argument('--responsibility_temperature',type=float,default=.10);p.add_argument('--responsibility_top_k',type=int,default=2);p.add_argument('--min_expert_utility',type=float,default=0.0);p.add_argument('--discovery_epochs',type=int,default=8);p.add_argument('--discovery_min_epochs',type=int,default=2);p.add_argument('--discovery_patience',type=int,default=4);p.add_argument('--discovery_lr',type=float,default=5e-4);p.add_argument('--discovery_min_improvement',type=float,default=1e-5)
    p.add_argument('--router_epochs',type=int,default=12);p.add_argument('--router_min_epochs',type=int,default=2);p.add_argument('--router_patience',type=int,default=5);p.add_argument('--router_lr',type=float,default=1e-3);p.add_argument('--router_min_improvement',type=float,default=1e-5);p.add_argument('--joint_refine_epochs',type=int,default=0);p.add_argument('--joint_lr',type=float,default=1e-4);p.add_argument('--joint_router_lambda',type=float,default=1.0);p.add_argument('--joint_min_improvement',type=float,default=1e-5)
    p.add_argument('--fallback_discovery_epochs',type=int,default=3);p.add_argument('--fallback_router_epochs',type=int,default=3);p.add_argument('--val_blocks',type=int,default=2);p.add_argument('--min_train_rows',type=int,default=800);p.add_argument('--min_val_rows',type=int,default=200);p.add_argument('--batch_size',type=int,default=1024);p.add_argument('--predict_batch_size',type=int,default=4096);p.add_argument('--samples_per_epoch',type=int,default=0);p.add_argument('--lr',type=float,default=1e-3);p.add_argument('--weight_decay',type=float,default=1e-4);p.add_argument('--grad_clip',type=float,default=5.0);p.add_argument('--print_every',type=int,default=1);p.add_argument('--magnitude_lambda',type=float,default=.01);p.add_argument('--sampling_beta',type=float,default=.9999);p.add_argument('--macro_f2_weight',type=float,default=1.0);p.add_argument('--min_selection_improvement',type=float,default=1e-4)
    p.add_argument('--baseline_router_lambda',type=float,default=.5);p.add_argument('--baseline_specialization_lambda',type=float,default=.01);p.add_argument('--baseline_magnitude_lambda',type=float,default=.01);p.add_argument('--baseline_utility_temperature',type=float,default=.25)
    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('--reference_alignment_atol',type=float,default=1e-6)
    a=p.parse_args();a.dev_folds=[int(x) for x in a.dev_folds.split(',') if x.strip()];a.holdout_folds=[int(x) for x in a.holdout_folds.split(',') if x.strip()];return a


def main():
    args=parse_args();out=Path(args.models_dir);out.mkdir(parents=True,exist_ok=True);first=min(args.dev_folds+args.holdout_folds);schema=load_shared_feature_schema(args.shared_results_dir,first);available=list(schema.get('faculties',[]))
    if not available:
        suffix=f'_fold_{first}.joblib';available=sorted([p.name[:-len(suffix)] for p in Path(args.cache_dir).glob(f'*{suffix}')])
    faculties=parse_faculties(args.faculties,available)
    print('='*170);print('SUITE9 — COMPETITIVE RESPONSIBILITY RESIDUAL MOE');print('Phase 1: sparse expert responsibility discovery | Phase 2: router distillation | exact Suite7 fallback');print('='*170);print(f'faculties={len(faculties)} folds={args.dev_folds+args.holdout_folds} top_k={args.responsibility_top_k} resp_T={args.responsibility_temperature} discovery={args.discovery_epochs} router={args.router_epochs} joint={args.joint_refine_epochs}')
    save_json({'faculties':faculties,'args':vars(args),'controlled_baseline':'Suite7','responsibility':'detached sparse top-k counterfactual BCE utility','fallback':'exact Suite7 when temporal validation does not improve'},out/'suite9_run_config.json')
    records=[];metrics=[];resp=[];regions=[];agree=[];gaps=[];trans=[];corr=[];training=[]
    for fold in args.dev_folds+args.holdout_folds:
        rr,mm,dd,ee,aa,gg,tt,cc,ss=run_fold(args,faculties,fold,out);records.extend(rr);metrics.extend(mm);resp.extend(dd);regions.extend(ee);agree.extend(aa);gaps.extend(gg);trans.extend(tt);corr.extend(cc);training.append(ss)
    pd.DataFrame(metrics).to_csv(out/'suite9_fold_metrics.csv',index=False);pd.DataFrame(resp).to_csv(out/'suite9_responsibility_diagnostics.csv',index=False);pd.DataFrame(regions).to_csv(out/'suite9_expert_region_diagnostics.csv',index=False);pd.DataFrame(agree).to_csv(out/'suite9_router_agreement.csv',index=False);pd.DataFrame(gaps).to_csv(out/'suite9_oracle_gap.csv',index=False);pd.DataFrame(trans).to_csv(out/'suite9_transfer_at20.csv',index=False);pd.DataFrame(corr).to_csv(out/'suite9_residual_correlations.csv',index=False);pd.DataFrame(training).to_csv(out/'suite9_training_summary.csv',index=False)
    pooled=pooled_ranking_rows(records,args.holdout_folds,args);pooled.to_csv(out/'suite9_holdout_pooled.csv',index=False);warning,_=operational_summary(records,faculties,args,out);cmp=build_comparison(pooled,warning,records,args.holdout_folds);cmp.to_csv(out/'suite9_comparison.csv',index=False);print_comparison(cmp)
    if args.reference_metrics:
        official=merge_external_references(cmp,args.reference_metrics);official.to_csv(out/'suite9_official_comparison.csv',index=False);print('\nOFFICIAL V2/COUNCIL-AUGMENTED COMPARISON');print(official.to_string(index=False))
    print(f'\nCompleted. Results: {out}')


if __name__=='__main__':main()
