"""One-knob ablations around linear_hp30 (priority B).

Axes (exactly one change each):
  A1 dual-EMA bandpass on mean4: y = EMA(tf) - EMA(ts)
  A2 per-frame common-mode removal across seeds, then mean + τ=30 HP
  A3 causal MAD scale on frozen hp30 before HMM
  A4 B3-style odd EMA+tanh readout on frozen hp30 (fit LODO train only)

Nested: for each outer D, pick config by mean inner Acc then H (never AASD/Carta).
External scored once with frozen selection. HMM p_stay=0.994 scale=0.8 (A1–A3);
A4 may select EMA τ / gain on LODO only.

Priority B: LODO H>0.80 Acc>70; Carta H>0.60 Acc>60; AASD H>0.60 (Acc soft).

usage:
  AXIS=a1 python -u ablate_hp30_oneknob.py
  AXIS=all python -u ablate_hp30_oneknob.py
"""
from __future__ import annotations

import csv
import json
import os
import time
import zlib

import numpy as np
from scipy.signal import lfilter

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, FS as FS128, SEED
from common_exp import EXP
from e1_switch import expand, integ_hmm, synth_trial
from scorer import aggregate, fast_score_subject

AXIS = os.environ.get("AXIS", "all").lower()
RUN_ROOT = os.path.join(EXP, "experiments", "multi_agent_opt", "runs")
LOOKAHEAD = 0.75
P_STAY = 0.994
SCALE = 0.8
HOP = 0.25
TEST_NAMES = ("AASD", "Carta2026")

A1_GRID = ((5.0, 30.0), (8.0, 30.0), (10.0, 40.0), (15.0, 45.0))
A3_TAU = (15.0, 30.0, 60.0)
A4_EMA_TAU = (2.0, 5.0, 10.0)
A4_GAIN = (0.5, 1.0, 2.0)


def log(path, msg):
    print(f"{time.strftime('%F %T')} {msg}", flush=True)
    os.makedirs(os.path.dirname(path), exist_ok=True)
    with open(path, "a") as fh:
        fh.write(msg + "\n")


def ema_1d(x, tau, hop=HOP):
    alpha = 1.0 - np.exp(-hop / float(tau))
    return lfilter([alpha], [1.0, -(1.0 - alpha)], np.asarray(x, np.float64))


def dual_bandpass(x, tf, ts):
    return (ema_1d(x, tf) - ema_1d(x, ts)).astype(np.float64)


def mad_scale(x, tau):
    """Causal: divide by EWMA of |x - running_mean| (MAD-like). Past-only."""
    x = np.asarray(x, np.float64)
    n = len(x)
    out = np.empty(n, np.float64)
    alpha = 1.0 - np.exp(-HOP / float(tau))
    mu, mad = 0.0, 1.0
    for t in range(n):
        scale = max(mad, 1e-6)
        out[t] = x[t] / scale
        mu = mu + alpha * (x[t] - mu)
        mad = mad + alpha * (abs(x[t] - mu) - mad)
    return out


def load_seed_stack():
    """Return per ds/key: D (T,4), att, t_end, and published mean/hp30 evidence dicts."""
    evs, lookahead = [], None
    for _s, exp in EC.SEEDS:
        ev, info = S.load_folds(exp, "causal")
        evs.append(ev)
        for ds in DS_KEYS:
            la = float(info[ds]["lookahead_s"])
            lookahead = la if lookahead is None else lookahead
    stack, mean_ev, hp_ev = {}, {}, {}
    for ds in DS_KEYS:
        stack[ds], mean_ev[ds], hp_ev[ds] = {}, {}, {}
        for k, e0 in evs[0][ds].items():
            D = np.stack([EC.delta(ev[ds][k]) for ev in evs], 1).astype(np.float64)
            base = dict(att=e0["att"], t_end=e0["t_end"], pre_switched=True)
            stack[ds][k] = dict(D=D, **base)
            m = D.mean(1)
            mean_ev[ds][k] = dict(r0=m, r1=np.zeros_like(m), **base)
            h = V4.highpass(D).mean(1).astype(np.float64)
            hp_ev[ds][k] = dict(r0=h, r1=np.zeros_like(h), **base)
    return stack, mean_ev, hp_ev, lookahead


