"""Subject-conditional affine / Platt on frozen Acc tip streams.

CPU-only backup after spectrogram-vit-acc chance-abandon.

Streams (frozen; no SW2↔swmix re-grid):
  1. Acc tip hard_abs_swmix|t1
  2. published SW2 fuse_general a=0.5

Method (LODO-train subjects only; never AASD/Carta labels):
  - Per train subject: fit Platt (a_s, b_s) on that subject's labeled frames
  - Subject features from unlabeled logits: mean, std, mean|z|, median, p90|z|, …
  - Ridge map: feats → (a, b)  [or scale-only a]
  - At eval: compute feats from the subject's stream (no labels) → (a,b) → z'=a z+b

Also baselines: tip/sw2 raw, global Platt, mean-of-subject-Platts.

Select by mean LODO Acc then H @ HMM 0.994/0.8. Score AASD + Carta.

DISTINCT from: platt-acc-tip (global only), online-moment-sw2 (causal EMA),
subj-adapt-emis-tip (HMM μ/σ), focal-synth-adapt-readout (stem fuse).

usage:
  CUDA_VISIBLE_DEVICES= OMP_NUM_THREADS=8 \\
    /root/disk_3tb/EEG-sAAD-Grand-Challenge-Training-Dataset/.venv/bin/python -u \\
    subj_cond_calib.py
"""
from __future__ import annotations

import json
import os
import time

import numpy as np
from scipy.optimize import minimize
from scipy.special import expit

import ensemble_clf_transformer_v4 as V4
import eval_external as E
import online_moment_sw2 as OMS
import sw2_hp30_blend as SW2
import sw2_swmix_blend as SM
from common import DS_KEYS

EXP = os.path.dirname(os.path.abspath(__file__))
LOG = os.path.join(EXP, "experiments", "subj_cond_calib.log")
OUT = os.path.join(EXP, "results", "research", "subj_cond_calib.json")
RESULTS_MD = os.path.join(EXP, "multi_agent_opt", "results_subj_cond_calib.md")
CKPT = os.path.join(EXP, "models", "subj_cond_calib")

P_STAY = 0.994
SCALE = 0.8
LOOKAHEAD = float(OMS.LOOKAHEAD)
A_SW2 = SW2.A_SW2
MAX_FIT = 80_000
SEED = 0
EPS = 1e-6
RIDGE_LAM = float(os.environ.get("RIDGE_LAM", "1.0"))
MIN_SUBJ_N = 200

TIP_KIND, TIP_THR, TIP_SHARP = OMS.TIP_KIND, OMS.TIP_THR, OMS.TIP_SHARP
LINEAR_HP30_EXT = OMS.LINEAR_HP30_EXT
SW2_ALONE_EXT = OMS.SW2_ALONE_EXT
SW2_SWMIX_LEADER = OMS.SW2_SWMIX_LEADER

# (name, stream, mode)
# mode: none | global_platt | mean_subj_platt | ridge_ab | ridge_a | hier_platt
VARIANT_SPECS = []
for stream in ("tip", "sw2"):
    VARIANT_SPECS.append((f"{stream}_raw", stream, "none"))
    VARIANT_SPECS.append((f"{stream}_global_platt", stream, "global_platt"))
    VARIANT_SPECS.append((f"{stream}_mean_subj_platt", stream, "mean_subj_platt"))
    VARIANT_SPECS.append((f"{stream}_ridge_ab", stream, "ridge_ab"))
    VARIANT_SPECS.append((f"{stream}_ridge_a", stream, "ridge_a"))
    VARIANT_SPECS.append((f"{stream}_hier_platt", stream, "hier_platt"))


def log_line(text):
    print(text, flush=True)
    os.makedirs(os.path.dirname(LOG), exist_ok=True)
    with open(LOG, "a") as fh:
        fh.write(text + "\n")


def subject_of(key, meta_entry=None):
    return OMS.subject_of(key, meta_entry)


