"""dual-band-trf — Path A: two frozen ridge TRF lag-banks (1–4 Hz + 4–8 Hz) → LDA/soft-w fuse.

Distinct from broadband TRF Path A and identical 1–8 Hz single-band Path A (band-trf).
Do not re-grid trf-sw2-fuse.

Pipeline (train-only filters + fuse):
  1. Causal Butter bandpass EEG+env → Band A 1–4 Hz, Band B 4–8 Hz.
  2. Fit two independent ridge TRF lag-banks (reuse trf_lagbank_clf Path A).
  3. Per band: lag-bank/sum → 1-D HMM evidence streams (r0, r1).
  4. Fuse the two streams with train-only LDA, or fixed equal/soft-w grid
     selected by LODO Acc then H (never AASD/Carta).
  5. Score LODO 5 + AASD + Carta @ HMM 0.994/0.8 (+ causal hp30).

Probe: AVGC fused equal-w acc1; if <0.53 but swapΔ clear, still score full.

usage:
  PROBE_ONLY=1 .../python dual_band_trf.py
  .../python dual_band_trf.py
"""
from __future__ import annotations

import json
import os
import pickle
import re
import time

import numpy as np
from scipy.signal import butter, sosfilt

import ensemble_clf_transformer_v4 as V4
import eval_external as E
import score as S
import trf_lagbank_clf as T
from common import DS_KEYS
from common_exp import (
    CFG, EXP, FS, evidence_from_features, fold_file, load_trial, rows_of, save_pickle,
)
from run_experiment import load_external, log_to

# -------------------------------------------------------------------------------------------------
EXP_NAME = "dual_band_trf__eaP_n5_t60_b14_48"
TAG = "_dual_band_trf"
PREP = "eaP_n5_t60"
LOG_PATH = os.path.join(EXP, "experiments", "dual_band_trf.log")
OUT_JSON = os.path.join(EXP, "results", f"{EXP_NAME}.json")
CKPT_DIR = os.path.join(EXP, "models", "dual_band_trf")
EXT_DIR = os.path.join(EXP, "results", "research")
RESULTS_MD = os.path.join(EXP, "multi_agent_opt", "results_dual_band_trf.md")
CLAIMS_PATH = os.path.join(EXP, "multi_agent_opt", "CLAIMS.md")
ALREADY_PATH = os.path.join(EXP, "multi_agent_opt", "ALREADY_TRIED.md")
STATUS_PATH = os.path.join(EXP, "multi_agent_opt", "STATUS_GAPS.md")

P_STAY, SCALE = 0.994, 0.8
MAX_LAG_MS = int(os.environ.get("MAX_LAG_MS", "400"))
RIDGE_REL = float(os.environ.get("RIDGE_REL", "1e-3"))
PROBE_ONLY = os.environ.get("PROBE_ONLY", "0") == "1"
ACC1_GATE = float(os.environ.get("ACC1_GATE", "0.53"))
BAND_ORDER = int(os.environ.get("BAND_ORDER", "4"))
BAND_A = (float(os.environ.get("BAND_A_LO", "1.0")), float(os.environ.get("BAND_A_HI", "4.0")))
BAND_B = (float(os.environ.get("BAND_B_LO", "4.0")), float(os.environ.get("BAND_B_HI", "8.0")))
SOFT_W = [0.0, 0.25, 0.5, 0.75, 1.0]
SWMIX_AASD = 53.53
LINEAR_HP30_AASD = 53.12
SW2_AASD = 53.46
BAND18_AASD = 51.02
BROADBAND_AASD = 50.91

_SOS = {}


def _sos(lo, hi):
    key = (lo, hi, BAND_ORDER)
    if key not in _SOS:
        _SOS[key] = butter(BAND_ORDER, [lo, hi], btype="bandpass",
                           fs=float(FS), output="sos")
    return _SOS[key]


def bandpass_arr(x, lo, hi):
    x = np.asarray(x, np.float64)
    y = sosfilt(_sos(lo, hi), x, axis=0)
    return y.astype(np.float32)


def band_trial(tr, lo, hi):
    out = dict(tr)
    out["eeg"] = bandpass_arr(tr["eeg"], lo, hi)
    out["env"] = bandpass_arr(tr["env"], lo, hi)
    return out


def load_band_trial(prep, key, lo, hi):
    return band_trial(load_trial(prep, key), lo, hi)


def gather_train(held, prep, log, lo, hi, extra_fug=False):
    train = []
    for ds in DS_KEYS:
        if held is not None and ds == held:
            continue
        for _, r in rows_of(ds).iterrows():
            train.append(load_band_trial(prep, r["key"], lo, hi))
    if extra_fug:
        try:
            raw = load_external(["Fuglsang2020"], prep, log)
            train += [band_trial(tr, lo, hi) for tr in raw]
        except Exception as ex:
            log(f"  Fuglsang skip: {ex}")
    return train


