"""AADNet-style correlation-bottleneck direct classifier (Acc push).

Separate EEG and speech temporal encoders → per-time cosine similarity →
pooled logit = corr(EEG,A) − corr(EEG,B). Already antisymmetric in (A,B).

Distinct from:
  - BMMS3 DensePath multilevel matching (different encoder/score)
  - XCorrMatched multi-lag bank → CNN (abandoned at chance)
  - concat-vlaai DirectNet / contrast_aad InfoNCE auxiliary

Recipe: eaP_n5_t60, 10 s, sw2, random init, chance-abort, LODO + AASD/Carta
@ p_stay 0.994 scale 0.8 + linear_hp30.

usage:
  GLIMPSE_THR=onorm ABORT_IF_CHANCE=1 python -u aadnet_corr_lodo.py
"""
from __future__ import annotations

import json
import os
import pickle
import time
from types import SimpleNamespace

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F

os.environ.setdefault("GLIMPSE_THR", "onorm")

import decoders
import direct_classifier as DC
import ensemble_clf_transformer_v4 as V4
import eval_external as E
import score as S
from common import DS_KEYS, SEED
from common_exp import CFG, EXP, FS, fold_file, load_trial, rows_of
from decoders import D, DEV, _targets
from e1_switch import draw_switch_times
from run_experiment import load_external, log_to

EXP_NAME = "direct_clf__eaP_n5_t60_w10_aadnet_corr_aug-sw2"
TAG = "_w10_aadnet_corr_aug-sw2"
LOG_PATH = os.path.join(EXP, "experiments", "aadnet_corr_lodo.log")
OUT_JSON = os.path.join(EXP, "results", f"{EXP_NAME}.json")
ALL5_PT = os.path.join(EXP, "models", f"all5_direct_clf{TAG}.pt")
CKPT_DIR = os.path.join(EXP, "models", "aadnet_corr")
EXT_DIR = os.path.join(EXP, "results", "research")
RESULTS_MD = os.path.join(EXP, "multi_agent_opt", "results_aadnet_corr.md")
RUN_DIR = os.path.join(EXP, "experiments", "multi_agent_opt", "runs", "r3_aadnet_20261107")
MAX_EPOCHS = int(os.environ.get("MAX_EPOCHS", "40"))
MIN_EPOCHS = int(os.environ.get("MIN_EPOCHS", "10"))
P_STAY, SCALE = 0.994, 0.8
WINDOW_S = 10.0
BATCH = int(os.environ.get("BATCH", "64"))
BACKBONE = "aadnet_corr"
CHANCE_STEPS = int(os.environ.get("CHANCE_STEPS", "50"))
CHANCE_LOSS = float(os.environ.get("CHANCE_LOSS", "0.685"))
SWAP_MIN = float(os.environ.get("SWAP_MIN", "0.01"))
D_MODEL = int(os.environ.get("D_MODEL", "32"))
EEG_K = int(os.environ.get("EEG_K", "9"))
STIM_K = int(os.environ.get("STIM_K", "5"))


class ChanceStuckError(RuntimeError):
    pass


