"""Prep-diverse classifier logit bank: 4 eaP seeds + lap_eaP s0 + lp7_eaP s0.

DISTINCT from SW2-as-5th-seed and SW2↔hp30 (no decoder SW2 stream). Prep diversity only.

Bank channels (aligned by trial key, min length):
  s0..s3  published eaP_n5_t60 w10b3 sw2 seeds
  lap     direct_clf__lap_eaP_w10b3_ptSPK_aug-sw2 (s0)
  lp7     direct_clf__lp7_eaP_w10b3_ptSPK_aug-sw2 (s0)

Candidates (always emit 1-D evidence):
  mean4 / mean5_lap / mean5_lp7 / mean6
  hp30_*   causal one-pole HP τ=30 on the corresponding equal mean
  soft_mean4_lap_w / soft_mean4_lp7_w / soft_mean4_both_w
  soft_hp30_lap_w / soft_hp30_lp7_w / soft_hp30_both_w
    where both = 0.5*(lap+lp7), w∈{0,0.25,0.5,0.75,1}

Selector: mean LODO Acc then H at HMM p_stay=0.994 scale=0.8. Never AASD/Carta labels.
Score 5 LODO + AASD + Carta2026. CPU only. Reuse fold/evidence caches; do not retrain.

Abort honestly if lap/lp7 LODO folds or external evidence pickles are missing/misaligned.

usage:
  PYTHONPATH=/root/disk_3tb/eeg-thao:.../reports/eda_full/scripts \\
    .../.venv/bin/python -u prep_diverse_seeds.py
"""
from __future__ import annotations

import json
import os
import pickle
import time

import numpy as np

import ensemble_clf as EC
import ensemble_clf_nested as N
import ensemble_clf_transformer_v4 as V4
import eval_external as E
import score as S
from common import DS_KEYS

EXP = os.path.dirname(os.path.abspath(__file__))
CACHE_DIR = os.path.join(EXP, "models", "prep_diverse_seeds", "cache")
LOG = os.path.join(EXP, "experiments", "prep_diverse_seeds.log")
OUT = os.path.join(EXP, "results", "research", "prep_diverse_seeds.json")
RESULTS_MD = os.path.join(EXP, "multi_agent_opt", "results_prep_diverse_seeds.md")
EVID = os.path.join(EXP, "results", "research")

P_STAY = 0.994
SCALE = 0.8
LOOKAHEAD = 0.75
HOP = 0.25
TAU = 30.0
SOFT_WS = (0.0, 0.25, 0.5, 0.75, 1.0)

LAP_EXP = "direct_clf__lap_eaP_w10b3_ptSPK_aug-sw2"
LP7_EXP = "direct_clf__lp7_eaP_w10b3_ptSPK_aug-sw2"

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))
CORPUS = ("AVGC", "DTU", "KUL", "UHD", "USTC")
TEST_NAMES = ("AASD", "Carta2026")


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 save_pkl(path, obj):
    os.makedirs(os.path.dirname(path), exist_ok=True)
    with open(path, "wb") as fh:
        pickle.dump(obj, fh, protocol=pickle.HIGHEST_PROTOCOL)


def load_pkl(path):
    with open(path, "rb") as fh:
        return pickle.load(fh)


def highpass_1d(x, tau=TAU, hop=HOP):
    return np.asarray(V4.highpass(np.asarray(x, np.float64).reshape(-1, 1), tau=float(tau), hop=hop),
                      np.float64).reshape(-1)


def require_file(path, label):
    if not os.path.isfile(path):
        raise FileNotFoundError(f"missing {label}: {path}")


def load_1d_folds(exp):
    """{ds: {key: (T,) delta}} from LODO folds."""
    for ds in DS_KEYS:
        require_file(os.path.join(EXP, "folds", exp, f"{ds}.pkl"), f"LODO fold {exp}/{ds}")
    ev, info = S.load_folds(exp, "causal")
    out = {}
    for ds in DS_KEYS:
        out[ds] = {k: EC.delta(e) for k, e in ev[ds].items()}
    return out, info