def to_ev_stream(stream):
    """stream[ds][k] = 1-D float array → evidence dict."""
    ev = {}
    for ds, table in stream.items():
        ev[ds] = {}
        for k, d in table.items():
            if isinstance(d, dict) and "r0" in d:
                ev[ds][k] = d
            else:
                raise TypeError("expected evidence dicts")
    return ev


def make_ev_from_1d(stack, transform_fn):
    """Apply transform_fn(D or meta) → 1-D evidence per trial."""
    ev = {}
    for ds in DS_KEYS:
        ev[ds] = {}
        for k, meta in stack[ds].items():
            d = transform_fn(meta["D"], ds, k, meta)
            d = np.asarray(d, np.float64)
            ev[ds][k] = dict(
                r0=d,
                r1=np.zeros_like(d),
                att=meta["att"],
                t_end=meta["t_end"],
                pre_switched=True,
            )
    return ev


def plain_acc1(ev, ds):
    per = {}
    for e in ev[ds].values():
        d = (e["r0"] - e["r1"])[::4]
        sg = np.where(e["att"][::4] == 0, 1.0, -1.0)
        per.setdefault(id(e) if "subject" not in e else e.get("subject"), []).append(d * sg)
    # group by nothing reliable on LODO — median over trials of mean sign
    vals = []
    for e in ev[ds].values():
        d = (e["r0"] - e["r1"])[::4]
        sg = np.where(np.asarray(e["att"])[::4] == 0, 1.0, -1.0)
        vals.append(float(np.mean((d * sg) > 0)))
    return float(np.median(vals)) if vals else float("nan")


def score_dataset_rich(ds, ev, lookahead, emis, p_stay=P_STAY):
    """Like score.score_dataset but keeps per-subject rows + miss."""
    train = [d for d in DS_KEYS if d != ds]
    if emis is None:
        A = np.concatenate(
            [
                (e["r0"] - e["r1"]) * np.where(e["att"] == 0, 1.0, -1.0)
                for d in train
                for e in ev[d].values()
            ]
        )
        mu, sd = float(A.mean()), float(A.std())
    else:
        mu, sd = emis
    rng = np.random.default_rng(SEED + DS_KEYS.index(ds))
    per = {}
    for _, r in S.rows_of(ds).iterrows():
        T = int(r["n"])
        e = ev[ds][r["key"]]
        lab = np.load(os.path.join(S.EDA_CACHE, "cnd", f"{r['key']}.npz"))
        att = lab["att_col"][:T].astype(int)
        d = (e["r0"] - e["r1"]).astype(float)
        t_end = e["t_end"].astype(float)
        st, d_syn, _ = synth_trial(r["key"], T, d, t_end, rng)
        if e.get("pre_switched"):
            d_syn = d
        guess = int(rng.integers(0, 2))
        dec = integ_hmm(d_syn, dict(p_stay=p_stay, mu=mu, sd=sd))
        labs = expand(dec, t_end, lookahead, T, guess)
        gt = np.where(st, 1 - att, att)
        per.setdefault(r["subj_uid"], []).append((labs, gt, r["key"]))
    subj_rows = []
    res = []
    for subj, lst in per.items():
        pred = np.concatenate([a for a, _, _ in lst])
        gt = np.concatenate([b for _, b, _ in lst])
        trial = np.concatenate([np.full(len(a), i) for i, (a, _, _) in enumerate(lst)])
        s = fast_score_subject(pred, gt, trial, fs=FS128)
        res.append(s)
        subj_rows.append(
            dict(
                ds=ds,
                subject=subj,
                Acc=float(s["acc"]),
                L=float(s["L"]) if np.isfinite(s["L"]) else float("nan"),
                SDT=float(s["sdt"]) if np.isfinite(s["sdt"]) else float("nan"),
                nSwitches=int(s["nSwitches"]),
                nUndetected=int(s["nUndetected"]),
                miss_rate=float(s["nUndetected"] / max(s["nSwitches"], 1)),
            )
        )
    a = aggregate(res)
    miss = a["nUndetected"] / max(a["nSwitches"], 1)
    return dict(
        Acc=float(a["Acc"]),
        SDT=float(a["SDT"]) if np.isfinite(a["SDT"]) else float("nan"),
        L=float(a["L"]) if np.isfinite(a["L"]) else float("nan"),
        H=float(a["H"]),
        nSwitches=int(a["nSwitches"]),
        nUndetected=int(a["nUndetected"]),
        miss_rate=float(miss),
        emis_mu=mu,
        emis_sd=sd,
        subjects=subj_rows,
        acc1=plain_acc1(ev, ds),
    )