class AADNetCorr(nn.Module):
    """Interface-compatible with DirectNet for fit/logits."""

    def __init__(self, C, Fs, backbone="aadnet_corr"):
        super().__init__()
        self.C, self.Fs = C, Fs
        d = D_MODEL
        # Causal depthwise-separable EEG encoder → d-dim sequence (left-pad only)
        self.eeg_dw = nn.Conv1d(C, C, EEG_K, padding=0, groups=C, bias=False)
        self.eeg_pw = nn.Conv1d(C, d, 1)
        self.eeg_bn = nn.BatchNorm1d(d)
        # Speech encoder on F features → d (left-pad only)
        self.stim_conv = nn.Conv1d(Fs, d, STIM_K, padding=0)
        self.stim_pw = nn.Conv1d(d, d, 1)
        self.tw = nn.Parameter(torch.zeros(int(WINDOW_S * FS)))
        # Scale the cosine so BCE logits are not tiny at init
        self.logit_scale = nn.Parameter(torch.tensor(5.0))

    def _eeg(self, E):
        # E (B,W,C) → (B,W,d); causal left-pad
        x = F.pad(E.transpose(1, 2), (EEG_K - 1, 0))
        x = self.eeg_dw(x)
        x = self.eeg_pw(x)
        x = self.eeg_bn(x)
        return F.gelu(x).transpose(1, 2)  # (B,W,d)

    def _stim(self, S):
        # S (B,W,F) → (B,W,d)
        x = F.pad(S.transpose(1, 2), (STIM_K - 1, 0))
        x = F.gelu(self.stim_conv(x))
        x = self.stim_pw(x)
        return x.transpose(1, 2)

    def _cos(self, a, b):
        a = F.normalize(a, dim=-1)
        b = F.normalize(b, dim=-1)
        return (a * b).sum(-1)  # (B,W)

    def g(self, E, A, B, feat=False):
        ze = self._eeg(E)
        za, zb = self._stim(A), self._stim(B)
        h = self._cos(ze, za) - self._cos(ze, zb)  # already antisym in A↔B
        out = (h * torch.softmax(self.tw, 0)).sum(1) * self.logit_scale
        return (out, ze) if feat else out

    def forward(self, E, S, feat=False):
        S = (S - S.mean(1, keepdim=True)) / (S.std(1, keepdim=True) + 1e-6)
        # Single g is enough (already antisym); keep DirectNet-style double for safety
        if feat:
            a, fa = self.g(E, S[:, :, 0], S[:, :, 1], True)
            b, fb = self.g(E, S[:, :, 1], S[:, :, 0], True)
            return 0.5 * (a - b), 0.5 * (fa + fb)
        return 0.5 * (
            self.g(E, S[:, :, 0], S[:, :, 1]) - self.g(E, S[:, :, 1], S[:, :, 0])
        )


# Use AADNet wherever DirectNet is constructed in this process.
DC.DirectNet = AADNetCorr


def fit_net(train, val, log, a, check_chance=True):
    Fs = train[0]["_S"].shape[-1]
    seed = D.get("train_seed", CFG["seed"])
    torch.manual_seed(seed)
    net = DC.DirectNet(58, Fs, a.backbone).to(DEV)
    n_param = sum(p.numel() for p in net.parameters())
    log(f"  AADNetCorr params {n_param} d={D_MODEL} eeg_k={EEG_K} stim_k={STIM_K} batch {D['batch_size']}")
    aug = decoders.DNNDec.__new__(decoders.DNNDec)
    aug.W, aug.fut, aug.hop, aug.C = DC.W, DC.FUT, DC.HOP, 58
    rs = np.random.default_rng(seed)
    Xv, Sv, yv = DC.windows(val, D["val_windows"], rs, None, a.p_switch, a.zero_eeg)
    opt = torch.optim.AdamW(net.parameters(), lr=D["lr"], weight_decay=D["weight_decay"])
    sch = torch.optim.lr_scheduler.ReduceLROnPlateau(opt, mode="min", factor=0.5, patience=D["lr_patience"])
    best, bad, state = np.inf, 0, None
    for ep in range(D["max_epochs"]):
        t1, tl = time.time(), []
        net.train()
        for step_i in range(D["steps_per_epoch"]):
            X, S, y = [z.to(DEV) for z in DC.windows(train, D["batch_size"], rs, aug, a.p_switch, a.zero_eeg)]
            loss = F.binary_cross_entropy_with_logits(net(X, S), y)
            tl.append(loss.item())
            opt.zero_grad()
            loss.backward()
            torch.nn.utils.clip_grad_norm_(net.parameters(), 5.0)
            opt.step()
            if check_chance and ep == 0 and len(tl) == CHANCE_STEPS:
                recent = float(np.mean(tl))
                log(f"    step {CHANCE_STEPS} train {recent:.4f}")
                if recent >= CHANCE_LOSS:
                    raise ChanceStuckError(
                        f"ABORT_CHANCE: mean loss {recent:.4f} >= {CHANCE_LOSS} after {CHANCE_STEPS} steps")
        net.eval()
        with torch.no_grad():
            lv = torch.cat([
                net(Xv[i:i + 256].to(DEV), Sv[i:i + 256].to(DEV)).cpu()
                for i in range(0, len(Xv), 256)])
        vl = float(F.binary_cross_entropy_with_logits(lv, yv))
        va = float(((lv > 0).float() == yv).float().mean())
        if ep >= a.min_epochs:
            sch.step(vl)
        log(f"    epoch {ep:02d} train {np.mean(tl):.4f} val BCE {vl:.4f} acc {va:.3f} "
            f"({time.time() - t1:.0f}s)")
        if vl < best - 1e-4:
            best, bad, state = vl, 0, {k: v.detach().clone() for k, v in net.state_dict().items()}
        elif ep >= a.min_epochs:
            bad += 1
            if bad >= D["patience"]:
                break
    if state is None:
        state = {k: v.detach().clone() for k, v in net.state_dict().items()}
    net.load_state_dict(state)
    net.eval()
    return net, best