def load_eap4_lodo():
    path = os.path.join(CACHE_DIR, "eap4_lodo.pkl")
    if os.path.isfile(path):
        log_line(f"cache hit {path}")
        return load_pkl(path)
    log_line("loading 4-seed eaP LODO folds …")
    t0 = time.time()
    evs = []
    for seed, exp in EC.SEEDS:
        for ds in DS_KEYS:
            require_file(os.path.join(EXP, "folds", exp, f"{ds}.pkl"), f"LODO fold {exp}/{ds}")
        ev, _info = S.load_folds(exp, "causal")
        evs.append(ev)
        log_line(f"  loaded {exp} (seed {seed})")
    logits = {}
    for ds in DS_KEYS:
        logits[ds] = {}
        for k in evs[0][ds].keys():
            cols = [EC.delta(ev[ds][k]) for ev in evs]
            logits[ds][k] = np.stack(cols, 1).astype(np.float64)
    save_pkl(path, logits)
    log_line(f"eap4 LODO cache wrote ({time.time() - t0:.0f}s)")
    return logits


def align_bank(eap4_ds, lap_ds, lp7_ds, ds_name):
    """Intersect keys; truncate to min length. Return {key: (n,6)} = [s0..s3,lap,lp7]."""
    keys = sorted(set(eap4_ds) & set(lap_ds) & set(lp7_ds))
    if not keys:
        raise RuntimeError(f"{ds_name}: no shared trial keys across eaP4/lap/lp7")
    missing_e = set(eap4_ds) - set(keys)
    missing_l = set(lap_ds) - set(keys)
    missing_p = set(lp7_ds) - set(keys)
    if missing_e or missing_l or missing_p:
        # allow tiny key diffs but abort if >5% of eaP keys missing from either prep
        n_e = len(eap4_ds)
        drop_frac = max(len(missing_l), len(missing_p), len(set(keys) ^ set(eap4_ds))) / max(n_e, 1)
        if drop_frac > 0.05:
            raise RuntimeError(
                f"{ds_name}: key misalignment drop_frac={drop_frac:.3f} "
                f"(eap={n_e} lap={len(lap_ds)} lp7={len(lp7_ds)} shared={len(keys)})"
            )
        log_line(
            f"  warn {ds_name}: dropping keys eap-only={len(missing_e)} "
            f"lap-extra={len(missing_l)} lp7-extra={len(missing_p)}"
        )
    out = {}
    len_mismatches = 0
    for k in keys:
        S4 = np.asarray(eap4_ds[k], np.float64)
        la = np.asarray(lap_ds[k], np.float64).reshape(-1)
        lp = np.asarray(lp7_ds[k], np.float64).reshape(-1)
        if S4.ndim != 2 or S4.shape[1] != 4:
            raise RuntimeError(f"{ds_name}/{k}: expected (T,4) eaP, got {S4.shape}")
        n = min(len(S4), len(la), len(lp))
        if n < 4:
            raise RuntimeError(f"{ds_name}/{k}: degenerate length {n}")
        if len(S4) != len(la) or len(S4) != len(lp):
            len_mismatches += 1
        out[k] = np.column_stack([S4[:n], la[:n], lp[:n]])
    if len_mismatches:
        frac = len_mismatches / max(len(keys), 1)
        log_line(f"  warn {ds_name}: length truncate on {len_mismatches}/{len(keys)} trials")
        if frac > 0.25:
            raise RuntimeError(f"{ds_name}: too many length mismatches ({frac:.2%})")
    return out


def build_lodo_bank(eap4, lap, lp7):
    bank = {}
    for ds in DS_KEYS:
        bank[ds] = align_bank(eap4[ds], lap[ds], lp7[ds], ds)
        log_line(f"  LODO bank {ds}: {len(bank[ds])} trials, cols=6")
    return bank


