"""band-trf — Path A TRF lag-bank with causal 1–8 Hz band-limit on EEG+env.

Reuses trf_lagbank_clf Path A (frozen ridge TRF → lag-bank HMM emissions) but
applies a causal Butterworth bandpass (1–8 Hz) to EEG and envelopes *before*
TRF fit and score. Distinct from broadband TRF Path A (LODO 0.6622; AASD 50.91).

Probe gate: AVGC acc1≥0.53 or abandon. If PASS → full LODO + AASD + Carta @0.994/0.8.

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

import json
import os
import pickle
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 = "band_trf_lagbank__eaP_n5_t60_b1_8"
TAG = "_band_trf"
PREP = "eaP_n5_t60"
LOG_PATH = os.path.join(EXP, "experiments", "band_trf_lagbank.log")
OUT_JSON = os.path.join(EXP, "results", f"{EXP_NAME}.json")
CKPT_DIR = os.path.join(EXP, "models", "band_trf_lagbank")
EXT_DIR = os.path.join(EXP, "results", "research")
RESULTS_MD = os.path.join(EXP, "multi_agent_opt", "results_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_LO = float(os.environ.get("BAND_LO", "1.0"))
BAND_HI = float(os.environ.get("BAND_HI", "8.0"))
BAND_ORDER = int(os.environ.get("BAND_ORDER", "4"))
SWMIX_AASD = 53.53
LINEAR_HP30_AASD = 53.12
SW2_AASD = 53.46

_SOS = None


def _sos():
    global _SOS
    if _SOS is None:
        _SOS = butter(BAND_ORDER, [BAND_LO, BAND_HI], btype="bandpass",
                      fs=float(FS), output="sos")
    return _SOS


def bandpass_arr(x):
    """Causal forward-only SOS bandpass (no filtfilt)."""
    x = np.asarray(x, np.float64)
    y = sosfilt(_sos(), x, axis=0)
    return y.astype(np.float32)


def band_trial(tr):
    """Copy trial with EEG + env band-limited to BAND_LO–BAND_HI Hz."""
    out = dict(tr)
    out["eeg"] = bandpass_arr(tr["eeg"])
    out["env"] = bandpass_arr(tr["env"])
    return out


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


def log_line(msg):
    print(msg, flush=True)


# -------------------------------------------------------------------------------------------------
def gather_train(held, prep, log, 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"]))
    if extra_fug:
        try:
            raw = load_external(["Fuglsang2020"], prep, log)
            train += [band_trial(tr) for tr in raw]
        except Exception as ex:
            log(f"  Fuglsang skip: {ex}")
    return train


def evidence_trial(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 run_fold(held, kind, max_lag, exp, log):
    t0 = time.time()
    train = gather_train(held, PREP, log)
    log(f"  fold held-out={held} kind={kind}: {len(train)} train trials, L={max_lag} "
        f"({max_lag/FS*1000:.0f} ms) band={BAND_LO}-{BAND_HI} Hz order={BAND_ORDER}")
    filt = T.fit_filters(train, kind, max_lag, log)
    os.makedirs(CKPT_DIR, exist_ok=True)
    ckpt = os.path.join(CKPT_DIR, f"held-{held}_{kind}.npz")
    np.savez(ckpt, kind=filt.kind, max_lag=filt.max_lag, W=filt.W, ridge=filt.ridge,
             n_comp=filt.n_comp, band_lo=BAND_LO, band_hi=BAND_HI, band_order=BAND_ORDER)
    del train
    rows = rows_of(held)
    tr0 = load_band_trial(PREP, rows.iloc[0]["key"])
    sp = T.swap_probe(filt, tr0)
    log(f"  swap-probe {sp}")
    ev = {}
    for _, r in rows.iterrows():
        tr = load_band_trial(PREP, r["key"])
        e, la = evidence_trial(filt, tr)
        ev[r["key"]] = e
    acc1, snr = T.signed_acc1(ev)
    info = dict(decoder=f"band_trf_lagbank_{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,
                band_lo=BAND_LO, band_hi=BAND_HI, 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 acc1={acc1:.3f} snr={snr:.3f}")
    return filt, acc1, snr, sp


def avgc_probe(kind, max_lag, log):
    log(f"=== AVGC Path A band-TRF probe kind={kind} "
        f"max_lag_ms={max_lag/FS*1000:.0f} band={BAND_LO}-{BAND_HI} Hz ===")
    filt, acc1, snr, sp = run_fold("AVGC", kind, max_lag, EXP_NAME + f"__probe_{kind}", log)
    ok = acc1 >= ACC1_GATE and sp["swap_delta"] >= 0.01
    log(f"  PROBE RESULT acc1={acc1:.4f} snr={snr:.3f} swapΔ={sp['swap_delta']:.4f} "
        f"gate_acc1>={ACC1_GATE} → {'PASS' if ok else 'FAIL'}")
    return ok, acc1, snr, sp, filt


def score_all(exp, kind, log):
    with open(fold_file(exp, "AVGC"), "rb") as fh:
        la = float(pickle.load(fh)["info"].get("lookahead_s", 0.75))
    ev, _ = S.load_folds(exp, "causal")
    per = {}
    for ds in DS_KEYS:
        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
        log(f"  PRESET LODO {ds}  H {r['H']:.4f}  Acc {r['Acc']:.2f}  L {r['L']:.3f}")
    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}")

    hp_ev = {}
    for ds in DS_KEYS:
        hp_ev[ds] = {}
        for key, e in ev[ds].items():
            signed = (e["r0"] - e["r1"]).astype(np.float64)
            hp = V4.highpass(signed[:, None], tau=30.0, hop=0.25)[:, 0]
            hp_ev[ds][key] = dict(e)
            hp_ev[ds][key]["r0"] = (hp / 2).astype(np.float32)
            hp_ev[ds][key]["r1"] = (-hp / 2).astype(np.float32)
    hp_per = {}
    for ds in DS_KEYS:
        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}")

    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[ds].values()])
    mu, sd = float(A.mean()), float(A.std())
    log(f"  external emissions mu {mu:.4f} sd {sd:.4f}")

    max_lag = int(round(MAX_LAG_MS / 1000 * FS))
    train = gather_train(None, PREP, log)
    filt = T.fit_filters(train, kind, max_lag, log)
    np.savez(os.path.join(CKPT_DIR, f"all5_{kind}.npz"),
             kind=filt.kind, max_lag=filt.max_lag, W=filt.W, ridge=filt.ridge,
             n_comp=filt.n_comp, band_lo=BAND_LO, band_hi=BAND_HI, band_order=BAND_ORDER)
    del train

    E.CONF.update(prep=PREP, targets=["env"])
    os.makedirs(EXT_DIR, exist_ok=True)
    ext = {}
    hp_parts = []
    for ds in DS_KEYS:
        for e in ev[ds].values():
            signed = (e["r0"] - e["r1"]).astype(np.float64)
            hp = V4.highpass(signed[:, None], tau=30.0, hop=0.25)[:, 0]
            hp_parts.append(hp * np.where(e["att"] == 0, 1.0, -1.0))
    mu_hp = float(np.concatenate(hp_parts).mean())
    sd_hp = float(np.concatenate(hp_parts).std())

    for ds in ("AASD", "Carta2026"):
        path = os.path.join(EXT_DIR, f"ext_band_trf_{ds}{TAG}_{kind}_evidence.pkl")
        if os.path.exists(path):
            with open(path, "rb") as fh:
                EV = pickle.load(fh)
            log(f"  loaded {path}")
        else:
            EV = {}
            trials = E.ext_trials(ds)
            log(f"  external {ds}: {len(trials)} trials")
            for i, tr in enumerate(trials):
                e, _ = evidence_trial(filt, band_trial(tr))
                e.update(att128=tr["att128"], n128=tr["n128"], subject=tr["subject"])
                EV[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, fh)
        r = E.score(EV, mu, sd * SCALE, P_STAY, 0.75)
        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)
        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 per, ext, mu, sd, mH, mA, hp_per, hp_mH, hp_mA, la


def write_results(kind, per, ext, mH, mA, hp_per, hp_mH, hp_mA, probe, status="done"):
    aasd = ext["AASD"]["raw"]["Acc"] if ext else None
    carta = ext["Carta2026"]["raw"]["Acc"] if ext else None
    lines = [
        "# results_band_trf",
        "",
        f"**Method: band-trf / Path A ({kind})** — causal Butterworth "
        f"**{BAND_LO:g}–{BAND_HI:g} Hz** (order {BAND_ORDER}) on EEG+env, then frozen "
        f"train-only ridge TRF lag-bank → HMM emissions (no deep net).",
        "",
        "Distinct from broadband TRF Path A (LODO 0.6622/60.37; AASD 50.91) and from "
        "trf-sw2-fuse / lp7_eaP classifier prep.",
        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: `band_trf_lagbank.py`. Checkpoints: `models/band_trf_lagbank/`. "
        f"JSON: `{OUT_JSON}`.",
        "",
        "## Path / probe",
        "",
        f"- Chosen: **Path A / {kind}** (band-limited frozen lag-bank HMM emissions)",
        f"- AVGC 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})",
        "",
    ]
    if status == "abandoned" or per is None:
        lines += [
            f"**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 band-TRF probe fails: try train-only LDA over broadband lag-bank dims "
            "as an Acc emission, or envelope-only 2–8 Hz TRF (narrower than 1–8). "
            "Do not re-grid trf-sw2-fuse / identical broadband Path A.",
            "",
        ]
        open(RESULTS_MD, "w").write("\n".join(lines) + "\n")
        return RESULTS_MD

    lines += [
        "## LODO (preset)",
        "",
        "| 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 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(
            "Band 1–8 Hz TRF did not lift Acc. Prefer a new Acc frame path "
            "(e.g. dual-band TRF 1–4 + 4–8 fused by train-only LDA, or decoder-sw3 Acc "
            "front-end) — do not re-grid trf-sw2-fuse / broadband Path A / Acc-stream blends."
        )
    else:
        lines.append(
            "If Acc still <60: fuse band-TRF with Acc leader under LODO Acc/H only if "
            "band-TRF AASD clears ~53; else try dual-band TRF LDA. Do not re-grid "
            "identical soft/hard Acc-stream×TRF."
        )
    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:30 +07 | band-trf | 1–8 Hz band-limited EEG+env before "
              "frozen ridge TRF lag-bank Path A; LODO+ext @0.994/0.8; ≠ broadband TRF Path A |")
    if needle not in text:
        open(CLAIMS_PATH, "a").write(
            f"\n| 2026-10-29 +07 | band-trf | band-TRF Path A | {status} | {note} |\n")
        return
    # replace status + trailing note for any current status token
    import re
    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 | band-trf | band-TRF Path A | {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()
    # bump updated stamp
    import re
    text = re.sub(
        r"Updated:.*",
        "Updated: 2026-10-29 (band-trf done).",
        text, count=1)
    # insert into Recently closed
    marker = "## Recently closed\n"
    if marker in text and "band-trf" not in text.split(marker, 1)[1][:800]:
        text = text.replace(
            marker,
            marker + f"\n- {done_line}\n",
            1)
    # NEXT IDEA section
    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))
    # force Path A ridge relative into T
    T.RIDGE_REL = RIDGE_REL
    log(f"band-trf start max_lag={max_lag} ({MAX_LAG_MS} ms) ridge={RIDGE_REL} "
        f"band={BAND_LO}-{BAND_HI} Hz order={BAND_ORDER} probe_only={PROBE_ONLY}")
    update_claims("running", "CPU Path A band 1–8 Hz TRF probe→score")

    kind = "trf"
    ok, acc1, snr, sp, filt = avgc_probe(kind, max_lag, log)
    probe = dict(ok=ok, acc1=acc1, snr=snr, **sp)

    if not ok:
        write_results(kind, None, None, None, None, None, None, None, probe, status="abandoned")
        note = (f"AVGC probe FAIL acc1={acc1:.4f} snr={snr:.3f} swapΔ={sp['swap_delta']:.4f} "
                f"(gate≥{ACC1_GATE}). No LODO/ext. `results_band_trf.md`.")
        update_claims("abandoned", note)
        append_already(
            f"- **band-trf** (`band_trf_lagbank.py`; causal Butter {BAND_LO:g}–{BAND_HI:g} Hz "
            f"on EEG+env then Path A ridge TRF lag-bank; ≠ broadband TRF Path A / trf-sw2-fuse / "
            f"lp7_eaP): AVGC probe acc1=**{acc1:.4f}** snr={snr:.3f} swapΔ={sp['swap_delta']:.4f} "
            f"→ FAIL gate≥{ACC1_GATE}. No LODO/ext. Do not rerun identical 1–8 Hz Path A. "
            f"`multi_agent_opt/results_band_trf.md`.")
        update_status(
            f"**band-trf** — AVGC probe FAIL acc1={acc1:.4f}. No LODO/ext. Do not rerun identical 1–8 Hz Path A.",
            "**Dual-band TRF LDA** (1–4 + 4–8 Hz Path A banks fused by train-only LDA) or "
            "decoder-sw3 Acc front-end — not another Acc-stream×TRF soft/hard grid.",
        )
        log("ABANDONED " + note)
        return 3

    if PROBE_ONLY:
        log(f"PROBE_ONLY done best={kind} {acc1:.4f}")
        update_claims("running", f"probe PASS {kind} 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:
        run_fold(held, kind, max_lag, exp, log)

    per, ext, mu, sd, mH, mA, hp_per, hp_mH, hp_mA, la = score_all(exp, kind, log)
    write_results(kind, per, ext, mH, mA, hp_per, hp_mH, hp_mA, probe)
    out = dict(
        method="band-trf", path="A", kind=kind, prep=PREP,
        band_lo=BAND_LO, band_hi=BAND_HI, 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, 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, broadband_trf_aasd=50.91),
        exp=exp,
    )
    json.dump(out, open(OUT_JSON, "w"), indent=1, default=float)
    aasd = ext["AASD"]["raw"]["Acc"]
    carta = ext["Carta2026"]["raw"]["Acc"]
    note = (f"Path A band {BAND_LO:g}–{BAND_HI:g}: probe acc1={acc1:.4f}; "
            f"LODO {mH:.4f}/{mA:.2f}; AASD {aasd:.2f} (Δ{aasd-SWMIX_AASD:+.2f} vs 53.53); "
            f"Carta {carta:.2f}. `results_band_trf.md`.")
    update_claims("done", note)
    append_already(
        f"- **band-trf** (`band_trf_lagbank.py`; causal Butter {BAND_LO:g}–{BAND_HI:g} Hz order "
        f"{BAND_ORDER} on EEG+env then Path A ridge TRF lag-bank; ≠ broadband TRF Path A "
        f"LODO 0.6622/AASD 50.91 / trf-sw2-fuse / lp7_eaP): AVGC probe acc1=**{acc1:.4f}** "
        f"swapΔ={sp['swap_delta']:.4f} PASS. LODO mean **{mH:.4f}/{mA:.2f}**. "
        f"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"Carta **{ext['Carta2026']['raw']['H']:.4f}/{carta:.2f}**. "
        f"Do not rerun identical 1–8 Hz Path A. `multi_agent_opt/results_band_trf.md`, "
        f"`{OUT_JSON}`.")
    update_status(
        f"**band-trf** — 1–8 Hz Path A; LODO **{mH:.4f}/{mA:.2f}**; AASD **{aasd:.2f}** "
        f"(Δ{aasd-SWMIX_AASD:+.2f} vs 53.53). Do not rerun identical 1–8 Hz Path A.",
        "**Dual-band TRF LDA** (1–4 + 4–8 fused train-only) or decoder-sw3 Acc front-end — "
        "not trf-sw2-fuse re-grid / identical broadband or 1–8 Path A.",
    )
    log(f"DONE {note}")
    return 0


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