"""Past-only causal EWMA μ/σ affine-to-train / whiten on Acc tip SW2 streams.

CPU-only. Reuses SW2 / swmix caches from sw2_swmix_blend.py (no re-grid of
SW2↔swmix soft/hard weights).

Tip streams (frozen):
  1. published SW2 fuse_general a=0.5
  2. Acc leader hard_abs_swmix|t1 from sw2_swmix_blend

Adaptation: past-only EWMA of unlabeled decision-stream moments; emit using
past EMA then update with raw z[t]:
  affine-to-train:  z' = (z - μ_ema) * (σ_train / σ_ema) + μ_train
  scale-only:       z' = (z - μ_ema) * (σ_train / σ_ema) + μ_ema
  online-whiten:    z' = (z - μ_ema) / σ_ema

τ∈{5,15,30,60}s + scale-only at τ=30. Distinct from online-moment-hp30
(4-seed linear_hp30) and Acc-stream soft/hard blend re-grids.

Variant selection: mean LODO Acc then H @ HMM 0.994/0.8 (never AASD/Carta).
Score LODO5 + AASD + Carta.

usage:
  PYTHONPATH=.../reports/eda_full/scripts:$PYTHONPATH \\
    /root/disk_3tb/EEG-sAAD-Grand-Challenge-Training-Dataset/.venv/bin/python -u online_moment_sw2.py
"""
from __future__ import annotations

import json
import os
import re
import time

import numpy as np
from scipy.signal import lfilter

import ensemble_clf_nested as N
import ensemble_clf_transformer_v4 as V4
import eval_external as E
import sw2_hp30_blend as SW2
import sw2_swmix_blend as SM
from common import DS_KEYS
from fuse_evidence import LA, OFF

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

P_STAY = 0.994
SCALE = 0.8
LOOKAHEAD = float(LA)
A_SW2 = SW2.A_SW2
HOP = 0.25
EPS = 1e-6
SCALE_CLIP = (0.25, 4.0)

# Acc tip leader from sw2_swmix_blend (do NOT re-grid)
TIP_KIND, TIP_THR, TIP_SHARP = "hard_abs_swmix", 1.0, 1.0

LINEAR_HP30_EXT = dict(AASD=dict(H=0.6422, Acc=53.12), Carta2026=dict(H=0.6520, Acc=60.54))
SW2_ALONE_EXT = dict(AASD=dict(H=0.6439, Acc=53.46), Carta2026=dict(H=0.6470, Acc=59.60))
SW2_SWMIX_LEADER = dict(AASD=dict(H=0.6424, Acc=53.53), Carta2026=dict(H=0.6460, Acc=59.71))

TAUS = (5.0, 15.0, 30.0, 60.0)

# (name, stream, mode, tau_s, persist_subject, scale_only)
# stream: sw2 | tip   mode: none | affine | whiten
VARIANT_SPECS = []
for stream in ("sw2", "tip"):
    VARIANT_SPECS.append((f"{stream}_raw", stream, "none", None, True, False))
    for tau in TAUS:
        VARIANT_SPECS.append((f"{stream}_affine_t{int(tau)}", stream, "affine", tau, True, False))
    VARIANT_SPECS.append((f"{stream}_affine_t30_scale", stream, "affine", 30.0, True, True))
    for tau in (15.0, 30.0, 60.0):
        VARIANT_SPECS.append((f"{stream}_whiten_t{int(tau)}", stream, "whiten", tau, True, False))


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):
    if isinstance(meta_entry, dict) and "subject" in meta_entry:
        return int(meta_entry["subject"])
    m = re.search(r"subject[-_]?(\d+)", str(key), re.I)
    if m:
        return int(m.group(1))
    m = re.search(r"_S(\d+)_", str(key), re.I)
    if m:
        return int(m.group(1))
    return hash(str(key)) % 10_000_007


def alpha_from_tau(tau):
    return float(1.0 - np.exp(-HOP / float(tau)))


def train_moments(streams, datasets):
    parts = []
    for ds in datasets:
        if ds not in streams:
            continue
        for _k, d in streams[ds].items():
            parts.append(np.asarray(d, np.float64).reshape(-1))
    if not parts:
        return 0.0, 1.0
    x = np.concatenate(parts)
    return float(x.mean()), float(x.std()) + EPS


