"""Train-only isotonic calibration on frozen focal↔synth fuse w=0.5 (AVGC/LODO).

isotonic-ds-fuse — monotone map tip fuse scores → calibrated probs → logit.
Fit on LODO-train only; leave-AVGC never sees AVGC labels. ≠ temperature
(causal-ds-temp), ≠ Platt Acc tip, ≠ adapt-readout EWMA, ≠ multi-stem soft-attn.

Variants
--------
- raw                      : tip fuse baseline (no cal)
- global_iso_all           : pooled train iso → apply to ALL streams (emis+held)
- held_iso_global          : pooled train iso → held only; emis from raw train
- held_iso_per_ds_pick     : fit iso per train ds; nested Acc·H pick which map → held
- per_ds_iso_emis_gheld    : per-ds iso on train for emis; held gets pooled iso

Select by mean LODO Acc then H @ HMM 0.994/0.8. Tip to beat: held_T_nll_med
0.8245/75.64 (LODO 0.8844/83.38).

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

import json
import os
import pickle
import time

import numpy as np
from scipy.special import expit, logit
from sklearn.isotonic import IsotonicRegression

import causal_moe_fuse as M
import ensemble_clf_nested as N
from common import DS_KEYS

EXP = os.path.dirname(os.path.abspath(__file__))
SRC_CACHE = os.path.join(EXP, "models", "focal_synth_adapt_readout", "cache")
CKPT = os.path.join(EXP, "models", "isotonic_ds_fuse")
LOG = os.path.join(EXP, "experiments", "isotonic_ds_fuse.log")
OUT = os.path.join(EXP, "results", "research", "isotonic_ds_fuse.json")
RESULTS_MD = os.path.join(EXP, "multi_agent_opt", "results_isotonic_ds_fuse.md")

P_STAY = 0.994
SCALE = 0.8
TEST_NAMES = ("AASD", "Carta2026")
MAX_FIT = 400_000
SEED = 0
PROB_CLIP = (1e-4, 1.0 - 1e-4)

# Tip after causal-ds-temp held_T_nll_med
TIP = dict(
    mean=dict(H=0.8844, Acc=83.38),
    AVGC=dict(H=0.8245, Acc=75.64),
    raw_fuse=dict(H=0.8226, Acc=75.54),
    AASD=dict(H=0.6227, Acc=51.17),
    Carta2026=dict(H=0.5534, Acc=49.41),
)
LINEAR_HP30_EXT = dict(
    AASD=dict(H=0.6422, Acc=53.12), Carta2026=dict(H=0.6520, Acc=60.54)
)
SW2_SWMIX_TIP = dict(AASD=dict(Acc=53.53), Carta2026=dict(Acc=59.71))

VARIANT_SPECS = [
    ("raw", "raw", False),
    ("global_iso_all", "global_iso_all", True),
    ("held_iso_global", "held_iso_global", True),
    ("held_iso_per_ds_pick", "held_iso_per_ds_pick", True),
    ("per_ds_iso_emis_gheld", "per_ds_iso_emis_gheld", True),
]


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 load_pkl(path):
    with open(path, "rb") as fh:
        return pickle.load(fh)


def copy_streams(streams):
    return {
        ds: {k: np.asarray(v, np.float64) for k, v in table.items()}
        for ds, table in streams.items()
    }


def collect_xy(streams, att, datasets, max_fit=MAX_FIT, rng=None):
    rng = rng or np.random.default_rng(SEED)
    xs, ys = [], []
    for ds in datasets:
        if ds not in streams:
            continue
        labels = att[ds]
        for key, d in streams[ds].items():
            if key not in labels:
                continue
            z = np.asarray(d, np.float64).reshape(-1)
            y = (np.asarray(labels[key]) == 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 fit_isotonic(x, y):
    if len(x) < 100 or y.min() == y.max():
        return dict(iso=None, nll=float("nan"), nll0=float("nan"), n=int(len(x)),
                    degenerate=True, x_min=float("nan"), x_max=float("nan"))
    lo, hi = PROB_CLIP
    iso = IsotonicRegression(y_min=lo, y_max=hi, out_of_bounds="clip")
    iso.fit(x, y)
    p = np.clip(iso.predict(x), lo, hi)
    nll = float(-(y * np.log(p) + (1.0 - y) * np.log(1.0 - p)).mean())
    p0 = np.clip(expit(x), lo, hi)
    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)), degenerate=False,
        x_min=float(np.min(x)), x_max=float(np.max(x)),
    )


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


def apply_iso_streams(streams, iso, only_ds=None):
    out = {}
    for ds, table in streams.items():
        if only_ds is not None and ds not in only_ds:
            out[ds] = {k: np.asarray(v, np.float64) for k, v in table.items()}
        else:
            out[ds] = apply_iso_table(table, iso)
    return out


def apply_iso_per_ds(streams, iso_map, default_iso=None):
    out = {}
    for ds, table in streams.items():
        iso = iso_map.get(ds, default_iso)
        out[ds] = apply_iso_table(table, iso)
    return out


def fit_iso_meta(info):
    """JSON-safe summary without the iso object."""
    return {
        k: info[k]
        for k in ("nll", "nll0", "n", "degenerate", "x_min", "x_max")
        if k in info
    }


def nested_pick_iso(streams, att, train_ds, iso_by_ds, use_fast=True):
    """Pick which train-ds iso map to apply to inner-held; Acc then H."""
    best_src, best_key, rows = None, None, []
    for src in train_ds:
        iso = iso_by_ds[src]["iso"]
        hs, acs = [], []
        for inner in train_ds:
            emis_ds = [d for d in train_ds if d != inner]
            if not emis_ds:
                continue
            adapted = apply_iso_streams(streams, iso, only_ds={inner})
            if use_fast:
                r = M.fast_score(adapted, inner, emis_ds)
            else:
                r = M.score_lodo(adapted, inner)
            hs.append(float(r["H"]))
            acs.append(float(r["Acc"]))
        if not hs:
            continue
        mean_h, mean_a = float(np.mean(hs)), float(np.mean(acs))
        rows.append(dict(src=src, H=mean_h, Acc=mean_a))
        key = (mean_a, mean_h)
        if best_key is None or key > best_key:
            best_key, best_src = key, src
    return best_src, rows


def apply_variant(streams, att, held, family):
    train_ds = [d for d in DS_KEYS if d != held]
    raw = copy_streams(streams)

    if family == "raw":
        return raw, dict(mode="raw", iso_src="identity")

    if family == "global_iso_all":
        x, y = collect_xy(raw, att, train_ds)
        info = fit_isotonic(x, y)
        cal = apply_iso_streams(raw, info["iso"])
        return cal, dict(
            mode=family, iso_src="pooled_train", **fit_iso_meta(info),
        )

    if family == "held_iso_global":
        x, y = collect_xy(raw, att, train_ds)
        info = fit_isotonic(x, y)
        cal = apply_iso_streams(raw, info["iso"], only_ds={held})
        return cal, dict(
            mode=family, iso_src="pooled_train→held", **fit_iso_meta(info),
        )

    # Per-dataset fits (train labels only).
    per = {d: fit_isotonic(*collect_xy(raw, att, [d])) for d in train_ds}
    iso_by_ds = {d: per[d] for d in train_ds}

    if family == "held_iso_per_ds_pick":
        src, rows = nested_pick_iso(raw, att, train_ds, iso_by_ds, use_fast=True)
        if src is None:
            return raw, dict(mode=family, iso_src="identity", nested=[])
        cal = apply_iso_streams(raw, iso_by_ds[src]["iso"], only_ds={held})
        return cal, dict(
            mode=family, iso_src=src, nested=rows,
            fit={d: fit_iso_meta(per[d]) for d in train_ds},
        )

    if family == "per_ds_iso_emis_gheld":
        x, y = collect_xy(raw, att, train_ds)
        ginfo = fit_isotonic(x, y)
        iso_map = {d: per[d]["iso"] for d in train_ds}
        # train streams: own iso; held: pooled
        cal = apply_iso_per_ds(raw, iso_map, default_iso=ginfo["iso"])
        cal[held] = apply_iso_table(raw[held], ginfo["iso"])
        return cal, dict(
            mode=family, iso_src="per_ds_emis+pooled_held",
            **fit_iso_meta(ginfo),
            fit={d: fit_iso_meta(per[d]) for d in train_ds},
        )

    raise ValueError(family)


def pick_variant(lodo_means, candidates):
    best_name, best_key = None, None
    for name in candidates:
        m = lodo_means[name]
        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 load_fuse_caches():
    fuse_by_held = {}
    for held in DS_KEYS:
        path = os.path.join(SRC_CACHE, f"focal_synth_w05__held-{held}.pkl")
        if not os.path.isfile(path):
            raise FileNotFoundError(path)
        fuse_by_held[held] = load_pkl(path)
        log_line(f"cache hit {path}")
    return fuse_by_held


def write_results_md(results):
    sel = results["selected"]
    prim = results["variants"][sel]
    avgc = prim["lodo"]["AVGC"]
    tip_a = TIP["AVGC"]
    mean = prim["lodo_mean"]
    dH = avgc["H"] - tip_a["H"]
    dA = avgc["Acc"] - tip_a["Acc"]
    aasd = prim.get("external", {}).get("AASD", {})
    carta = prim.get("external", {}).get("Carta2026", {})

    lines = []
    lines.append("# results_isotonic_ds_fuse\n")
    lines.append(
        "**Claim:** `isotonic-ds-fuse` — train-only **isotonic regression** "
        "(monotone map tip fuse scores → calibrated probs → logit) on frozen "
        "**focal↔synth fuse w=0.5**. Per-dataset or global fit on non-held; "
        "leave-AVGC fits without AVGC labels.\n"
    )
    lines.append(
        "**Distinct from** `causal-ds-temp` (temperature / T grids — CLOSED), "
        "`platt-acc-tip` (isotonic on Acc SW2 streams), `focal-synth-adapt-readout` "
        "(per-subj EWMA), multi-stem soft-attn pool.\n"
    )
    lines.append(
        f"**Honesty:** Train labels only. Never AASD/Carta for selection. "
        f"Select mean LODO Acc then H @ **{P_STAY}/{SCALE}**.\n"
    )
    lines.append(
        f"**Compute:** CPU; reuse `models/focal_synth_adapt_readout/cache/`. "
        f"Code: `isotonic_ds_fuse.py`. JSON: `results/research/isotonic_ds_fuse.json`.\n"
    )
    lines.append("## Selection\n")
    lines.append("| Rule | Pick |")
    lines.append("|------|------|")
    lines.append(f"| mean LODO Acc then H (isotonic variants) | **`{sel}`** |")
    lines.append(
        f"| Tip to beat (held_T_nll_med) | "
        f"**{tip_a['H']:.4f} / {tip_a['Acc']:.2f}** |"
    )
    lines.append(
        f"| Raw fuse sanity | "
        f"**{TIP['raw_fuse']['H']:.4f} / {TIP['raw_fuse']['Acc']:.2f}** |"
    )
    ranked = results["selection"]["ranked"]
    lines.append(f"\nRanked Acc: {' → '.join(ranked)}\n")

    lines.append("## LODO (preset)\n")
    lines.append(
        "| Variant | mean H / Acc | AVGC H / Acc | iso_src@AVGC | selectable |"
    )
    lines.append(
        "|---------|--------------|--------------|--------------|------------|"
    )
    for name, _fam, selectable in VARIANT_SPECS:
        v = results["variants"][name]
        mark = "**" if name == sel else ""
        src = v.get("fit", {}).get("AVGC", {}).get("iso_src", "—")
        lines.append(
            f"| {mark}{name}{mark} | {mark}{v['lodo_mean']['H']:.4f} / "
            f"{v['lodo_mean']['Acc']:.2f}{mark} | "
            f"{mark}{v['lodo']['AVGC']['H']:.4f} / {v['lodo']['AVGC']['Acc']:.2f}{mark} | "
            f"{src} | "
            f"{'**SELECTED**' if name == sel else ('yes' if selectable else 'no')} |"
        )
    lines.append(
        f"\nSelected AVGC vs tip **{tip_a['H']:.4f}/{tip_a['Acc']:.2f}**: "
        f"**ΔH {dH:+.4f} / ΔAcc {dA:+.2f}**.\n"
    )

    lines.append("## Selected per-held\n")
    lines.append("| Held | iso_src | H / Acc |")
    lines.append("|------|---------|---------|")
    for held in DS_KEYS:
        info = prim["fit"].get(held, {})
        sc = prim["lodo"][held]
        lines.append(
            f"| {held} | {info.get('iso_src', '—')} | "
            f"{sc['H']:.4f} / {sc['Acc']:.2f} |"
        )

    if aasd:
        lines.append("\n## External (bookkeeping; Acc tip not claimed)\n")
        lines.append("| Variant | AASD H / Acc | Carta H / Acc |")
        lines.append("|---------|--------------|---------------|")
        for name in ("raw", sel):
            v = results["variants"][name]
            a = v["external"]["AASD"]
            c = v["external"]["Carta2026"]
            mark = "**" if name == sel else ""
            lines.append(
                f"| {mark}{name}{mark} | {mark}{a['H']:.4f} / {a['Acc']:.2f}{mark} | "
                f"{c['H']:.4f} / {c['Acc']:.2f} |"
            )

    lines.append("\n## Targets\n")
    lines.append("| Target | Result |")
    lines.append("|--------|--------|")
    ge = avgc["H"] >= 0.85 and avgc["Acc"] >= 78
    lines.append(
        f"| AVGC ≥0.85 / Acc≥78 | **{'HIT' if ge else 'miss'}** "
        f"({avgc['H']:.4f} / {avgc['Acc']:.2f}) |"
    )
    tip_moved = (dH >= 0.0005) or (dA >= 0.05)
    lines.append(
        f"| Tip moved (ΔH≥5e-4 or ΔAcc≥0.05 vs 0.8245/75.64) | "
        f"{'yes' if tip_moved else 'no / flat-hurt'} |"
    )

    lines.append("\n## Verdict\n")
    lines.append(
        f"Selected **`{sel}`**: LODO mean **{mean['H']:.4f}/{mean['Acc']:.2f}**, "
        f"AVGC **{avgc['H']:.4f}/{avgc['Acc']:.2f}** "
        f"(Δtip {dH:+.4f} H / {dA:+.2f} Acc). "
        f"{'Clears' if ge else 'Does not clear'} AVGC 0.85/78. "
        f"{'Tip moved.' if tip_moved else 'Tip not improved.'}\n"
    )
    lines.append("## Do not repeat\n")
    lines.append(
        "Do not re-grid train-only isotonic (global / held-only / per-ds nested-pick "
        "/ per-ds-emis) on frozen focal↔synth fuse w=0.5 at HMM 0.994/0.8. "
        "Still do not reopen causal-ds-temp T grids.\n"
    )
    lines.append("## NEXT IDEA\n")
    if ge:
        lines.append(
            "AVGC bar met — freeze and push AASD Acc on Acc front-end only.\n"
        )
    else:
        lines.append(
            "Isotonic on tip fuse saturated vs tip. Prefer **evidential-tip-stack** "
            "(Dirichlet / non-neg or logistic stack over frozen tip stems focal/"
            "synth/IRM; train-only causal linear/isotonic/logistic on logits — "
            "≠ closed multi-stem soft-attn pool) — not Mixup/SSL/DANN/T/isotonic.\n"
        )

    os.makedirs(os.path.dirname(RESULTS_MD), exist_ok=True)
    with open(RESULTS_MD, "w") as fh:
        fh.write("\n".join(lines) + "\n")
    log_line(f"wrote {RESULTS_MD}")


def main():
    os.makedirs(CKPT, exist_ok=True)
    os.makedirs(os.path.dirname(LOG), exist_ok=True)
    open(LOG, "w").close()
    t_all = time.time()

    log_line(
        f"isotonic-ds-fuse CPU p_stay {P_STAY} scale {SCALE} "
        f"tip_AVGC {TIP['AVGC']['H']:.4f}/{TIP['AVGC']['Acc']:.2f}"
    )
    log_line(
        "honesty: train-only isotonic; leave-held never uses held labels; "
        "never AASD/Carta for selection"
    )
    log_line(
        "distinct from causal-ds-temp T / platt-acc-tip / adapt-readout / soft-attn"
    )

    N.load_all()
    att = N.G["att"]

    log_line("=== load tip fuse caches ===")
    fuse_by_held = load_fuse_caches()
    san = M.score_lodo(fuse_by_held["AVGC"], "AVGC")
    log_line(
        f"sanity raw focal↔synth fuse AVGC H {san['H']:.4f} Acc {san['Acc']:.2f} "
        f"(expect ~0.8226/75.54)"
    )

    results = dict(
        method=("train-only isotonic calibration on frozen "
                "focal↔synth fuse w=0.5"),
        p_stay=P_STAY, scale=SCALE, device="cpu",
        honesty=("Train-only isotonic fit; leave-held without held labels. "
                 "Select mean LODO Acc then H. No AASD/Carta labels."),
        distinct_from=[
            "causal-ds-temp", "platt-acc-tip", "focal-synth-adapt-readout",
            "multi-stem-attn-pool",
        ],
        baselines=dict(
            tip_held_T_nll_med=TIP, linear_hp30_ext=LINEAR_HP30_EXT,
            sw2_swmix_tip=SW2_SWMIX_TIP,
        ),
        variants={},
    )

    log_line("=== LODO ===")
    lodo_means = {}
    for name, family, selectable in VARIANT_SPECS:
        t0 = time.time()
        per = {}
        fit_infos = {}
        for held in DS_KEYS:
            streams = fuse_by_held[held]
            adapted, info = apply_variant(streams, att, held, family)
            safe = {
                k: v for k, v in info.items()
                if isinstance(v, (int, float, str, bool, type(None)))
                or k in ("nested", "fit")
            }
            fit_infos[held] = safe
            off = M.score_lodo(adapted, held)
            per[held] = dict(
                H=off["H"], Acc=off["Acc"], SDT=off.get("SDT"),
                L=off.get("L"), acc1=off.get("acc1"),
            )
            log_line(
                f"LODO {name:24s} {held:5s}  src={info.get('iso_src', '—')}  "
                f"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:24s}  H {mean_h:.4f} Acc {mean_a:.2f}  "
            f"({time.time() - t0:.0f}s)"
        )
        lodo_means[name] = dict(H=mean_h, Acc=mean_a)
        results["variants"][name] = dict(
            family=family, selectable=selectable,
            fit=fit_infos, lodo=per, lodo_mean=dict(H=mean_h, Acc=mean_a),
        )

    adapt_names = [n for n, _f, sel in VARIANT_SPECS if sel]
    selected = pick_variant(lodo_means, adapt_names)
    ranked = sorted(
        adapt_names,
        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["selection"] = dict(
        criterion="mean LODO Acc then H (isotonic variants; never AASD/Carta)",
        ranked=ranked, selected=selected,
        excluded_from_select=[n for n, _f, sel in VARIANT_SPECS if not sel],
    )
    results["selected"] = selected

    log_line("=== external (bookkeeping) ===")
    try:
        import stem_ms96_irm_synth_fuse as SF
        import ensemble_clf_transformer_v4 as V4

        corp_path = os.path.join(SRC_CACHE, "focal_synth_w05__all5_corpus.pkl")
        ext_path = os.path.join(SRC_CACHE, "focal_synth_w05__all5_external.pkl")
        if not (os.path.isfile(corp_path) and os.path.isfile(ext_path)):
            log_line("WARN: missing all5 corpus/external caches; skip external")
        else:
            corp = load_pkl(corp_path)
            ext_fuse = load_pkl(ext_path)
            _ext_logits, ext_meta = SF.load_external()
            train_ds_ext = list(V4.CORPUS)

            for name, family, _sel in VARIANT_SPECS:
                if family == "raw":
                    adapted_corp = corp
                    adapted_test = ext_fuse
                    info = dict(iso_src="identity")
                elif family == "global_iso_all":
                    x, y = collect_xy(corp, att, train_ds_ext)
                    fit = fit_isotonic(x, y)
                    adapted_corp = apply_iso_streams(corp, fit["iso"])
                    adapted_test = apply_iso_streams(ext_fuse, fit["iso"])
                    info = dict(iso_src="pooled_train", **fit_iso_meta(fit))
                elif family == "held_iso_global":
                    x, y = collect_xy(corp, att, train_ds_ext)
                    fit = fit_isotonic(x, y)
                    adapted_corp = corp  # emis raw
                    adapted_test = apply_iso_streams(ext_fuse, fit["iso"])
                    info = dict(iso_src="pooled→ext", **fit_iso_meta(fit))
                elif family == "held_iso_per_ds_pick":
                    per = {
                        d: fit_isotonic(*collect_xy(corp, att, [d]))
                        for d in train_ds_ext
                    }
                    src, rows = nested_pick_iso(
                        corp, att, train_ds_ext, per, use_fast=True)
                    iso = per[src]["iso"] if src else None
                    adapted_corp = corp
                    adapted_test = apply_iso_streams(ext_fuse, iso)
                    info = dict(iso_src=src or "identity", nested=rows)
                elif family == "per_ds_iso_emis_gheld":
                    x, y = collect_xy(corp, att, train_ds_ext)
                    ginfo = fit_isotonic(x, y)
                    per = {
                        d: fit_isotonic(*collect_xy(corp, att, [d]))
                        for d in train_ds_ext
                    }
                    iso_map = {d: per[d]["iso"] for d in train_ds_ext}
                    adapted_corp = apply_iso_per_ds(
                        corp, iso_map, default_iso=ginfo["iso"])
                    adapted_test = apply_iso_streams(ext_fuse, ginfo["iso"])
                    info = dict(
                        iso_src="per_ds_emis+pooled_ext", **fit_iso_meta(ginfo),
                    )
                else:
                    raise ValueError(family)

                mu_e, sd_e = SF.emissions_from(
                    adapted_corp, att, datasets=train_ds_ext)
                ext = {}
                for ds in TEST_NAMES:
                    r = SF.score_external(
                        adapted_test[ds], ext_meta[ds], mu_e, sd_e)
                    ext[ds] = dict(H=r["H"], Acc=r["Acc"])
                    log_line(
                        f"EXT {name:24s} {ds:10s}  src={info.get('iso_src')}  "
                        f"H {r['H']:.4f} Acc {r['Acc']:.2f}"
                    )
                results["variants"][name]["external"] = ext
                results["variants"][name]["emis"] = dict(mu=mu_e, sd=sd_e)
                results["variants"][name]["ext_fit"] = {
                    k: v for k, v in info.items()
                    if isinstance(v, (int, float, str, bool, type(None)))
                    or k in ("nested",)
                }
    except Exception as exc:
        log_line(f"WARN: external scoring failed: {exc!r}")

    prim = results["variants"][selected]
    avgc = prim["lodo"]["AVGC"]
    d_tip = dict(
        H=avgc["H"] - TIP["AVGC"]["H"], Acc=avgc["Acc"] - TIP["AVGC"]["Acc"],
    )
    headline = dict(
        selected=selected,
        lodo_mean=prim["lodo_mean"],
        lodo_AVGC=avgc,
        AVGC_delta_vs_tip=d_tip,
        targets=dict(
            AVGC_ge_085_78=bool(avgc["H"] >= 0.85 and avgc["Acc"] >= 78),
        ),
        tip_moved=bool(d_tip["H"] >= 5e-4 or d_tip["Acc"] >= 0.05),
        tip_improved=bool(d_tip["H"] >= 5e-4 or d_tip["Acc"] >= 0.05),
    )
    if "external" in prim:
        headline["AASD"] = prim["external"]["AASD"]
        headline["Carta2026"] = prim["external"]["Carta2026"]
    results["headline"] = headline
    log_line(
        f"HEADLINE {selected} AVGC H {avgc['H']:.4f} Acc {avgc['Acc']:.2f} "
        f"(Δtip {d_tip['H']:+.4f}/{d_tip['Acc']:+.2f})  "
        f"LODO mean {prim['lodo_mean']['H']:.4f}/{prim['lodo_mean']['Acc']:.2f}"
    )

    os.makedirs(os.path.dirname(OUT), exist_ok=True)
    with open(OUT, "w") as fh:
        json.dump(results, fh, indent=1, default=float)
    with open(os.path.join(CKPT, "summary.json"), "w") as fh:
        json.dump(
            dict(selected=selected, lodo_means=lodo_means, headline=headline),
            fh, indent=1, default=float,
        )
    write_results_md(results)
    log_line(f"wrote {OUT} ({time.time() - t_all:.0f}s)")


if __name__ == "__main__":
    main()