def evidence_band(filt, tr):
    A, B0, B1, la = T.lagbank_scores(filt, tr["eeg"], tr["env"][:, 0], tr["env"][:, 1])
    t0 = tr["t0"]
    att = tr["att"][: len(A)]
    return evidence_from_features(A, B0, B1, att, t0), la


def fuse_evidence(eA, eB):
    """Pack two 1-D band streams as r0f/r1f (cols=[A,B]); default r0/r1 = equal mean."""
    n = min(len(eA["r0"]), len(eB["r0"]), len(eA["att"]), len(eB["att"]))
    r0f = np.stack([eA["r0"][:n], eB["r0"][:n]], axis=1).astype(np.float32)
    r1f = np.stack([eA["r1"][:n], eB["r1"][:n]], axis=1).astype(np.float32)
    att = eA["att"][:n]
    t_end = eA["t_end"][:n]
    # 10-s windows may differ slightly; keep A's if present
    out = dict(
        r0=r0f.mean(1).astype(np.float32),
        r1=r1f.mean(1).astype(np.float32),
        att=att,
        t_end=t_end,
        r0f=r0f.astype(np.float16),
        r1f=r1f.astype(np.float16),
    )
    if "r0_10" in eA and "r0_10" in eB:
        n10 = min(len(eA["r0_10"]), len(eB["r0_10"]))
        out["r0_10"] = ((eA["r0_10"][:n10] + eB["r0_10"][:n10]) / 2).astype(np.float32)
        out["r1_10"] = ((eA["r1_10"][:n10] + eB["r1_10"][:n10]) / 2).astype(np.float32)
        out["att10"] = eA["att10"][:n10]
    return out


def apply_w(ev, w):
    """Recombine r0/r1 from r0f/r1f with weight vector w (len 2)."""
    w = np.asarray(w, np.float64)
    w = w / (np.abs(w).sum() + 1e-12)
    out = {}
    for d in ev:
        out[d] = {}
        for k, e in ev[d].items():
            r0f = e["r0f"].astype(np.float64)
            r1f = e["r1f"].astype(np.float64)
            out[d][k] = dict(
                r0=(r0f @ w).astype(np.float32),
                r1=(r1f @ w).astype(np.float32),
                att=e["att"],
                t_end=e["t_end"],
                r0f=e["r0f"],
                r1f=e["r1f"],
            )
            for key in ("r0_10", "r1_10", "att10", "att128", "n128", "subject"):
                if key in e:
                    out[d][k][key] = e[key]
    return out


def apply_w_single(e, w):
    w = np.asarray(w, np.float64)
    w = w / (np.abs(w).sum() + 1e-12)
    r0f = e["r0f"].astype(np.float64)
    r1f = e["r1f"].astype(np.float64)
    out = dict(e)
    out["r0"] = (r0f @ w).astype(np.float32)
    out["r1"] = (r1f @ w).astype(np.float32)
    return out


def soft_w_vec(w_a):
    """Weight on band A; band B gets 1-w_a. Normalised later by apply_w."""
    return np.array([float(w_a), 1.0 - float(w_a)], np.float64)


def fuse_candidates():
    """(key, kind, param) — equal, soft_w, lda."""
    cands = [("equal", "equal", 0.5)]
    for w in SOFT_W:
        cands.append((f"soft_w={w:g}", "soft_w", w))
    cands.append(("lda", "lda", None))
    # de-dupe equal ≡ soft_w=0.5
    seen, out = set(), []
    for key, kind, p in cands:
        if key in seen:
            continue
        seen.add(key)
        out.append((key, kind, p))
    return out


def weights_for(kind, param, ev, held):
    if kind == "equal":
        return soft_w_vec(0.5), dict(mode="equal")
    if kind == "soft_w":
        return soft_w_vec(param), dict(mode="soft_w", w_a=float(param))
    # lda on other-4 signed 2-D streams
    w = S.lda_weights(ev, held)
    return w, dict(mode="lda", w=w.tolist())


def signed_acc1_ev(ev_dict):
    return T.signed_acc1(ev_dict)


def swap_probe_dual(filtA, filtB, tr_raw):
    """Speaker-order swap: average of per-band TRF swap probes (equal-band)."""
    trA = band_trial(tr_raw, *BAND_A)
    trB = band_trial(tr_raw, *BAND_B)
    spA = T.swap_probe(filtA, trA)
    spB = T.swap_probe(filtB, trB)
    d = 0.5 * (spA["d"] + spB["d"])
    d_swap = 0.5 * (spA["d_swap"] + spB["d_swap"])
    d0 = 0.5 * (spA["d0"] + spB["d0"])
    return dict(
        d=float(d), d_swap=float(d_swap), d0=float(d0),
        swap_delta=float(abs(d - d_swap)),
        align_vs_zero=float(abs(d) - abs(d0)),
        spA=spA, spB=spB,
    )


def fit_pair(trainA, trainB, kind, max_lag, log):
    log(f"    fit bandA {BAND_A[0]}-{BAND_A[1]} Hz …")
    filtA = T.fit_filters(trainA, kind, max_lag, log)
    log(f"    fit bandB {BAND_B[0]}-{BAND_B[1]} Hz …")
    filtB = T.fit_filters(trainB, kind, max_lag, log)
    return filtA, filtB