def _ema_past(x, alpha, init):
    """Past-only EMA at each t (init at t=0); also return final EMA including last x."""
    x = np.asarray(x, np.float64).reshape(-1)
    a = float(alpha)
    y, _ = lfilter([a], [1.0, -(1.0 - a)], x, zi=np.asarray([init * (1.0 - a)], np.float64))
    past = np.empty_like(x)
    past[0] = init
    if len(x) > 1:
        past[1:] = y[:-1]
    return past, float(y[-1]) if len(y) else float(init)


def adapt_1d(z, mu_tgt, sd_tgt, alpha, mode, scale_only=False,
             init_mu=None, init_second=None):
    """Causal EMA moment match. Emit using past EMA, then update with raw z[t]."""
    z = np.asarray(z, np.float64).reshape(-1)
    if mode == "none" or mode is None or len(z) == 0:
        return z.copy(), (mu_tgt if init_mu is None else init_mu), (
            mu_tgt * mu_tgt + sd_tgt * sd_tgt if init_second is None else init_second)
    mu0 = float(mu_tgt if init_mu is None else init_mu)
    sec0 = float((mu_tgt * mu_tgt + sd_tgt * sd_tgt) if init_second is None else init_second)
    mu_past, mu_final = _ema_past(z, alpha, mu0)
    sec_past, sec_final = _ema_past(z * z, alpha, sec0)
    var = np.maximum(sec_past - mu_past * mu_past, EPS)
    sd = np.sqrt(var)
    lo, hi = SCALE_CLIP
    if mode == "affine":
        scale = np.clip(sd_tgt / sd, lo, hi)
        if scale_only:
            out = (z - mu_past) * scale + mu_past
        else:
            out = (z - mu_past) * scale + mu_tgt
    elif mode == "whiten":
        out = (z - mu_past) / sd
    else:
        out = z.copy()
    return out, mu_final, sec_final


def adapt_streams(streams, meta_by_ds, mu_tgt, sd_tgt, alpha, mode,
                  persist_subject=True, scale_only=False):
    """Apply per-subject (or per-trial) causal adapt. Trials sorted by key."""
    if mode == "none" or mode is None:
        return {ds: {k: np.asarray(d, np.float64) for k, d in table.items()}
                for ds, table in streams.items()}
    out = {}
    for ds, table in streams.items():
        meta = (meta_by_ds or {}).get(ds) or {}
        by_sub = {}
        for key in table:
            entry = meta.get(key)
            # LODO meta is (att, t_end); external is dict with subject
            sid = subject_of(key, entry if isinstance(entry, dict) else None)
            by_sub.setdefault(sid, []).append(key)
        adapted = {}
        for _sid, keys in by_sub.items():
            keys = sorted(keys)
            state_mu, state_second = None, None
            for key in keys:
                if not persist_subject:
                    state_mu, state_second = None, None
                y, state_mu, state_second = adapt_1d(
                    table[key], mu_tgt, sd_tgt, alpha, mode, scale_only=scale_only,
                    init_mu=state_mu, init_second=state_second,
                )
                adapted[key] = y
        out[ds] = adapted
    return out


def tip_stream(sw2, swmix_aligned):
    """hard_abs_swmix|t1 gate: prefer swmix when |swmix|>=1 else SW2."""
    return SM.apply_gate_all(sw2, swmix_aligned, TIP_KIND, TIP_THR, TIP_SHARP)


def build_raw_held(Z, swmix_full):
    """Per held: raw sw2 fuse and tip (hard_abs_swmix|t1) streams."""
    sw2_held, tip_held = {}, {}
    for held in DS_KEYS:
        sw2 = SW2.fuse_sw2_held(Z, held, a=A_SW2)
        sm = SM.align_swmix_to_sw2(swmix_full, sw2)
        sw2_held[held] = sw2
        tip_held[held] = tip_stream(sw2, sm)
    return sw2_held, tip_held


def score_lodo_held(stream_all, meta, held):
    ev = SW2.ev_from_stream(stream_all, meta)
    V4._install_scorer_state(ev, LOOKAHEAD)
    return N.official(held, ev, P_STAY, SCALE)