def load_ext_1d(tag):
    """Load external evidence pickles → {ds: {key: (T,)}} plus meta from first available."""
    out, meta = {}, {}
    for ds in TEST_NAMES:
        path = os.path.join(EVID, f"ext_clf_{ds}_{tag}_evidence_s0.pkl")
        require_file(path, f"external {tag} {ds}")
        with open(path, "rb") as fh:
            ev = pickle.load(fh)
        out[ds], meta[ds] = {}, {}
        for k, e in ev.items():
            d = (np.asarray(e["r0"], np.float64) - np.asarray(e["r1"], np.float64))
            out[ds][k] = d
            meta[ds][k] = dict(
                att=np.asarray(e["att"]),
                t_end=np.asarray(e["t_end"], np.float64),
                att128=np.asarray(e["att128"]),
                n128=int(e["n128"]),
                subject=int(e["subject"]),
            )
        log_line(f"  ext {tag} {ds}: {len(out[ds])} trials")
    return out, meta


def build_ext_bank(eap4_test, lap_ext, lp7_ext, meta_ref):
    """Align eaP4 (T,4) with lap/lp7 1d using meta_ref keys (from eaP/V4)."""
    bank = {}
    for ds in TEST_NAMES:
        bank[ds] = align_bank(eap4_test[ds], lap_ext[ds], lp7_ext[ds], f"ext-{ds}")
        # prefer meta from V4 for eaP keys; fall back to lap meta lengths
        log_line(f"  EXT bank {ds}: {len(bank[ds])} trials")
    return bank


def agg_stream(X6_ds, kind, w=None):
    """Reduce {key:(n,6)} → {key:(n,)}."""
    out = {}
    for k, X in X6_ds.items():
        X = np.asarray(X, np.float64)
        s4 = X[:, :4]
        lap = X[:, 4]
        lp7 = X[:, 5]
        mean4 = s4.mean(1)
        mean5_lap = np.column_stack([s4, lap]).mean(1)
        mean5_lp7 = np.column_stack([s4, lp7]).mean(1)
        mean6 = X.mean(1)
        both = 0.5 * (lap + lp7)
        hp4 = highpass_1d(mean4)
        if kind == "mean4":
            out[k] = mean4
        elif kind == "mean5_lap":
            out[k] = mean5_lap
        elif kind == "mean5_lp7":
            out[k] = mean5_lp7
        elif kind == "mean6":
            out[k] = mean6
        elif kind == "lap":
            out[k] = lap
        elif kind == "lp7":
            out[k] = lp7
        elif kind == "both_prep":
            out[k] = both
        elif kind == "hp30_mean4":
            out[k] = hp4
        elif kind == "hp30_mean5_lap":
            out[k] = highpass_1d(mean5_lap)
        elif kind == "hp30_mean5_lp7":
            out[k] = highpass_1d(mean5_lp7)
        elif kind == "hp30_mean6":
            out[k] = highpass_1d(mean6)
        elif kind == "soft_mean4_lap":
            ww = float(w)
            out[k] = (1.0 - ww) * mean4 + ww * lap
        elif kind == "soft_mean4_lp7":
            ww = float(w)
            out[k] = (1.0 - ww) * mean4 + ww * lp7
        elif kind == "soft_mean4_both":
            ww = float(w)
            out[k] = (1.0 - ww) * mean4 + ww * both
        elif kind == "soft_hp30_lap":
            ww = float(w)
            out[k] = (1.0 - ww) * hp4 + ww * lap
        elif kind == "soft_hp30_lp7":
            ww = float(w)
            out[k] = (1.0 - ww) * hp4 + ww * lp7
        elif kind == "soft_hp30_both":
            ww = float(w)
            out[k] = (1.0 - ww) * hp4 + ww * both
        else:
            raise ValueError(kind)
    return out


def apply_rule_bank(bank, kind, w=None):
    return {ds: agg_stream(bank[ds], kind, w=w) for ds in bank}


