"""Past-only subject/trial adaptive HMM emission μ±,σ on Acc tip streams.

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

Tip streams (frozen evidence — NOT affine-transformed):
  1. published SW2 fuse_general a=0.5
  2. Acc leader hard_abs_swmix|t1 from sw2_swmix_blend

Adaptation (DISTINCT from online-moment-sw2 logit affine/whiten):
  Keep evidence z[t] fixed. Adapt Gaussian emission params (μ, σ) used by the
  2-state HMM (±μ shared magnitude) with past-only EWMA:
    abs_mu   — μ ← EWMA(|z|); σ ← σ0·(μ/μ0)
    m2_ratio — from EWMA(z²) keep train ρ=σ0/μ0; μ=√(m2/(1+ρ²)), σ=ρ·μ
    soft_mu  — EWMA of soft-provisional signed z under filtered P(state);
               σ fixed at σ0 (or soft residual if soft_mu_sd)

Decode @ p_stay=0.994, emission scale baked into σ0 = train_sd·0.8.
Select by mean LODO Acc then H (never AASD/Carta). Score LODO5 + AASD + Carta.

≠ online-moment-sw2, ≠ platt-acc-tip, ≠ domain-emis tip↔hp30, ≠ §C6 bank.

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

import json
import os
import re
import time

import numpy as np

import ensemble_clf_transformer_v4 as V4
import eval_external as E
import score as S
import sw2_hp30_blend as SW2
import sw2_swmix_blend as SM
from common import DS_KEYS, FS as FS128, SEED
from e1_switch import expand, synth_trial
from fuse_evidence import LA, OFF
from scorer import aggregate, fast_score_subject

try:
    import numba
except ImportError:
    numba = None

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

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

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 = (15.0, 30.0, 60.0)
# mode ids for numba: 0 none, 1 abs_mu, 2 m2_ratio, 3 soft_mu, 4 soft_mu_sd
MODE_ID = dict(none=0, abs_mu=1, m2_ratio=2, soft_mu=3, soft_mu_sd=4)

# (name, stream, mode, tau_s, persist_subject)
VARIANT_SPECS = []
for stream in ("tip", "sw2"):
    VARIANT_SPECS.append((f"{stream}_raw", stream, "none", None, True))
    for tau in TAUS:
        VARIANT_SPECS.append((f"{stream}_abs_mu_t{int(tau)}", stream, "abs_mu", tau, False))
        VARIANT_SPECS.append((f"{stream}_m2_t{int(tau)}", stream, "m2_ratio", tau, False))
        VARIANT_SPECS.append((f"{stream}_soft_mu_t{int(tau)}", stream, "soft_mu", tau, False))
    VARIANT_SPECS.append((f"{stream}_soft_mu_sd_t30", stream, "soft_mu_sd", 30.0, False))
    VARIANT_SPECS.append((f"{stream}_soft_mu_subj_t30", stream, "soft_mu", 30.0, True))
    VARIANT_SPECS.append((f"{stream}_abs_mu_subj_t30", stream, "abs_mu", 30.0, True))


def _njit(fn):
    return numba.njit(cache=False)(fn) if numba is not None else fn


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 tip_stream(sw2, swmix_aligned):
    return SM.apply_gate_all(sw2, swmix_aligned, TIP_KIND, TIP_THR, TIP_SHARP)


def build_raw_held(Z, swmix_full):
    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 train_signed_emis(streams, meta, datasets):
    parts = []
    for ds in datasets:
        if ds not in streams:
            continue
        for k, d in streams[ds].items():
            if ds not in meta or k not in meta[ds]:
                continue
            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(max(A.std(), EPS))


def avg_corpus_stream(streams_by_held):
    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


@_njit
def integ_adapt_nb(d, p_stay, mu0, sd0, alpha, mode_id, mu_lo, mu_hi, sd_lo, sd_hi):
    """Past-only adaptive ±μ Gaussian HMM. Emit with (μ,σ) then update from z[t].

    mode_id: 0 fixed, 1 abs_mu, 2 m2_ratio, 3 soft_mu, 4 soft_mu_sd
    Returns (decisions int8, mu_final, sd_final).
    """
    n = d.shape[0]
    out = np.empty(n, np.int8)
    mu = mu0
    sd = sd0
    m_abs = mu0
    m2 = mu0 * mu0 + sd0 * sd0
    rho = sd0 / max(mu0, 1e-6)
    lp0 = np.log(0.5)
    lp1 = np.log(0.5)
    ls = np.log(p_stay)
    lsw = np.log(1.0 - p_stay)
    a = alpha
    one_m_a = 1.0 - a
    for t in range(n):
        if t > 0:
            aa = np.logaddexp(lp0 + ls, lp1 + lsw)
            bb = np.logaddexp(lp1 + ls, lp0 + lsw)
            lp0, lp1 = aa, bb
        inv = 1.0 / max(sd, 1e-6)
        z0 = (d[t] - mu) * inv
        z1 = (d[t] + mu) * inv
        lp0 = lp0 - 0.5 * z0 * z0
        lp1 = lp1 - 0.5 * z1 * z1
        nrm = np.logaddexp(lp0, lp1)
        lp0 = lp0 - nrm
        lp1 = lp1 - nrm
        p1 = np.exp(lp1)
        out[t] = 1 if p1 > 0.5 else 0

        if mode_id == 0 or a <= 0.0:
            continue
        xt = d[t]
        if mode_id == 1:
            m_abs = one_m_a * m_abs + a * (xt if xt >= 0.0 else -xt)
            mu = m_abs
            if mu < mu_lo:
                mu = mu_lo
            elif mu > mu_hi:
                mu = mu_hi
            sd = sd0 * (mu / max(mu0, 1e-6))
            if sd < sd_lo:
                sd = sd_lo
            elif sd > sd_hi:
                sd = sd_hi
        elif mode_id == 2:
            m2 = one_m_a * m2 + a * xt * xt
            mu = np.sqrt(max(m2 / (1.0 + rho * rho), 1e-12))
            if mu < mu_lo:
                mu = mu_lo
            elif mu > mu_hi:
                mu = mu_hi
            sd = rho * mu
            if sd < sd_lo:
                sd = sd_lo
            elif sd > sd_hi:
                sd = sd_hi
        else:
            # soft provisional: signed obs toward +μ under P(state0)=1-p1
            w0 = 1.0 - p1
            signed = (w0 - p1) * xt
            mu = one_m_a * mu + a * signed
            if mu < 0.0:
                mu = -mu
            if mu < mu_lo:
                mu = mu_lo
            elif mu > mu_hi:
                mu = mu_hi
            if mode_id == 4:
                r0 = xt - mu
                r1 = xt + mu
                resid2 = w0 * r0 * r0 + p1 * r1 * r1
                var = one_m_a * (sd * sd) + a * resid2
                sd = np.sqrt(max(var, 1e-12))
                if sd < sd_lo:
                    sd = sd_lo
                elif sd > sd_hi:
                    sd = sd_hi
    return out, mu, sd


def integ_adapt(d, p_stay, mu0, sd0, alpha, mode, state=None):
    """Run adaptive HMM; state=(mu,sd) carried across trials when persist_subject."""
    d = np.ascontiguousarray(np.asarray(d, np.float64).reshape(-1))
    mode_id = MODE_ID[mode]
    if state is None:
        mu_i, sd_i = float(mu0), float(sd0)
    else:
        mu_i, sd_i = float(state[0]), float(state[1])
    mu_lo, mu_hi = MU_CLIP[0] * mu0, MU_CLIP[1] * mu0
    sd_lo, sd_hi = SD_CLIP[0] * sd0, SD_CLIP[1] * sd0
    if mode_id == 0 or alpha is None or alpha <= 0.0 or len(d) == 0:
        # fixed path via same nb for consistency
        dec, mu_f, sd_f = integ_adapt_nb(
            d, float(p_stay), mu_i, sd_i, 0.0, 0, mu_lo, mu_hi, sd_lo, sd_hi
        )
        return dec, (mu_f, sd_f)
    dec, mu_f, sd_f = integ_adapt_nb(
        d, float(p_stay), mu_i, sd_i, float(alpha), mode_id, mu_lo, mu_hi, sd_lo, sd_hi
    )
    return dec, (mu_f, sd_f)


def score_lodo_held_adapt(stream_all, meta, held, mu0, sd0, mode, alpha, persist_subject):
    """Mirror score.score_dataset on held-out with adaptive emissions; evidence pre_switched."""
    ev = SW2.ev_from_stream(stream_all, meta)
    # install for any shared state; Acc from adaptive path below
    V4._install_scorer_state(ev, LOOKAHEAD)
    rng = np.random.default_rng(SEED + DS_KEYS.index(held))
    per = {}
    # group keys by subject for optional persist
    rows = list(S.rows_of(held).iterrows())
    by_sub = {}
    for _, r in rows:
        sid = r["subj_uid"]
        by_sub.setdefault(sid, []).append(r)

    for sid in sorted(by_sub.keys(), key=lambda x: str(x)):
        rlist = sorted(by_sub[sid], key=lambda r: str(r["key"]))
        state = None
        for r in rlist:
            T = int(r["n"])
            e = ev[held][r["key"]]
            lab = np.load(os.path.join(S.EDA_CACHE, "cnd", f"{r['key']}.npz"))
            att = lab["att_col"][:T].astype(int)
            d = (e["r0"] - e["r1"]).astype(float)
            t_end = e["t_end"].astype(float)
            st, d_syn, _ = synth_trial(r["key"], T, d, t_end, rng)
            if e.get("pre_switched"):
                d_syn = d
            guess = int(rng.integers(0, 2))
            if not persist_subject:
                state = None
            dec, state = integ_adapt(
                d_syn, P_STAY, mu0, sd0, alpha if mode != "none" else 0.0, mode, state=state
            )
            labs = expand(dec, t_end, LOOKAHEAD, T, guess)
            per.setdefault(sid, []).append((labs, np.where(st, 1 - att, att)))

    res = []
    for _subj, lst in per.items():
        pred = np.concatenate([a for a, _ in lst])
        gt = np.concatenate([b for _, b in lst])
        trial = np.concatenate([np.full(len(a), i) for i, (a, _) in enumerate(lst)])
        res.append(fast_score_subject(pred, gt, trial, fs=FS128))
    a = aggregate(res)
    return dict(
        Acc=a["Acc"], SDT=a["SDT"], L=a["L"], H=a["H"],
        nSwitches=a["nSwitches"], nUndetected=a["nUndetected"],
        emis_mu=mu0, emis_sd=sd0,
    )


def score_ext_adapt(ev, mu0, sd0, mode, alpha, persist_subject):
    """External real-switch score with adaptive emissions (past-only)."""
    rng = np.random.default_rng(SEED)
    by_sub = {}
    for key in sorted(ev):
        e = ev[key]
        sid = e["subject"]
        by_sub.setdefault(sid, []).append(key)

    per = {}
    for sid in sorted(by_sub.keys(), key=lambda x: str(x)):
        keys = by_sub[sid]
        state = None
        for key in keys:
            e = ev[key]
            d = (e["r0"] - e["r1"]).astype(float)
            if not persist_subject:
                state = None
            dec, state = integ_adapt(
                d, P_STAY, mu0, sd0, alpha if mode != "none" else 0.0, mode, state=state
            )
            labs = expand(
                dec, e["t_end"].astype(float), LOOKAHEAD, e["n128"], int(rng.integers(0, 2))
            )
            per.setdefault(sid, []).append((labs, e["att128"].astype(float)))

    res = []
    for _s, lst in per.items():
        pred = np.concatenate([a for a, _ in lst])
        gt = np.concatenate([b for _, b in lst])
        trial = np.concatenate([np.full(len(a), i) for i, (a, _) in enumerate(lst)])
        res.append(fast_score_subject(pred, gt, trial, fs=FS128))
    a = aggregate(res)
    return dict(
        Acc=a["Acc"], SDT=a["SDT"], L=a["L"], H=a["H"],
        nSwitches=a["nSwitches"], nUndetected=a["nUndetected"],
    )


def blend_ext_tip(sw2_ev, sm_aligned):
    return SM.blend_ext_ev(sw2_ev, sm_aligned, TIP_KIND, TIP_THR, TIP_SHARP)


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 _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_subj_adapt_emis_tip\n")
    lines.append(
        "**Claim:** `subj-adapt-emis-tip` — past-only per-trial/subject adaptive "
        "**HMM Gaussian emission** μ±,σ 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(
        "Evidence stream frozen. Adapt emissions via EWMA under provisional soft state "
        "(`soft_mu` / `soft_mu_sd`) or unlabeled moment match (`abs_mu`, `m2_ratio`). "
        "**DISTINCT** from `online-moment-sw2` (logit affine), `platt-acc-tip`, "
        "`domain-emis-acc-tip`, and §C6 reliability/CUSUM/MSM bank.\n"
    )
    lines.append(
        f"HMM preset **{P_STAY} / {SCALE}**. Code: `subj_adapt_emis_tip.py`. "
        f"JSON: `results/research/subj_adapt_emis_tip.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 adaptive-emission rule 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 past-only adaptive HMM emissions (μ±,σ) of "
            "Acc tip SW2 / `hard_abs_swmix|t1` does not create AASD Acc>60. Emission-param "
            "drift tracking is as flat as logit-stream online-moment on the same tip family.\n"
        )

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

    lines.append("## NEXT IDEA\n")
    nxt = results.get("next_idea") or (
        "Emission μ/σ online tracking on tip Acc streams does not close Acc>60 "
        "(same ceiling ~53.5 as logit moment match). Prefer a **qualitatively new Acc "
        "front-end** (non-vlaai / non-tip-postprocess) that lifts AASD acc1, or a "
        "Carta-aware train recipe that transfers Acc without banned §C6 banks. "
        "Keep tip AASD Acc 53.53 and `linear_hp30` Carta 60.54 as portfolio leaders."
    )
    lines.append(nxt + "\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"subj-adapt-emis-tip CPU  p_stay={P_STAY} scale={SCALE} a_sw2={A_SW2} "
        f"tip={TIP_KIND}|t{TIP_THR:g} n_var={len(VARIANT_SPECS)}"
    )
    log_line(
        "honesty: adapt emission μ±,σ only (evidence frozen); past-only EWMA; "
        "no labels/entropy-min; no AASD/Carta for select; ≠ logit affine"
    )

    # Warm numba
    _ = integ_adapt(np.zeros(8), P_STAY, 1.0, 1.0, 0.1, "soft_mu", state=None)

    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_subj_adapt_emis_tip\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 vs tip_raw / fixed emissions
    mu_s, sd_s = train_signed_emis(tip_held["AVGC"], meta, [d for d in DS_KEYS if d != "AVGC"])
    r_tip = score_lodo_held_adapt(
        tip_held["AVGC"], meta, "AVGC", mu_s, sd_s * SCALE, "none", 0.0, True
    )
    log_line(
        f"sanity AVGC tip_raw H {r_tip['H']:.4f} Acc {r_tip['Acc']:.2f} "
        f"(expect ~0.7159 / ~67.94); emis μ {mu_s:.4f} σ·scale {sd_s*SCALE:.4f}"
    )

    results = dict(
        status="running",
        method="subj-adapt-emis-tip",
        p_stay=P_STAY,
        scale=SCALE,
        a_sw2=A_SW2,
        tip=dict(kind=TIP_KIND, thresh=TIP_THR, sharp=TIP_SHARP),
        taus=list(TAUS),
        mu_clip=list(MU_CLIP),
        sd_clip=list(SD_CLIP),
        honesty=(
            "Past-only EWMA adaptive HMM emission μ±,σ on Acc tip SW2/tip. "
            "Evidence frozen (≠ online-moment logit affine). No labels, no entropy-min, "
            "no soft/hard blend re-grid. ≠ platt / domain-emis tip↔hp30 / §C6 bank."
        ),
        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 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_signed_emis(raw, meta, train_ds)
            sd_dec = sd_t * SCALE
            off = score_lodo_held_adapt(
                raw, meta, held, mu_t, sd_dec, mode, alpha, persist
            )
            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, sd_decode=sd_dec,
            )
            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,
            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,
    )

    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": 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_signed_emis(
            corp_raw[stream], meta, list(DS_KEYS)
        )
        log_line(
            f"corpus {stream} signed emis mu {mu_corp[stream]:.6f} sd {sd_corp[stream]:.6f}"
        )
    results["train_emis_corpus"] = {
        s: dict(mu=mu_corp[s], sd=sd_corp[s]) for s in ("sw2", "tip")
    }

    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 in VARIANT_SPECS:
        alpha = 0.0 if mode == "none" else alpha_from_tau(tau)
        mu_e, sd_e = mu_corp[stream], sd_corp[stream]
        if mode == "none" and stream == "sw2":
            mu_e, sd_e = float(emis_sw2[A_SW2][0]), float(emis_sw2[A_SW2][1])
        sd_dec = sd_e * SCALE
        ext = {}
        for ds in ("AASD", "Carta2026"):
            base_ev = EV_sw2[ds][A_SW2] if stream == "sw2" else tip_ext_ev[ds]
            if mode == "none":
                r = E.score(base_ev, mu_e, sd_dec, P_STAY, LOOKAHEAD)
            else:
                r = score_ext_adapt(base_ev, mu_e, sd_dec, mode, alpha, persist)
            pl = E.plain(base_ev)
            ext[ds] = dict(
                H=r["H"], Acc=r["Acc"], SDT=r["SDT"], L=r["L"],
                acc1=pl["acc1"], nSwitches=r.get("nSwitches"), nUndetected=r.get("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, sd_decode=sd_dec)

    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"]

    next_idea = (
        "Emission μ/σ online tracking on tip Acc streams does not close Acc>60 "
        "(same ceiling ~53.5 as logit moment match). Prefer a **qualitatively new Acc "
        "front-end** (non-vlaai / non-tip-postprocess) that lifts AASD acc1, or a "
        "Carta-aware train recipe that transfers Acc without banned §C6 banks. "
        "Keep tip AASD Acc 53.53 and `linear_hp30` Carta 60.54 as portfolio leaders."
    )
    if aasd["Acc"] > 60:
        next_idea = (
            "Adaptive emissions cleared Acc>60 — freeze this emission schedule and "
            "stress-test Carta; avoid re-grid of tip soft-w / logit affine."
        )
    results["next_idea"] = next_idea

    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_emis_corpus=results["train_emis_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()