def configure():
    DC.W = int(WINDOW_S * FS)
    DC.POS0, DC.LAB = DC.W - DC.FUT - DC.HOP, DC.W - FS
    D["targets"] = ["env", "onset", "dom"]
    D["augment"] = {**CFG["dnn_augment"], **CFG["aug_variants"]["cluster"], "clf_p_switch2": 0.5}
    D["train_seed"] = int(CFG["seed"])
    D["max_epochs"] = MAX_EPOCHS
    D["steps_per_epoch"] = 250
    D["batch_size"] = BATCH
    D["patience"] = 6
    decoders.apply_overrides([], ["clf_p_switch2=0.5"])


def namespace():
    return SimpleNamespace(
        backbone=BACKBONE, p_switch=0.5, zero_eeg=False, min_epochs=MIN_EPOCHS,
        init_from=None, prep="eaP_n5_t60", tag=TAG,
    )


def swap_test(log, a):
    torch.manual_seed(0)
    net = DC.DirectNet(58, 3, a.backbone).to(DEV).eval()
    with torch.no_grad():
        E = torch.randn(8, DC.W, 58, device=DEV)
        A = torch.randn(8, DC.W, 3, device=DEV)
        B = torch.randn(8, DC.W, 3, device=DEV)
        S_ab = torch.stack([A, B], dim=2)
        S_ba = torch.stack([B, A], dim=2)
        y_ab = net(E, S_ab)
        y_ba = net(E, S_ba)
        anti_err = float((y_ab + y_ba).abs().mean())
        delta = float((y_ab - y_ba).abs().mean())
        gab0 = net(torch.zeros_like(E), S_ab)
        gba0 = net(torch.zeros_like(E), S_ba)
        delta0 = float((gab0 - gba0).abs().mean())
    n_param = sum(p.numel() for p in net.parameters())
    log(f"swap-test params {n_param} anti_err {anti_err:.3e} "
        f"swap_delta {delta:.4f} zero_eeg_delta {delta0:.4f}")
    del net
    if DEV.type == "cuda":
        torch.cuda.empty_cache()
    if anti_err > 1e-4:
        raise RuntimeError(f"antisymmetry broken: mean |y_ab+y_ba|={anti_err}")
    if delta < SWAP_MIN:
        raise RuntimeError(f"swap-delta too small ({delta:.3e})")
    return delta, delta0, anti_err


