src/covcollab/universaleve/multitask.py

"""Multi-task Universal Eve: detect covert comms AND fingerprint the structure.

Motivation (architecture research): the covert-trained detector is a PRESENCE
detector that is BLIND to format/channel/M in the deep-covert regime -- the
structure information is genuinely buried (SNR walls).  So a dual-capability warden
is really a detector + a *conditional* fingerprinter, and the headline is the
**structure-recovery frontier**: at what adversary advantage (regime / SNR) does
the warden graduate from "something is transmitting" to "it's OFDM, M=16, covert
policy on".

Model: the validated UniversalEve backbone (multi-scale Conv1d -> SSM -> masked
antenna pool + 7-dim spatial eigen-branch) produces a detection embedding ``e``; a
**spectral/pilot branch** (PSD + cyclic-autocorrelation, where format identity
lives) is concatenated for the structure heads.  Heads: detection (BCE, all
samples) + format / M / K / d / channel / policy-arm (CE, H1 only), combined with a
**masked, uncertainty-weighted** (Kendall-Gal) multi-task loss so an unlearnable
format gradient in deep-covert doesn't inject negative transfer onto detection.

Regimes:
  A  joint multi-task from scratch.
  C  detection-only pretrain -> freeze backbone -> probe structure off the frozen
     detection embedding (isolates the representational content; the probing
     question with a proper head, stratified by regime).
"""

from __future__ import annotations

import argparse
import json
import math
import os
import sys
import time

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F

from ..formats import FORMAT_IDS
from .dataset import to_real_iq
from .device import pick_device
from .model import N_SPATIAL, AntennaEncoder, spatial_features


def _auc(score: np.ndarray, lab: np.ndarray) -> float:
    """ROC-AUC via the Mann-Whitney statistic (ties counted at 1/2). Self-contained so the
    trainer needs no part of the generation-only audit stack."""
    s1, s0 = score[lab == 1], score[lab == 0]
    return float(np.mean(s1[:, None] > s0[None, :]) + 0.5 * np.mean(s1[:, None] == s0[None, :]))

# --------------------------------------------------------------------------
# label vocabularies (match the controlled dataset)
# --------------------------------------------------------------------------
FMT_VOCAB = list(FORMAT_IDS)                                   # sc,ofdm,dfts_ofdm,otfs,afdm,ofdm_comb
M_VOCAB = [8, 12, 16, 25]
K_VOCAB = [2, 4]
D_VOCAB = [1, 2, 4]
CHAN_VOCAB = ["flat", "multipath", "doppler"]
ARM_VOCAB = ["none", "random", "optimized"]
REGIMES = ["covert", "comparable", "detectable"]

# structure tasks: (name, vocab)
STRUCT_TASKS = [("format", FMT_VOCAB), ("M", M_VOCAB), ("K", K_VOCAB),
                ("d", D_VOCAB), ("chan", CHAN_VOCAB), ("arm", ARM_VOCAB)]
TASKS = ["det"] + [t for t, _ in STRUCT_TASKS]


def _idx(vocab):
    return {str(v): i for i, v in enumerate(vocab)}


_MAPS = {"format": _idx(FMT_VOCAB), "M": _idx(M_VOCAB), "K": _idx(K_VOCAB),
         "d": _idx(D_VOCAB), "chan": _idx(CHAN_VOCAB), "arm": _idx(ARM_VOCAB)}

SPEC_LAGS = (16, 32, 48, 64, 80, 160, 240)                    # cyclic-autocorr lags (CP/frame cues)
SPEC_PSD_BINS = 64
SPEC_DIM = SPEC_PSD_BINS + len(SPEC_LAGS)

# Device on which per-batch feature extraction (complex FFT + spatial eigvalsh) runs.
# None -> CPU (default; MPS has no complex support, so features must stay on CPU there).
# main() sets this to 'cuda' when training on an NVIDIA GPU, so the whole step runs on-device.
_FEAT_DEVICE: "str | None" = None


