"""Soft/hard blend: frozen TRF Path A lag-bank evidence ↔ Acc leader.

Streams (never retrained here):
  trf    = trf_lagbank__eaP_n5_t60_trf Path A fold / external evidence
  leader = SW2↔swmix Acc leader hard_abs_swmix|t1 (AASD Acc 53.53), built from
           published SW2 fuse a=0.5 + technique-synth-switch (swmix) caches
  (also score pure SW2 a=0.5 as const/soft reference)

Grid: soft w∈{0,0.25,0.5,0.75,1} and causal |trf| / |leader| / disagree gates.
Align streams by matching t_end (TRF starts ~0.25 s later / shorter than SW2 grid).
Select by mean LODO Acc then H at HMM p_stay=0.994 scale=0.8 (never AASD/Carta).
Score AASD + Carta with the selected rule. CPU only.

DISTINCT from: TRF Path A alone, SW2↔swmix re-grid, SW2↔hp30, stem-sw2-ms.

usage:
  PYTHONPATH=/root/disk_3tb/eeg-thao:.../reports/eda_full/scripts:$PYTHONPATH \\
  /root/disk_3tb/EEG-sAAD-Grand-Challenge-Training-Dataset/.venv/bin/python -u trf_sw2_fuse.py
"""
from __future__ import annotations

import json
import os
import pickle
import time

import numpy as np
from scipy.signal import lfilter
from scipy.special import expit

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
import sw2_hp30_blend as SW2
import sw2_swmix_blend as SM
from common import DS_KEYS
from fuse_evidence import LA, OFF

EXP = os.path.dirname(os.path.abspath(__file__))
CACHE_DIR = os.path.join(EXP, "models", "trf_sw2_fuse", "cache")
LOG = os.path.join(EXP, "experiments", "trf_sw2_fuse.log")
OUT = os.path.join(EXP, "results", "research", "trf_sw2_fuse.json")
RESULTS_MD = os.path.join(EXP, "multi_agent_opt", "results_trf_sw2_fuse.md")

TRF_EXP = "trf_lagbank__eaP_n5_t60_trf"
TRF_EXT = {
    "AASD": os.path.join(
        EXP, "results", "research", "ext_trf_lagbank_AASD_trf_lagbank_trf_evidence.pkl"
    ),
    "Carta2026": os.path.join(
        EXP, "results", "research", "ext_trf_lagbank_Carta2026_trf_lagbank_trf_evidence.pkl"
    ),
}

# Acc leader from sw2-swmix-blend (published select)
LEADER_KIND, LEADER_THR, LEADER_SHARP = "hard_abs_swmix", 1.0, 1.0

P_STAY = 0.994
SCALE = 0.8
LOOKAHEAD = float(LA)
A_SW2 = SW2.A_SW2

LINEAR_HP30_EXT = dict(AASD=dict(H=0.6422, Acc=53.12), Carta2026=dict(H=0.6520, Acc=60.54))
SW2_ALONE_EXT = dict(AASD=dict(H=0.6439, Acc=53.46), Carta2026=dict(H=0.6470, Acc=59.60))
LEADER_ALONE_EXT = dict(AASD=dict(H=0.6424, Acc=53.53), Carta2026=dict(H=0.6460, Acc=59.71))
TRF_ALONE_EXT = dict(AASD=dict(H=0.6219, Acc=50.91), Carta2026=dict(H=0.5984, Acc=54.58))


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 ewma_1d(x, tau_s=4.0, hop=0.25):
    x = np.asarray(x, np.float64)
    alpha = 1.0 - np.exp(-hop / tau_s)
    return lfilter([alpha], [1.0, -(1.0 - alpha)], x)