def emissions_from_stream(streams, meta, datasets):
    parts = []
    for ds in datasets:
        for k, d in streams[ds].items():
            att = meta[ds][k][0]
            n = min(len(d), len(att))
            parts.append(
                np.asarray(d[:n], np.float64)
                * np.where(np.asarray(att)[:n] == 0, 1.0, -1.0)
            )
    A = np.concatenate(parts)
    return float(A.mean()), float(A.std())


def avg_corpus_stream(streams_by_held):
    """Average held-specific streams into a single corpus stream."""
    acc = {ds: {} for ds in DS_KEYS}
    counts = {ds: {} for ds in DS_KEYS}
    for held in DS_KEYS:
        stream = streams_by_held[held]
        for ds in DS_KEYS:
            for k, d in stream[ds].items():
                d = np.asarray(d, np.float64)
                if k not in acc[ds]:
                    acc[ds][k] = np.zeros_like(d, np.float64)
                    counts[ds][k] = 0
                n = min(len(acc[ds][k]), len(d))
                acc[ds][k][:n] += d[:n]
                counts[ds][k] += 1
    out = {}
    for ds in DS_KEYS:
        out[ds] = {k: acc[ds][k] / max(counts[ds][k], 1) for k in acc[ds]}
    return out


def pick_variant(lodo_means):
    best_name, best_key = None, None
    for name, m in lodo_means.items():
        key = (float(m["Acc"]), float(m["H"]))
        if best_key is None or key > best_key:
            best_key, best_name = key, name
    return best_name