# --------------------------------------------------------------------------
# feature extraction (complex ops -> stay on CPU; the net is real-valued)
# --------------------------------------------------------------------------
def spectral_feats(Yb: torch.Tensor) -> torch.Tensor:
    """(n,R,T) complex -> (n, SPEC_DIM) real: antenna-mean log-PSD (64 bins) +
    normalized cyclic-autocorrelation magnitudes at frame-relevant lags."""
    n, r, t = Yb.shape
    Yf = torch.fft.fft(Yb, dim=-1)
    psd = torch.log1p((Yf.abs() ** 2).mean(1))                # (n,T)
    k = t // SPEC_PSD_BINS
    psd = F.avg_pool1d(psd.unsqueeze(1), kernel_size=k, stride=k).squeeze(1)[:, :SPEC_PSD_BINS]
    psd = (psd - psd.mean(1, keepdim=True)) / (psd.std(1, keepdim=True) + 1e-6)
    energy = (Yb.abs() ** 2).mean((1, 2)).clamp_min(1e-9)     # (n,)
    acs = []
    for L in SPEC_LAGS:
        ac = (Yb[..., :-L] * Yb[..., L:].conj()).mean(-1)     # (n,R) complex
        acs.append(ac.abs().mean(1) / energy)                 # (n,)
    return torch.cat([psd, torch.stack(acs, 1)], 1).float()   # (n, SPEC_DIM)


def batch_feats(Yb: torch.Tensor):
    """(n,R,T) complex64 -> (x (n,R,3,T), sp (n,7), mask (n,R) bool, spec (n,SPEC_DIM)).

    Runs on ``_FEAT_DEVICE`` when set (CUDA path: complex64 FFT + eigvalsh on the GPU);
    callers move the returned float32 features to the net device afterwards."""
    if _FEAT_DEVICE is not None:
        Yb = Yb.to(_FEAT_DEVICE)
    n, r, _ = Yb.shape
    x = to_real_iq(Yb)                                        # (n,R,3,T) float32
    mask = torch.ones(n, r, dtype=torch.bool, device=Yb.device)
    sp = spatial_features(Yb, mask)                           # (n,7)
    spec = spectral_feats(Yb)                                 # (n,SPEC_DIM)
    return x, sp, mask, spec


# --------------------------------------------------------------------------
# model
# --------------------------------------------------------------------------
class SpectralMLP(nn.Module):
    def __init__(self, in_dim=SPEC_DIM, d=48, drop=0.2):
        super().__init__()
        self.net = nn.Sequential(nn.Linear(in_dim, d), nn.GELU(), nn.Dropout(drop),
                                 nn.Linear(d, d), nn.GELU())
        self.d = d

    def forward(self, s):
        return self.net(s)


class MultiTaskUniversalEve(nn.Module):
    """Shared detection backbone -> embedding ``e``; spectral branch -> ``spec_emb``;
    detection head off ``e``; structure heads off ``[e, spec_emb]``."""

    def __init__(self, width=96, drop=0.3, spec_d=48):
        super().__init__()
        self.ant = AntennaEncoder(3, width, drop=drop)
        self.D = self.ant.d
        self.attn = nn.Linear(self.D, 1)
        self.spatial_norm = nn.LayerNorm(N_SPATIAL)
        self.block = nn.Sequential(nn.Linear(2 * self.D + N_SPATIAL, self.D), nn.GELU(), nn.Dropout(drop))
        self.det_head = nn.Linear(self.D, 1)                  # detection off e
        self.spec = SpectralMLP(SPEC_DIM, spec_d, drop=min(0.3, drop))
        sd = self.D + spec_d
        self.struct_heads = nn.ModuleDict(
            {name: nn.Sequential(nn.Linear(sd, self.D), nn.GELU(), nn.Dropout(drop),
                                 nn.Linear(self.D, len(vocab)))
             for name, vocab in STRUCT_TASKS})

    def embed(self, x, sp, mask):
        """x:(N,R,3,T) real, sp:(N,7), mask:(N,R) -> detection embedding e:(N,D)."""
        n, r = x.shape[:2]
        z = self.ant(x.reshape(n * r, *x.shape[2:])).reshape(n, r, self.D)
        m = mask.unsqueeze(-1)
        a = torch.softmax(self.attn(z).masked_fill(~m, float("-inf")), dim=1)
        attn_pool = (a * z).sum(1)
        mean_pool = (z * m).sum(1) / m.sum(1).clamp_min(1)
        return self.block(torch.cat([attn_pool, mean_pool, self.spatial_norm(sp)], dim=1))

    def forward(self, x, sp, mask, spec):
        e = self.embed(x, sp, mask)
        se = torch.cat([e, self.spec(spec)], dim=1)
        out = {"det": self.det_head(e).squeeze(-1)}
        for name in self.struct_heads:
            out[name] = self.struct_heads[name](se)
        return out


