"""Past-only per-subject/trial causal scale / temperature / affine on
frozen focal-IRM ↔ synth fuse w=0.5 (NEW tip AVGC 0.8226/75.54).

Readout adapt only — no gated residual net, no IRM↔synth agree-gate,
no Acc-tip post-process, no stem BCE re-tune.

Families
--------
1. Label-free causal (past-only EWMA):
   - temp:   z' = z / max(T_past / T0, eps)   T_past=EWMA(|z|), T0=train median |z|
   - scale:  keep local mean; match past σ → train σ
   - affine: match past (μ,σ) → (0, train_σ)
   Persist EMA state across trials of the same subject when flagged.
2. Train-fold fit (LODO train labels only; never AASD/Carta):
   - train_temp  (diagnostic; ≈ invariant under HMM emissions)
   - train_scale (a·z)
   - train_platt (a·z+b)
3. Hybrid: train_platt then causal trial temp.

Select by mean LODO Acc then H @ HMM 0.994/0.8. Score LODO5+AASD+Carta.

Caches: reuse synth from models/fuse_conf_resid/cache/; infer focal from
models/stem_ms96_focal_avgc/; write focal↔synth under
models/focal_synth_adapt_readout/cache/. CPU preferred.

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

import json
import os
import pickle
import re
import time

import numpy as np
from scipy.optimize import minimize, minimize_scalar
from scipy.signal import lfilter
from scipy.special import expit

import causal_moe_fuse as M
import ensemble_clf_nested as N
import ensemble_clf_transformer_v2 as V
import ensemble_clf_transformer_v4 as V4
import stem_ms96_irm_swa_fuse as F
import stem_ms96_irm_synth_fuse as SF
from common import DS_KEYS

EXP = os.path.dirname(os.path.abspath(__file__))
CACHE_DIR = os.path.join(EXP, "models", "focal_synth_adapt_readout", "cache")
FCR_CACHE = os.path.join(EXP, "models", "fuse_conf_resid", "cache")
FOCAL_DIR = os.path.join(EXP, "models", "stem_ms96_focal_avgc")
SYNTH_DIR = os.environ.get(
    "SYNTH_DIR", os.path.join(EXP, "models", "stem_ms96_synth_switch"))
LOG = os.path.join(EXP, "experiments", "focal_synth_adapt_readout.log")
OUT = os.path.join(EXP, "results", "research", "focal_synth_adapt_readout.json")
RESULTS_MD = os.path.join(EXP, "multi_agent_opt", "results_focal_synth_adapt_readout.md")
CKPT = os.path.join(EXP, "models", "focal_synth_adapt_readout")

P_STAY = 0.994
SCALE = 0.8
TEST_NAMES = ("AASD", "Carta2026")
WINDOW = 96
W_FUSE = 0.5
HOP = 0.25
EPS = 1e-6
SCALE_CLIP = (0.5, 2.0)
TEMP_CLIP = (0.5, 2.0)
MAX_FIT = 400_000
SEED = 0

TIP = dict(  # focal↔synth w=0.5
    mean=dict(H=0.8821, Acc=83.36),
    AVGC=dict(H=0.8226, Acc=75.54),
    AASD=dict(H=0.6208, Acc=51.06),
    Carta2026=dict(H=0.5496, Acc=49.14),
)
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))

# (name, family, tau_s|None, persist_subj, selectable)
# family: raw | temp | scale | affine | train_temp | train_scale | train_platt | platt_temp
VARIANT_SPECS = [
    ("fuse_w05", "raw", None, False, False),
    ("trial_temp_t15", "temp", 15.0, False, True),
    ("trial_temp_t30", "temp", 30.0, False, True),
    ("trial_temp_t60", "temp", 60.0, False, True),
    ("subj_temp_t30", "temp", 30.0, True, True),
    ("trial_scale_t30", "scale", 30.0, False, True),
    ("subj_scale_t30", "scale", 30.0, True, True),
    ("trial_affine_t30", "affine", 30.0, False, True),
    ("subj_affine_t30", "affine", 30.0, True, True),
    ("train_temp", "train_temp", None, False, False),  # diagnostic (≈invariant)
    ("train_scale", "train_scale", None, False, True),
    ("train_platt", "train_platt", None, False, True),
    ("platt_then_trial_temp_t30", "platt_temp", 30.0, False, True),
]

DEVICE = os.environ.get("DEVICE", "cpu")


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 alpha_from_tau(tau):
    return float(1.0 - np.exp(-HOP / float(tau)))


def subject_of(key, meta_entry=None):
    if meta_entry is not None 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 _ema_past(x, alpha, init):
    x = np.asarray(x, np.float64).reshape(-1)
    a = float(alpha)
    y, _ = lfilter([a], [1.0, -(1.0 - a)], x, zi=np.asarray([init * (1.0 - a)], np.float64))
    past = np.empty_like(x)
    past[0] = init
    if len(x) > 1:
        past[1:] = y[:-1]
    return past, float(y[-1]) if len(y) else float(init)


def train_abs_median(streams, datasets):
    parts = []
    for ds in datasets:
        for _k, d in streams[ds].items():
            parts.append(np.abs(np.asarray(d, np.float64).reshape(-1)))
    x = np.concatenate(parts)
    return float(np.median(x)) + EPS


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


def adapt_temp_1d(z, T0, alpha, init_abs=None):
    """Causal temperature: divide by past EWMA(|z|)/T0."""
    z = np.asarray(z, np.float64).reshape(-1)
    if len(z) == 0:
        return z.copy(), (T0 if init_abs is None else init_abs)
    a0 = float(T0 if init_abs is None else init_abs)
    abs_past, abs_final = _ema_past(np.abs(z), alpha, a0)
    lo, hi = TEMP_CLIP
    T = np.clip(abs_past / max(T0, EPS), lo, hi)
    return z / T, abs_final


def adapt_moment_1d(z, mu_tgt, sd_tgt, alpha, mode, scale_only=False,
                    init_mu=None, init_second=None):
    z = np.asarray(z, np.float64).reshape(-1)
    if mode is None or len(z) == 0:
        return z.copy(), (mu_tgt if init_mu is None else init_mu), (
            mu_tgt * mu_tgt + sd_tgt * sd_tgt if init_second is None else init_second)
    mu0 = float(mu_tgt if init_mu is None else init_mu)
    sec0 = float((mu_tgt * mu_tgt + sd_tgt * sd_tgt) if init_second is None else init_second)
    mu_past, mu_final = _ema_past(z, alpha, mu0)
    sec_past, sec_final = _ema_past(z * z, alpha, sec0)
    var = np.maximum(sec_past - mu_past * mu_past, EPS)
    sd = np.sqrt(var)
    lo, hi = SCALE_CLIP
    if mode == "affine":
        scale = np.clip(sd_tgt / sd, lo, hi)
        if scale_only:
            out = (z - mu_past) * scale + mu_past
        else:
            out = (z - mu_past) * scale + mu_tgt
    else:
        out = z.copy()
    return out, mu_final, sec_final


def adapt_streams_causal(streams, meta_by_ds, family, tau, persist_subject,
                         T0=None, mu_tgt=None, sd_tgt=None):
    """Apply label-free past-only adapt. Trials sorted by key within subject."""
    if family == "raw":
        return {ds: {k: np.asarray(d, np.float64) for k, d in table.items()}
                for ds, table in streams.items()}
    alpha = alpha_from_tau(tau)
    out = {}
    for ds, table in streams.items():
        meta = (meta_by_ds or {}).get(ds) or {}
        by_sub = {}
        for key in table:
            sid = subject_of(key, meta.get(key))
            by_sub.setdefault(sid, []).append(key)
        adapted = {}
        for _sid, keys in by_sub.items():
            keys = sorted(keys)
            state_abs = state_mu = state_sec = None
            for key in keys:
                if not persist_subject:
                    state_abs = state_mu = state_sec = None
                z = table[key]
                if family == "temp":
                    y, state_abs = adapt_temp_1d(z, T0, alpha, init_abs=state_abs)
                elif family == "scale":
                    y, state_mu, state_sec = adapt_moment_1d(
                        z, mu_tgt, sd_tgt, alpha, "affine", scale_only=True,
                        init_mu=state_mu, init_second=state_sec)
                elif family == "affine":
                    y, state_mu, state_sec = adapt_moment_1d(
                        z, 0.0, sd_tgt, alpha, "affine", scale_only=False,
                        init_mu=state_mu, init_second=state_sec)
                else:
                    raise ValueError(family)
                adapted[key] = y
        out[ds] = adapted
    return out


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 nll_temp(T, x, y):
    T = max(float(T), 1e-3)
    p = np.clip(expit(x / T), 1e-7, 1.0 - 1e-7)
    return float(-(y * np.log(p) + (1.0 - y) * np.log(1.0 - p)).mean())


def fit_temperature(x, y):
    res = minimize_scalar(lambda T: nll_temp(T, x, y), bounds=(0.05, 20.0),
                          method="bounded", options=dict(xatol=1e-4))
    T = float(res.x)
    return dict(T=T, nll=float(res.fun), nll0=nll_temp(1.0, x, y), n=int(len(x)))


def nll_platt(ab, x, y):
    a, b = float(ab[0]), float(ab[1])
    p = np.clip(expit(a * x + b), 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, scale_only=False):
    if scale_only:
        res = minimize_scalar(
            lambda a: nll_platt([a, 0.0], x, y),
            bounds=(1e-3, 20.0), method="bounded", options=dict(xatol=1e-4))
        a, b = float(res.x), 0.0
        nll = float(res.fun)
    else:
        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])
        nll = float(res.fun)
    return dict(a=a, b=b, nll=nll, nll0=nll_platt([1.0, 0.0], x, y), n=int(len(x)),
                scale_only=bool(scale_only))


def apply_affine_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_temp_streams(streams, T):
    return {ds: {k: np.asarray(v, np.float64) / T for k, v in table.items()}
            for ds, table in streams.items()}


def fit_train_and_apply(streams, att, train_ds, family):
    x, y = collect_xy(streams, att, train_ds)
    if len(x) < 100 or y.min() == y.max():
        raw = {ds: {k: np.asarray(d, np.float64) for k, d in table.items()}
               for ds, table in streams.items()}
        return raw, dict(mode=family, degenerate=True, n=int(len(x)))
    if family == "train_temp":
        info = fit_temperature(x, y)
        return apply_temp_streams(streams, info["T"]), {**info, "mode": family}
    if family == "train_scale":
        info = fit_platt(x, y, scale_only=True)
        return apply_affine_streams(streams, info["a"], 0.0), {**info, "mode": family}
    if family == "train_platt":
        info = fit_platt(x, y, scale_only=False)
        return apply_affine_streams(streams, info["a"], info["b"]), {**info, "mode": family}
    raise ValueError(family)


def apply_variant(streams, att, train_ds, family, tau, persist, meta_by_ds=None):
    """Return (adapted_streams, fit_info)."""
    if family == "raw":
        raw = {ds: {k: np.asarray(d, np.float64) for k, d in table.items()}
               for ds, table in streams.items()}
        return raw, dict(mode="raw")
    if family in ("train_temp", "train_scale", "train_platt"):
        return fit_train_and_apply(streams, att, train_ds, family)
    if family == "platt_temp":
        platt_st, info = fit_train_and_apply(streams, att, train_ds, "train_platt")
        T0 = train_abs_median(platt_st, train_ds)
        adapted = adapt_streams_causal(
            platt_st, meta_by_ds, "temp", tau, persist, T0=T0)
        return adapted, {**info, "mode": "platt_temp", "T0": T0, "tau": tau}
    if family == "temp":
        T0 = train_abs_median(streams, train_ds)
        adapted = adapt_streams_causal(
            streams, meta_by_ds, "temp", tau, persist, T0=T0)
        return adapted, dict(mode="temp", T0=T0, tau=tau, persist=persist)
    if family in ("scale", "affine"):
        mu_t, sd_t = train_moments(streams, train_ds)
        adapted = adapt_streams_causal(
            streams, meta_by_ds, family, tau, persist, mu_tgt=mu_t, sd_tgt=sd_t)
        return adapted, dict(mode=family, mu=mu_t, sd=sd_t, tau=tau, persist=persist)
    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 _infer_one(ckpt_path, feat, device, tag):
    import torch
    t0 = time.time()
    log_line(f"  infer {tag} {ckpt_path} on {device}")
    net, mu, sd = F.load_ckpt(ckpt_path, device)
    st = V.infer_all(net, feat, mu, sd, WINDOW, device)
    del net
    if device.type == "cuda":
        torch.cuda.empty_cache()
    log_line(f"  infer {tag} done ({time.time() - t0:.0f}s)")
    return st


def _load_or_infer(cache_path, ckpt_path, feat, tag, prefer=None):
    if os.path.isfile(cache_path):
        log_line(f"cache hit {cache_path}")
        return load_pkl(cache_path)
    if prefer and os.path.isfile(prefer):
        log_line(f"reuse {prefer} → {cache_path}")
        st = load_pkl(prefer)
        save_pkl(cache_path, st)
        return st
    import torch
    device = torch.device(DEVICE if (DEVICE == "cpu" or torch.cuda.is_available()) else "cpu")
    st = _infer_one(ckpt_path, feat, device, tag)
    save_pkl(cache_path, st)
    return st


def ensure_held_fuse(held, feat_all):
    path = os.path.join(CACHE_DIR, f"focal_synth_w05__held-{held}.pkl")
    if os.path.isfile(path):
        log_line(f"cache hit {path}")
        return load_pkl(path)
    foc_c = os.path.join(CACHE_DIR, f"_tmp_focal__held-{held}.pkl")
    syn_c = os.path.join(CACHE_DIR, f"_tmp_synth__held-{held}.pkl")
    fcr_syn = os.path.join(FCR_CACHE, f"_tmp_synth__held-{held}.pkl")
    focal = _load_or_infer(
        foc_c, os.path.join(FOCAL_DIR, f"held-{held}.pt"), feat_all,
        f"held-{held}-focal", prefer=None)
    synth = _load_or_infer(
        syn_c, os.path.join(SYNTH_DIR, f"held-{held}.pt"), feat_all,
        f"held-{held}-synth", prefer=fcr_syn)
    blended = SF.blend_streams(focal, synth, W_FUSE)
    save_pkl(path, blended)
    log_line(f"cache write {path}")
    return blended


def ensure_all5_corpus(feat_all):
    path = os.path.join(CACHE_DIR, "focal_synth_w05__all5_corpus.pkl")
    if os.path.isfile(path):
        log_line(f"cache hit {path}")
        return load_pkl(path)
    foc_c = os.path.join(CACHE_DIR, "_tmp_focal__all5_corpus.pkl")
    syn_c = os.path.join(CACHE_DIR, "_tmp_synth__all5_corpus.pkl")
    fcr_syn = os.path.join(FCR_CACHE, "_tmp_synth__all5_corpus.pkl")
    focal = _load_or_infer(
        foc_c, os.path.join(FOCAL_DIR, "all5.pt"), feat_all,
        "all5-corpus-focal", prefer=None)
    synth = _load_or_infer(
        syn_c, os.path.join(SYNTH_DIR, "all5.pt"), feat_all,
        "all5-corpus-synth", prefer=fcr_syn)
    blended = SF.blend_streams(focal, synth, W_FUSE)
    save_pkl(path, blended)
    log_line(f"cache write {path}")
    return blended


def ensure_all5_external(ext_feat):
    path = os.path.join(CACHE_DIR, "focal_synth_w05__all5_external.pkl")
    if os.path.isfile(path):
        log_line(f"cache hit {path}")
        return load_pkl(path)
    foc_c = os.path.join(CACHE_DIR, "_tmp_focal__all5_external.pkl")
    syn_c = os.path.join(CACHE_DIR, "_tmp_synth__all5_external.pkl")
    fcr_syn = os.path.join(FCR_CACHE, "_tmp_synth__all5_external.pkl")
    focal = _load_or_infer(
        foc_c, os.path.join(FOCAL_DIR, "all5.pt"), ext_feat,
        "all5-ext-focal", prefer=None)
    synth = _load_or_infer(
        syn_c, os.path.join(SYNTH_DIR, "all5.pt"), ext_feat,
        "all5-ext-synth", prefer=fcr_syn)
    out = {ds: SF.blend_one(focal[ds], synth[ds], W_FUSE) for ds in focal}
    save_pkl(path, out)
    log_line(f"cache write {path}")
    return out


def write_results_md(results):
    sel = results["selected"]
    prim = results["variants"][sel]
    avgc = prim["lodo"]["AVGC"]
    tip_a = TIP["AVGC"]
    aasd = prim["external"]["AASD"]
    carta = prim["external"]["Carta2026"]
    mean = prim["lodo_mean"]
    dH = avgc["H"] - tip_a["H"]
    dA = avgc["Acc"] - tip_a["Acc"]
    lines = []
    lines.append("# results_focal_synth_adapt_readout\n")
    lines.append(
        "**Claim:** `focal-synth-adapt-readout` — past-only per-subject/trial "
        "causal **scale / temperature / affine** (and train-fold Platt/scale) on "
        "frozen **focal-IRM ↔ synth fuse w=0.5**.\n"
    )
    lines.append(
        "**Distinct from** `fuse-conf-resid` (gated residual net), "
        "`irm-synth-agree-gate`, `online-moment` on Acc tip / IRM↔SWA fuse, "
        "tip Acc PP. No stem BCE / AVGC curriculum.\n"
    )
    lines.append(
        f"**Honesty:** Label-free causal adapt where possible; train labels only "
        f"for Platt/scale/temp fit on LODO train folds. Select mean LODO Acc then H "
        f"@ HMM **{P_STAY}/{SCALE}**. Never AASD/Carta for selection.\n"
    )
    lines.append(
        f"**Compute:** CPU; caches `models/focal_synth_adapt_readout/cache/` "
        f"(synth reused from fuse_conf_resid). Code: `focal_synth_adapt_readout.py`. "
        f"JSON: `results/research/focal_synth_adapt_readout.json`.\n"
    )
    lines.append("## Selection\n")
    lines.append("| Rule | Pick |")
    lines.append("|------|------|")
    lines.append(
        f"| mean LODO Acc then H (adapt only) | **`{sel}`** |")
    lines.append(
        f"| Raw fuse sanity AVGC | **{TIP['AVGC']['H']:.4f} / {TIP['AVGC']['Acc']:.2f}** |")
    ranked = results["selection"]["ranked"]
    lines.append(f"\nRanked Acc: {' → '.join(ranked[:6])}\n")
    lines.append("## LODO (preset)\n")
    lines.append("| Variant | mean H / Acc | AVGC H / Acc | selectable |")
    lines.append("|---------|--------------|--------------|------------|")
    for name, *_rest, selectable in VARIANT_SPECS:
        v = results["variants"][name]
        mark = "**" if name == sel else ""
        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"{'**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("## External (preset)\n")
    lines.append(
        "| Variant | AASD H / Acc | ΔAcc vs tip 51.06 | ΔAcc vs hp30 53.12 | Carta H / Acc |"
    )
    lines.append(
        "|---------|--------------|-------------------|--------------------|---------------|"
    )
    for name in ("fuse_w05", 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"{a['Acc'] - TIP['AASD']['Acc']:+.2f} | "
            f"{a['Acc'] - LINEAR_HP30_EXT['AASD']['Acc']:+.2f} | "
            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}) |"
    )
    lines.append(
        f"| AASD Acc>60 | miss ({aasd['Acc']:.2f} vs tip SW2/swmix "
        f"{SW2_SWMIX_TIP['AASD']['Acc']:.2f} / hp30 {LINEAR_HP30_EXT['AASD']['Acc']:.2f}) |"
    )
    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"AASD Acc **{aasd['Acc']:.2f}**, Carta **{carta['Acc']:.2f}**. "
        f"{'Clears' if ge else 'Does not clear'} AVGC 0.85/78.\n"
    )
    lines.append("## Do not repeat\n")
    lines.append(
        "Do not re-grid past-only causal temp/scale/affine or train Platt/scale "
        "on frozen focal↔synth fuse w=0.5 at this HMM.\n"
    )
    lines.append("## NEXT IDEA\n")
    if ge:
        lines.append(
            "AVGC bar met — freeze this readout and push AASD Acc on Acc front-end only.\n"
        )
    else:
        lines.append(
            "Stop decision-layer readout adapts on tip fuse (temp/scale/affine/Platt "
            "saturated like online-moment / calib). Prefer Acc front-end only, or a "
            "**train-time** change that reshapes AVGC evidence without BCE γ/λ/curriculum "
            "re-grids — e.g. AVGC-subject mixup / hard-negative mining inside the tip "
            "stem recipe, not another focal γ.\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(CACHE_DIR, exist_ok=True)
    os.makedirs(CKPT, exist_ok=True)
    os.makedirs(os.path.dirname(LOG), exist_ok=True)
    open(LOG, "w").close()
    t_all = time.time()
    import torch
    torch.set_num_threads(int(os.environ.get("OMP_NUM_THREADS", "8")))
    log_line(
        f"focal-synth-adapt-readout DEVICE={DEVICE} p_stay {P_STAY} scale {SCALE} "
        f"w={W_FUSE}"
    )
    log_line(
        "honesty: past-only causal T/scale/affine; train-fold Platt/scale only; "
        "select Acc then H; never AASD/Carta labels"
    )
    log_line(
        "distinct from fuse-conf-resid / irm-synth-agree-gate / online-moment Acc-tip / tip Acc PP"
    )

    N.load_all()
    att = N.G["att"]
    feat_all = V.build_features()["ms"]

    log_line("=== cache focal↔synth fuse w=0.5 ===")
    fuse_by_held = {}
    for held in DS_KEYS:
        fuse_by_held[held] = ensure_held_fuse(held, feat_all)

    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=("past-only per-subj/trial causal scale/temperature/affine + "
                "train-fold Platt/scale on frozen focal↔synth fuse w=0.5"),
        p_stay=P_STAY, scale=SCALE, w_fuse=W_FUSE, device=DEVICE,
        honesty=("Label-free causal adapt; train labels only for Platt/scale/temp. "
                 "Select mean LODO Acc then H. No AASD/Carta for selection."),
        baselines=dict(focal_synth_tip=TIP, linear_hp30_ext=LINEAR_HP30_EXT,
                       sw2_swmix_tip=SW2_SWMIX_TIP),
        variants={},
    )

    log_line("=== LODO ===")
    lodo_means = {}
    for name, family, tau, persist, selectable in VARIANT_SPECS:
        t0 = time.time()
        per = {}
        fit_infos = {}
        for held in DS_KEYS:
            streams = fuse_by_held[held]
            train_ds = [d for d in DS_KEYS if d != held]
            adapted, info = apply_variant(
                streams, att, train_ds, family, tau, persist, meta_by_ds=None)
            # drop non-json iso objects
            fit_infos[held] = {k: v for k, v in info.items()
                               if isinstance(v, (int, float, str, bool, type(None)))}
            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: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}  "
            f"({time.time() - t0:.0f}s)"
        )
        lodo_means[name] = dict(H=mean_h, Acc=mean_a)
        results["variants"][name] = dict(
            family=family, tau=tau, persist_subject=persist, selectable=selectable,
            fit=fit_infos, lodo=per, lodo_mean=dict(H=mean_h, Acc=mean_a),
        )

    adapt_names = [n for n, *_r, 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 (adapt variants only; never AASD/Carta)",
        ranked=ranked, selected=selected,
        excluded_from_select=[n for n, *_r, sel in VARIANT_SPECS if not sel],
    )
    results["selected"] = selected

    log_line("=== external ===")
    corp = ensure_all5_corpus(feat_all)
    ext_logits, ext_meta = SF.load_external()
    ext_feat = V4.build_features_from(ext_logits)["ms"]
    ext_fuse = ensure_all5_external(ext_feat)
    train_ds_ext = list(V4.CORPUS)

    for name, family, tau, persist, _sel in VARIANT_SPECS:
        adapted_train, info = apply_variant(
            corp, att, train_ds_ext, family, tau, persist, meta_by_ds=None)
        mu_e, sd_e = SF.emissions_from(adapted_train, att, datasets=train_ds_ext)
        # For causal adapt on external: use same family with corpus T0/moments;
        # re-apply via apply_variant on a combined dict then take test keys —
        # cleaner: call adapt with train moments from corpus + persist meta.
        if family == "raw":
            adapted_test = ext_fuse
        elif family in ("train_temp", "train_scale", "train_platt"):
            if family == "train_temp":
                adapted_test = apply_temp_streams(ext_fuse, info["T"])
            else:
                adapted_test = apply_affine_streams(
                    ext_fuse, info["a"], 0.0 if family == "train_scale" else info["b"])
        elif family == "platt_temp":
            platt_ext = apply_affine_streams(ext_fuse, info["a"], info["b"])
            adapted_test = adapt_streams_causal(
                platt_ext, ext_meta, "temp", tau, persist, T0=info["T0"])
        elif family == "temp":
            adapted_test = adapt_streams_causal(
                ext_fuse, ext_meta, "temp", tau, persist, T0=info["T0"])
        elif family in ("scale", "affine"):
            adapted_test = adapt_streams_causal(
                ext_fuse, ext_meta, family, tau, persist,
                mu_tgt=info.get("mu", 0.0), sd_tgt=info["sd"])
        else:
            raise ValueError(family)
        ext = {}
        for ds in TEST_NAMES:
            r = SF.score_external(adapted_test[ds], ext_meta[ds], mu_e, sd_e)
            ext[ds] = r
            d_tip = r["Acc"] - TIP[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"ΔAcc vs tip {d_tip:+.2f}  vs 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"]
    avgc = prim["lodo"]["AVGC"]
    d_tip = dict(H=avgc["H"] - TIP["AVGC"]["H"], Acc=avgc["Acc"] - TIP["AVGC"]["Acc"])
    results["headline"] = dict(
        selected=selected,
        AASD=aasd, Carta2026=carta,
        lodo_mean=prim["lodo_mean"],
        lodo_AVGC=avgc,
        AVGC_delta_vs_tip=d_tip,
        AASD_Acc_delta_vs_tip=aasd["Acc"] - TIP["AASD"]["Acc"],
        AASD_Acc_delta_vs_linear_hp30=aasd["Acc"] - LINEAR_HP30_EXT["AASD"]["Acc"],
        AASD_Acc_delta_vs_sw2_swmix=aasd["Acc"] - SW2_SWMIX_TIP["AASD"]["Acc"],
        targets=dict(
            AVGC_ge_085_78=bool(avgc["H"] >= 0.85 and avgc["Acc"] >= 78),
            AASD_Acc_gt_60=bool(aasd["Acc"] > 60),
        ),
    )
    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"AASD Acc {aasd['Acc']:.2f}  Carta Acc {carta['Acc']:.2f}"
    )
    log_line(
        f"HEADLINE LODO mean H {prim['lodo_mean']['H']:.4f} "
        f"Acc {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=results["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()