def candidate_rules():
    rules = [
        ("mean4", None),
        ("mean5_lap", None),
        ("mean5_lp7", None),
        ("mean6", None),
        ("lap", None),
        ("lp7", None),
        ("both_prep", None),
        ("hp30_mean4", None),  # ≡ linear_hp30 on eaP4
        ("hp30_mean5_lap", None),
        ("hp30_mean5_lp7", None),
        ("hp30_mean6", None),
    ]
    for kind in (
        "soft_mean4_lap", "soft_mean4_lp7", "soft_mean4_both",
        "soft_hp30_lap", "soft_hp30_lp7", "soft_hp30_both",
    ):
        for w in SOFT_WS:
            rules.append((kind, w))
    return rules


def rule_key(kind, w):
    if w is None:
        return kind
    return f"{kind}_w={w:g}"


def ev_from_stream(stream, meta_from_nested=True):
    """Build LODO evidence using nested att/tend when available via N.to_ev."""
    return N.to_ev(stream)


def score_lodo_stream(stream):
    """Score all 5 held-outs; return mean H/Acc and per-ds."""
    ev = ev_from_stream(stream)
    hs, acs, per = [], [], {}
    for held in DS_KEYS:
        r = N.official(held, ev, P_STAY, SCALE)
        hs.append(r["H"])
        acs.append(r["Acc"])
        per[held] = dict(H=r["H"], Acc=r["Acc"], SDT=r["SDT"], L=r.get("L"), acc1=r.get("acc1"))
    return float(np.mean(hs)), float(np.mean(acs)), per


def emissions_signed(stream_all, att_map, datasets):
    parts = []
    for ds in datasets:
        for k, d in stream_all[ds].items():
            att = att_map[ds][k]
            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 att_from_lodo_bank(bank):
    """Use nested G att (loaded by N.load_all); lengths already matched via to_ev keys."""
    return {ds: N.G["att"][ds] for ds in DS_KEYS}