class LinearProbes(nn.Module):
    """Structure probes on a FROZEN detection embedding (regime C).  MLP probes so
    the comparison to A is about the representation, not head capacity."""

    def __init__(self, d, drop=0.2):
        super().__init__()
        self.heads = nn.ModuleDict(
            {name: nn.Sequential(nn.Linear(d, d), nn.GELU(), nn.Dropout(drop),
                                 nn.Linear(d, len(vocab)))
             for name, vocab in STRUCT_TASKS})

    def forward(self, e):
        return {name: self.heads[name](e) for name in self.heads}


# --------------------------------------------------------------------------
# masked, uncertainty-weighted multi-task loss (Kendall-Gal)
# --------------------------------------------------------------------------
class MTLoss(nn.Module):
    def __init__(self, tasks=TASKS):
        super().__init__()
        self.tasks = list(tasks)
        self.log_sigma = nn.Parameter(torch.zeros(len(self.tasks)))  # learnable uncertainty
        self.bce = nn.BCEWithLogitsLoss()
        self.ce = nn.CrossEntropyLoss()

    def forward(self, out, labels, h1):
        """out: head logits; labels: dict of index tensors (+ 'det' float01); h1: bool mask.
        Structure losses are computed on H1 only.  Returns (total, raw{task:loss})."""
        raw = {}
        raw["det"] = self.bce(out["det"], labels["det"])
        h1 = h1.bool()
        for name, _ in STRUCT_TASKS:
            if name in self.tasks and h1.any():
                raw[name] = self.ce(out[name][h1], labels[name][h1])
            elif name in self.tasks:
                raw[name] = out[name].sum() * 0.0
        total = 0.0
        for i, tsk in enumerate(self.tasks):
            s = self.log_sigma[i]
            total = total + torch.exp(-s) * raw[tsk] + 0.5 * s
        return total, {k: float(v.detach()) for k, v in raw.items()}


# --------------------------------------------------------------------------
# data
# --------------------------------------------------------------------------
def load_arrays(data_dir: str, split: str, max_n: int | None = None, seed: int = 0) -> dict:
    """Load one split's Y + encoded multi-task labels as torch tensors (Y on CPU)."""
    from .controlled import load_split
    d = load_split(data_dir, split)
    Y = torch.from_numpy(d["Y"])                              # (n,R,T) complex64
    n = Y.shape[0]
    if max_n and max_n < n:
        rng = np.random.default_rng(seed)
        keep = np.sort(rng.choice(n, size=max_n, replace=False))
        Y = Y[keep]
        d = {k: (v[keep] if hasattr(v, "__len__") and len(v) == n else v) for k, v in d.items()}
        n = max_n
    out = {"Y": Y, "n": n}
    out["det"] = torch.from_numpy(d["label"].astype(np.float32))
    out["format"] = torch.tensor([_MAPS["format"][str(v)] for v in d["format"]], dtype=torch.long)
    out["M"] = torch.tensor([_MAPS["M"][str(int(v))] for v in d["n_tx"]], dtype=torch.long)
    out["K"] = torch.tensor([_MAPS["K"][str(int(v))] for v in d["n_msg_users"]], dtype=torch.long)
    out["d"] = torch.tensor([_MAPS["d"][str(int(v))] for v in d["msg_dim"]], dtype=torch.long)
    out["chan"] = torch.tensor([_MAPS["chan"][str(v)] for v in d["channel_family"]], dtype=torch.long)
    out["arm"] = torch.tensor([_MAPS["arm"][str(v)] for v in d["policy_arm"]], dtype=torch.long)
    out["regime"] = np.array([str(v) for v in d["regime"]])
    out["arm_str"] = np.array([str(v) for v in d["policy_arm"]])
    out["fmt_str"] = np.array([str(v) for v in d["format"]])
    out["eve_snr"] = np.asarray(d["eve_snr_db"], dtype=np.float32)
    out["cell_id"] = np.asarray(d["cell_id"], dtype=np.int64)   # same-emitter grouping (multi-look)
    return out