def emis_on(ev, datasets):
    A = np.concatenate(
        [
            (e["r0"] - e["r1"]) * np.where(e["att"] == 0, 1.0, -1.0)
            for d in datasets
            for e in ev[d].values()
        ]
    )
    return float(A.mean()), float(A.std())


def ev_to_dmap(ev):
    return {
        ds: {k: (e["r0"] - e["r1"]).astype(np.float64) for k, e in table.items()}
        for ds, table in ev.items()
    }


def nested_select_and_score(_unused, configs, log_path, axis_name):
    """Honest nested: inner Acc→H via fast N.evaluate; outer once via rich official score.
    Global tag for external = majority of per-outer picks (tie: higher mean outer Acc).
    """
    from collections import Counter

    dmaps = {tag: ev_to_dmap(cev) for tag, cev in configs}
    picks = []
    for outer in DS_KEYS:
        inner_means = {}
        for tag, cev in configs:
            rows = []
            dmap = dmaps[tag]
            for inner in DS_KEYS:
                if inner == outer:
                    continue
                train3 = [d for d in DS_KEYS if d not in (outer, inner)]
                mu, sd = N.emis(dmap, train3)
                rows.append(N.evaluate(inner, dmap[inner], mu, sd * SCALE, P_STAY))
            inner_means[tag] = (
                float(np.mean([r["Acc"] for r in rows])),
                float(np.mean([r["H"] for r in rows])),
            )
        best_tag = max(inner_means.keys(), key=lambda t: inner_means[t])
        cev = dict(configs)[best_tag]
        train4 = [d for d in DS_KEYS if d != outer]
        mu, sd = emis_on(cev, train4)
        outer_r = score_dataset_rich(outer, cev, LOOKAHEAD, (mu, sd * SCALE), P_STAY)
        picks.append(
            dict(
                outer_ds=outer,
                selected=best_tag,
                inner_Acc=inner_means[best_tag][0],
                inner_H=inner_means[best_tag][1],
                metrics=outer_r,
            )
        )
        log(
            log_path,
            f"  {axis_name} outer={outer} sel={best_tag} "
            f"innerAcc={inner_means[best_tag][0]:.2f} innerH={inner_means[best_tag][1]:.4f} "
            f"→ H={outer_r['H']:.4f} Acc={outer_r['Acc']:.2f} "
            f"SDT={outer_r['SDT']:.2f} miss={outer_r['miss_rate']:.3f}",
        )

    votes = Counter(p["selected"] for p in picks)
    top_n = votes.most_common()[0][1]
    candidates = [t for t, n in votes.items() if n == top_n]

    def tag_outer_acc(t):
        rows = [p["metrics"] for p in picks if p["selected"] == t]
        return (
            float(np.mean([r["Acc"] for r in rows])),
            float(np.mean([r["H"] for r in rows])),
        )

    tag_ext = max(candidates, key=tag_outer_acc)

    # Coherent LODO table: all outers with frozen tag_ext
    cev = dict(configs)[tag_ext]
    per = {}
    for outer in DS_KEYS:
        train4 = [d for d in DS_KEYS if d != outer]
        mu, sd = emis_on(cev, train4)
        per[outer] = score_dataset_rich(outer, cev, LOOKAHEAD, (mu, sd * SCALE), P_STAY)
    lodo = dict(
        H=float(np.mean([per[d]["H"] for d in DS_KEYS])),
        Acc=float(np.mean([per[d]["Acc"] for d in DS_KEYS])),
        L=float(np.mean([per[d]["L"] for d in DS_KEYS])),
        SDT=float(np.nanmean([per[d]["SDT"] for d in DS_KEYS])),
        miss_rate=float(np.mean([per[d]["miss_rate"] for d in DS_KEYS])),
        per=per,
    )
    mean_per = {tag_ext: dict(H=lodo["H"], Acc=lodo["Acc"])}
    for tag, _ in configs:
        if tag != tag_ext:
            mean_per[tag] = dict(H=None, Acc=None)

    log(
        log_path,
        f"  {axis_name} GLOBAL sel={tag_ext} votes={dict(votes)} LODO mean "
        f"H={lodo['H']:.4f} Acc={lodo['Acc']:.2f}",
    )
    return tag_ext, lodo, mean_per, picks