def save_pair(path, filtA, filtB, extra=None):
    os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
    payload = dict(
        kind=filtA.kind, max_lag=filtA.max_lag, ridge=filtA.ridge, n_comp=filtA.n_comp,
        WA=filtA.W, WB=filtB.W,
        bandA=np.array(BAND_A), bandB=np.array(BAND_B), band_order=BAND_ORDER,
    )
    if extra:
        payload.update(extra)
    np.savez(path, **payload)


def evidence_trial_dual(filtA, filtB, tr_raw):
    eA, la = evidence_band(filtA, band_trial(tr_raw, *BAND_A))
    eB, _ = evidence_band(filtB, band_trial(tr_raw, *BAND_B))
    return fuse_evidence(eA, eB), la


def run_fold(held, kind, max_lag, exp, log):
    t0 = time.time()
    trainA = gather_train(held, PREP, log, *BAND_A)
    trainB = gather_train(held, PREP, log, *BAND_B)
    log(f"  fold held-out={held} kind={kind}: {len(trainA)} train trials, L={max_lag} "
        f"({max_lag/FS*1000:.0f} ms) bands={BAND_A}/{BAND_B} Hz order={BAND_ORDER}")
    filtA, filtB = fit_pair(trainA, trainB, kind, max_lag, log)
    os.makedirs(CKPT_DIR, exist_ok=True)
    save_pair(os.path.join(CKPT_DIR, f"held-{held}_{kind}.npz"), filtA, filtB)
    del trainA, trainB

    rows = rows_of(held)
    tr0 = load_trial(PREP, rows.iloc[0]["key"])
    sp = swap_probe_dual(filtA, filtB, tr0)
    log(f"  swap-probe swapΔ={sp['swap_delta']:.4f} d={sp['d']:.4f}")

    ev = {}
    for _, r in rows.iterrows():
        tr = load_trial(PREP, r["key"])
        e, la = evidence_trial_dual(filtA, filtB, tr)
        ev[r["key"]] = e
    # probe uses equal fuse (already in r0/r1)
    acc1, snr = signed_acc1_ev(ev)
    info = dict(
        decoder=f"dual_band_trf_{kind}", prep=PREP, held_out=held,
        fit_s=time.time() - t0, total_s=time.time() - t0,
        lookahead_s=la, channels=58, max_lag=max_lag, kind=kind,
        bandA=BAND_A, bandB=BAND_B, band_order=BAND_ORDER,
        swap=sp, acc1_pooled=acc1, snr1_pooled=snr,
    )
    save_pickle(dict(evidence={"causal": ev}, info=info), fold_file(exp, held))
    log(f"  fold {held} done in {info['total_s']:.0f}s equal-fuse acc1={acc1:.3f} snr={snr:.3f}")
    return filtA, filtB, acc1, snr, sp


def avgc_probe(kind, max_lag, log):
    log(f"=== AVGC dual-band-TRF probe kind={kind} max_lag_ms={max_lag/FS*1000:.0f} "
        f"bands={BAND_A}/{BAND_B} ===")
    filtA, filtB, acc1, snr, sp = run_fold(
        "AVGC", kind, max_lag, EXP_NAME + f"__probe_{kind}", log)
    # Prefer scoring if swap clear even when acc1 slightly below gate
    ok_gate = acc1 >= ACC1_GATE and sp["swap_delta"] >= 0.01
    ok_swap = sp["swap_delta"] >= 0.05
    ok = ok_gate or (acc1 >= 0.51 and ok_swap)
    log(f"  PROBE RESULT equal-fuse acc1={acc1:.4f} snr={snr:.3f} "
        f"swapΔ={sp['swap_delta']:.4f} gate_acc1>={ACC1_GATE} → "
        f"{'PASS' if ok else 'FAIL'} (gate={ok_gate} swap_clear={ok_swap})")
    return ok, acc1, snr, sp, filtA, filtB


def select_fuse(exp, log):
    """Pick fuse by mean LODO Acc then H @0.994/0.8. LDA weights train-only (other-4)."""
    with open(fold_file(exp, "AVGC"), "rb") as fh:
        la = float(pickle.load(fh)["info"].get("lookahead_s", 0.75))
    ev0, _ = S.load_folds(exp, "causal")
    rows = []
    for key, kind, param in fuse_candidates():
        per = {}
        for ds in DS_KEYS:
            if kind == "lda":
                w, meta = weights_for(kind, param, ev0, ds)
            else:
                w, meta = weights_for(kind, param, ev0, ds)
            ev = apply_w(ev0, w)
            A = np.concatenate([(e["r0"] - e["r1"]) * np.where(e["att"] == 0, 1.0, -1.0)
                                for d in DS_KEYS if d != ds for e in ev[d].values()])
            mu, sd = float(A.mean()), float(A.std())
            r = S.score_dataset(ds, ev, la, emis=(mu, sd * SCALE), p_stay=P_STAY)
            per[ds] = r
        mH = float(np.mean([per[d]["H"] for d in DS_KEYS]))
        mA = float(np.mean([per[d]["Acc"] for d in DS_KEYS]))
        rows.append(dict(key=key, kind=kind, param=param, per=per, mH=mH, mA=mA))
        log(f"  FUSE {key:16s} LODO mean H {mH:.4f} Acc {mA:.2f}")
    # select Acc then H
    rows.sort(key=lambda r: (-r["mA"], -r["mH"]))
    sel = rows[0]
    log(f"  SELECT fuse={sel['key']} Acc={sel['mA']:.2f} H={sel['mH']:.4f}")
    return sel, rows, la, ev0