def _to_dev(t, dev):
    return {k: (v.to(dev) if torch.is_tensor(v) else v) for k, v in t.items()}


# --------------------------------------------------------------------------
# evaluation: the structure-recovery frontier
# --------------------------------------------------------------------------
@torch.no_grad()
def evaluate(model, arr, device, *, batch=512, probes=None, embed_only=False) -> dict:
    """Per-regime detection AUC + per-attribute H1 accuracy (overall, per regime,
    per arm for 'format').  ``probes`` (regime C) reads the frozen embedding."""
    model.eval()
    if probes is not None:
        probes.eval()
    n = arr["n"]
    det_logits = np.empty(n, np.float32)
    preds = {name: np.empty(n, np.int64) for name, _ in STRUCT_TASKS}
    for lo in range(0, n, batch):
        hi = min(lo + batch, n)
        Yb = arr["Y"][lo:hi]
        x, sp, mask, spec = batch_feats(Yb)
        x, sp, mask, spec = x.to(device), sp.to(device), mask.to(device), spec.to(device)
        if probes is not None:
            e = model.embed(x, sp, mask)
            det_logits[lo:hi] = model.det_head(e).squeeze(-1).cpu().numpy()
            ph = probes(e)
            for name, _ in STRUCT_TASKS:
                preds[name][lo:hi] = ph[name].argmax(1).cpu().numpy()
        else:
            out = model(x, sp, mask, spec)
            det_logits[lo:hi] = out["det"].cpu().numpy()
            for name, _ in STRUCT_TASKS:
                preds[name][lo:hi] = out[name].argmax(1).cpu().numpy()

    labels = {name: arr[name].numpy() for name, _ in STRUCT_TASKS}
    det = arr["det"].numpy()
    reg = arr["regime"]
    h1 = det == 1
    res = {"n": int(n), "detection_auc": {}, "structure_acc": {}, "format_acc_by_arm": {}}

    # detection AUC overall + per regime
    res["detection_auc"]["overall"] = round(float(_auc(det_logits, det)), 4) if 0 < det.sum() < n else None
    for rg in REGIMES:
        m = reg == rg
        if m.sum() > 1 and 0 < det[m].sum() < m.sum():
            res["detection_auc"][rg] = round(float(_auc(det_logits[m], det[m])), 4)

    # structure accuracy (H1 only): overall + per regime
    for name, vocab in STRUCT_TASKS:
        acc = {"chance": round(1.0 / len(vocab), 3)}
        mm = h1
        acc["overall"] = round(float((preds[name][mm] == labels[name][mm]).mean()), 4) if mm.sum() else None
        for rg in REGIMES:
            m = h1 & (reg == rg)
            if m.sum():
                acc[rg] = round(float((preds[name][m] == labels[name][m]).mean()), 4)
        res["structure_acc"][name] = acc

    # format accuracy per arm x regime (is the covert 'optimized' arm the hardest to fingerprint?)
    for arm in ARM_VOCAB:
        row = {}
        for rg in REGIMES:
            m = h1 & (arr["arm_str"] == arm) & (reg == rg)
            if m.sum():
                row[rg] = round(float((preds["format"][m] == labels["format"][m]).mean()), 4)
        res["format_acc_by_arm"][arm] = row
    return res


# --------------------------------------------------------------------------
# training
# --------------------------------------------------------------------------
def _lr_factor(frac, warm=0.03, min_frac=0.05):
    if frac < warm:
        return frac / warm
    p = (frac - warm) / max(1e-9, 1 - warm)
    return min_frac + 0.5 * (1 - min_frac) * (1 + math.cos(math.pi * min(1.0, p)))


def _sample_batch(arr, idx, dev):
    Yb = arr["Y"][idx]
    x, sp, mask, spec = batch_feats(Yb)
    labels = {"det": arr["det"][idx]}
    for name, _ in STRUCT_TASKS:
        labels[name] = arr[name][idx]
    x, sp, mask, spec = x.to(dev), sp.to(dev), mask.to(dev), spec.to(dev)
    labels = {k: v.to(dev) for k, v in labels.items()}
    return x, sp, mask, spec, labels