def gate_series(leader, trf, kind, thresh, sharp, ewma_tau=4.0):
    """g∈[0,1]; high g → trust leader (Acc stream)."""
    f = np.asarray(leader, np.float64)
    h = np.asarray(trf, np.float64)
    n = min(len(f), len(h))
    f, h = f[:n], h[:n]
    if kind == "soft_w":
        return np.full(n, float(thresh), np.float64)
    if kind == "const_leader":
        return np.ones(n, np.float64)
    if kind == "const_trf":
        return np.zeros(n, np.float64)
    if kind == "abs_leader":
        return expit(sharp * (np.abs(f) - thresh))
    if kind == "ewma_abs_leader":
        return expit(sharp * (ewma_1d(np.abs(f), ewma_tau) - thresh))
    if kind == "abs_trf":
        # high |trf| → trust trf (low g)
        return expit(sharp * (thresh - np.abs(h)))
    if kind == "ewma_abs_trf":
        return expit(sharp * (thresh - ewma_1d(np.abs(h), ewma_tau)))
    if kind == "ewma_abs_either":
        af = ewma_1d(np.abs(f), ewma_tau)
        ah = ewma_1d(np.abs(h), ewma_tau)
        return expit(sharp * (af - ah - thresh))
    if kind == "disagree":
        return expit(sharp * (thresh - np.abs(f - h)))
    if kind == "ewma_disagree":
        return expit(sharp * (thresh - ewma_1d(np.abs(f - h), ewma_tau)))
    if kind == "hard_abs_leader":
        return (np.abs(f) >= thresh).astype(np.float64)
    if kind == "hard_abs_trf":
        # prefer trf when |trf| >= thr else leader
        return (np.abs(h) < thresh).astype(np.float64)
    if kind == "abs_and_disagree":
        a = expit(sharp * (np.abs(f) - thresh))
        d = expit(sharp * (thresh - np.abs(f - h)))
        return a * d
    raise ValueError(kind)


def candidate_rules():
    rules = []
    for w in (0.0, 0.25, 0.5, 0.75, 1.0):
        rules.append(("soft_w", w, 1.0))
    rules += [
        ("const_leader", 0.0, 1.0),
        ("const_trf", 0.0, 1.0),
        ("abs_leader", 0.5, 4.0),
        ("abs_leader", 1.0, 4.0),
        ("abs_leader", 1.5, 4.0),
        ("ewma_abs_leader", 0.5, 4.0),
        ("ewma_abs_leader", 1.0, 4.0),
        ("ewma_abs_leader", 1.5, 4.0),
        ("abs_trf", 0.05, 40.0),
        ("abs_trf", 0.1, 40.0),
        ("abs_trf", 0.2, 40.0),
        ("ewma_abs_trf", 0.05, 40.0),
        ("ewma_abs_trf", 0.1, 40.0),
        ("ewma_abs_either", 0.0, 4.0),
        ("ewma_abs_either", 0.25, 4.0),
        ("disagree", 0.5, 4.0),
        ("disagree", 1.0, 4.0),
        ("disagree", 1.5, 4.0),
        ("ewma_disagree", 0.5, 4.0),
        ("ewma_disagree", 1.0, 4.0),
        ("hard_abs_leader", 0.5, 1.0),
        ("hard_abs_leader", 1.0, 1.0),
        ("hard_abs_leader", 1.5, 1.0),
        ("hard_abs_trf", 0.05, 1.0),
        ("hard_abs_trf", 0.1, 1.0),
        ("hard_abs_trf", 0.2, 1.0),
        ("abs_and_disagree", 0.75, 4.0),
        ("abs_and_disagree", 1.0, 4.0),
    ]
    return rules


def rule_key(kind, thr, sharp):
    if kind == "soft_w":
        return f"soft_w={thr:g}"
    return f"{kind}|t{thr:g}|s{sharp:g}"


def _match_tend(ta, tb, tol=1e-6):
    ia = ib = 0
    idx_a, idx_b = [], []
    ta = np.asarray(ta, np.float64)
    tb = np.asarray(tb, np.float64)
    while ia < len(ta) and ib < len(tb):
        da = ta[ia] - tb[ib]
        if abs(da) <= tol:
            idx_a.append(ia)
            idx_b.append(ib)
            ia += 1
            ib += 1
        elif da < 0:
            ia += 1
        else:
            ib += 1
    return np.asarray(idx_a, np.int64), np.asarray(idx_b, np.int64)