def score_external_stream(stream_1d, meta, mu_e, sd_e):
    ev = {}
    for key, d in stream_1d.items():
        m = meta[key]
        d = np.asarray(d, np.float64)
        n = min(len(d), len(m["att"]), len(m["t_end"]))
        ev[key] = dict(
            r0=d[:n], r1=np.zeros(n), att=np.asarray(m["att"])[:n],
            t_end=np.asarray(m["t_end"], np.float64)[:n],
            att128=m["att128"], n128=m["n128"], subject=m["subject"],
        )
    return E.score(ev, mu_e, sd_e * SCALE, P_STAY, LOOKAHEAD)


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(summary):
    sel = summary["selected"]
    ext = summary["external"]
    lines = []
    lines.append("# results_prep_diverse_seeds\n")
    lines.append(
        "Stack **prep-diverse** classifier logits — 4 published `eaP_n5_t60` seeds plus "
        "`lap_eaP` s0 and `lp7_eaP` s0 — then equal-mean / causal HP τ=30 on mean / soft-w "
        "between eaP-4-mean (or hp30) and lap/lp7 streams.\n"
    )
    lines.append(
        "**Not** SW2-as-5th-seed and **not** SW2↔hp30 (no decoder SW2 stream).\n"
    )
    lines.append(
        f"HMM preset **{P_STAY} / {SCALE}**. Code: `prep_diverse_seeds.py`. "
        f"JSON: `results/research/prep_diverse_seeds.json`.\n"
    )
    lines.append("## Selection (mean LODO Acc then H; never AASD/Carta)\n")
    lines.append(
        f"**SELECTED `{sel['key']}`** — mean LODO H **{sel['mean_LODO_H']:.4f}** "
        f"Acc **{sel['mean_LODO_Acc']:.2f}**\n"
    )
    lines.append("| Held-out | H | Acc % |")
    lines.append("|---|---:|---:|")
    for ds in DS_KEYS:
        p = sel["per_ds"][ds]
        lines.append(f"| {ds} | {p['H']:.4f} | {p['Acc']:.2f} |")
    lines.append(
        f"| **mean** | **{sel['mean_LODO_H']:.4f}** | **{sel['mean_LODO_Acc']:.2f}** |\n"
    )
    lines.append("### Rule grid (top by Acc then H)\n")
    lines.append("| Rule | mean H | mean Acc |")
    lines.append("|---|---:|---:|")
    ranked = sorted(
        summary["lodo_grid"],
        key=lambda r: (r["mean_LODO_Acc"], r["mean_LODO_H"]),
        reverse=True,
    )
    for r in ranked[:25]:
        mark = " **←**" if r["key"] == sel["key"] else ""
        lines.append(
            f"| `{r['key']}`{mark} | {r['mean_LODO_H']:.4f} | {r['mean_LODO_Acc']:.2f} |"
        )
    lines.append("\n## External (preset)\n")
    lines.append("| Set | selected H/Acc | vs linear_hp30 | vs SW2-alone |")
    lines.append("|---|---|---|---|")
    for ds in TEST_NAMES:
        s = ext[ds]["selected"]
        b = LINEAR_HP30_EXT[ds]
        w = SW2_ALONE_EXT[ds]
        lines.append(
            f"| {ds} | {s['H']:.4f} / **{s['Acc']:.2f}** | "
            f"{b['H']:.4f}/{b['Acc']:.2f} | {w['H']:.4f}/{w['Acc']:.2f} |"
        )
    if "refs" in ext.get("AASD", {}):
        lines.append("\n### Reference tags\n")
        lines.append("| Set | selected | mean4 | hp30_mean4 | mean6 | hp30_mean6 |")
        lines.append("|---|---|---|---|---|---|")
        for ds in TEST_NAMES:
            refs = ext[ds].get("refs", {})
            def fmt(t):
                if t not in refs:
                    return "—"
                x = refs[t]
                return f"{x['H']:.4f}/{x['Acc']:.2f}"
            lines.append(
                f"| {ds} | {fmt('selected')} | {fmt('mean4')} | {fmt('hp30_mean4')} | "
                f"{fmt('mean6')} | {fmt('hp30_mean6')} |"
            )
    aasd = ext["AASD"]["selected"]
    carta = ext["Carta2026"]["selected"]
    d_hp = aasd["Acc"] - LINEAR_HP30_EXT["AASD"]["Acc"]
    d_sw = aasd["Acc"] - SW2_ALONE_EXT["AASD"]["Acc"]
    lines.append("\n## Targets\n")
    lines.append("| Target | Result |")
    lines.append("|---|---|")
    lines.append(
        f"| AASD Acc vs linear_hp30 53.12 | Acc **{aasd['Acc']:.2f}** (Δ {d_hp:+.2f}); "
        f"H {aasd['H']:.4f} |"
    )
    lines.append(
        f"| AASD Acc vs SW2-alone 53.46 | Acc **{aasd['Acc']:.2f}** (Δ {d_sw:+.2f}) |"
    )
    lines.append(
        f"| Carta vs linear_hp30 60.54 | Acc **{carta['Acc']:.2f}**; H {carta['H']:.4f} |"
    )
    lines.append(
        f"| LODO mean | H {sel['mean_LODO_H']:.4f} Acc {sel['mean_LODO_Acc']:.2f} |\n"
    )
    lines.append("## Verdict\n")
    lines.append(summary.get("verdict", "") + "\n")
    lines.append("## NEXT IDEA\n")
    lines.append(summary.get("next_idea", "") + "\n")
    with open(RESULTS_MD, "w") as fh:
        fh.write("\n".join(lines))


def abandon(reason):
    log_line(f"ABORT: {reason}")
    summary = dict(status="abandoned", reason=reason, method="prep-diverse-seeds")
    os.makedirs(os.path.dirname(OUT), exist_ok=True)
    with open(OUT, "w") as fh:
        json.dump(summary, fh, indent=2)
    with open(RESULTS_MD, "w") as fh:
        fh.write(
            "# results_prep_diverse_seeds\n\n"
            f"**ABANDONED**: {reason}\n\n"
            "Do not invent scores. Fix caches / alignment, then retry.\n"
        )
    return summary


