"""Train-fold-only Platt / isotonic calibration 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

Calibration (LODO train folds only; never AASD/Carta labels):
  Platt:    z' = a·z + b   (fit via NLL of sigmoid(a·z+b) vs att==0)
  Isotonic: z' = logit(iso(z))  (iso maps z→P(att==0); out-of-bounds clipped)

Then HMM p_stay=0.994 scale=0.8. Select by mean LODO Acc then H.
Score AASD + Carta with corpus-fit calib + emissions from calibrated train.

DISTINCT from stem_ms96_calib Platt, online-moment-sw2, Acc soft-w blends,
and domain-emis-acc-tip (emission-LL gating).

usage:
  PYTHONPATH=.../reports/eda_full/scripts:$PYTHONPATH \\
    /root/disk_3tb/EEG-sAAD-Grand-Challenge-Training-Dataset/.venv/bin/python -u platt_acc_tip.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, logit
from sklearn.isotonic import IsotonicRegression

import ensemble_clf_nested as N
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
from fuse_evidence import LA, OFF

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

P_STAY = 0.994
SCALE = 0.8
LOOKAHEAD = float(LA)
A_SW2 = SW2.A_SW2
MAX_FIT = 400_000
SEED = 0
PROB_CLIP = (1e-6, 1.0 - 1e-6)

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 | platt | isotonic
VARIANT_SPECS = [
    ("tip_raw", "tip", "none"),
    ("tip_platt", "tip", "platt"),
    ("tip_isotonic", "tip", "isotonic"),
    ("sw2_raw", "sw2", "none"),
    ("sw2_platt", "sw2", "platt"),
    ("sw2_isotonic", "sw2", "isotonic"),
]


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 collect_xy(streams, meta, datasets, max_fit=MAX_FIT, rng=None):
    """Binary labels y=(att==0); evidence from streams. Subsample for fit speed."""
    rng = rng or np.random.default_rng(SEED)
    xs, ys = [], []
    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
            xs.append(z[:n])
            ys.append(y[:n])
    if not xs:
        return np.zeros(0), np.zeros(0)
    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]
    return x, y


def nll_platt(ab, x, y):
    a, b = float(ab[0]), float(ab[1])
    p = expit(a * x + b)
    p = np.clip(p, 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):
    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)],
    )
    a, b = float(res.x[0]), float(res.x[1])
    return dict(a=a, b=b, nll=float(res.fun), nll0=nll_platt([1.0, 0.0], x, y), n=int(len(x)))


def fit_isotonic(x, y):
    iso = IsotonicRegression(y_min=PROB_CLIP[0], y_max=PROB_CLIP[1], out_of_bounds="clip")
    iso.fit(x, y)
    p = np.clip(iso.predict(x), PROB_CLIP[0], PROB_CLIP[1])
    nll = float(-(y * np.log(p) + (1.0 - y) * np.log(1.0 - p)).mean())
    p0 = np.clip(expit(x), PROB_CLIP[0], PROB_CLIP[1])
    nll0 = float(-(y * np.log(p0) + (1.0 - y) * np.log(1.0 - p0)).mean())
    return dict(iso=iso, nll=nll, nll0=nll0, n=int(len(x)),
                x_min=float(np.min(x)), x_max=float(np.max(x)))


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


def apply_isotonic_streams(streams, iso):
    out = {}
    lo, hi = PROB_CLIP
    for ds, table in streams.items():
        out[ds] = {}
        for k, v in table.items():
            z = np.asarray(v, np.float64).reshape(-1)
            p = np.clip(iso.predict(z), lo, hi)
            out[ds][k] = logit(p)
    return out


def apply_platt_ev(ev, a, b):
    out = {}
    for k, e in ev.items():
        d = a * np.asarray(e["r0"], np.float64) + b
        n = len(d)
        out[k] = 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_isotonic_ev(ev, iso):
    out = {}
    lo, hi = PROB_CLIP
    for k, e in ev.items():
        z = np.asarray(e["r0"], np.float64).reshape(-1)
        p = np.clip(iso.predict(z), lo, hi)
        d = logit(p)
        n = len(d)
        out[k] = 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 fit_and_apply(streams, meta, train_ds, mode):
    """Fit on train_ds only; apply to all datasets in streams. Return (calibrated, fit_info)."""
    if mode == "none" or mode is None:
        raw = {ds: {k: np.asarray(d, np.float64) for k, d in table.items()}
               for ds, table in streams.items()}
        return raw, dict(mode="none")
    x, y = collect_xy(streams, meta, train_ds)
    if len(x) < 100 or y.min() == y.max():
        log_line(f"  WARN fit degenerate n={len(x)} y_unique={np.unique(y)}; identity")
        raw = {ds: {k: np.asarray(d, np.float64) for k, d in table.items()}
               for ds, table in streams.items()}
        return raw, dict(mode=mode, degenerate=True, n=int(len(x)))
    if mode == "platt":
        pl = fit_platt(x, y)
        cal = apply_platt_streams(streams, pl["a"], pl["b"])
        return cal, dict(mode="platt", a=pl["a"], b=pl["b"], nll=pl["nll"], nll0=pl["nll0"], n=pl["n"])
    if mode == "isotonic":
        iso_info = fit_isotonic(x, y)
        cal = apply_isotonic_streams(streams, iso_info["iso"])
        return cal, dict(
            mode="isotonic",
            nll=iso_info["nll"],
            nll0=iso_info["nll0"],
            n=iso_info["n"],
            x_min=iso_info["x_min"],
            x_max=iso_info["x_max"],
            iso=iso_info["iso"],
        )
    raise ValueError(mode)


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 avg_corpus_stream(streams_by_held):
    return OMS.avg_corpus_stream(streams_by_held)


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, IsotonicRegression):
        return dict(
            X_min_=float(o.X_min_),
            X_max_=float(o.X_max_),
            n_features_in_=int(getattr(o, "n_features_in_", 1)),
        )
    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_platt_acc_tip\n")
    lines.append(
        "**Claim:** `platt-acc-tip` — train-fold-only **Platt** (a·x+b) and optional "
        "**isotonic** (logit∘iso) on Acc tip streams (CPU):\n"
        "1. Acc leader `hard_abs_swmix|t1` (AASD Acc tip 53.53)\n"
        "2. published SW2 `fuse_general` a=0.5\n"
    )
    lines.append(
        "**DISTINCT** from stem `results_calib.md` Platt, `online-moment-sw2`, "
        "Acc soft-w blends, and `domain-emis-acc-tip` (emission-LL).\n"
    )
    lines.append(
        f"HMM preset **{P_STAY} / {SCALE}**. Code: `platt_acc_tip.py`. "
        f"JSON: `results/research/platt_acc_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"
    )

    fit = prim.get("fit_corpus") or prim.get("fit_summary") or {}
    if fit:
        lines.append("### Selected fit (corpus / summary)\n")
        lines.append("```")
        lines.append(json.dumps({k: v for k, v in fit.items() if k != "iso"}, indent=2, default=_json_default))
        lines.append("```\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 Platt/isotonic 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 train-fold Platt/isotonic of Acc tip SW2 / "
            "`hard_abs_swmix|t1` does not create AASD Acc>60. Same qualitative flatness "
            "as stem Platt on logits and online-moment on tip streams (~53.46–53.53).\n"
        )

    lines.append("## Do not repeat\n")
    lines.append(
        "Do not rerun train-fold Platt/isotonic 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. "
        "Do not confuse with stem `results_calib.md` Platt.\n"
    )

    lines.append("## NEXT IDEA\n")
    lines.append(
        "Calibration of Acc tip decision streams (Platt/isotonic) does not unlock "
        "AASD Acc>60 — bottleneck is not train-fold score→label mapping of these streams. "
        "Prefer a **qualitatively new** Acc front-end that clears chance and lifts AASD "
        "acc1, or finish/compare unlabeled emission-aware choice (`domain-emis-acc-tip`) "
        "among already scored Acc leaders. 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"platt-acc-tip CPU  p_stay={P_STAY} scale={SCALE} a_sw2={A_SW2} "
        f"tip={TIP_KIND}|t{TIP_THR:g} variants={len(VARIANT_SPECS)}"
    )
    log_line(
        "honesty: train-fold-only Platt/isotonic on Acc tip SW2/tip; "
        "no AASD/Carta labels; no SW2↔swmix w re-grid; ≠ stem calib / online-moment / emis-LL"
    )

    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_platt_acc_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 = OMS.build_raw_held(Z, swmix_full)
    raw_by_stream = dict(sw2=sw2_held, tip=tip_held)

    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="platt-acc-tip",
        p_stay=P_STAY,
        scale=SCALE,
        a_sw2=A_SW2,
        tip=dict(kind=TIP_KIND, thresh=TIP_THR, sharp=TIP_SHARP),
        max_fit=MAX_FIT,
        honesty=(
            "Train-fold-only Platt (a·x+b) / isotonic (logit∘iso) on Acc tip "
            "SW2 fuse and/or hard_abs_swmix|t1. No AASD/Carta labels, no soft-w re-grid. "
            "Distinct from stem calib, online-moment-sw2, domain-emis-acc-tip."
        ),
        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 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]
            cal, fit_info = fit_and_apply(raw, meta, train_ds, mode)
            off = score_lodo_held(cal, meta, held)
            fit_log = {k: v for k, v in fit_info.items() if k != "iso"}
            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
            extra = ""
            if mode == "platt" and "a" in fit_info:
                extra = f"  a={fit_info['a']:.4f} b={fit_info['b']:.4f}"
            elif mode == "isotonic" and "nll" in fit_info:
                extra = f"  nll={fit_info['nll']:.4f}"
            log_line(
                f"LODO {name:16s} {held:5s}  H {off['H']:.4f} Acc {off['Acc']:.2f}{extra}"
            )
        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:16s}  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": avg_corpus_stream(sw2_held),
        "tip": 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 (all variants; headline = selected) ===")
    for name, stream, mode in VARIANT_SPECS:
        # Fit on full corpus (all LODO ds); apply to corpus + external
        cal_corp, fit_info = fit_and_apply(corp_raw[stream], meta, list(DS_KEYS), mode)
        fit_store = {k: v for k, v in fit_info.items() if k != "iso"}
        results["variants"][name]["fit_corpus"] = fit_store

        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))

        if mode == "platt":
            log_line(
                f"corpus {name} a={fit_info.get('a')} b={fit_info.get('b')} "
                f"nll={fit_info.get('nll')} emis μ={mu_e:.6f} σ={sd_e:.6f}"
            )
        elif mode == "isotonic":
            log_line(
                f"corpus {name} nll={fit_info.get('nll')} "
                f"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]
            if mode == "none":
                ev_use = base_ev
            elif mode == "platt":
                ev_use = apply_platt_ev(base_ev, fit_info["a"], fit_info["b"])
            elif mode == "isotonic":
                ev_use = apply_isotonic_ev(base_ev, fit_info["iso"])
            else:
                raise ValueError(mode)
            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:16s} {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,
                headline=results["headline"],
                fit_corpus={
                    n: {k: v for k, v in results["variants"][n].get("fit_corpus", {}).items()}
                    for n in results["variants"]
                },
            ),
            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()