def score_ext_stream(stream_1d, train_ev_for_emis, log_path, tag):
    """stream_1d[ds][key]=array; train_ev for emissions from LODO hp-like evidence."""
    mu, sd = emis_on(train_ev_for_emis, DS_KEYS)
    # rebuild external from V4 test logits transformed the same way externally — caller passes EV
    raise NotImplementedError


def priority_b_ok(lodo_mean, ext):
    return (
        lodo_mean["H"] > 0.80
        and lodo_mean["Acc"] > 70.0
        and ext["Carta2026"]["H"] > 0.60
        and ext["Carta2026"]["Acc"] > 60.0
        and ext["AASD"]["H"] > 0.60
    )


def write_subj_csv(path, subject_rows):
    os.makedirs(os.path.dirname(path), exist_ok=True)
    if not subject_rows:
        return
    keys = list(subject_rows[0].keys())
    with open(path, "w", newline="") as fh:
        w = csv.DictWriter(fh, fieldnames=keys)
        w.writeheader()
        w.writerows(subject_rows)


def write_md(path, axis, tag, lodo, ext, baseline_note):
    lines = [
        f"# results_ablate_hp30_{axis}",
        "",
        f"Selected: **{tag}**",
        "",
        "| Set | H | Acc | L | SDT | miss | acc1 |",
        "|---|---:|---:|---:|---:|---:|---:|",
    ]
    for ds, m in lodo["per"].items():
        lines.append(
            f"| {ds} | {m['H']:.4f} | {m['Acc']:.2f} | {m['L']:.4f} | {m['SDT']:.2f} | "
            f"{m['miss_rate']:.3f} | {m['acc1']:.3f} |"
        )
    lines.append(
        f"| **LODO mean** | **{lodo['H']:.4f}** | **{lodo['Acc']:.2f}** | {lodo['L']:.4f} | "
        f"{lodo['SDT']:.2f} | {lodo['miss_rate']:.3f} | — |"
    )
    for ds in TEST_NAMES:
        m = ext[ds]
        lines.append(
            f"| {ds} | {m['H']:.4f} | {m['Acc']:.2f} | {m['L']:.4f} | {m['SDT']:.2f} | "
            f"{m['miss_rate']:.3f} | {m.get('acc1', float('nan')):.3f} |"
        )
    lines += [
        "",
        baseline_note,
        "",
        "Priority B: LODO H>0.80 Acc>70; Carta H>0.60 Acc>60; AASD H>0.60 (Acc soft).",
    ]
    with open(path, "w") as fh:
        fh.write("\n".join(lines) + "\n")


def archive_fail(axis, tag, lodo, ext, md_path):
    line = (
        f"- **ablate-hp30-{axis}** (`ablate_hp30_oneknob.py`; {tag}): "
        f"LODO **{lodo['H']:.4f}/{lodo['Acc']:.2f}**; "
        f"AASD **{ext['AASD']['H']:.4f}/{ext['AASD']['Acc']:.2f}**; "
        f"Carta **{ext['Carta2026']['H']:.4f}/{ext['Carta2026']['Acc']:.2f}**. "
        f"Priority-B FAIL. Do not rerun this exact one-knob grid. `{os.path.basename(md_path)}`."
    )
    with open(os.path.join(EXP, "multi_agent_opt", "ALREADY_TRIED.md"), "a") as fh:
        fh.write("\n" + line + "\n")


def load_ext_seed_stack():
    """(T,4) logits per external trial + meta."""
    test_logits, test_meta = V4.load_test()
    return test_logits, test_meta


def build_ext_ev(test_logits, test_meta, transform_1d_from_D):
    ext = {}
    for ds in TEST_NAMES:
        ext[ds] = {}
        for k, D in test_logits[ds].items():
            D = np.asarray(D, np.float64)
            d = transform_1d_from_D(D)
            m = test_meta[ds][k]
            ext[ds][k] = dict(
                r0=np.asarray(d, np.float64),
                r1=np.zeros(len(d), np.float64),
                att=m["att"],
                t_end=m["t_end"],
                att128=m["att128"],
                n128=m["n128"],
                subject=m["subject"],
            )
    return ext