def ensure_trf_lodo():
    path = os.path.join(CACHE_DIR, "trf_lodo.pkl")
    if os.path.isfile(path):
        log_line(f"cache hit {path}")
        return load_pkl(path)
    from common_exp import fold_file

    missing = [fold_file(TRF_EXP, ds) for ds in DS_KEYS if not os.path.exists(fold_file(TRF_EXP, ds))]
    if missing:
        raise FileNotFoundError("TRF Path A LODO folds missing:\n" + "\n".join(missing))
    log_line(f"loading TRF Path A LODO folds ({TRF_EXP}) …")
    t0 = time.time()
    ev, info = S.load_folds(TRF_EXP, "causal")
    out = {ds: {k: EC.delta(e) for k, e in ev[ds].items()} for ds in DS_KEYS}
    te = {ds: {k: np.asarray(e["t_end"], np.float64) for k, e in ev[ds].items()} for ds in DS_KEYS}
    la = float(info[DS_KEYS[0]].get("lookahead_s", 0.40625))
    save_pkl(path, (out, te, la))
    log_line(f"TRF LODO cache wrote ({time.time() - t0:.0f}s) la={la}")
    return out, te, la


def ensure_trf_external():
    path = os.path.join(CACHE_DIR, "trf_external.pkl")
    if os.path.isfile(path):
        log_line(f"cache hit {path}")
        return load_pkl(path)
    missing = [p for p in TRF_EXT.values() if not os.path.isfile(p)]
    if missing:
        raise FileNotFoundError("TRF external evidence missing:\n" + "\n".join(missing))
    out = {}
    for ds, p in TRF_EXT.items():
        raw = load_pkl(p)
        out[ds] = {k: EC.delta(e) for k, e in raw.items()}
        out[ds + "__te"] = {k: np.asarray(e["t_end"], np.float64) for k, e in raw.items()}
        out[ds + "__meta"] = raw
    save_pkl(path, out)
    log_line(f"TRF external cache wrote → {path}")
    return out


def build_leader_held(Z, swmix_full, held):
    """SW2↔swmix Acc leader stream on SW2 grid for this held-out weight fit."""
    sw2 = SW2.fuse_sw2_held(Z, held, a=A_SW2)
    sm = SM.align_swmix_to_sw2(swmix_full, sw2)
    return SM.apply_gate_all(sw2, sm, LEADER_KIND, LEADER_THR, LEADER_SHARP), sw2


def align_trf_onto_leader(leader_st, meta, trf_d, trf_te):
    """Place TRF deltas onto leader/SW2 time grid via t_end match; missing → 0.

    Returns (leader_trunc, trf_on_grid, meta_trunc) with identical lengths per trial.
    Uses the intersection of timestamps (truncate both to matched stamps).
    """
    out_l, out_t, out_meta = {}, {}, {}
    for ds in leader_st:
        out_l[ds], out_t[ds], out_meta[ds] = {}, {}, {}
        for k, f in leader_st[ds].items():
            if k not in trf_d.get(ds, {}):
                continue
            f = np.asarray(f, np.float64)
            h = np.asarray(trf_d[ds][k], np.float64)
            att, te_l = meta[ds][k]
            te_l = np.asarray(te_l, np.float64)[: len(f)]
            te_h = np.asarray(trf_te[ds][k], np.float64)[: len(h)]
            il, ih = _match_tend(te_l, te_h)
            if len(il) < 8:
                continue
            out_l[ds][k] = f[il].copy()
            out_t[ds][k] = h[ih].copy()
            out_meta[ds][k] = (np.asarray(att)[il], te_l[il])
    return out_l, out_t, out_meta


def apply_gate_stream(leader_st, trf_st, kind, thresh, sharp):
    out = {}
    for key in leader_st:
        if key not in trf_st:
            continue
        f = np.asarray(leader_st[key], np.float64)
        h = np.asarray(trf_st[key], np.float64)
        n = min(len(f), len(h))
        g = gate_series(f[:n], h[:n], kind, thresh, sharp)
        out[key] = (g * f[:n] + (1.0 - g) * h[:n]).astype(np.float64)
    return out


def apply_gate_all(leader_all, trf_all, kind, thresh, sharp):
    return {
        ds: apply_gate_stream(leader_all[ds], trf_all[ds], kind, thresh, sharp)
        for ds in leader_all
        if ds in trf_all
    }