def nll_platt(ab, x, y):
    a, b = float(ab[0]), float(ab[1])
    p = np.clip(expit(a * x + b), 1e-7, 1.0 - 1e-7)
    return float(-(y * np.log(p) + (1.0 - y) * np.log(1.0 - p)).mean())


def fit_platt(x, y):
    x = np.asarray(x, np.float64).reshape(-1)
    y = np.asarray(y, np.float64).reshape(-1)
    if len(x) < 50 or y.min() == y.max():
        return dict(a=1.0, b=0.0, n=int(len(x)), degenerate=True)
    res = minimize(
        lambda ab: nll_platt(ab, x, y),
        x0=np.array([1.0, 0.0]),
        method="L-BFGS-B",
        bounds=[(1e-3, 20.0), (-10.0, 10.0)],
    )
    return dict(a=float(res.x[0]), b=float(res.x[1]), n=int(len(x)), degenerate=False)


def subject_feats(z):
    z = np.asarray(z, np.float64).reshape(-1)
    if len(z) == 0:
        return np.zeros(7, np.float64)
    az = np.abs(z)
    return np.array([
        float(z.mean()),
        float(z.std()) + EPS,
        float(az.mean()),
        float(np.median(z)),
        float(np.percentile(az, 90)),
        float(np.mean(z * z)),
        float(np.tanh(z).mean()),
    ], dtype=np.float64)


def group_subject_xy(streams, meta, datasets):
    """Return dict sid -> (z, y) pooled over trials in datasets."""
    bags = {}
    for ds in datasets:
        if ds not in streams:
            continue
        for key, d in streams[ds].items():
            att, _te = meta[ds][key]
            z = np.asarray(d, np.float64).reshape(-1)
            y = (np.asarray(att) == 0).astype(np.float64).reshape(-1)
            n = min(len(z), len(y))
            if n <= 0:
                continue
            sid = (ds, subject_of(key))
            if sid not in bags:
                bags[sid] = [[], []]
            bags[sid][0].append(z[:n])
            bags[sid][1].append(y[:n])
    out = {}
    for sid, (zs, ys) in bags.items():
        out[sid] = (np.concatenate(zs), np.concatenate(ys))
    return out


def group_subject_z(streams, datasets):
    """Unlabeled subject bags (for feat extraction at eval)."""
    bags = {}
    for ds in datasets:
        if ds not in streams:
            continue
        for key, d in streams[ds].items():
            z = np.asarray(d, np.float64).reshape(-1)
            if len(z) == 0:
                continue
            sid = (ds, subject_of(key))
            bags.setdefault(sid, []).append(z)
    return {sid: np.concatenate(parts) for sid, parts in bags.items()}


def fit_train_bank(streams, meta, train_ds, rng):
    """Per-subject Platt + feats on train_ds. Also global Platt."""
    bags = group_subject_xy(streams, meta, train_ds)
    rows = []
    for sid, (z, y) in bags.items():
        if len(z) < MIN_SUBJ_N:
            continue
        if len(z) > MAX_FIT:
            idx = rng.choice(len(z), size=MAX_FIT, replace=False)
            z_fit, y_fit = z[idx], y[idx]
        else:
            z_fit, y_fit = z, y
        pl = fit_platt(z_fit, y_fit)
        if pl.get("degenerate"):
            continue
        feats = subject_feats(z)
        rows.append(dict(sid=sid, feats=feats, a=pl["a"], b=pl["b"], n=pl["n"]))
    # global
    xs, ys = [], []
    for sid, (z, y) in bags.items():
        xs.append(z)
        ys.append(y)
    if xs:
        x = np.concatenate(xs)
        y = np.concatenate(ys)
        if len(x) > MAX_FIT:
            idx = rng.choice(len(x), size=MAX_FIT, replace=False)
            x, y = x[idx], y[idx]
        g = fit_platt(x, y)
    else:
        g = dict(a=1.0, b=0.0, n=0, degenerate=True)
    return rows, g