def score_ext_ev(ext_ev, mu, sd, log_path):
    out = {}
    for ds in TEST_NAMES:
        r = E.score(ext_ev[ds], mu, sd * SCALE, P_STAY, LOOKAHEAD)
        # enrich miss
        miss = r["nUndetected"] / max(r["nSwitches"], 1)
        # acc1
        acc1 = E.plain(ext_ev[ds])["acc1"]
        out[ds] = dict(
            H=float(r["H"]),
            Acc=float(r["Acc"]),
            L=float(r["L"]),
            SDT=float(r["SDT"]),
            nSwitches=int(r["nSwitches"]),
            nUndetected=int(r["nUndetected"]),
            miss_rate=float(miss),
            acc1=float(acc1),
        )
        log(
            log_path,
            f"  EXT {ds} H={out[ds]['H']:.4f} Acc={out[ds]['Acc']:.2f} "
            f"SDT={out[ds]['SDT']:.2f} miss={out[ds]['miss_rate']:.3f}",
        )
    return out


def fit_b3_odd(train_ev, ema_tau, gain):
    """Fit odd linear map: y = gain * tanh(w * EMA_tau(d) + w0*d) with w from ridge on signed labels.
    Features [d, ema(d)] are odd; no bias. Closed-form: w = (X'X+λI)^-1 X'y with y=±1.
    Returns transform function on 1-D d.
    """
    xs, ys = [], []
    for ds in DS_KEYS:
        for e in train_ev[ds].values():
            d = (e["r0"] - e["r1"]).astype(np.float64)
            fe = np.stack([d, ema_1d(d, ema_tau)], 1)
            lab = np.where(np.asarray(e["att"]) == 0, 1.0, -1.0)
            xs.append(fe)
            ys.append(lab)
    X = np.concatenate(xs, 0)
    y = np.concatenate(ys, 0)
    # subsample for speed
    rng = np.random.default_rng(0)
    if len(X) > 200_000:
        idx = rng.choice(len(X), 200_000, replace=False)
        X, y = X[idx], y[idx]
    lam = 1e-2
    xtx = X.T @ X + lam * np.eye(2)
    w = np.linalg.solve(xtx, X.T @ y)

    def apply_d(d):
        d = np.asarray(d, np.float64)
        fe = np.stack([d, ema_1d(d, ema_tau)], 1)
        return (gain * np.tanh(fe @ w)).astype(np.float64)

    return apply_d, w