def ev_from_stream(stream, meta):
    ev = {}
    for ds in DS_KEYS:
        if ds not in stream:
            continue
        ev[ds] = {}
        for k, d in stream[ds].items():
            if k not in meta[ds]:
                continue
            att, te = meta[ds][k]
            d = np.asarray(d, np.float64)
            n = len(d)
            ev[ds][k] = dict(
                r0=d,
                r1=np.zeros(n),
                att=np.asarray(att)[:n],
                t_end=np.asarray(te, np.float64)[:n],
                pre_switched=True,
            )
    return ev


def score_lodo_held(stream_all, meta, held):
    ev = ev_from_stream(stream_all, meta)
    V4._install_scorer_state(ev, LOOKAHEAD)
    return N.official(held, ev, P_STAY, SCALE)


def mean_lodo_for_rule(Z, meta, swmix_full, trf_d, trf_te, kind, thr, sharp):
    hs, acs, per = [], [], {}
    for held in DS_KEYS:
        leader, _sw2 = build_leader_held(Z, swmix_full, held)
        lead_a, trf_a, meta_a = align_trf_onto_leader(leader, meta, trf_d, trf_te)
        gated = apply_gate_all(lead_a, trf_a, kind, thr, sharp)
        r = score_lodo_held(gated, meta_a, held)
        hs.append(r["H"])
        acs.append(r["Acc"])
        per[held] = dict(H=r["H"], Acc=r["Acc"], SDT=r["SDT"], L=r.get("L"))
    return float(np.mean(hs)), float(np.mean(acs)), per


def align_ext_trf_to_leader(trf_stream, trf_te, leader_ev):
    """Align TRF external deltas onto leader evidence t_end grid."""
    out = {}
    for k, e in leader_ev.items():
        if k not in trf_stream:
            continue
        f = np.asarray(e["r0"], np.float64)
        te_l = np.asarray(e["t_end"], np.float64)[: len(f)]
        h = np.asarray(trf_stream[k], np.float64).reshape(-1)
        te_h = np.asarray(trf_te[k], np.float64)[: len(h)]
        il, ih = _match_tend(te_l, te_h)
        if len(il) < 8:
            continue
        out[k] = dict(
            leader=f[il].copy(),
            trf=h[ih].copy(),
            att=np.asarray(e["att"])[il],
            t_end=te_l[il],
            att128=e["att128"],
            n128=e["n128"],
            subject=e["subject"],
        )
    return out


def blend_ext_aligned(aligned, kind, thr, sharp):
    out = {}
    for k, a in aligned.items():
        f = a["leader"]
        h = a["trf"]
        n = min(len(f), len(h))
        g = gate_series(f[:n], h[:n], kind, thr, sharp)
        d = g * f[:n] + (1.0 - g) * h[:n]
        out[k] = dict(
            r0=d,
            r1=np.zeros(n),
            att=a["att"][:n],
            t_end=a["t_end"][:n],
            att128=a["att128"],
            n128=a["n128"],
            subject=a["subject"],
        )
    return out


def pack_stream_ext(aligned, which):
    """which: 'leader' | 'trf'."""
    out = {}
    for k, a in aligned.items():
        d = np.asarray(a[which], np.float64)
        n = len(d)
        out[k] = dict(
            r0=d,
            r1=np.zeros(n),
            att=a["att"][:n],
            t_end=a["t_end"][:n],
            att128=a["att128"],
            n128=a["n128"],
            subject=a["subject"],
        )
    return out


def corpus_emis_for_blend(Z, meta, swmix_full, trf_d, trf_te, kind, thr, sharp):
    acc = {ds: {} for ds in DS_KEYS}
    counts = {ds: {} for ds in DS_KEYS}
    meta_ref = {ds: {} for ds in DS_KEYS}
    for held in DS_KEYS:
        leader, _ = build_leader_held(Z, swmix_full, held)
        lead_a, trf_a, meta_a = align_trf_onto_leader(leader, meta, trf_d, trf_te)
        gated = apply_gate_all(lead_a, trf_a, kind, thr, sharp)
        for ds in DS_KEYS:
            for k, d in gated.get(ds, {}).items():
                if k not in acc[ds]:
                    acc[ds][k] = np.zeros_like(d, np.float64)
                    counts[ds][k] = 0
                    meta_ref[ds][k] = meta_a[ds][k]
                n = min(len(acc[ds][k]), len(d))
                acc[ds][k][:n] += d[:n]
                counts[ds][k] += 1
    parts = []
    for ds in DS_KEYS:
        for k, s in acc[ds].items():
            d = s / max(counts[ds][k], 1)
            att = meta_ref[ds][k][0]
            n = min(len(d), len(att))
            parts.append(d[:n] * np.where(np.asarray(att)[:n] == 0, 1.0, -1.0))
    A = np.concatenate(parts)
    return float(A.mean()), float(A.std())