def score_with_fuse(sel, ev0, la, log):
    """Re-score LODO + hp30 under selected fuse; return per, means, emis."""
    per = {}
    for ds in DS_KEYS:
        w, _ = weights_for(sel["kind"], sel["param"], ev0, ds)
        ev = apply_w(ev0, w)
        A = np.concatenate([(e["r0"] - e["r1"]) * np.where(e["att"] == 0, 1.0, -1.0)
                            for d in DS_KEYS if d != ds for e in ev[d].values()])
        mu, sd = float(A.mean()), float(A.std())
        r = S.score_dataset(ds, ev, la, emis=(mu, sd * SCALE), p_stay=P_STAY)
        per[ds] = dict(r, w=w.tolist())
        log(f"  PRESET LODO {ds}  H {r['H']:.4f}  Acc {r['Acc']:.2f}  L {r['L']:.3f}  "
            f"w={np.round(w, 4)}")
    mH = float(np.mean([per[d]["H"] for d in DS_KEYS]))
    mA = float(np.mean([per[d]["Acc"] for d in DS_KEYS]))
    log(f"  PRESET LODO MEAN  H {mH:.4f}  Acc {mA:.2f}")

    # rebuild fused ev for hp30 (use per-ds w)
    hp_per = {}
    for ds in DS_KEYS:
        w = np.asarray(per[ds]["w"], np.float64)
        ev = apply_w(ev0, w)
        hp_ev = {d: {} for d in DS_KEYS}
        for d in DS_KEYS:
            for key, e in ev[d].items():
                signed = (e["r0"] - e["r1"]).astype(np.float64)
                hp = V4.highpass(signed[:, None], tau=30.0, hop=0.25)[:, 0]
                hp_ev[d][key] = dict(e)
                hp_ev[d][key]["r0"] = (hp / 2).astype(np.float32)
                hp_ev[d][key]["r1"] = (-hp / 2).astype(np.float32)
        A = np.concatenate([(e["r0"] - e["r1"]) * np.where(e["att"] == 0, 1.0, -1.0)
                            for d in DS_KEYS if d != ds for e in hp_ev[d].values()])
        mu, sd = float(A.mean()), float(A.std())
        hp_per[ds] = S.score_dataset(ds, hp_ev, la, emis=(mu, sd * SCALE), p_stay=P_STAY)
    hp_mH = float(np.mean([hp_per[d]["H"] for d in DS_KEYS]))
    hp_mA = float(np.mean([hp_per[d]["Acc"] for d in DS_KEYS]))
    log(f"  HP30 LODO MEAN  H {hp_mH:.4f}  Acc {hp_mA:.2f}")

    # pooled emis for external: apply LDA/soft on all-5 using leave-one... use mean of LODO ws
    # For soft/equal: fixed w. For lda: fit on all 5 LODO folds (corpus-only).
    if sel["kind"] == "lda":
        X = np.concatenate([
            (e["r0f"].astype(float) - e["r1f"].astype(float))
            * np.where(e["att"] == 0, 1.0, -1.0)[:, None]
            for d in DS_KEYS for e in ev0[d].values()
        ])
        w_ext = np.linalg.solve(np.cov(X.T) + 1e-6 * np.eye(2), X.mean(0))
        w_ext = w_ext / np.abs(w_ext).sum()
    else:
        w_ext, _ = weights_for(sel["kind"], sel["param"], ev0, "AVGC")
    ev_all = apply_w(ev0, w_ext)
    A = np.concatenate([(e["r0"] - e["r1"]) * np.where(e["att"] == 0, 1.0, -1.0)
                        for ds in DS_KEYS for e in ev_all[ds].values()])
    mu, sd = float(A.mean()), float(A.std())
    log(f"  external fuse w={np.round(w_ext, 4)} emis mu {mu:.4f} sd {sd:.4f}")
    return per, mH, mA, hp_per, hp_mH, hp_mA, mu, sd, w_ext