def ridge_fit(X, Y, lam=RIDGE_LAM):
    """X (N,d) → Y (N,k). Returns W (d+1, k) with bias row."""
    X = np.asarray(X, np.float64)
    Y = np.asarray(Y, np.float64)
    if Y.ndim == 1:
        Y = Y[:, None]
    N, d = X.shape
    Xb = np.concatenate([X, np.ones((N, 1))], axis=1)
    A = Xb.T @ Xb + lam * np.eye(d + 1)
    A[-1, -1] = max(lam * 1e-3, 1e-8)  # weaker bias regularisation
    W = np.linalg.solve(A, Xb.T @ Y)
    return W


def ridge_predict(W, feats):
    x = np.append(np.asarray(feats, np.float64).reshape(-1), 1.0)
    return x @ W


def apply_ab_streams(streams, meta, datasets, ab_by_sid, default_ab=(1.0, 0.0)):
    out = {ds: {} for ds in streams}
    for ds in datasets:
        if ds not in streams:
            continue
        for key, d in streams[ds].items():
            sid = (ds, subject_of(key))
            a, b = ab_by_sid.get(sid, default_ab)
            out[ds][key] = float(a) * np.asarray(d, np.float64) + float(b)
    # copy any datasets not in `datasets` unchanged if present
    for ds, table in streams.items():
        if ds in out and out[ds]:
            continue
        out[ds] = {k: np.asarray(v, np.float64) for k, v in table.items()}
    return out


def apply_const_streams(streams, a, b):
    return {
        ds: {k: float(a) * np.asarray(v, np.float64) + float(b) for k, v in table.items()}
        for ds, table in streams.items()
    }


def build_ab_map(mode, rows, g, streams, datasets):
    """Predict (a,b) per subject in `datasets` using unlabeled feats + train bank."""
    default = (float(g.get("a", 1.0)), float(g.get("b", 0.0)))
    if mode == "none":
        return {}, (1.0, 0.0), dict(mode="none")
    if mode == "global_platt":
        return {}, (default[0], default[1]), dict(mode="global_platt", a=default[0], b=default[1], n=g.get("n"))
    if not rows:
        return {}, default, dict(mode=mode, fallback="global", a=default[0], b=default[1])

    A = np.array([r["a"] for r in rows], np.float64)
    B = np.array([r["b"] for r in rows], np.float64)
    F = np.stack([r["feats"] for r in rows], axis=0)
    info = dict(mode=mode, n_subj=len(rows), mean_a=float(A.mean()), mean_b=float(B.mean()))

    if mode == "mean_subj_platt":
        ab = (float(A.mean()), float(B.mean()))
        return {}, ab, info

    z_bags = group_subject_z(streams, datasets)
    ab_map = {}
    if mode == "ridge_ab":
        W = ridge_fit(F, np.stack([A, B], 1))
        info["W_shape"] = list(W.shape)
        for sid, z in z_bags.items():
            pred = ridge_predict(W, subject_feats(z))
            a = float(np.clip(pred[0], 1e-3, 20.0))
            b = float(np.clip(pred[1], -10.0, 10.0))
            ab_map[sid] = (a, b)
        return ab_map, default, info

    if mode == "ridge_a":
        W = ridge_fit(F, A)
        info["W_shape"] = list(W.shape)
        for sid, z in z_bags.items():
            a = float(np.clip(ridge_predict(W, subject_feats(z)).ravel()[0], 1e-3, 20.0))
            ab_map[sid] = (a, 0.0)
        return ab_map, (default[0], 0.0), info

    if mode == "hier_platt":
        # residual: a_s / a_g , b_s - b_g predicted from feats; apply on top of global
        ag, bg = default
        Ya = np.log(np.clip(A / max(ag, 1e-3), 1e-3, 20.0))
        Yb = B - bg
        Wa = ridge_fit(F, Ya)
        Wb = ridge_fit(F, Yb)
        for sid, z in z_bags.items():
            da = float(ridge_predict(Wa, subject_feats(z)).ravel()[0])
            db = float(ridge_predict(Wb, subject_feats(z)).ravel()[0])
            a = float(np.clip(ag * np.exp(da), 1e-3, 20.0))
            b = float(np.clip(bg + db, -10.0, 10.0))
            ab_map[sid] = (a, b)
        info["a_global"] = ag
        info["b_global"] = bg
        return ab_map, default, info

    raise ValueError(mode)