def build_leader_external(EV_sw2, sm_ext):
    """Apply Acc-leader gate on SW2↔swmix external for each corpus."""
    out = {}
    for ds in ("AASD", "Carta2026"):
        sw2_ev = EV_sw2[ds][A_SW2]
        sm_al = SM.align_ext_swmix_to_sw2(sm_ext[ds], sw2_ev)
        blended = SM.blend_ext_ev(sw2_ev, sm_al, LEADER_KIND, LEADER_THR, LEADER_SHARP)
        out[ds] = blended
    return out


def _json_default(o):
    if isinstance(o, (np.floating, np.integer)):
        return float(o)
    if isinstance(o, np.ndarray):
        return o.tolist()
    raise TypeError(type(o))


def write_md_abandon(reason):
    text = f"""# results_trf_sw2_fuse

**Status: abandoned**

Could not load TRF Path A and/or SW2/swmix Acc-leader evidence.

Reason:
```
{reason}
```

## NEXT IDEA

Restore TRF folds (`{TRF_EXP}`), SW2 caches, and swmix pickles. Prefer **band-limited TRF** (theta/alpha or speech-band envelopes) as a new Path A emission if Acc fuse stays stuck — do not retrain identical full-band TRF Path A alone.
"""
    with open(RESULTS_MD, "w") as fh:
        fh.write(text)


def write_md_partial(selected, reason):
    with open(RESULTS_MD, "w") as fh:
        fh.write("# results_trf_sw2_fuse\n\n**Status: partial (LODO only)**\n\n")
        fh.write(
            f"Selected: `{selected['key']}` LODO mean H {selected['mean_LODO_H']:.4f} "
            f"Acc {selected['mean_LODO_Acc']:.2f}\n\nExternal abort: {reason}\n"
        )