def main():
    os.makedirs(CACHE_DIR, 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"prep-diverse-seeds start  p_stay={P_STAY} scale={SCALE} tau={TAU} "
        f"(CPU; no SW2; no GPU)"
    )
    log_line("DISTINCT from sw2-5th-seed / sw2-hp30-blend: prep diversity only")

    try:
        eap4 = load_eap4_lodo()
        lap, _ = load_1d_folds(LAP_EXP)
        log_line(f"loaded LODO {LAP_EXP}")
        lp7, _ = load_1d_folds(LP7_EXP)
        log_line(f"loaded LODO {LP7_EXP}")
        bank_lodo = build_lodo_bank(eap4, lap, lp7)
    except (FileNotFoundError, RuntimeError) as e:
        abandon(str(e))
        return

    N.load_all()

    # sanity: mean4 ≈ published equal; hp30_mean4 ≈ linear_hp30 LODO-ish
    for kind, w in (("mean4", None), ("hp30_mean4", None), ("mean6", None), ("lap", None)):
        stream = apply_rule_bank(bank_lodo, kind, w=w)
        # only score AVGC for smoke
        ev = N.to_ev(stream)
        r = N.official("AVGC", ev, P_STAY, SCALE)
        log_line(f"sanity AVGC {rule_key(kind, w):24s} H {r['H']:.4f} Acc {r['Acc']:.2f}")

    rules = candidate_rules()
    log_line(f"scoring {len(rules)} rules on mean LODO Acc then H")
    rows = []
    best = None
    for kind, w in rules:
        t0 = time.time()
        stream = apply_rule_bank(bank_lodo, kind, w=w)
        mean_h, mean_a, per = score_lodo_stream(stream)
        key = rule_key(kind, w)
        row = dict(
            kind=kind, w=w, key=key,
            mean_LODO_H=mean_h, mean_LODO_Acc=mean_a, per_ds=per,
        )
        rows.append(row)
        log_line(
            f"  LODO {key:28s} H {mean_h:.4f} Acc {mean_a:.2f} ({time.time() - t0:.0f}s)"
        )
        sel = (mean_a, mean_h)
        if best is None or sel > best[0]:
            best = (sel, row)

    selected = best[1]
    log_line(
        f"SELECTED {selected['key']} mean LODO H {selected['mean_LODO_H']:.4f} "
        f"Acc {selected['mean_LODO_Acc']:.2f}"
    )

    # External
    try:
        lap_ext, lap_meta = load_ext_1d("lap_w10b3")
        lp7_ext, lp7_meta = load_ext_1d("lp7_w10b3")
        _train_logits, train_att = V4.load_train()
        test_logits, test_meta = V4.load_test()
        bank_ext = build_ext_bank(test_logits, lap_ext, lp7_ext, test_meta)
    except (FileNotFoundError, RuntimeError) as e:
        abandon(f"external load failed: {e}")
        return

    # Emissions for selected: LODO OOF streams (all 5), signed by LODO att
    kind, w = selected["kind"], selected["w"]
    stream_lodo_sel = apply_rule_bank(bank_lodo, kind, w=w)
    att_lodo = att_from_lodo_bank(bank_lodo)
    # Only use keys present in stream
    att_trim = {
        ds: {k: att_lodo[ds][k] for k in stream_lodo_sel[ds] if k in att_lodo[ds]}
        for ds in DS_KEYS
    }
    mu_c, sd_c = emissions_signed(stream_lodo_sel, att_trim, list(DS_KEYS))
    log_line(f"corpus selected emis mu={mu_c:.4f} sd={sd_c:.4f}")

    ref_kinds = [
        ("selected", kind, w),
        ("mean4", "mean4", None),
        ("hp30_mean4", "hp30_mean4", None),
        ("mean6", "mean6", None),
        ("hp30_mean6", "hp30_mean6", None),
    ]

    ext_rows = {}
    for ds in TEST_NAMES:
        ext_rows[ds] = {"refs": {}}
        for tag, knd, ww in ref_kinds:
            stream = agg_stream(bank_ext[ds], knd, w=ww)
            if tag == "selected":
                mu_u, sd_u = mu_c, sd_c
            else:
                corp = apply_rule_bank(bank_lodo, knd, w=ww)
                att_t = {
                    d: {k: att_lodo[d][k] for k in corp[d] if k in att_lodo[d]}
                    for d in DS_KEYS
                }
                mu_u, sd_u = emissions_signed(corp, att_t, list(DS_KEYS))
            # meta: prefer V4 test_meta; fill from lap if needed
            meta = {}
            for k in stream:
                if k in test_meta[ds]:
                    meta[k] = test_meta[ds][k]
                elif k in lap_meta[ds]:
                    meta[k] = lap_meta[ds][k]
                else:
                    meta[k] = lp7_meta[ds][k]
            r = score_external_stream(stream, meta, mu_u, sd_u)
            rec = dict(H=r["H"], Acc=r["Acc"], SDT=r["SDT"], L=r["L"],
                       nSwitches=r["nSwitches"], nUndetected=r["nUndetected"])
            if tag == "selected":
                ext_rows[ds]["selected"] = rec
            ext_rows[ds]["refs"][tag] = rec
            base = LINEAR_HP30_EXT[ds]["Acc"]
            log_line(
                f"EXT {ds} {tag:12s} H {r['H']:.4f} Acc {r['Acc']:.2f} "
                f"(Δ vs hp30 {r['Acc'] - base:+.2f})"
            )

    aasd = ext_rows["AASD"]["selected"]
    carta = ext_rows["Carta2026"]["selected"]
    d_hp = aasd["Acc"] - LINEAR_HP30_EXT["AASD"]["Acc"]
    d_sw = aasd["Acc"] - SW2_ALONE_EXT["AASD"]["Acc"]
    moved = aasd["Acc"] > 60 or (
        aasd["Acc"] > max(LINEAR_HP30_EXT["AASD"]["Acc"], SW2_ALONE_EXT["AASD"]["Acc"]) + 0.5
    )
    if aasd["Acc"] > 60:
        verdict = "Selected prep-diverse rule clears AASD Acc>60."
    elif moved:
        verdict = (
            "Selected rule improves AASD Acc vs linear_hp30/SW2-alone but still short of 60."
        )
    else:
        verdict = (
            "Honest LODO Acc/H selector on prep-diverse eaP+lap+lp7 bank does not beat "
            "linear_hp30 / SW2-alone on AASD Acc; prep diversity alone is not an Acc>60 path."
        )
    next_idea = (
        "Front-end / wait for newseed-hp30 (5th eaP-style classifier seed → linear_hp30). "
        "Do not re-grid SW2 bank / SW2↔hp30 / prep-diverse soft-w on this bank."
    )

    summary = dict(
        status="done",
        method="prep-diverse-seeds",
        selected=selected,
        p_stay=P_STAY,
        scale=SCALE,
        tau=TAU,
        lodo_grid=rows,
        external=ext_rows,
        baselines=dict(
            linear_hp30_ext=LINEAR_HP30_EXT,
            sw2_alone_ext=SW2_ALONE_EXT,
        ),
        deltas=dict(AASD_vs_hp30=d_hp, AASD_vs_sw2=d_sw),
        open_targets_moved=bool(moved),
        verdict=verdict,
        next_idea=next_idea,
        elapsed_s=time.time() - t_all,
        unused_train_att_note="external emis from LODO OOF; train_att keys available "
        f"n_corpus={sum(len(train_att[d]) for d in CORPUS)}",
    )
    with open(OUT, "w") as fh:
        json.dump(summary, fh, indent=2, default=_json_default)
    write_md(summary)
    log_line(f"done in {time.time() - t_all:.0f}s → {OUT}")
    log_line(
        f"HEADLINE {selected['key']} LODO {selected['mean_LODO_H']:.4f}/"
        f"{selected['mean_LODO_Acc']:.2f}  AASD {aasd['H']:.4f}/{aasd['Acc']:.2f} "
        f"(Δhp {d_hp:+.2f} Δsw2 {d_sw:+.2f})  Carta {carta['H']:.4f}/{carta['Acc']:.2f}"
    )


if __name__ == "__main__":
    main()