def calibrate(streams, meta, train_ds, eval_ds, mode, rng):
    if mode == "none":
        cal = {ds: {k: np.asarray(v, np.float64) for k, v in streams[ds].items()}
               for ds in streams}
        return cal, dict(mode="none")
    rows, g = fit_train_bank(streams, meta, train_ds, rng)
    ab_map, default, info = build_ab_map(mode, rows, g, streams, eval_ds)
    if mode in ("global_platt", "mean_subj_platt"):
        a, b = default
        cal = apply_const_streams(streams, a, b)
    else:
        # apply per-subject where known; else default (global)
        cal = apply_ab_streams(streams, meta, eval_ds, ab_map, default_ab=default)
        # also map train subjects consistently if needed for emissions
        train_map, _, _ = build_ab_map(mode, rows, g, streams, train_ds)
        cal_train = apply_ab_streams(streams, meta, train_ds, train_map, default_ab=default)
        for ds in train_ds:
            if ds in cal_train:
                cal[ds] = cal_train[ds]
    info["global"] = dict(a=g.get("a"), b=g.get("b"), n=g.get("n"))
    return cal, info


def apply_ab_ev(ev, ab_by_sid, default_ab, use_subject_field=True):
    out = {}
    for key, e in ev.items():
        if use_subject_field:
            sid = ("ext", subject_of(key, e))
        else:
            sid = ("ext", subject_of(key))
        a, b = ab_by_sid.get(sid, default_ab)
        # also try matching only by subject int
        if sid not in ab_by_sid:
            sid2 = subject_of(key, e)
            # search any key ending with this subject in ab_by_sid
            for k2, ab in ab_by_sid.items():
                if k2[1] == sid2:
                    a, b = ab
                    break
        d = float(a) * np.asarray(e["r0"], np.float64) + float(b)
        n = len(d)
        out[key] = dict(
            r0=d, r1=np.zeros(n),
            att=e["att"][:n], t_end=e["t_end"][:n],
            att128=e["att128"], n128=e["n128"], subject=e["subject"],
        )
    return out


def apply_const_ev(ev, a, b):
    out = {}
    for key, e in ev.items():
        d = float(a) * np.asarray(e["r0"], np.float64) + float(b)
        n = len(d)
        out[key] = dict(
            r0=d, r1=np.zeros(n),
            att=e["att"][:n], t_end=e["t_end"][:n],
            att128=e["att128"], n128=e["n128"], subject=e["subject"],
        )
    return out


def score_lodo_held(stream_all, meta, held):
    return OMS.score_lodo_held(stream_all, meta, held)


def emissions_from_stream(streams, meta, datasets):
    return OMS.emissions_from_stream(streams, meta, datasets)


def pick_variant(lodo_means):
    return OMS.pick_variant(lodo_means)


def _json_default(o):
    if isinstance(o, (np.floating, np.integer)):
        return float(o)
    if isinstance(o, np.ndarray):
        return o.tolist()
    if isinstance(o, tuple):
        return list(o)
    raise TypeError(type(o))