def train_joint(train, val, *, device, steps=4000, width=96, batch=256, lr=1e-3,
                tasks=TASKS, run_dir="runs/mtl_A", log_every=200, seed=0, verbose=True) -> dict:
    """Regime A: joint multi-task from scratch."""
    os.makedirs(run_dir, exist_ok=True)
    torch.manual_seed(seed)
    rng = np.random.default_rng(seed)
    model = MultiTaskUniversalEve(width=width).to(device)
    mtl = MTLoss(tasks).to(device)
    opt = torch.optim.AdamW(list(model.parameters()) + list(mtl.parameters()), lr=lr, weight_decay=1e-4)
    hist = []
    t0 = time.perf_counter()
    n = train["n"]
    for it in range(steps):
        for g in opt.param_groups:
            g["lr"] = lr * _lr_factor(it / max(1, steps))
        idx = torch.from_numpy(rng.choice(n, size=batch, replace=False))
        x, sp, mask, spec, labels = _sample_batch(train, idx, device)
        model.train()
        out = model(x, sp, mask, spec)
        loss, raw = mtl(out, labels, labels["det"])
        opt.zero_grad()
        loss.backward()
        torch.nn.utils.clip_grad_norm_(list(model.parameters()) + list(mtl.parameters()), 1.0)
        opt.step()
        if verbose and (it % log_every == 0 or it == steps - 1):
            lv = float(loss.detach())
            sps = (it + 1) / (time.perf_counter() - t0)
            print(f"  [A it={it:5d}] loss={lv:.3f} "
                  + " ".join(f"{k}={v:.3f}" for k, v in raw.items())
                  + f"  {sps:.1f} it/s", flush=True)
            hist.append({"it": it, "loss": round(lv, 4), "raw": {k: round(v, 4) for k, v in raw.items()}})
    torch.save({"model": model.state_dict(), "mtl": mtl.state_dict()}, os.path.join(run_dir, "ckpt.pt"))
    va = evaluate(model, val, device)
    if verbose:
        print(f"  [A] val det_auc={va['detection_auc']}  "
              f"format_acc={ {r: va['structure_acc']['format'].get(r) for r in REGIMES} }", flush=True)
    return {"model": model, "history": hist, "val": va, "wall_s": round(time.perf_counter() - t0, 1)}


def train_detonly_then_probe(train, val, *, device, det_steps=4000, probe_steps=2500,
                             width=96, batch=256, lr=1e-3, run_dir="runs/mtl_C",
                             log_every=200, seed=1, verbose=True) -> dict:
    """Regime C: detection-only pretrain -> freeze backbone -> MLP structure probes
    on the frozen detection embedding."""
    os.makedirs(run_dir, exist_ok=True)
    torch.manual_seed(seed)
    rng = np.random.default_rng(seed)
    model = MultiTaskUniversalEve(width=width).to(device)
    bce = nn.BCEWithLogitsLoss()
    opt = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=1e-4)
    t0 = time.perf_counter()
    n = train["n"]
    # -- detection-only pretrain --
    for it in range(det_steps):
        for g in opt.param_groups:
            g["lr"] = lr * _lr_factor(it / max(1, det_steps))
        idx = torch.from_numpy(rng.choice(n, size=batch, replace=False))
        x, sp, mask, spec, labels = _sample_batch(train, idx, device)
        model.train()
        logit = model.det_head(model.embed(x, sp, mask)).squeeze(-1)
        loss = bce(logit, labels["det"])
        opt.zero_grad(); loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0); opt.step()
        if verbose and (it % log_every == 0 or it == det_steps - 1):
            print(f"  [C-det it={it:5d}] bce={float(loss):.3f}  {(it+1)/(time.perf_counter()-t0):.1f} it/s", flush=True)
    # -- freeze backbone, train probes on frozen embedding --
    for p in model.parameters():
        p.requires_grad_(False)
    probes = LinearProbes(model.D).to(device)
    popt = torch.optim.AdamW(probes.parameters(), lr=1e-3, weight_decay=1e-4)
    ce = nn.CrossEntropyLoss()
    tp = time.perf_counter()
    for it in range(probe_steps):
        idx = torch.from_numpy(rng.choice(n, size=batch, replace=False))
        x, sp, mask, spec, labels = _sample_batch(train, idx, device)
        with torch.no_grad():
            e = model.embed(x, sp, mask)
        h1 = labels["det"].bool()
        if h1.sum() < 2:
            continue
        ph = probes(e[h1])
        loss = sum(ce(ph[name], labels[name][h1]) for name, _ in STRUCT_TASKS)
        popt.zero_grad(); loss.backward(); popt.step()
        if verbose and (it % log_every == 0 or it == probe_steps - 1):
            print(f"  [C-probe it={it:5d}] ce_sum={float(loss):.3f}  {(it+1)/(time.perf_counter()-tp):.1f} it/s", flush=True)
    torch.save({"model": model.state_dict(), "probes": probes.state_dict()}, os.path.join(run_dir, "ckpt.pt"))
    va = evaluate(model, val, device, probes=probes)
    if verbose:
        print(f"  [C] val det_auc={va['detection_auc']}  "
              f"format_acc={ {r: va['structure_acc']['format'].get(r) for r in REGIMES} }", flush=True)
    return {"model": model, "probes": probes, "val": va, "wall_s": round(time.perf_counter() - t0, 1)}