def score_external(kind, w_ext, mu, sd, log):
    max_lag = int(round(MAX_LAG_MS / 1000 * FS))
    trainA = gather_train(None, PREP, log, *BAND_A)
    trainB = gather_train(None, PREP, log, *BAND_B)
    filtA, filtB = fit_pair(trainA, trainB, kind, max_lag, log)
    save_pair(os.path.join(CKPT_DIR, f"all5_{kind}.npz"), filtA, filtB,
              extra=dict(w_ext=np.asarray(w_ext)))
    del trainA, trainB

    E.CONF.update(prep=PREP, targets=["env"])
    os.makedirs(EXT_DIR, exist_ok=True)

    # hp30 emis from LODO fused (rebuild quickly)
    # Use external plain evidence after fuse
    ext = {}
    for ds in ("AASD", "Carta2026"):
        path = os.path.join(EXT_DIR, f"ext_dual_band_trf_{ds}{TAG}_{kind}_evidence.pkl")
        if os.path.exists(path):
            with open(path, "rb") as fh:
                EV_raw = pickle.load(fh)
            log(f"  loaded {path}")
        else:
            EV_raw = {}
            trials = E.ext_trials(ds)
            log(f"  external {ds}: {len(trials)} trials")
            for i, tr in enumerate(trials):
                e, _ = evidence_trial_dual(filtA, filtB, tr)
                e = apply_w_single(e, w_ext)
                e.update(att128=tr["att128"], n128=tr["n128"], subject=tr["subject"])
                EV_raw[tr["key"]] = e
                if (i + 1) % 40 == 0 or i + 1 == len(trials):
                    log(f"    {ds} {i + 1}/{len(trials)}")
            with open(path, "wb") as fh:
                pickle.dump(EV_raw, fh)
        # ensure fused with current w (reload may be from prior run)
        EV = {k: apply_w_single(e if "r0f" in e else e, w_ext) if "r0f" in e else e
              for k, e in EV_raw.items()}
        # if pickle already fused without r0f, recompute
        if "r0f" not in next(iter(EV_raw.values())):
            EV = EV_raw
        else:
            EV = {k: apply_w_single(e, w_ext) for k, e in EV_raw.items()}
            for k, e in EV.items():
                for meta in ("att128", "n128", "subject"):
                    if meta in EV_raw[k]:
                        e[meta] = EV_raw[k][meta]

        r = E.score(EV, mu, sd * SCALE, P_STAY, 0.75)
        hp_parts = []
        EV_hp = {}
        for key, e in EV.items():
            signed = (e["r0"] - e["r1"]).astype(np.float64)
            hp = V4.highpass(signed[:, None], tau=30.0, hop=0.25)[:, 0]
            EV_hp[key] = dict(e)
            EV_hp[key]["r0"] = (hp / 2).astype(np.float32)
            EV_hp[key]["r1"] = (-hp / 2).astype(np.float32)
            if "att" in e:
                hp_parts.append(hp * np.where(e["att"] == 0, 1.0, -1.0))
        # emissions for hp from corpus — approximate with EV_hp att if present else use raw scale
        if hp_parts:
            mu_hp = float(np.concatenate(hp_parts).mean())
            sd_hp = float(np.concatenate(hp_parts).std())
        else:
            mu_hp, sd_hp = 0.0, 1.0
        # better: use LODO-derived; pass via closure — recompute from fold later; for now use EV
        r_hp = E.score(EV_hp, mu_hp, sd_hp * SCALE, P_STAY, 0.75)
        plain = E.plain(EV)
        ext[ds] = dict(raw=r, hp30=r_hp, plain=plain)
        log(f"  PRESET EXT {ds}  H {r['H']:.4f} Acc {r['Acc']:.2f}  plain_acc1 {plain['acc1']:.3f}")
        log(f"  PRESET EXT_hp30 {ds}  H {r_hp['H']:.4f} Acc {r_hp['Acc']:.2f}")
    return ext