def write_md(results):
    sel = results["selected"]
    prim = results["variants"][sel]
    aasd = prim["external"]["AASD"]
    carta = prim["external"]["Carta2026"]
    tip_acc = SW2_SWMIX_LEADER["AASD"]["Acc"]
    hp_acc = LINEAR_HP30_EXT["AASD"]["Acc"]
    lines = []
    lines.append("# results_subj_cond_calib\n")
    lines.append(
        "**Claim:** `subj-cond-calib` — subject-conditional affine/Platt on frozen Acc tip "
        "`hard_abs_swmix|t1` (+ SW2). Per LODO-train subject fit (a_s,b_s); ridge map from "
        "unlabeled logit moments → (a,b); apply on held-out / AASD / Carta subjects without "
        "test labels. CPU. Backup after spectrogram-vit-acc chance-abandon.\n"
    )
    lines.append(
        "**DISTINCT** from `platt-acc-tip` (global only), `online-moment-sw2`, "
        "`subj-adapt-emis-tip` (HMM μ/σ), `focal-synth-adapt-readout` (stem fuse).\n"
    )
    lines.append(
        f"HMM **{P_STAY}/{SCALE}**. Code: `subj_cond_calib.py`. "
        f"JSON: `results/research/subj_cond_calib.json`.\n"
    )
    lines.append("## Selection (mean LODO Acc then H; never AASD/Carta)\n")
    lines.append(
        f"**SELECTED `{sel}`** — mean LODO H **{prim['lodo_mean']['H']:.4f}** "
        f"Acc **{prim['lodo_mean']['Acc']:.2f}**\n"
    )
    lines.append("| Held-out | H | Acc % |")
    lines.append("|---|---:|---:|")
    for ds in DS_KEYS:
        p = prim["lodo"][ds]
        lines.append(f"| {ds} | {p['H']:.4f} | {p['Acc']:.2f} |")
    lines.append(
        f"| **mean** | **{prim['lodo_mean']['H']:.4f}** | **{prim['lodo_mean']['Acc']:.2f}** |\n"
    )
    lines.append("### Variant table\n")
    lines.append(
        "| Variant | LODO H / Acc | AASD H / Acc | ΔAcc vs 53.53 | Carta H / Acc |"
    )
    lines.append("|---------|--------------|--------------|---------------|---------------|")
    ranked = sorted(
        results["variants"].items(),
        key=lambda kv: (
            0 if kv[0] == sel else 1,
            -float(kv[1]["lodo_mean"]["Acc"]),
            -float(kv[1]["lodo_mean"]["H"]),
        ),
    )
    for name, v in ranked:
        if "external" not in v:
            continue
        a = v["external"]["AASD"]
        c = v["external"]["Carta2026"]
        mark = " **←**" if name == sel else ""
        lines.append(
            f"| `{name}`{mark} | {v['lodo_mean']['H']:.4f} / {v['lodo_mean']['Acc']:.2f} | "
            f"{a['H']:.4f} / {a['Acc']:.2f} | {a['Acc']-tip_acc:+.2f} | "
            f"{c['H']:.4f} / {c['Acc']:.2f} |"
        )
    lines.append("\n## Targets\n")
    lines.append("| Target | Result |")
    lines.append("|---|---|")
    lines.append(
        f"| AASD Acc vs tip 53.53 / hp30 53.12 | Acc **{aasd['Acc']:.2f}** "
        f"(Δ {aasd['Acc']-tip_acc:+.2f} / {aasd['Acc']-hp_acc:+.2f}); H {aasd['H']:.4f} |"
    )
    lines.append(
        f"| Carta vs linear_hp30 60.54 | Acc **{carta['Acc']:.2f}** "
        f"(Δ {carta['Acc']-60.54:+.2f}); H {carta['H']:.4f} |"
    )
    lines.append(
        f"| Acc>60? | **{'YES' if aasd['Acc'] > 60 else 'NO'}** (AASD Acc {aasd['Acc']:.2f}) |"
    )
    lines.append(
        f"| Tip moved? | **{'YES' if aasd['Acc'] > tip_acc else 'NO'}** |\n"
    )
    lines.append("## Verdict\n")
    if aasd["Acc"] > tip_acc:
        lines.append(
            f"Subject-conditional calib lifts AASD Acc to {aasd['Acc']:.2f} "
            f"(Δ+{aasd['Acc']-tip_acc:.2f} vs tip).\n"
        )
    else:
        lines.append(
            "Subject-conditional ridge/mean/hier Platt on Acc tip does not beat "
            "hard_abs_swmix|t1 tip Acc 53.53 under honest LODO Acc/H selection.\n"
        )
    lines.append("## Do not repeat\n")
    lines.append(
        "Do not re-grid subject-conditional ridge/Platt on the same Acc tip SW2 / "
        "`hard_abs_swmix|t1` streams. Do not re-grid SW2↔swmix soft/hard. "
        "SpecViT Mel-STFT Acc front-end already chance-abandoned.\n"
    )
    lines.append("## NEXT IDEA\n")
    lines.append(
        "Unused Acc-first: **speech-envelope TRF residual into published SW2 vlaai** "
        "(identity-at-0 residual Path B that already learns) **or** "
        "**cross-dataset prototype memory** (LODO-train subject prototype bank → "
        "nearest-prototype emission shift) — not SSL/DANN/Path A classical/"
        "switch-schedule/Mixup/tip PP/SpecViT re-grid.\n"
    )
    with open(RESULTS_MD, "w") as fh:
        fh.write("\n".join(lines))