def write_md(summary):
    sel = summary["selected"]
    ext = summary["external"]
    lines = []
    lines.append("# results_trf_sw2_fuse\n")
    lines.append(
        "Soft/hard blend of **frozen TRF Path A** lag-bank evidence "
        f"(`{TRF_EXP}`; AASD Acc 50.91) with **SW2↔swmix Acc leader** "
        f"`{LEADER_KIND}|t{LEADER_THR:g}` (AASD Acc **53.53**), aligned by matching `t_end`. "
        "**Not** TRF Path A alone / SW2↔swmix re-grid / SW2↔hp30 / stem-sw2-ms.\n"
    )
    lines.append(
        f"HMM preset **{P_STAY} / {SCALE}**. Code: `trf_sw2_fuse.py`. "
        f"JSON: `results/research/trf_sw2_fuse.json`.\n"
    )
    lines.append("## Selection (mean LODO Acc then H; never AASD/Carta)\n")
    lines.append(
        f"**SELECTED `{sel['key']}`** — mean LODO H **{sel['mean_LODO_H']:.4f}** "
        f"Acc **{sel['mean_LODO_Acc']:.2f}**\n"
    )
    lines.append("| Held-out | H | Acc % |")
    lines.append("|---|---:|---:|")
    for ds in DS_KEYS:
        p = sel["per_ds"][ds]
        lines.append(f"| {ds} | {p['H']:.4f} | {p['Acc']:.2f} |")
    lines.append(
        f"| **mean** | **{sel['mean_LODO_H']:.4f}** | **{sel['mean_LODO_Acc']:.2f}** |\n"
    )
    lines.append("### Soft-w grid (reference)\n")
    lines.append("| Rule | mean H | mean Acc |")
    lines.append("|---|---:|---:|")
    for r in summary["lodo_grid"]:
        if r["kind"] == "soft_w" or r["key"] == sel["key"]:
            mark = " **←**" if r["key"] == sel["key"] else ""
            lines.append(
                f"| `{r['key']}`{mark} | {r['mean_LODO_H']:.4f} | {r['mean_LODO_Acc']:.2f} |"
            )
    lines.append("\n## External (preset)\n")
    lines.append(
        "| Set | selected H/Acc | leader_only | trf_only | linear_hp30 | SW2 | leader |"
    )
    lines.append("|---|---|---|---|---|---|---|")
    for ds in ("AASD", "Carta2026"):
        s = ext[ds]["selected"]
        lead = ext[ds]["leader_only"]
        trf = ext[ds]["trf_only"]
        b = LINEAR_HP30_EXT[ds]
        swb = SW2_ALONE_EXT[ds]
        lb = LEADER_ALONE_EXT[ds]
        lines.append(
            f"| {ds} | {s['H']:.4f} / **{s['Acc']:.2f}** | {lead['H']:.4f}/{lead['Acc']:.2f} | "
            f"{trf['H']:.4f}/{trf['Acc']:.2f} | {b['H']:.4f}/{b['Acc']:.2f} | "
            f"{swb['H']:.4f}/{swb['Acc']:.2f} | {lb['H']:.4f}/{lb['Acc']:.2f} |"
        )
    aasd = ext["AASD"]["selected"]
    carta = ext["Carta2026"]["selected"]
    d_hp = aasd["Acc"] - LINEAR_HP30_EXT["AASD"]["Acc"]
    d_sw2 = aasd["Acc"] - SW2_ALONE_EXT["AASD"]["Acc"]
    d_lead = aasd["Acc"] - LEADER_ALONE_EXT["AASD"]["Acc"]
    lines.append("\n## Targets\n")
    lines.append("| Target | Result |")
    lines.append("|---|---|")
    lines.append(
        f"| AASD Acc vs leader 53.53 / hp30 53.12 / SW2 53.46 | Acc **{aasd['Acc']:.2f}** "
        f"(Δlead {d_lead:+.2f}; Δhp {d_hp:+.2f}; ΔSW2 {d_sw2:+.2f}); H {aasd['H']:.4f} |"
    )
    lines.append(
        f"| Carta vs linear_hp30 60.54 | Acc **{carta['Acc']:.2f}**; H {carta['H']:.4f} |"
    )
    lines.append(
        f"| LODO mean | H {sel['mean_LODO_H']:.4f} Acc {sel['mean_LODO_Acc']:.2f} |"
    )
    lines.append(f"| AASD Acc>60? | {'YES' if aasd['Acc'] > 60 else 'NO'} |\n")
    lines.append("## Verdict\n")
    if aasd["Acc"] > 60:
        lines.append("Selected TRF↔Acc-leader blend clears AASD Acc>60.\n")
    else:
        lines.append(
            "Honest LODO Acc/H selector on TRF↔Acc-leader does not create AASD Acc>60. "
            "Chance-cleared TRF (acc1≈0.54, AASD≈50.9) does not lift the Acc-leader mid-50s stream.\n"
        )
    lines.append("## NEXT IDEA\n")
    lines.append(
        "Do not re-grid TRF↔SW2/swmix soft/hard under LODO Acc/H. Prefer **band-limited TRF** "
        "(theta/alpha or speech-band envelopes as Path A emissions) if Acc fuse stays stuck — "
        "a qualitatively new frame-evidence Acc path, not another Acc-stream×TRF blend. "
        "Keep Acc leader 53.53 / SW2 53.46 / `linear_hp30` Carta 60.54 as portfolio leaders.\n"
    )
    with open(RESULTS_MD, "w") as fh:
        fh.write("\n".join(lines))


def update_claims(status, note):
    path = os.path.join(EXP, "multi_agent_opt", "CLAIMS.md")
    if not os.path.isfile(path):
        return
    # Markdown tables split on '|'; keep rule names pipe-safe.
    note = note.replace("|", "\\|")
    lines = open(path).read().splitlines()
    out = []
    for ln in lines:
        if "| trf-sw2-fuse |" in ln and ln.strip().startswith("|"):
            parts = [p.strip() for p in ln.strip().strip("|").split("|")]
            if len(parts) >= 5:
                parts[3] = status
                parts[4] = note
                # drop any accidental overflow columns from prior broken writes
                parts = parts[:5]
                ln = "| " + " | ".join(parts) + " |"
        out.append(ln)
    open(path, "w").write("\n".join(out) + "\n")