def run_axis(axis, stack, hp_ev, mean_ev, test_logits, test_meta):
    run_id = f"ablate_hp30_{axis}_{time.strftime('%Y%m%d')}"
    run_dir = os.path.join(RUN_ROOT, run_id)
    log_path = os.path.join(run_dir, "run.log")
    os.makedirs(run_dir, exist_ok=True)
    open(log_path, "w").close()
    log(log_path, f"=== AXIS {axis} start ===")

    configs = []
    ext_builders = {}

    if axis == "a1_bandpass":
        for tf, ts in A1_GRID:
            tag = f"bp_{tf:g}_{ts:g}"

            def make_tf(tf=tf, ts=ts):
                def _t(D, *a):
                    return dual_bandpass(D.mean(1), tf, ts)

                return _t

            ev = make_ev_from_1d(stack, make_tf())
            configs.append((tag, ev))
            ext_builders[tag] = (lambda D, tf=tf, ts=ts: dual_bandpass(D.mean(1), tf, ts))

    elif axis == "a2_cmrem":
        # baseline off = published hp30
        configs.append(("cm_off_hp30", hp_ev))
        ext_builders["cm_off_hp30"] = lambda D: V4.highpass(D).mean(1).astype(np.float64)

        def cm_then_hp(D, *a):
            cm = D - D.mean(1, keepdims=True)
            return V4.highpass(cm).mean(1).astype(np.float64)

        ev = make_ev_from_1d(stack, cm_then_hp)
        configs.append(("cm_on_hp30", ev))
        ext_builders["cm_on_hp30"] = lambda D: V4.highpass(D - D.mean(1, keepdims=True)).mean(1).astype(
            np.float64
        )

    elif axis == "a3_mad":
        for tau in A3_TAU:
            tag = f"mad_t{tau:g}"

            def make_tf(tau=tau):
                def _t(D, *a):
                    # D unused path: use published hp30 from mean of HP seeds
                    h = V4.highpass(D).mean(1).astype(np.float64)
                    return mad_scale(h, tau)

                return _t

            ev = make_ev_from_1d(stack, make_tf())
            configs.append((tag, ev))
            ext_builders[tag] = (
                lambda D, tau=tau: mad_scale(V4.highpass(D).mean(1).astype(np.float64), tau)
            )

    elif axis == "a4_b3":
        # Fit each (ema_tau, gain) on all5 train hp30 (no nested refit of w per outer for speed —
        # but selection still nested on which (tau,gain) via LODO). Fit w once on all folds' hp30
        # excluding nothing for feature fit is slightly leaky across outer; do per-outer fit in select.
        # Simpler honest approach: for each config, for each outer, fit w on train4 hp30, apply to all,
        # then nested score. Heavy but correct.
        for ema_tau in A4_EMA_TAU:
            for gain in A4_GAIN:
                tag = f"b3_e{ema_tau:g}_g{gain:g}"
                # placeholder ev filled later per-outer — build global fit on all5 for candidate pool
                apply_d, w = fit_b3_odd(hp_ev, ema_tau, gain)
                ev = {}
                for ds in DS_KEYS:
                    ev[ds] = {}
                    for k, e in hp_ev[ds].items():
                        d0 = (e["r0"] - e["r1"]).astype(np.float64)
                        d = apply_d(d0)
                        ev[ds][k] = dict(
                            r0=d,
                            r1=np.zeros_like(d),
                            att=e["att"],
                            t_end=e["t_end"],
                            pre_switched=True,
                        )
                configs.append((tag, ev))
                ext_builders[tag] = (
                    lambda D, apply_d=apply_d: apply_d(V4.highpass(D).mean(1).astype(np.float64))
                )
    else:
        raise ValueError(axis)

    tag, lodo, all_means, picks = nested_select_and_score(None, configs, log_path, axis)
    # subjects
    subj_rows = []
    for ds, m in lodo["per"].items():
        for s in m["subjects"]:
            subj_rows.append(s)
    write_subj_csv(
        os.path.join(EXP, "results", "research", f"ablate_hp30_{axis}_subjects.csv"),
        subj_rows,
    )

    train_ev = dict(configs)[tag]
    mu, sd = emis_on(train_ev, DS_KEYS)
    ext_ev = build_ext_ev(test_logits, test_meta, ext_builders[tag])
    ext = score_ext_ev(ext_ev, mu, sd, log_path)

    ok = priority_b_ok(lodo, ext)
    out_json = os.path.join(EXP, "results", "research", f"ablate_hp30_{axis}.json")
    out_md = os.path.join(EXP, "multi_agent_opt", f"results_ablate_hp30_{axis}.md")
    payload = dict(
        method=f"ablate_hp30_{axis}",
        selected=tag,
        lodo=dict(
            H=lodo["H"],
            Acc=lodo["Acc"],
            L=lodo["L"],
            SDT=lodo["SDT"],
            miss_rate=lodo["miss_rate"],
            per={
                d: {
                    k: m[k]
                    for k in (
                        "H",
                        "Acc",
                        "L",
                        "SDT",
                        "miss_rate",
                        "acc1",
                        "nSwitches",
                        "nUndetected",
                    )
                }
                for d, m in lodo["per"].items()
            },
        ),
        all_configs={t: dict(H=v["H"], Acc=v["Acc"]) for t, v in all_means.items()},
        external=ext,
        verdict="PASS" if ok else "FAIL",
        priority_b=ok,
        baseline="linear_hp30 0.7899/69.21; AASD 0.6422/53.12; Carta 0.6520/60.54",
    )
    # JSON-safe
    def scrub(o):
        if isinstance(o, dict):
            return {k: scrub(v) for k, v in o.items()}
        if isinstance(o, (list, tuple)):
            return [scrub(v) for v in o]
        if isinstance(o, (np.floating, np.integer)):
            return float(o)
        if isinstance(o, float) and (np.isnan(o) or np.isinf(o)):
            return None
        return o

    with open(out_json, "w") as fh:
        json.dump(scrub(payload), fh, indent=2)
    write_md(
        out_md,
        axis,
        tag,
        lodo,
        ext,
        "Baseline linear_hp30: LODO 0.7899/69.21; AASD 0.6422/53.12; Carta 0.6520/60.54.",
    )
    # append verdict line
    with open(out_md, "a") as fh:
        fh.write(f"\nVerdict: **{payload['verdict']}**.\n")
    log(log_path, f"VERDICT {payload['verdict']}")

    claim = (
        f"| {time.strftime('%Y-%m-%d %H:%M')} +07 | ablate-hp30-{axis} | one-knob {axis} sel={tag} | "
        f"done | {payload['verdict']} LODO {lodo['H']:.4f}/{lodo['Acc']:.2f}; "
        f"AASD {ext['AASD']['Acc']:.2f}; Carta {ext['Carta2026']['Acc']:.2f}. "
        f"`results_ablate_hp30_{axis}.md`. |"
    )
    with open(os.path.join(EXP, "multi_agent_opt", "CLAIMS.md"), "a") as fh:
        fh.write("\n" + claim + "\n")
    if not ok:
        archive_fail(axis, tag, lodo, ext, out_md)
    return ok, payload