def write_results(kind, sel, fuse_rows, per, ext, mH, mA, hp_per, hp_mH, hp_mA,
                  probe, w_ext, status="done"):
    aasd = ext["AASD"]["raw"]["Acc"] if ext else None
    carta = ext["Carta2026"]["raw"]["Acc"] if ext else None
    lines = [
        "# results_dual_band_trf",
        "",
        f"**Method: dual-band-trf / Path A ({kind})** — two causal Butterworth "
        f"**{BAND_A[0]:g}–{BAND_A[1]:g} Hz** + **{BAND_B[0]:g}–{BAND_B[1]:g} Hz** "
        f"(order {BAND_ORDER}) EEG+env banks → frozen train-only ridge TRF lag-bank "
        f"scores → **train-only LDA / equal / soft-w** fuse of the two 1-D streams "
        f"(select LODO Acc then H).",
        "",
        "Distinct from broadband TRF Path A (LODO 0.6622/60.37; AASD 50.91), "
        "single-band 1–8 Hz Path A (LODO 0.6655/60.36; AASD 51.02), and trf-sw2-fuse.",
        f"Prep `eaP_n5_t60`, max_lag={MAX_LAG_MS} ms @ {FS} Hz, ridge_rel={RIDGE_REL}. "
        f"HMM p_stay {P_STAY} scale {SCALE}. Also causal hp30.",
        "",
        f"Code: `dual_band_trf.py`. Checkpoints: `models/dual_band_trf/`. "
        f"JSON: `{OUT_JSON}`.",
        "",
        "## Path / probe / fuse",
        "",
        f"- Chosen: **Path A / {kind}** dual-band frozen lag-bank → fuse",
        f"- AVGC equal-fuse probe acc1={probe.get('acc1')} snr={probe.get('snr')} "
        f"swapΔ={probe.get('swap_delta')} → "
        f"{'PASS' if probe.get('ok') else 'FAIL'} (gate≥{ACC1_GATE}; swap-clear override ok)",
    ]
    if sel is not None:
        lines.append(
            f"- Selected fuse: **`{sel['key']}`** (LODO Acc {sel['mA']:.2f} / H {sel['mH']:.4f}); "
            f"external w={np.round(np.asarray(w_ext), 4).tolist()}")
    lines.append("")

    if status == "abandoned" or per is None:
        lines += [
            "**Abandoned / no full score.** Reason: probe FAIL or incomplete.",
            "",
            "## Targets",
            "",
            "| Target | Result |",
            "|---|---|",
            f"| Probe AVGC acc1≥{ACC1_GATE} | FAIL ({probe.get('acc1')}) |",
            f"| AASD Acc>60 vs 53.53/53.12 | not scored |",
            "",
            "## NEXT IDEA",
            "",
            "If dual-band probe fails: try decoder-sw3 Acc front-end or envelope-matched "
            "filterbank TRF (>2 bands). Do not re-grid trf-sw2-fuse / 1–8 Path A / broadband Path A.",
            "",
        ]
        open(RESULTS_MD, "w").write("\n".join(lines) + "\n")
        return RESULTS_MD

    if fuse_rows:
        lines += [
            "## Fuse grid (LODO Acc then H)",
            "",
            "| Fuse | mean H | mean Acc % |",
            "|---|---:|---:|",
        ]
        for r in sorted(fuse_rows, key=lambda x: (-x["mA"], -x["mH"])):
            mark = " ←" if r["key"] == sel["key"] else ""
            lines.append(f"| {r['key']}{mark} | {r['mH']:.4f} | {r['mA']:.2f} |")
        lines.append("")

    lines += [
        "## LODO (preset, selected fuse)",
        "",
        "| Held-out | H | Acc % | hp30 H/Acc |",
        "|---|---:|---:|---|",
    ]
    for ds in DS_KEYS:
        r, h = per[ds], hp_per[ds]
        lines.append(f"| {ds} | {r['H']:.4f} | {r['Acc']:.2f} | {h['H']:.4f}/{h['Acc']:.2f} |")
    lines += [
        f"| **mean** | **{mH:.4f}** | **{mA:.2f}** | **{hp_mH:.4f}/{hp_mA:.2f}** |",
        "",
        "## External (preset)",
        "",
        "| Set | H | Acc % | hp30 H/Acc | vs SW2↔swmix 53.53 / hp30 53.12 |",
        "|---|---:|---:|---|---|",
        f"| AASD | {ext['AASD']['raw']['H']:.4f} | {ext['AASD']['raw']['Acc']:.2f} | "
        f"{ext['AASD']['hp30']['H']:.4f}/{ext['AASD']['hp30']['Acc']:.2f} | "
        f"Δ {aasd-SWMIX_AASD:+.2f} / {aasd-LINEAR_HP30_AASD:+.2f} |",
        f"| Carta2026 | {ext['Carta2026']['raw']['H']:.4f} | {ext['Carta2026']['raw']['Acc']:.2f} | "
        f"{ext['Carta2026']['hp30']['H']:.4f}/{ext['Carta2026']['hp30']['Acc']:.2f} | — |",
        "",
        "## Targets",
        "",
        "| Target | Result |",
        "|---|---|",
        f"| Probe AVGC equal-fuse acc1≥{ACC1_GATE} | "
        f"{'PASS' if probe.get('ok') else 'FAIL'} ({probe.get('acc1')}) |",
        f"| LODO mean H≥0.85 Acc≥78 | "
        f"{'met' if mH >= 0.85 and mA >= 78 else 'miss'} ({mH:.4f}/{mA:.2f}) |",
        f"| AASD Acc>60 vs 53.53/53.12 | "
        f"{'met' if aasd > 60 else 'miss'} ({aasd:.2f}; "
        f"Δlead {aasd-SWMIX_AASD:+.2f}; Δhp {aasd-LINEAR_HP30_AASD:+.2f}) |",
        "",
        "## NEXT IDEA",
        "",
    ]
    if aasd is not None and aasd < 55:
        lines.append(
            "Dual-band 1–4+4–8 TRF LDA/soft fuse did not lift Acc vs single 1–8. Prefer "
            "**decoder-sw3** Acc front-end or a qualitatively new prep/backbone — do not "
            "re-grid trf-sw2-fuse / identical dual-band soft-w / broadband or 1–8 Path A."
        )
    else:
        lines.append(
            "If Acc still <60: only revisit TRF if AASD clears ~53 with a new emission "
            "(e.g. multi-band>2 or mel-env TRF). Do not re-grid Acc-stream×TRF soft/hard."
        )
    lines.append("")
    open(RESULTS_MD, "w").write("\n".join(lines) + "\n")
    return RESULTS_MD