# --------------------------------------------------------------------------
# regime B: multi-look aggregation (lift the fingerprinting frontier)
# --------------------------------------------------------------------------
# A warden watching a persistent emitter collects many blocks; pooling L looks of
# the SAME emitter (same factorial cell -> same format/M/arm/channel) averages out
# per-block noise and raises the fingerprint SNR ~sqrt(L) without any new data.
def _h1_by_cell(arr) -> dict:
    cid = arr["cell_id"]
    det = arr["det"].numpy()
    cells = {}
    for c in np.unique(cid[det == 1]):
        cells[int(c)] = np.where((cid == c) & (det == 1))[0]
    return cells


def _sample_look_idx(cells, keys, n_looks, L, rng) -> torch.Tensor:
    """(n_looks*L,) flat indices, ordered look-major (each look = L blocks of one cell)."""
    out = []
    for _ in range(n_looks):
        pool = cells[int(keys[rng.integers(len(keys))])]
        out.append(pool[rng.integers(len(pool), size=L)])
    return torch.from_numpy(np.concatenate(out))


def _look_feats(arr, idx):
    return batch_feats(arr["Y"][idx])


def _pool_struct(model, x, sp, mask, spec, n_looks, L):
    """Encode L blocks/look, mean-pool e and spec_emb over the look -> structure logits."""
    e = model.embed(x, sp, mask).view(n_looks, L, -1).mean(1)
    se = model.spec(spec).view(n_looks, L, -1).mean(1)
    sfeat = torch.cat([e, se], 1)
    return {name: model.struct_heads[name](sfeat) for name, _ in STRUCT_TASKS}


def train_multilook(train, val, *, device, steps=4500, width=96, det_batch=256,
                    n_looks=32, look_sizes=(1, 2, 4, 8), lr=1e-3, run_dir="runs/mtl_B",
                    log_every=250, seed=2, verbose=True) -> dict:
    """Joint multi-task with MULTI-LOOK structure heads (random L per step)."""
    os.makedirs(run_dir, exist_ok=True)
    torch.manual_seed(seed)
    rng = np.random.default_rng(seed)
    model = MultiTaskUniversalEve(width=width).to(device)
    log_sigma = torch.nn.Parameter(torch.zeros(len(TASKS), device=device))
    bce, ce = nn.BCEWithLogitsLoss(), nn.CrossEntropyLoss()
    opt = torch.optim.AdamW(list(model.parameters()) + [log_sigma], lr=lr, weight_decay=1e-4)
    cells = _h1_by_cell(train)
    keys = np.array(list(cells))
    n = train["n"]
    t0 = time.perf_counter()
    for it in range(steps):
        for g in opt.param_groups:
            g["lr"] = lr * _lr_factor(it / max(1, steps))
        L = int(rng.choice(look_sizes))
        idxd = torch.from_numpy(rng.choice(n, det_batch, replace=False))
        xd, spd, maskd, specd, labd = _sample_batch(train, idxd, device)
        lidx = _sample_look_idx(cells, keys, n_looks, L, rng)
        xs, sps, masks, specs = _look_feats(train, lidx)
        xs, sps, masks, specs = xs.to(device), sps.to(device), masks.to(device), specs.to(device)
        rep = lidx.view(n_looks, L)[:, 0]
        slab = {name: train[name][rep].to(device) for name, _ in STRUCT_TASKS}
        model.train()
        det_logit = model.det_head(model.embed(xd, spd, maskd)).squeeze(-1)
        slog = _pool_struct(model, xs, sps, masks, specs, n_looks, L)
        raw = {"det": bce(det_logit, labd["det"])}
        for name, _ in STRUCT_TASKS:
            raw[name] = ce(slog[name], slab[name])
        total = sum(torch.exp(-log_sigma[i]) * raw[t] + 0.5 * log_sigma[i] for i, t in enumerate(TASKS))
        opt.zero_grad(); total.backward()
        torch.nn.utils.clip_grad_norm_(list(model.parameters()) + [log_sigma], 1.0); opt.step()
        if verbose and (it % log_every == 0 or it == steps - 1):
            print(f"  [B it={it:5d} L={L}] loss={float(total.detach()):.3f} "
                  f"det={raw['det']:.3f} format={raw['format']:.3f} chan={raw['chan']:.3f} M={raw['M']:.3f}"
                  f"  {(it+1)/(time.perf_counter()-t0):.1f} it/s", flush=True)
    torch.save({"model": model.state_dict()}, os.path.join(run_dir, "ckpt.pt"))
    sweep = {int(L): evaluate_multilook(model, val, device, int(L)) for L in look_sizes}
    if verbose:
        fmt = {L: sweep[L]["structure_acc"]["format"]["overall"] for L in sweep}
        print(f"  [B] val format-acc vs L: {fmt}", flush=True)
    return {"model": model, "L_sweep_val": sweep, "wall_s": round(time.perf_counter() - t0, 1)}