def main():
    os.makedirs(CACHE_DIR, exist_ok=True)
    os.makedirs(os.path.dirname(LOG), exist_ok=True)
    os.makedirs(os.path.dirname(OUT), exist_ok=True)
    open(LOG, "w").close()
    t_all = time.time()
    update_claims("running", "CPU TRF Path A ↔ Acc-leader soft/hard blend LODO grid…")
    log_line(
        f"trf-sw2-fuse start  p_stay={P_STAY} scale={SCALE} a_sw2={A_SW2} OFF={OFF} "
        f"leader={LEADER_KIND}|t{LEADER_THR:g}"
    )

    try:
        Z, meta = SW2.ensure_sw2_lodo()
        swmix_full, la_sm = SM.ensure_swmix_lodo()
        trf_d, trf_te, la_trf = ensure_trf_lodo()
        log_line(f"lookahead LA={LOOKAHEAD} swmix_la={la_sm} trf_la={la_trf}")
    except FileNotFoundError as e:
        log_line(f"ABORT: {e}")
        summary = dict(
            status="abandoned",
            reason=str(e),
            next_idea="Restore TRF folds / SW2 / swmix caches; try band-limited TRF next.",
        )
        with open(OUT, "w") as fh:
            json.dump(summary, fh, indent=2)
        write_md_abandon(str(e))
        update_claims("abandoned", str(e)[:180])
        return

    # sanity: pure leader and pure TRF on AVGC (aligned)
    leader, _ = build_leader_held(Z, swmix_full, "AVGC")
    lead_a, trf_a, meta_a = align_trf_onto_leader(leader, meta, trf_d, trf_te)
    r_lead = score_lodo_held(lead_a, meta_a, "AVGC")
    r_trf = score_lodo_held(trf_a, meta_a, "AVGC")
    log_line(
        f"sanity AVGC leader-aligned H {r_lead['H']:.4f} Acc {r_lead['Acc']:.2f} "
        f"(expect ~0.72 Acc~68)"
    )
    log_line(
        f"sanity AVGC trf-aligned H {r_trf['H']:.4f} Acc {r_trf['Acc']:.2f} "
        f"(TRF Path A reported AVGC 0.6532/60.81)"
    )

    rules = candidate_rules()
    log_line(f"scoring {len(rules)} rules on mean LODO Acc then H")
    rows = []
    best = None
    for kind, thr, sharp in rules:
        t0 = time.time()
        mean_h, mean_a, per = mean_lodo_for_rule(
            Z, meta, swmix_full, trf_d, trf_te, kind, thr, sharp
        )
        key = rule_key(kind, thr, sharp)
        row = dict(
            kind=kind,
            thresh=thr,
            sharp=sharp,
            key=key,
            mean_LODO_H=mean_h,
            mean_LODO_Acc=mean_a,
            per_ds=per,
        )
        rows.append(row)
        log_line(
            f"  LODO {key:36s} H {mean_h:.4f} Acc {mean_a:.2f} ({time.time() - t0:.0f}s)"
        )
        sel = (mean_a, mean_h)
        if best is None or sel > best[0]:
            best = (sel, row)

    selected = best[1]
    log_line(
        f"SELECTED {selected['key']} mean LODO H {selected['mean_LODO_H']:.4f} "
        f"Acc {selected['mean_LODO_Acc']:.2f}"
    )

    try:
        EV_sw2, emis_sw2 = SW2.ensure_sw2_external()
        sm_ext = SM.ensure_swmix_external()
        trf_ext = ensure_trf_external()
        leader_ext = build_leader_external(EV_sw2, sm_ext)
    except FileNotFoundError as e:
        log_line(f"ABORT external: {e}")
        summary = dict(
            status="partial",
            selected=selected,
            lodo_rows=rows,
            reason=str(e),
            next_idea="Restore TRF/SW2/swmix external evidence pickles.",
        )
        with open(OUT, "w") as fh:
            json.dump(summary, fh, indent=2, default=_json_default)
        write_md_partial(selected, str(e))
        update_claims("partial", f"LODO only; {selected['key']}")
        return

    kind, thr, sharp = selected["kind"], selected["thresh"], selected["sharp"]
    mu_c, sd_c = corpus_emis_for_blend(
        Z, meta, swmix_full, trf_d, trf_te, kind, thr, sharp
    )
    log_line(f"corpus blend emis mu={mu_c:.4f} sd={sd_c:.4f}")
    mu_lead, sd_lead = corpus_emis_for_blend(
        Z, meta, swmix_full, trf_d, trf_te, "const_leader", 0.0, 1.0
    )
    mu_trf, sd_trf = corpus_emis_for_blend(
        Z, meta, swmix_full, trf_d, trf_te, "const_trf", 0.0, 1.0
    )
    log_line(f"corpus leader emis mu={mu_lead:.4f} sd={sd_lead:.4f}")
    log_line(f"corpus trf emis mu={mu_trf:.4f} sd={sd_trf:.4f}")

    ext_rows = {}
    for ds in ("AASD", "Carta2026"):
        aligned = align_ext_trf_to_leader(
            trf_ext[ds], trf_ext[ds + "__te"], leader_ext[ds]
        )
        blended = blend_ext_aligned(aligned, kind, thr, sharp)
        lead_only = pack_stream_ext(aligned, "leader")
        trf_only = pack_stream_ext(aligned, "trf")
        for tag, ev_use, mu, sd in (
            ("selected", blended, mu_c, sd_c),
            ("leader_only", lead_only, mu_lead, sd_lead),
            ("trf_only", trf_only, mu_trf, sd_trf),
        ):
            r = E.score(ev_use, mu, sd * SCALE, P_STAY, LOOKAHEAD)
            pl = E.plain(ev_use)
            ext_rows.setdefault(ds, {})[tag] = dict(
                H=r["H"],
                Acc=r["Acc"],
                SDT=r["SDT"],
                L=r["L"],
                acc1=pl["acc1"],
                nSwitches=r["nSwitches"],
                nUndetected=r["nUndetected"],
            )
            log_line(
                f"EXT {ds} {tag:12s} H {r['H']:.4f} Acc {r['Acc']:.2f} "
                f"(leader {LEADER_ALONE_EXT[ds]['Acc']:.2f}; "
                f"SW2 {SW2_ALONE_EXT[ds]['Acc']:.2f}; "
                f"hp30 {LINEAR_HP30_EXT[ds]['Acc']:.2f}; "
                f"trf {TRF_ALONE_EXT[ds]['Acc']:.2f})"
            )

    summary = dict(
        status="done",
        method="trf-sw2-fuse",
        selected=selected,
        p_stay=P_STAY,
        scale=SCALE,
        a_sw2=A_SW2,
        OFF=OFF,
        leader=dict(kind=LEADER_KIND, thresh=LEADER_THR, sharp=LEADER_SHARP),
        trf_exp=TRF_EXP,
        lodo_grid=rows,
        external=ext_rows,
        baselines=dict(
            linear_hp30_ext=LINEAR_HP30_EXT,
            sw2_alone_ext=SW2_ALONE_EXT,
            leader_alone_ext=LEADER_ALONE_EXT,
            trf_alone_ext=TRF_ALONE_EXT,
        ),
        elapsed_s=time.time() - t_all,
    )
    with open(OUT, "w") as fh:
        json.dump(summary, fh, indent=2, default=_json_default)
    write_md(summary)

    aasd = ext_rows["AASD"]["selected"]
    carta = ext_rows["Carta2026"]["selected"]
    note = (
        f"Select {selected['key']}. LODO {selected['mean_LODO_H']:.4f}/"
        f"{selected['mean_LODO_Acc']:.2f}. AASD {aasd['Acc']:.2f} "
        f"(vs leader 53.53 / hp30 53.12). Carta {carta['Acc']:.2f}. "
        f"Acc>60={'YES' if aasd['Acc'] > 60 else 'NO'}. `results_trf_sw2_fuse.md`."
    )
    update_claims("done", note)
    log_line(f"done in {time.time() - t_all:.0f}s → {OUT}")
    log_line(note)


if __name__ == "__main__":
    main()