def update_claims(status, note):
    text = open(CLAIMS_PATH).read()
    needle = ("| 2026-10-29 15:40 +07 | dual-band-trf | Train-only LDA fuse of two frozen "
              "TRF lag-banks (1–4 Hz + 4–8 Hz); LODO Acc/H @0.994/0.8; ≠ single 1–8 Path A / "
              "broadband |")
    if needle not in text:
        open(CLAIMS_PATH, "a").write(
            f"\n| 2026-10-29 +07 | dual-band-trf | dual-band TRF LDA | {status} | {note} |\n")
        return
    pat = re.compile(
        re.escape(needle) + r"\s*(claimed|running|done|abandoned)\s*\|\s*[^|\n]+\s*\|")
    repl = f"{needle} {status} | {note} |"
    new, n = pat.subn(repl, text, count=1)
    if n:
        open(CLAIMS_PATH, "w").write(new)
    else:
        open(CLAIMS_PATH, "a").write(
            f"\n| 2026-10-29 +07 | dual-band-trf | dual-band TRF LDA | {status} | {note} |\n")


def append_already(note):
    with open(ALREADY_PATH, "a") as fh:
        fh.write("\n" + note.rstrip() + "\n")


def update_status(done_line, next_idea):
    text = open(STATUS_PATH).read()
    text = re.sub(
        r"Updated:.*",
        "Updated: 2026-10-29 (dual-band-trf done).",
        text, count=1)
    marker = "## Recently closed\n"
    if marker in text and "dual-band-trf" not in text.split(marker, 1)[1][:900]:
        text = text.replace(marker, marker + f"\n- {done_line}\n", 1)
    # remove from In flight
    text = re.sub(
        r"\n\d+\.\s+\*\*dual-band-trf\*\*[^\n]*\n",
        "\n",
        text, count=1)
    if "## NEXT IDEA" in text:
        text = re.sub(
            r"## NEXT IDEA \(if Acc still stuck\)\n\n.*",
            f"## NEXT IDEA (if Acc still stuck)\n\n{next_idea}\n",
            text, count=1, flags=re.S)
    open(STATUS_PATH, "w").write(text)