@torch.no_grad()
def evaluate_multilook(model, arr, device, L, *, batch_looks=256) -> dict:
    """Partition each cell's H1 blocks into looks of L, pool, predict structure.
    Per-attribute accuracy overall / per regime, and format accuracy per arm."""
    model.eval()
    cells = _h1_by_cell(arr)
    rows, labs = [], {name: [] for name, _ in STRUCT_TASKS}
    reg, armv = [], []
    for pool in cells.values():
        m = len(pool) // L
        if m == 0:
            continue
        for row in pool[:m * L].reshape(m, L):
            rows.append(row)
            for name, _ in STRUCT_TASKS:
                labs[name].append(int(arr[name][row[0]]))
            reg.append(arr["regime"][row[0]])
            armv.append(arr["arm_str"][row[0]])
    if not rows:
        return {"L": L, "n_looks": 0, "structure_acc": {}}
    look_idx = np.stack(rows)                                 # (Nl, L)
    Nl = look_idx.shape[0]
    preds = {name: np.empty(Nl, np.int64) for name, _ in STRUCT_TASKS}
    for lo in range(0, Nl, batch_looks):
        hi = min(lo + batch_looks, Nl)
        flat = torch.from_numpy(look_idx[lo:hi].reshape(-1))
        x, sp, mask, spec = _look_feats(arr, flat)
        x, sp, mask, spec = x.to(device), sp.to(device), mask.to(device), spec.to(device)
        slog = _pool_struct(model, x, sp, mask, spec, hi - lo, L)
        for name, _ in STRUCT_TASKS:
            preds[name][lo:hi] = slog[name].argmax(1).cpu().numpy()
    reg, armv = np.array(reg), np.array(armv)
    res = {"L": L, "n_looks": int(Nl), "structure_acc": {}, "format_acc_by_arm": {}}
    for name, _ in STRUCT_TASKS:
        lab = np.array(labs[name])
        acc = {"overall": round(float((preds[name] == lab).mean()), 4)}
        for rg in REGIMES:
            mm = reg == rg
            if mm.sum():
                acc[rg] = round(float((preds[name][mm] == lab[mm]).mean()), 4)
        res["structure_acc"][name] = acc
    flab = np.array(labs["format"])
    for arm in ARM_VOCAB:
        mm = armv == arm
        if mm.sum():
            res["format_acc_by_arm"][arm] = round(float((preds["format"][mm] == flab[mm]).mean()), 4)
    return res