def adapt_ext_ev(ev, mu_tgt, sd_tgt, alpha, mode, scale_only=False, persist=True):
    """Adapt external evidence r0 in place-structure; carry EMA across subject trials."""
    by_sub = {}
    for key, e in ev.items():
        sid = subject_of(key, e)
        by_sub.setdefault(sid, []).append(key)
    out = {}
    for _sid, keys in by_sub.items():
        keys = sorted(keys)
        state_mu, state_second = None, None
        for key in keys:
            if not persist:
                state_mu, state_second = None, None
            e = ev[key]
            y, state_mu, state_second = adapt_1d(
                e["r0"], mu_tgt, sd_tgt, alpha, mode, scale_only=scale_only,
                init_mu=state_mu, init_second=state_second,
            )
            n = len(y)
            out[key] = dict(
                r0=y,
                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 blend_ext_tip(sw2_ev, sm_aligned):
    return SM.blend_ext_ev(sw2_ev, sm_aligned, TIP_KIND, TIP_THR, TIP_SHARP)


def _json_default(o):
    if isinstance(o, (np.floating, np.integer)):
        return float(o)
    if isinstance(o, np.ndarray):
        return o.tolist()
    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_online_moment_sw2\n")
    lines.append(
        "**Claim:** `online-moment-sw2` — past-only causal EWMA μ/σ **affine-to-train** "
        "or **whiten** on Acc tip streams (CPU):\n"
        "1. published SW2 `fuse_general` a=0.5\n"
        "2. Acc leader `hard_abs_swmix|t1` from `sw2_swmix_blend`\n"
    )
    lines.append(
        f"**τ∈{{{','.join(str(int(t)) for t in TAUS)}}}s** + scale-only @τ=30. "
        "**DISTINCT** from `online-moment-hp30` (4-seed linear_hp30) and Acc-stream "
        "soft/hard blend re-grids (no SW2↔swmix w re-grid).\n"
    )
    lines.append(
        f"HMM preset **{P_STAY} / {SCALE}**. Code: `online_moment_sw2.py`. "
        f"JSON: `results/research/online_moment_sw2.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 (LODO Acc desc; selected first)\n")
    lines.append(
        "| Variant | LODO H / Acc | AASD H / Acc | ΔAcc vs 53.53 | ΔAcc vs 53.12 | 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} | {a['Acc']-hp_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"| LODO mean | H {prim['lodo_mean']['H']:.4f} Acc {prim['lodo_mean']['Acc']:.2f} |\n"
    )

    lines.append("## Verdict\n")
    if aasd["Acc"] > 60:
        lines.append("Selected online-moment on Acc tip clears AASD Acc>60.\n")
    elif aasd["Acc"] > tip_acc + 0.15:
        lines.append(
            "Selected rule lifts AASD Acc vs tip 53.53 but does not clear Acc>60.\n"
        )
    else:
        lines.append(
            "Honest LODO Acc/H selector on causal EWMA moment match of Acc tip SW2 / "
            "`hard_abs_swmix|t1` does not create AASD Acc>60. Same qualitative flatness "
            "as online-moment-hp30, now on the Acc tip family (~53.46–53.53).\n"
        )

    lines.append("## Do not repeat\n")
    lines.append(
        "Do not rerun past-only EWMA affine/whiten on frozen SW2 fuse a=0.5 or "
        "`hard_abs_swmix|t1` tip streams at this HMM. Do not re-grid SW2↔swmix soft/hard.\n"
    )

    lines.append("## NEXT IDEA\n")
    lines.append(
        "Bottleneck is not 1st/2nd-order drift of Acc tip decision streams "
        "(online-moment flat on hp30 and SW2/tip). Prefer a **qualitatively new** Acc "
        "front-end that clears chance and lifts AASD acc1, or unlabeled "
        "emission-aware choice among *already scored* Acc leaders without soft-w re-grids. "
        "Keep tip AASD Acc 53.53 and `linear_hp30` Carta 60.54 as portfolio leaders.\n"
    )
    with open(RESULTS_MD, "w") as fh:
        fh.write("\n".join(lines))


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()
    log_line(
        f"online-moment-sw2 CPU  p_stay={P_STAY} scale={SCALE} a_sw2={A_SW2} "
        f"tip={TIP_KIND}|t{TIP_THR:g} taus={TAUS}"
    )
    log_line(
        "honesty: past-only EWMA moments on Acc tip SW2/tip; no entropy-min; "
        "no AASD/Carta labels; no SW2↔swmix w re-grid"
    )

    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} OFF={OFF}")
    except FileNotFoundError as e:
        log_line(f"ABORT: {e}")
        summary = dict(status="abandoned", reason=str(e))
        with open(OUT, "w") as fh:
            json.dump(summary, fh, indent=2)
        with open(RESULTS_MD, "w") as fh:
            fh.write(f"# results_online_moment_sw2\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 = build_raw_held(Z, swmix_full)
    raw_by_stream = dict(sw2=sw2_held, tip=tip_held)

    # Sanity
    r_sw2 = score_lodo_held(sw2_held["AVGC"], meta, "AVGC")
    r_tip = score_lodo_held(tip_held["AVGC"], meta, "AVGC")
    log_line(
        f"sanity AVGC sw2_raw H {r_sw2['H']:.4f} Acc {r_sw2['Acc']:.2f} "
        f"(expect ~0.71 / ~68)"
    )
    log_line(
        f"sanity AVGC tip_raw H {r_tip['H']:.4f} Acc {r_tip['Acc']:.2f} "
        f"(expect ~0.7159 / ~67.94 from sw2_swmix_blend)"
    )

    results = dict(
        status="running",
        method="online-moment-sw2",
        p_stay=P_STAY,
        scale=SCALE,
        a_sw2=A_SW2,
        tip=dict(kind=TIP_KIND, thresh=TIP_THR, sharp=TIP_SHARP),
        taus=list(TAUS),
        scale_clip=list(SCALE_CLIP),
        honesty=(
            "Past-only EWMA affine/whiten on Acc tip SW2 fuse and/or hard_abs_swmix|t1. "
            "No labels, no entropy-min, no soft/hard blend re-grid. "
            "Distinct from online-moment-hp30."
        ),
        baselines=dict(
            linear_hp30_ext=LINEAR_HP30_EXT,
            sw2_alone_ext=SW2_ALONE_EXT,
            sw2_swmix_leader=SW2_SWMIX_LEADER,
        ),
        variants={},
    )
    lodo_means = {}

    log_line(f"=== LODO ({len(VARIANT_SPECS)} variants; selection) ===")
    for name, stream, mode, tau, persist, scale_only in VARIANT_SPECS:
        t0 = time.time()
        alpha = 0.0 if mode == "none" else alpha_from_tau(tau)
        per = {}
        for held in DS_KEYS:
            raw = raw_by_stream[stream][held]
            train_ds = [d for d in DS_KEYS if d != held]
            mu_t, sd_t = train_moments(raw, train_ds)
            adapted = adapt_streams(
                raw, None, mu_t, sd_t, alpha, mode,
                persist_subject=persist, scale_only=scale_only,
            )
            off = score_lodo_held(adapted, meta, held)
            per[held] = dict(
                H=off["H"], Acc=off["Acc"], SDT=off.get("SDT"), L=off.get("L"),
                train_mu=mu_t, train_sd=sd_t,
            )
            log_line(f"LODO {name:28s} {held:5s}  H {off['H']:.4f} Acc {off['Acc']:.2f}")
        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:28s}  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, tau=tau, alpha=alpha if mode != "none" else None,
            persist_subject=persist, scale_only=scale_only,
            lodo=per, lodo_mean=dict(H=mean_h, Acc=mean_a),
        )

    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"top5: {ranked[:5]}")
    results["selected"] = selected
    results["selection"] = dict(
        criterion="mean LODO Acc then H (never AASD/Carta)",
        ranked=ranked,
        selected=selected,
    )

    # External
    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

    # Corpus raw streams (avg over held) for train-moment targets + emissions
    corp_raw = {
        "sw2": avg_corpus_stream(sw2_held),
        "tip": avg_corpus_stream(tip_held),
    }
    mu_corp = {}
    sd_corp = {}
    for stream in ("sw2", "tip"):
        mu_corp[stream], sd_corp[stream] = train_moments(corp_raw[stream], list(DS_KEYS))
        log_line(
            f"corpus {stream} moments mu {mu_corp[stream]:.6f} sd {sd_corp[stream]:.6f}"
        )
    results["train_moments_corpus"] = {
        s: dict(mu=mu_corp[s], sd=sd_corp[s]) for s in ("sw2", "tip")
    }

    # Prebuild tip external evidence once
    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] = blend_ext_tip(sw2_ev, sm_al)

    log_line("=== external (all variants; headline = selected) ===")
    for name, stream, mode, tau, persist, scale_only in VARIANT_SPECS:
        alpha = 0.0 if mode == "none" else alpha_from_tau(tau)
        mu_t, sd_t = mu_corp[stream], sd_corp[stream]
        adapted_train = adapt_streams(
            corp_raw[stream], None, mu_t, sd_t, alpha, mode,
            persist_subject=persist, scale_only=scale_only,
        )
        mu_e, sd_e = emissions_from_stream(adapted_train, meta, list(DS_KEYS))
        # fallback for raw sw2: use published emis if close
        if mode == "none" and stream == "sw2":
            mu_e, sd_e = float(emis_sw2[A_SW2][0]), float(emis_sw2[A_SW2][1])

        ext = {}
        for ds in ("AASD", "Carta2026"):
            if stream == "sw2":
                base_ev = EV_sw2[ds][A_SW2]
            else:
                base_ev = tip_ext_ev[ds]
            if mode == "none":
                ev_use = base_ev
            else:
                ev_use = adapt_ext_ev(
                    base_ev, mu_t, sd_t, alpha, mode,
                    scale_only=scale_only, persist=persist,
                )
            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:28s} {ds:10s}  H {r['H']:.4f} Acc {r['Acc']:.2f}  "
                f"Δtip {d_tip:+.2f}  Δhp30 {d_hp:+.2f}"
            )
        results["variants"][name]["external"] = ext
        results["variants"][name]["emis"] = dict(mu=mu_e, sd=sd_e)

    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),
        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"Carta H {carta['H']:.4f} Acc {carta['Acc']:.2f}"
    )
    log_line(
        f"HEADLINE LODO mean H {prim['lodo_mean']['H']:.4f} Acc {prim['lodo_mean']['Acc']:.2f}  "
        f"AVGC H {prim['lodo']['AVGC']['H']:.4f} Acc {prim['lodo']['AVGC']['Acc']:.2f}"
    )

    with open(OUT, "w") as fh:
        json.dump(results, fh, indent=2, default=_json_default)
    with open(os.path.join(CKPT, "selection.json"), "w") as fh:
        json.dump(
            dict(
                selected=selected,
                lodo_means=lodo_means,
                train_moments_corpus=results["train_moments_corpus"],
                headline=results["headline"],
            ),
            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()