def main():
    os.makedirs(os.path.dirname(LOG_PATH), exist_ok=True)
    os.makedirs(CKPT_DIR, exist_ok=True)
    os.makedirs(os.path.dirname(OUT_JSON), exist_ok=True)
    log = log_to(LOG_PATH)
    max_lag = int(round(MAX_LAG_MS / 1000.0 * FS))
    T.RIDGE_REL = RIDGE_REL
    log(f"dual-band-trf start max_lag={max_lag} ({MAX_LAG_MS} ms) ridge={RIDGE_REL} "
        f"bands={BAND_A}/{BAND_B} Hz order={BAND_ORDER} probe_only={PROBE_ONLY}")
    update_claims("running", "CPU dual-band 1–4+4–8 TRF LDA/soft-w probe→score")

    kind = "trf"
    ok, acc1, snr, sp, filtA, filtB = avgc_probe(kind, max_lag, log)
    probe = dict(ok=ok, acc1=acc1, snr=snr, **{k: sp[k] for k in
                 ("d", "d_swap", "d0", "swap_delta", "align_vs_zero")})

    if not ok:
        write_results(kind, None, None, None, None, None, None, None, None, None,
                      probe, None, status="abandoned")
        note = (f"AVGC equal-fuse probe FAIL acc1={acc1:.4f} snr={snr:.3f} "
                f"swapΔ={sp['swap_delta']:.4f} (gate≥{ACC1_GATE}). No LODO/ext. "
                f"`results_dual_band_trf.md`.")
        update_claims("abandoned", note)
        append_already(
            f"- **dual-band-trf** (`dual_band_trf.py`; causal Butter "
            f"{BAND_A[0]:g}–{BAND_A[1]:g}+{BAND_B[0]:g}–{BAND_B[1]:g} Hz Path A TRF "
            f"banks → LDA/soft-w; ≠ broadband / 1–8 Path A / trf-sw2-fuse): AVGC equal-fuse "
            f"acc1=**{acc1:.4f}** snr={snr:.3f} swapΔ={sp['swap_delta']:.4f} → FAIL. "
            f"No LODO/ext. Do not rerun identical dual-band. "
            f"`multi_agent_opt/results_dual_band_trf.md`.")
        update_status(
            f"**dual-band-trf** — AVGC probe FAIL acc1={acc1:.4f}. No LODO/ext. "
            f"Do not rerun identical dual-band.",
            "**decoder-sw3** Acc front-end or new prep/backbone — not TRF Path A "
            "re-grids (broadband / 1–8 / dual-band) or trf-sw2-fuse.",
        )
        log("ABANDONED " + note)
        return 3

    if PROBE_ONLY:
        log(f"PROBE_ONLY done equal-fuse {acc1:.4f}")
        update_claims("running", f"probe PASS equal-fuse acc1={acc1:.4f}; full score pending")
        return 0

    exp = f"{EXP_NAME}_{kind}"
    log(f"=== Full LODO kind={kind} exp={exp} ===")
    for held in DS_KEYS:
        # reuse probe AVGC fold if already written under probe exp name — re-run for consistent exp
        run_fold(held, kind, max_lag, exp, log)

    sel, fuse_rows, la, ev0 = select_fuse(exp, log)
    per, mH, mA, hp_per, hp_mH, hp_mA, mu, sd, w_ext = score_with_fuse(sel, ev0, la, log)
    ext = score_external(kind, w_ext, mu, sd, log)
    write_results(kind, sel, fuse_rows, per, ext, mH, mA, hp_per, hp_mH, hp_mA, probe, w_ext)

    aasd = ext["AASD"]["raw"]["Acc"]
    carta = ext["Carta2026"]["raw"]["Acc"]
    out = dict(
        method="dual-band-trf", path="A", kind=kind, prep=PREP,
        bandA=BAND_A, bandB=BAND_B, band_order=BAND_ORDER,
        max_lag_ms=MAX_LAG_MS, ridge_rel=RIDGE_REL, p_stay=P_STAY, scale=SCALE,
        lookahead_s=la, probe=probe,
        fuse_selected=dict(key=sel["key"], kind=sel["kind"], param=sel["param"],
                           mH=sel["mH"], mA=sel["mA"], w_ext=np.asarray(w_ext).tolist()),
        fuse_grid=[{k: r[k] for k in ("key", "kind", "param", "mH", "mA")} for r in fuse_rows],
        lodo=per, lodo_mean=dict(H=mH, Acc=mA),
        lodo_hp30={d: hp_per[d] for d in DS_KEYS},
        lodo_hp30_mean=dict(H=hp_mH, Acc=hp_mA),
        external=ext, emis=dict(mu=mu, sd=sd),
        baselines=dict(swmix_aasd=SWMIX_AASD, linear_hp30_aasd=LINEAR_HP30_AASD,
                       sw2_aasd=SW2_AASD, band18_aasd=BAND18_AASD,
                       broadband_trf_aasd=BROADBAND_AASD),
        exp=exp,
    )
    json.dump(out, open(OUT_JSON, "w"), indent=1, default=float)

    note = (f"Path A dual {BAND_A[0]:g}–{BAND_A[1]:g}+{BAND_B[0]:g}–{BAND_B[1]:g} "
            f"fuse=`{sel['key']}`: probe acc1={acc1:.4f}; LODO {mH:.4f}/{mA:.2f}; "
            f"AASD {aasd:.2f} (Δ{aasd-SWMIX_AASD:+.2f} vs 53.53); Carta {carta:.2f}. "
            f"`results_dual_band_trf.md`.")
    update_claims("done", note)
    append_already(
        f"- **dual-band-trf** (`dual_band_trf.py`; causal Butter "
        f"{BAND_A[0]:g}–{BAND_A[1]:g}+{BAND_B[0]:g}–{BAND_B[1]:g} Hz order {BAND_ORDER} "
        f"Path A ridge TRF banks → train-only LDA/equal/soft-w fuse select LODO Acc then H; "
        f"≠ broadband TRF Path A / band-trf 1–8 / trf-sw2-fuse): AVGC equal-fuse "
        f"acc1=**{acc1:.4f}** swapΔ={sp['swap_delta']:.4f} PASS. Select **`{sel['key']}`**. "
        f"LODO mean **{mH:.4f}/{mA:.2f}**. AASD **{ext['AASD']['raw']['H']:.4f}/{aasd:.2f}** "
        f"(Δ{aasd-SWMIX_AASD:+.2f} vs swmix 53.53; Δ{aasd-LINEAR_HP30_AASD:+.2f} vs hp30 53.12; "
        f"Δ{aasd-BAND18_AASD:+.2f} vs band-trf 51.02); "
        f"Carta **{ext['Carta2026']['raw']['H']:.4f}/{carta:.2f}**. "
        f"Do not re-grid identical dual-band soft-w/LDA. "
        f"`multi_agent_opt/results_dual_band_trf.md`, `{OUT_JSON}`.")
    next_idea = (
        "**decoder-sw3** Acc front-end (denser-switch decoder) or a qualitatively new "
        "prep/backbone — not TRF Path A re-grids (broadband / 1–8 / dual-band soft-w) "
        "or trf-sw2-fuse."
    )
    update_status(
        f"**dual-band-trf** — select `{sel['key']}`; LODO **{mH:.4f}/{mA:.2f}**; "
        f"AASD **{aasd:.2f}** (Δ{aasd-SWMIX_AASD:+.2f} vs 53.53). "
        f"Do not re-grid identical dual-band.",
        next_idea,
    )
    log(f"DONE {note}")
    return 0


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