# --------------------------------------------------------------------------
# CLI
# --------------------------------------------------------------------------
def main(argv=None) -> int:
    ap = argparse.ArgumentParser(prog="covcollab-eve-mtl",
                                 description="Train + evaluate the multi-task Universal Eve (detect + fingerprint).")
    ap.add_argument("--data", default="huggingface/covcollab-eve-detection")
    ap.add_argument("--regime", choices=("A", "C", "B", "both"), default="both",
                    help="A=joint, C=det-rep probe, B=multi-look (lift the fingerprint frontier)")
    ap.add_argument("--steps", type=int, default=4000)
    ap.add_argument("--probe-steps", type=int, default=2500)
    ap.add_argument("--look-sizes", type=int, nargs="*", default=[1, 2, 4, 8], help="regime B L-sweep")
    ap.add_argument("--n-looks", type=int, default=32, help="regime B looks per step")
    ap.add_argument("--width", type=int, default=96)
    ap.add_argument("--batch", type=int, default=256)
    ap.add_argument("--max-train", type=int, default=None, help="subsample train (default: all)")
    ap.add_argument("--device", default="auto")
    ap.add_argument("--feat-device", default="auto",
                    help="where per-batch feature extraction runs: 'auto'=net device on CUDA "
                         "(complex64 FFT+eigvalsh on-GPU), else CPU (MPS lacks complex); or cpu/cuda")
    ap.add_argument("--out", default="runs/mtl")
    ap.add_argument("--eval-splits", nargs="*", default=["test_iid", "test_ood"])
    ap.add_argument("--smoke", action="store_true")
    args = ap.parse_args(argv)

    if args.smoke:
        args.steps, args.probe_steps, args.max_train, args.width = 60, 40, 1500, 48

    dev = pick_device(args.device)
    global _FEAT_DEVICE
    if args.feat_device == "auto":
        _FEAT_DEVICE = "cuda" if dev == "cuda" else None          # CUDA-only; MPS/CPU keep CPU features
    elif args.feat_device in ("cpu", "none"):
        _FEAT_DEVICE = None
    else:
        _FEAT_DEVICE = args.feat_device
    os.makedirs(args.out, exist_ok=True)
    print(f"device={dev}  feat_device={_FEAT_DEVICE or 'cpu'}  data={args.data}  regime={args.regime}  "
          f"steps={args.steps}  width={args.width}  max_train={args.max_train}", flush=True)

    train = load_arrays(args.data, "train", max_n=args.max_train)
    val = load_arrays(args.data, "val")
    print(f"loaded train n={train['n']}  val n={val['n']}", flush=True)

    results = {"config": {"regime": args.regime, "steps": args.steps, "width": args.width,
                          "batch": args.batch, "max_train": args.max_train, "device": dev}}
    tests = {sp: load_arrays(args.data, sp) for sp in args.eval_splits}

    if args.regime in ("A", "both"):
        r = train_joint(train, val, device=dev, steps=args.steps, width=args.width,
                        batch=args.batch, run_dir=os.path.join(args.out, "A"))
        results["A"] = {"val": r["val"], "wall_s": r["wall_s"],
                        "test": {sp: evaluate(r["model"], tests[sp], dev) for sp in tests}}
    if args.regime in ("C", "both"):
        r = train_detonly_then_probe(train, val, device=dev, det_steps=args.steps,
                                     probe_steps=args.probe_steps, width=args.width,
                                     batch=args.batch, run_dir=os.path.join(args.out, "C"))
        results["C"] = {"val": r["val"], "wall_s": r["wall_s"],
                        "test": {sp: evaluate(r["model"], tests[sp], dev, probes=r["probes"]) for sp in tests}}
    if args.regime == "B":
        ls = tuple(args.look_sizes)
        r = train_multilook(train, val, device=dev, steps=args.steps, width=args.width,
                            det_batch=args.batch, n_looks=args.n_looks, look_sizes=ls,
                            run_dir=os.path.join(args.out, "B"))
        results["B"] = {"wall_s": r["wall_s"], "look_sizes": list(ls),
                        "L_sweep": {sp: {int(L): evaluate_multilook(r["model"], tests[sp], dev, int(L))
                                         for L in ls} for sp in tests}}

    with open(os.path.join(args.out, "results.json"), "w") as f:
        json.dump(results, f, indent=2)
    print(f"\nresults -> {args.out}/results.json", flush=True)
    return 0


if __name__ == "__main__":
    sys.exit(main())