def calibrate_ext(mode, rows, g, tip_or_sw2_ev):
    """Build ab map for external subjects from unlabeled r0; return adapted ev + info."""
    default = (float(g.get("a", 1.0)), float(g.get("b", 0.0)))
    if mode == "none":
        return tip_or_sw2_ev, dict(mode="none"), default
    if mode in ("global_platt", "mean_subj_platt"):
        if mode == "mean_subj_platt" and rows:
            default = (
                float(np.mean([r["a"] for r in rows])),
                float(np.mean([r["b"] for r in rows])),
            )
        elif mode == "global_platt":
            default = (float(g.get("a", 1.0)), float(g.get("b", 0.0)))
        return apply_const_ev(tip_or_sw2_ev, *default), dict(mode=mode, a=default[0], b=default[1]), default

    # Build fake streams for feat extraction
    streams = {"ext": {k: e["r0"] for k, e in tip_or_sw2_ev.items()}}
    ab_map, default2, info = build_ab_map(mode, rows, g, streams, ["ext"])
    return apply_ab_ev(tip_or_sw2_ev, ab_map, default2), info, default2


def main():
    os.makedirs(CKPT, exist_ok=True)
    os.makedirs(os.path.dirname(LOG), exist_ok=True)
    os.makedirs(os.path.dirname(OUT), exist_ok=True)
    open(LOG, "w").close()
    t_all = time.time()
    rng = np.random.default_rng(SEED)
    log_line(
        f"subj-cond-calib CPU  p_stay={P_STAY} scale={SCALE} tip={TIP_KIND}|t{TIP_THR:g} "
        f"variants={len(VARIANT_SPECS)} ridge_lam={RIDGE_LAM}"
    )
    log_line(
        "honesty: LODO-train subject Platt bank + unlabeled-feat ridge → (a,b); "
        "never AASD/Carta labels; ≠ global-only Platt / online-moment / emis-adapt"
    )

    try:
        Z, meta = SM.ensure_sw2_lodo()
        swmix_full, la_sm = SM.ensure_swmix_lodo()
        log_line(f"lookahead LA={LOOKAHEAD} swmix_fold_la={la_sm}")
    except FileNotFoundError as e:
        log_line(f"ABORT: {e}")
        with open(OUT, "w") as fh:
            json.dump(dict(status="abandoned", reason=str(e)), fh, indent=2)
        with open(RESULTS_MD, "w") as fh:
            fh.write(f"# results_subj_cond_calib\n\n**Status: abandoned**\n\n{e}\n")
        return

    log_line("building raw SW2 fuse + tip (hard_abs_swmix|t1) per held …")
    sw2_held, tip_held = OMS.build_raw_held(Z, swmix_full)
    raw_by_stream = dict(sw2=sw2_held, tip=tip_held)

    r_tip = score_lodo_held(tip_held["AVGC"], meta, "AVGC")
    log_line(
        f"sanity AVGC tip_raw H {r_tip['H']:.4f} Acc {r_tip['Acc']:.2f} "
        f"(expect ~0.7159 / ~67.94)"
    )

    results = dict(
        status="running",
        method="subj-cond-calib",
        p_stay=P_STAY,
        scale=SCALE,
        tip=dict(kind=TIP_KIND, thresh=TIP_THR, sharp=TIP_SHARP),
        ridge_lam=RIDGE_LAM,
        honesty=(
            "Subject-conditional affine/Platt on Acc tip / SW2: train-subject Platt bank "
            "+ unlabeled logit-moment ridge → (a,b). No AASD/Carta labels. "
            "Backup after SpecViT chance-abandon."
        ),
        baselines=dict(
            linear_hp30_ext=LINEAR_HP30_EXT,
            sw2_alone_ext=SW2_ALONE_EXT,
            sw2_swmix_leader=SW2_SWMIX_LEADER,
            spectrogram_vit="ABORT_CHANCE mean_loss 0.6962",
        ),
        variants={},
    )
    lodo_means = {}

    log_line(f"=== LODO ({len(VARIANT_SPECS)} variants) ===")
    for name, stream, mode in VARIANT_SPECS:
        t0 = time.time()
        per = {}
        fit_per = {}
        for held in DS_KEYS:
            raw = raw_by_stream[stream][held]
            train_ds = [d for d in DS_KEYS if d != held]
            # eval_ds includes all for applying map; score held only
            cal, fit_info = calibrate(raw, meta, train_ds, list(DS_KEYS), mode, rng)
            off = score_lodo_held(cal, meta, held)
            fit_log = {k: v for k, v in fit_info.items() if k != "W"}
            per[held] = dict(
                H=off["H"], Acc=off["Acc"], SDT=off.get("SDT"), L=off.get("L"),
                fit=fit_log,
            )
            fit_per[held] = fit_log
            log_line(
                f"LODO {name:22s} {held:5s}  H {off['H']:.4f} Acc {off['Acc']:.2f}  "
                f"n_subj={fit_info.get('n_subj', '-')}"
            )
        mean_h = float(np.mean([per[d]["H"] for d in DS_KEYS]))
        mean_a = float(np.mean([per[d]["Acc"] for d in DS_KEYS]))
        log_line(
            f"LODO_MEAN {name:22s}  H {mean_h:.4f} Acc {mean_a:.2f}  ({time.time()-t0:.0f}s)"
        )
        lodo_means[name] = dict(H=mean_h, Acc=mean_a)
        results["variants"][name] = dict(
            stream=stream, mode=mode, lodo=per, lodo_mean=dict(H=mean_h, Acc=mean_a),
            fit_per_held=fit_per,
        )

    selected = pick_variant(lodo_means)
    ranked = sorted(
        lodo_means.keys(),
        key=lambda n: (lodo_means[n]["Acc"], lodo_means[n]["H"]),
        reverse=True,
    )
    log_line(
        f"SELECTED (LODO Acc then H): {selected}  "
        f"H {lodo_means[selected]['H']:.4f} Acc {lodo_means[selected]['Acc']:.2f}"
    )
    log_line(f"ranked: {ranked}")
    results["selected"] = selected
    results["selection"] = dict(
        criterion="mean LODO Acc then H (never AASD/Carta)",
        ranked=ranked, selected=selected,
    )

    try:
        EV_sw2, emis_sw2 = SM.ensure_sw2_external()
        sm_ext = SM.ensure_swmix_external()
    except FileNotFoundError as e:
        log_line(f"ABORT external: {e}")
        results["status"] = "partial"
        results["reason"] = str(e)
        with open(OUT, "w") as fh:
            json.dump(results, fh, indent=2, default=_json_default)
        write_md(results)
        return

    corp_raw = {
        "sw2": OMS.avg_corpus_stream(sw2_held),
        "tip": OMS.avg_corpus_stream(tip_held),
    }
    tip_ext_ev = {}
    for ds in ("AASD", "Carta2026"):
        sw2_ev = EV_sw2[ds][A_SW2]
        sm_al = SM.align_ext_swmix_to_sw2(sm_ext[ds], sw2_ev)
        tip_ext_ev[ds] = SM.blend_ext_ev(sw2_ev, sm_al, TIP_KIND, TIP_THR, TIP_SHARP)

    log_line("=== external ===")
    for name, stream, mode in VARIANT_SPECS:
        corp = corp_raw[stream]
        rows, g = fit_train_bank(corp, meta, list(DS_KEYS), rng)
        # emissions from calibrated corpus
        cal_corp, fit_info = calibrate(corp, meta, list(DS_KEYS), list(DS_KEYS), mode, rng)
        if mode == "none" and stream == "sw2":
            mu_e, sd_e = float(emis_sw2[A_SW2][0]), float(emis_sw2[A_SW2][1])
        else:
            mu_e, sd_e = emissions_from_stream(cal_corp, meta, list(DS_KEYS))
        results["variants"][name]["fit_corpus"] = {
            k: v for k, v in fit_info.items() if k != "W"
        }
        results["variants"][name]["emis"] = dict(mu=mu_e, sd=sd_e)
        log_line(
            f"corpus {name} n_subj={fit_info.get('n_subj', '-')} "
            f"global_a={g.get('a')} global_b={g.get('b')} emis μ={mu_e:.6f} σ={sd_e:.6f}"
        )

        ext = {}
        for ds in ("AASD", "Carta2026"):
            base_ev = EV_sw2[ds][A_SW2] if stream == "sw2" else tip_ext_ev[ds]
            ev_use, _info, _def = calibrate_ext(mode, rows, g, base_ev)
            r = E.score(ev_use, mu_e, sd_e * SCALE, P_STAY, LOOKAHEAD)
            pl = E.plain(ev_use)
            ext[ds] = dict(
                H=r["H"], Acc=r["Acc"], SDT=r["SDT"], L=r["L"],
                acc1=pl["acc1"], nSwitches=r["nSwitches"], nUndetected=r["nUndetected"],
            )
            d_tip = r["Acc"] - SW2_SWMIX_LEADER[ds]["Acc"]
            d_hp = r["Acc"] - LINEAR_HP30_EXT[ds]["Acc"]
            log_line(
                f"EXT {name:22s} {ds:10s}  H {r['H']:.4f} Acc {r['Acc']:.2f}  "
                f"Δtip {d_tip:+.2f}  Δhp30 {d_hp:+.2f}"
            )
        results["variants"][name]["external"] = ext

    prim = results["variants"][selected]
    aasd = prim["external"]["AASD"]
    carta = prim["external"]["Carta2026"]
    d_tip = aasd["Acc"] - SW2_SWMIX_LEADER["AASD"]["Acc"]
    d_hp = aasd["Acc"] - LINEAR_HP30_EXT["AASD"]["Acc"]
    results["headline"] = dict(
        selected=selected,
        AASD=aasd,
        Carta2026=carta,
        AASD_Acc_delta_vs_tip=d_tip,
        AASD_Acc_delta_vs_linear_hp30=d_hp,
        AASD_Acc_gt_60=bool(aasd["Acc"] > 60),
        tip_moved=bool(aasd["Acc"] > SW2_SWMIX_LEADER["AASD"]["Acc"]),
        lodo_mean=prim["lodo_mean"],
        lodo_AVGC=prim["lodo"]["AVGC"],
    )
    results["status"] = "done"
    results["elapsed_s"] = time.time() - t_all
    log_line(
        f"HEADLINE {selected} AASD H {aasd['H']:.4f} Acc {aasd['Acc']:.2f} "
        f"(Δtip {d_tip:+.2f}, Δhp30 {d_hp:+.2f}; >60={'YES' if aasd['Acc'] > 60 else 'NO'}; "
        f"tip_moved={'YES' if results['headline']['tip_moved'] else 'NO'})  "
        f"Carta H {carta['H']:.4f} Acc {carta['Acc']:.2f}"
    )

    with open(OUT, "w") as fh:
        json.dump(results, fh, indent=2, default=_json_default)
    write_md(results)
    log_line(f"wrote {OUT} + {RESULTS_MD} ({time.time() - t_all:.0f}s)")


if __name__ == "__main__":
    main()