def main():
    t0 = time.time()
    axes = (
        ["a1_bandpass", "a2_cmrem", "a3_mad", "a4_b3"]
        if AXIS in ("all", "")
        else [AXIS if AXIS.startswith("a") else f"a{AXIS}"]
    )
    # normalize names
    remap = {
        "a1": "a1_bandpass",
        "a2": "a2_cmrem",
        "a3": "a3_mad",
        "a4": "a4_b3",
        "a1_bandpass": "a1_bandpass",
        "a2_cmrem": "a2_cmrem",
        "a3_mad": "a3_mad",
        "a4_b3": "a4_b3",
    }
    axes = [remap.get(a, a) for a in axes]

    print("loading 4-seed stacks…", flush=True)
    stack, mean_ev, hp_ev, la = load_seed_stack()
    V4._install_scorer_state(mean_ev, la)
    print(f"lookahead={la}; scorer state installed; loading external logits…", flush=True)
    test_logits, test_meta = load_ext_seed_stack()

    # claim batch
    with open(os.path.join(EXP, "multi_agent_opt", "CLAIMS.md"), "a") as fh:
        fh.write(
            f"\n| {time.strftime('%Y-%m-%d %H:%M')} +07 | ablate-hp30-oneknob | "
            f"one-knob sequence {axes} priority B | claimed | ablate_hp30_oneknob.py |\n"
        )

    summary = []
    for ax in axes:
        ok, payload = run_axis(ax, stack, hp_ev, mean_ev, test_logits, test_meta)
        summary.append(payload)
        if ok:
            print(f"EARLY STOP: {ax} PASS priority B", flush=True)
            break

    out = os.path.join(EXP, "multi_agent_opt", "results_ablate_hp30_summary.md")
    lines = [
        "# results_ablate_hp30_summary",
        "",
        "Priority B: LODO H>0.80 Acc>70; Carta Acc>60 & H>0.60; AASD H>0.60 (Acc soft).",
        "",
        "| Axis | Selected | LODO H/Acc | AASD H/Acc | Carta H/Acc | Verdict |",
        "|---|---|---|---|---|---|",
        "| linear_hp30 baseline | τ=30 mean | 0.7899/69.21 | 0.6422/53.12 | 0.6520/60.54 | — |",
    ]
    for p in summary:
        ax = p["method"].replace("ablate_hp30_", "")
        lines.append(
            f"| {ax} | {p['selected']} | {p['lodo']['H']:.4f}/{p['lodo']['Acc']:.2f} | "
            f"{p['external']['AASD']['H']:.4f}/{p['external']['AASD']['Acc']:.2f} | "
            f"{p['external']['Carta2026']['H']:.4f}/{p['external']['Carta2026']['Acc']:.2f} | "
            f"**{p['verdict']}** |"
        )
    lines += ["", f"Elapsed wall ~{time.time() - t0:.0f}s."]
    with open(out, "w") as fh:
        fh.write("\n".join(lines) + "\n")
    print(f"wrote {out}", flush=True)
    return 0 if any(p["verdict"] == "PASS" for p in summary) else 1


if __name__ == "__main__":
    raise SystemExit(main())