def run_fold(held, exp, log, a, check_chance=False):
    rng = np.random.default_rng(CFG["seed"] + DS_KEYS.index(held))
    train, val = [], []
    for ds in DS_KEYS:
        if ds == held:
            continue
        rows = rows_of(ds)
        vs = rng.choice(sorted(rows.subject.unique()))
        for _, r in rows.iterrows():
            (val if r["subject"] == vs else train).append(load_trial(a.prep, r["key"]))
    train += load_external(["Fuglsang2020"], a.prep, log)
    for tr in train + val:
        tr["_S"] = _targets(tr)
    log(f"  fold held-out={held}: {len(train)} train / {len(val)} val, W={DC.W / FS:g}s "
        f"chance_probe={'on' if check_chance else 'off'}")
    t0 = time.time()
    net, best = fit_net(train, val, log, a, check_chance=check_chance)
    t_fit = time.time() - t0
    del train, val
    os.makedirs(CKPT_DIR, exist_ok=True)
    ckpt = os.path.join(CKPT_DIR, f"held-{held}.pt")
    torch.save(net.state_dict(), ckpt)
    log(f"  saved {ckpt}")
    srng = np.random.default_rng(SEED + DS_KEYS.index(held))
    ev, ctl = {}, {k: {} for k in ("normal", "zero_eeg", "shift_eeg", "no_frontal")}
    for _, r in rows_of(held).iterrows():
        tr = load_trial(a.prep, r["key"])
        Sfeat, x, att, T128 = _targets(tr), tr["eeg"], tr["att"].astype(int), int(r["n"])
        times = draw_switch_times(srng, T128 / 128)
        srng.integers(0, 2)
        st128, cur, prev = np.zeros(T128, bool), False, 0
        for tt in times:
            s0 = min(T128 - 1, int(round(tt * 128)))
            st128[prev:s0] = cur
            cur, prev = not cur, s0
        st128[prev:] = cur
        st = st128[np.minimum(T128 - 1, np.round((np.arange(len(x)) / FS + tr["t0"]) * 128).astype(int))]
        Ssw = np.where(st[:, None, None], Sfeat[:, ::-1], Sfeat)
        lg, starts = DC.logits(net, x, Ssw)
        truth = (att ^ st)[np.maximum(starts - DC.HOP, 0)]
        n10 = len(lg) // 40
        ev[r["key"]] = dict(
            r0=lg / 2, r1=-lg / 2, att=truth.astype(np.int8),
            t_end=(starts / FS + tr["t0"]).astype(np.float32),
            r0_10=lg[:n10 * 40].reshape(n10, 40).mean(1) / 2,
            r1_10=-lg[:n10 * 40].reshape(n10, 40).mean(1) / 2,
            att10=(truth[:n10 * 40].reshape(n10, 40).mean(1) > 0.5).astype(np.int8),
            pre_switched=True)
        xf = x.copy()
        xf[:, DC.FRONTAL] = 0.0
        for name, xc in (("normal", x), ("zero_eeg", np.zeros_like(x)),
                         ("shift_eeg", np.roll(x, len(x) // 2, 0)), ("no_frontal", xf)):
            l1, s1 = DC.logits(net, xc, Sfeat, step=4)
            ctl[name].setdefault(r["subj_uid"], []).append(
                (l1 > 0) == (att[np.maximum(s1 - DC.HOP, 0)] == 0))
    controls = {
        k: dict(pooled=float(np.mean(np.concatenate([np.concatenate(v) for v in d.values()]))),
                subject_median=float(np.median([np.mean(np.concatenate(v)) for v in d.values()])))
        for k, d in ctl.items()}
    info = dict(decoder="direct_clf", prep=a.prep, held_out=held, fit_s=t_fit,
                total_s=time.time() - t0, lookahead_s=(DC.FUT + DC.HOP) / FS,
                best_val=best, channels=58, window_s=WINDOW_S, backbone=BACKBONE,
                controls=controls)
    from common_exp import save_pickle
    save_pickle(dict(evidence={"causal": ev}, info=info), fold_file(exp, held))
    log(f"  fold held-out={held} done in {info['total_s']:.0f}s best_val {best:.4f} "
        + "  ".join(f"{k} {v['pooled']:.3f}" for k, v in controls.items()))
    del net
    if DEV.type == "cuda":
        torch.cuda.empty_cache()


def score_hp30(ev, la, log):
    hp_ev = {}
    for ds in DS_KEYS:
        hp_ev[ds] = {}
        for key, e in ev[ds].items():
            signed = (e["r0"] - e["r1"]).astype(np.float64)
            hp = V4.highpass(signed[:, None], tau=30.0, hop=0.25)[:, 0]
            hp_ev[ds][key] = dict(e)
            hp_ev[ds][key]["r0"] = (hp / 2).astype(np.float32)
            hp_ev[ds][key]["r1"] = (-hp / 2).astype(np.float32)
    per = {}
    for ds in DS_KEYS:
        A = np.concatenate([(e["r0"] - e["r1"]) * np.where(e["att"] == 0, 1.0, -1.0)
                            for d in DS_KEYS if d != ds for e in hp_ev[d].values()])
        mu, sd = float(A.mean()), float(A.std())
        r = S.score_dataset(ds, hp_ev, la, emis=(mu, sd * SCALE), p_stay=P_STAY)
        per[ds] = r
        log(f"  HP30 LODO {ds}  H {r['H']:.4f}  Acc {r['Acc']:.2f}")
    mH = float(np.mean([per[d]["H"] for d in DS_KEYS]))
    mA = float(np.mean([per[d]["Acc"] for d in DS_KEYS]))
    log(f"  HP30 LODO MEAN  H {mH:.4f}  Acc {mA:.2f}")
    return per, mH, mA


def score_preset(log, a):
    la = (DC.FUT + DC.HOP) / FS
    ev, _ = S.load_folds(EXP_NAME, "causal")
    per = {}
    for ds in DS_KEYS:
        A = np.concatenate([(e["r0"] - e["r1"]) * np.where(e["att"] == 0, 1.0, -1.0)
                            for d in DS_KEYS if d != ds for e in ev[d].values()])
        mu, sd = float(A.mean()), float(A.std())
        r = S.score_dataset(ds, ev, la, emis=(mu, sd * SCALE), p_stay=P_STAY)
        per[ds] = r
        log(f"  PRESET LODO {ds}  H {r['H']:.4f}  Acc {r['Acc']:.2f}")
    mH = float(np.mean([per[d]["H"] for d in DS_KEYS]))
    mA = float(np.mean([per[d]["Acc"] for d in DS_KEYS]))
    log(f"  PRESET LODO MEAN  H {mH:.4f}  Acc {mA:.2f}")
    hp_per, hp_mH, hp_mA = score_hp30(ev, la, log)

    A = np.concatenate([(e["r0"] - e["r1"]) * np.where(e["att"] == 0, 1.0, -1.0)
                        for ds in DS_KEYS for e in ev[ds].values()])
    mu, sd = float(A.mean()), float(A.std())
    E.CONF.update(prep=a.prep, targets=list(D["targets"]))
    os.makedirs(EXT_DIR, exist_ok=True)
    ev_paths = {ds: os.path.join(EXT_DIR, f"ext_clf_{ds}{TAG}_evidence.pkl") for ds in ("AASD", "Carta2026")}
    if any(not os.path.exists(p) for p in ev_paths.values()):
        if os.path.exists(ALL5_PT):
            net = DC.DirectNet(58, 3, BACKBONE).to(DEV)
            net.load_state_dict(torch.load(ALL5_PT, map_location=DEV, weights_only=False))
            net.eval()
            log(f"  loaded {ALL5_PT}")
        else:
            rng = np.random.default_rng(CFG["seed"] + 99)
            train, val = [], []
            for ds in DS_KEYS:
                rows = rows_of(ds)
                vs = rng.choice(sorted(rows.subject.unique()))
                for _, r in rows.iterrows():
                    (val if r["subject"] == vs else train).append(load_trial(a.prep, r["key"]))
            train += load_external(["Fuglsang2020"], a.prep, log)
            for tr in train + val:
                tr["_S"] = _targets(tr)
            log(f"  all-5 train {len(train)} / val {len(val)}")
            net, best = fit_net(train, val, log, a, check_chance=False)
            torch.save(net.state_dict(), ALL5_PT)
            log(f"  saved {ALL5_PT} best val {best:.4f}")
            del train, val
        for ds, path in ev_paths.items():
            if os.path.exists(path):
                continue
            EV = {}
            trials = E.ext_trials(ds)
            log(f"  external {ds}: {len(trials)} trials")
            for i, tr in enumerate(trials):
                lg, starts = DC.logits(net, tr["eeg"], _targets(tr))
                truth = tr["att"].astype(int)[np.maximum(starts - DC.HOP, 0)]
                EV[tr["key"]] = dict(
                    r0=lg / 2, r1=-lg / 2, att=truth.astype(np.int8),
                    t_end=(starts / FS + tr["t0"]).astype(np.float32),
                    att128=tr["att128"], n128=tr["n128"], subject=tr["subject"])
                if (i + 1) % 40 == 0 or i + 1 == len(trials):
                    log(f"    {ds} {i + 1}/{len(trials)}")
            with open(path, "wb") as fh:
                pickle.dump(EV, fh)
            log(f"  wrote {path}")
        del net
        if DEV.type == "cuda":
            torch.cuda.empty_cache()

    hp_parts = []
    for ds in DS_KEYS:
        for e in ev[ds].values():
            signed = (e["r0"] - e["r1"]).astype(np.float64)
            hp = V4.highpass(signed[:, None], tau=30.0, hop=0.25)[:, 0]
            hp_parts.append(hp * np.where(e["att"] == 0, 1.0, -1.0))
    mu_hp = float(np.concatenate(hp_parts).mean())
    sd_hp = float(np.concatenate(hp_parts).std())

    ext = {}
    for ds, path in ev_paths.items():
        with open(path, "rb") as fh:
            EV = pickle.load(fh)
        r = E.score(EV, mu, sd * SCALE, P_STAY, 0.75)
        EV_hp = {}
        for key, e in EV.items():
            signed = (e["r0"] - e["r1"]).astype(np.float64)
            hp = V4.highpass(signed[:, None], tau=30.0, hop=0.25)[:, 0]
            EV_hp[key] = dict(e)
            EV_hp[key]["r0"] = (hp / 2).astype(np.float32)
            EV_hp[key]["r1"] = (-hp / 2).astype(np.float32)
        r_hp = E.score(EV_hp, mu_hp, sd_hp * SCALE, P_STAY, 0.75)
        ext[ds] = dict(raw=r, hp30=r_hp)
        log(f"  PRESET EXT {ds}  H {r['H']:.4f} Acc {r['Acc']:.2f}")
        log(f"  PRESET EXT_hp30 {ds}  H {r_hp['H']:.4f} Acc {r_hp['Acc']:.2f}")
    return per, ext, mu, sd, mH, mA, hp_per, hp_mH, hp_mA


def write_results(per, ext, mH, mA, hp_per, hp_mH, hp_mA, swap_delta, status="done"):
    lines = [
        "# results_aadnet_corr",
        "",
        f"Status: **{status}**. AADNet-corr (separate EEG/stim encoders + cosine bottleneck).",
        f"Swap-test delta={swap_delta:.4f}. Prep eaP_n5_t60, 10 s, sw2. HMM {P_STAY}/{SCALE}.",
        "",
        "## LODO",
        "",
        "| Held-out | H | Acc % | hp30 H/Acc |",
        "|---|---:|---:|---|",
    ]
    for ds in DS_KEYS:
        r, h = per[ds], hp_per[ds]
        lines.append(f"| {ds} | {r['H']:.4f} | {r['Acc']:.2f} | {h['H']:.4f}/{h['Acc']:.2f} |")
    lines += [
        f"| **mean** | **{mH:.4f}** | **{mA:.2f}** | **{hp_mH:.4f}/{hp_mA:.2f}** |",
        "",
        "## External",
        "",
        "| Set | H | Acc % | hp30 H/Acc | Acc>70/60 |",
        "|---|---:|---:|---|---|",
        f"| AASD | {ext['AASD']['raw']['H']:.4f} | {ext['AASD']['raw']['Acc']:.2f} | "
        f"{ext['AASD']['hp30']['H']:.4f}/{ext['AASD']['hp30']['Acc']:.2f} | "
        f"{'PASS' if ext['AASD']['raw']['Acc'] > 70 else 'FAIL'} |",
        f"| Carta2026 | {ext['Carta2026']['raw']['H']:.4f} | {ext['Carta2026']['raw']['Acc']:.2f} | "
        f"{ext['Carta2026']['hp30']['H']:.4f}/{ext['Carta2026']['hp30']['Acc']:.2f} | "
        f"{'PASS' if ext['Carta2026']['raw']['Acc'] > 60 else 'FAIL'} |",
        "",
        f"Code: `aadnet_corr_lodo.py`. Checkpoints: `{CKPT_DIR}/`, `{ALL5_PT}`.",
    ]
    open(RESULTS_MD, "w").write("\n".join(lines) + "\n")
    return RESULTS_MD


def write_abandon(reason, swap_delta=None):
    lines = [
        "# results_aadnet_corr",
        "",
        f"**ABANDONED**: {reason}",
        f"Swap-test delta={swap_delta}.",
        "",
        "Bulky checkpoints not written (chance abort before fold finish).",
    ]
    open(RESULTS_MD, "w").write("\n".join(lines) + "\n")
    return RESULTS_MD


def main():
    os.makedirs(RUN_DIR, exist_ok=True)
    configure()
    log = log_to(LOG_PATH)
    a = namespace()
    log(f"=== {EXP_NAME} AADNetCorr device {DEV} max_epochs {MAX_EPOCHS} "
        f"W={DC.W} FS={FS} batch={BATCH} d={D_MODEL} ===")

    swap_delta, swap_delta0, anti_err = swap_test(log, a)

    chance_done = any(os.path.exists(fold_file(EXP_NAME, h)) for h in DS_KEYS)
    try:
        for held in DS_KEYS:
            path = fold_file(EXP_NAME, held)
            if os.path.exists(path):
                log(f"  fold held-out={held}: cached {path}")
                chance_done = True
                continue
            run_fold(held, EXP_NAME, log, a, check_chance=not chance_done)
            chance_done = True
    except ChanceStuckError as e:
        log(f"ABANDON: {e}")
        write_abandon(str(e), swap_delta=swap_delta)
        out = dict(experiment=EXP_NAME, status="abandoned", reason=str(e),
                   swap_test=dict(delta=swap_delta, zero_eeg_delta=swap_delta0, anti_err=anti_err))
        os.makedirs(os.path.dirname(OUT_JSON), exist_ok=True)
        json.dump(out, open(OUT_JSON, "w"), indent=1, default=float)
        json.dump(out, open(os.path.join(RUN_DIR, "metrics.json"), "w"), indent=1, default=float)
        raise SystemExit(3)

    per, ext, mu, sd, mH, mA, hp_per, hp_mH, hp_mA = score_preset(log, a)
    write_results(per, ext, mH, mA, hp_per, hp_mH, hp_mA, swap_delta)
    out = dict(
        experiment=EXP_NAME, status="done", backbone=BACKBONE, window_s=WINDOW_S,
        swap_test=dict(delta=swap_delta, zero_eeg_delta=swap_delta0, anti_err=anti_err),
        preset=dict(p_stay=P_STAY, scale=SCALE, emis_mu=mu, emis_sd=sd,
                    lodo={d: dict(H=per[d]["H"], Acc=per[d]["Acc"]) for d in DS_KEYS},
                    mean_H=mH, mean_Acc=mA,
                    hp30_mean_H=hp_mH, hp30_mean_Acc=hp_mA,
                    external={ds: ext[ds] for ds in ext}),
        targets=dict(
            AASD_Acc_gt_70=ext["AASD"]["raw"]["Acc"] > 70,
            Carta_Acc_gt_60=ext["Carta2026"]["raw"]["Acc"] > 60,
        ),
    )
    json.dump(out, open(OUT_JSON, "w"), indent=1, default=float)
    json.dump(out, open(os.path.join(RUN_DIR, "metrics.json"), "w"), indent=1, default=float)
    log(f"wrote {OUT_JSON}")

    # Cleanup policy: if Acc far below bar, drop bulky all5/fold ckpts but keep summary.
    aasd_acc = ext["AASD"]["raw"]["Acc"]
    if aasd_acc < 60 and mA < 75:
        log(f"failure cleanup: AASD Acc {aasd_acc:.2f} < 60 — removing bulky checkpoints")
        victims = []
        if os.path.exists(ALL5_PT):
            victims.append(ALL5_PT)
        if os.path.isdir(CKPT_DIR):
            victims.extend(os.path.join(CKPT_DIR, f) for f in os.listdir(CKPT_DIR) if f.endswith(".pt"))
        for p in victims:
            try:
                os.remove(p)
                log(f"  deleted {p}")
            except OSError:
                pass


if __name__ == "__main__":
    main()
