code/draftalign/da_decode.py

"""Training-free Draft-Verify (DV) block decoding for SDAR at block 32.

Per block (same grid / valid / prompt-tail conventions as sdar_harness.decode.block_diffusion_generate):
  1. the dense drafter generates the block (draftalign.drafter.draft_block, setting s4 | s8 | dyn90) -> D;
  2. the MoE JUDGES the draft in-distribution with two complementary-halves forwards (store_kv=False):
       A = even valid slots [MASK] + odd slots D,  B = the reverse;
     every slot is read from the forward in which it was MASKED: fp32 probs with the [MASK] logit
     suppressed (moe_probe.slot_metrics), argmax a_i, p_i = top-1, q_i = p(D_i);
  3. accept rule (apply_accept_rule): commit slot i to a_i if p_i > tau_commit (strict, as stock);
     else take the DRAFT token if (a_i == D_i and p_i > tau_acc) or q_i > tau_acc_q; else [MASK].
     If nothing was committed / accepted, commit the single best slot by p_i (progress guarantee);
  4. the STOCK denoising rule from that state (stock_pass: bf16 softmax, strict > threshold, >= 1
     commit per pass, decode.py:230-264 verbatim) until no mask remains, then the kv flush
     (store_kv=True); the finished block is also flushed into the drafter's cache.
     `rejudge`: after every stock pass that leaves >= rejudge_k open slots, redraft the open slots
     (committed slots fixed) and re-judge them with halves over the open slots only (no progress
     forcing: the stock pass already made progress).

`draft=None` runs the identical loop with NO drafter and NO judge: that is the stock decode, and it
must reproduce block_diffusion_generate token-for-token and pass-for-pass (tests/test_da_decode.py).

judge="blind" (zero extra MoE forwards; the halves judge confirmed 76% of WRONG draft tokens at > .95
in the AB probe): the block's first STOCK pass runs exactly as stock (bf16 softmax, strict > threshold,
>= 1 forced commit); from the SAME forward's fp32 softmax (MASK suppressed) read a_i, p_i and
q_i = p_i(D_i) for every slot masked at that forward, then -- after the stock commits -- accept D_i at
every STILL-OPEN slot with q_i > tau_acc_q (and p_draft_i > tau_draft when tau_draft > 0).  A stock
commit is never overridden; n_judge = 0; the pass counts as a stock pass.  With `rejudge`, every later
stock pass re-reads q_i for its open slots against the CURRENT draft (no redraft) and accepts the same
way (code CODE_ACCEPT_LATE).  tau_commit / tau_acc / rejudge_k are unused in blind mode.

judge="full" (the TRAINED regime; section 3.1 of the design doc): per block, ONE MoE forward whose
every open valid slot holds the drafter's token (no masks at all), read at EVERY open slot -- fp32
softmax with the [MASK] logit suppressed -> a_i, p_i = top-1, q_i = p(D_i).  Commit slot i to a_i if
p_i > tau_commit (strict).  Every uncommitted open slot keeps D_i as TENTATIVE context if a_i == D_i
and becomes [MASK] otherwise (`full_remask_only` -> always [MASK]: the ablation).  The same judge pass
is then repeated on the new state (committed slots hold their tokens, tentative slots hold D_i, masked
slots [MASK]; read at all open slots = tentative + masked) until every valid slot is committed; at
least one commit per pass (the highest p_i among the open slots) so it always terminates.  After
`full_max_passes` judge passes the remaining open slots fall back to the STOCK rule (they are masked
and the stock denoising loop finishes the block).  Then the flush (store_kv) and the drafter flush,
as in every mode.  These forwards are counted as "judge" forwards.

Two OFF-by-default decode-rule variants (every default path is byte-identical without them):

  ANCHORED DRAFTING (`draft_after_pass=N`, blind only; N = 0 is today's rule).  With N >= 1 the block
  starts as the STOCK block and its first N passes are ordinary stock passes (bf16 softmax, strict >
  threshold, >= 1 commit; counted as denoise passes).  Only then is the drafter run -- over the
  STILL-OPEN slots, with the N passes' commits held FIXED as anchors (`draft_block(valid=open slots,
  final=the committed block)`, the same clean drafter prefix) -- so the draft is conditioned on real
  MoE tokens.  The blind acceptance rule then runs on the NEXT stock pass (pass N+1: q_i read from its
  own forward, accept D_i at the still-open slots with q_i > tau_acc_q) and the block finishes with
  stock passes, exactly as the blind rule does today.  `DABlock.anchored` / `n_anchor` record the
  anchor slots; `draft_tokens` holds the committed tokens at them.

  ONE-PASS HYBRID (`judge_passes=K`, full only; K = 0 is today's unbounded loop).  The full judge runs
  K passes with the same commit rule (confirm at tau_commit, override at tau_override, tentative /
  remask); after them EVERY uncommitted slot is re-masked -- no tentative draft context survives --
  and the STOCK denoising loop finishes the block (the `full_max_passes` fall-back path).  The K
  forwards count as judge forwards (n_judge, `full_passes_per_block`), the stock passes after them as
  denoise passes.

  RE-DRAFT BETWEEN JUDGE PASSES (`full_redraft_every=K`, full only; K = 0 is today's rule; phase 3).
  After every K-th judge pass the [MASK] slots of the block (the ones the judge re-masked) are filled
  again by the drafter.  The drafter sees ONLY verified tokens: the prompt tail and the judge-committed
  slots of this block, on top of its prefix cache; every tentative draft slot is hidden as [MASK] in its
  input, so no draft is ever conditioned on a token the judge has not committed.  Only the drafter's
  tokens at the [MASK] slots are used; tentative slots keep their draft token.  Drafter steps =
  ceil(#[MASK] slots / `full_redraft_rate`), at most 8 (the s8 draft's 4 slots per step by default),
  logged as drafter kind "redraft".  The new tokens become the slots' current draft (the tentative
  check and q_i compare against it) and are flagged on the next judge pass like every draft token.
  Only the judge commits, so every token's last step is a judge pass.  Per block the record keeps the
  re-draft rounds, re-drafted slots, and how many re-drafted tokens equal the judge's argmax at the
  pass before (the drafter switched to the judge's choice) or the draft the judge had rejected.

  JUDGE DIAGNOSTIC (`judge_diag=True`, full only; changes no decision).  At every judge pass, over the
  open slots whose next slot holds a real token different from their own: how often the judge's argmax
  equals that next token (the untrained model's next-token copy), split into flagged (draft) slots and
  [MASK] slots.  Compare arms against each other, not against zero: an off-by-one draft makes some
  next-token answers correct.

Draft FLAG (round 2; only with a flag-gated adapter, `MoEMeter(draft_flag=True)` -- see
`adapter.py`'s module docstring and `run_da_decode.load_adapter_into`): every judge pass is run with
`adapter`'s per-position context armed at its TENTATIVE DRAFT slots (open and not [MASK]), which
both adds the trained `draft_embed` vector to those slots' input embeddings (passed as
`inputs_embeds`, or added by an `embed_tokens` hook when the model's forward cannot take them) and
gates the LoRA delta to those positions.  Every other forward -- prefill, kv flush, stock denoise,
the halves / blind judges -- is armed with an ALL-FALSE flag, under which the projections are
bit-identical to the frozen base and no vector is added, i.e. it is the stock model.  Without such
an adapter (`draft_flag=False`, every cell so far) nothing is armed at all.

Expert pool (`PoolCtrl` / `enable_pool_moe`): a per-forward top-M expert restriction for every BLOCK
forward the MoE does (judge / denoise / rejudge; NEVER the prefill, and the flush only with
`pool_flush`).  Per layer: the fp32 router softmax of all 32 block rows; the VALID slots vote; the
top-M pool is built with `train_forward.expert_pool` for rules "full" (dMoE, sum of the full softmax)
and "top8" (sum of the RENORMALISED top-k weights), or with the DES-Vote rule "des" (sum of the
UNNORMALISED top-k weights, `sdar_harness/desvote.py:96-99` = its Algorithm 3); probabilities outside
the pool are zeroed, then top-8 + renormalise (`train_forward.moe_forward`'s arithmetic, so M >= E is
bit-identical to the unrestricted forward), then the hit-only expert loop.  The forward writes the
RESTRICTED `selected_experts` into moe_instr's SINK, so the counted experts are the ones that ran.

Numerics: the stock rule keeps decode.py's bf16 softmax + strict > threshold untouched; fp32 is used
only inside the judge.  Expert loads per MoE forward are read from sdar_harness.moe_instr's SINK
(the exact `selected_experts` tensor the dispatch indexes) with the same per-layer unique count as
run_research_baselines' `unique_expert_layer_loads` (desvote.py:165).
"""
from __future__ import annotations

import os
import time
from contextlib import contextmanager
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Sequence

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

from sdar_harness.decode import BlockTrace, get_num_transfer_tokens, sample_with_confidence
from sdar_harness.moe_instr import SINK
from sdar_harness.routing import moe_blocks
from draftalign.adapter import draft_flag_scope
from draftalign.seqcache import SeqCache
from draftalign.drafter import SETTINGS, draft_block
from draftalign.moe_probe import build_block_state, slot_metrics
from draftalign.train_forward import expert_pool

MOE_KIND_CODE = {"prefill": 0, "denoise": 1, "kvflush": 2, "judge": 3, "rejudge": 4}
DRAFTER_KIND_CODE = {"prefill": 0, "draft": 1, "redraft": 2, "flush": 3}
# per-slot judge outcome codes
CODE_MASK, CODE_COMMIT, CODE_ACCEPT_EQ, CODE_ACCEPT_Q, CODE_FORCED, CODE_ACCEPT_LATE = 0, 1, 2, 3, 4, 5
JUDGE_MODES = ("halves", "blind", "full")
POOL_RULES = ("full", "top8", "des")
POOLED_KINDS = ("denoise", "judge", "rejudge")     # block forwards the pool restricts (never "prefill")
FULL_MAX_PASSES = 32


# ---------------------------------------------------------------------------
# per-forward expert pool (dMoE / DES-Vote), patched into SDARMoeSparseMoeBlock.forward
# ---------------------------------------------------------------------------
class PoolCtrl:
    """Module-global controller for `pool_moe_forward` (one decode runs single-threaded per GPU).

    `M` / `rule` are the budget; `valid` is the bool [N] mask of the block rows that VOTE (the
    generated slots -- the prompt tail of the first decode block never votes, as in
    `desvote.CTRL.valid` and `train_forward.training_forward`).  `enabled` is flipped per forward
    by `MoEMeter` (prefill and, unless `pool_flush`, the kv flush run unrestricted).
    `force_restrict` runs the restricted arithmetic even at M >= E, which must be bit-identical.
    """

    def __init__(self):
        self.M: Optional[int] = None
        self.rule: str = "full"
        self.valid: Optional[torch.Tensor] = None
        self.enabled = False
        self.force_restrict = False
        self.sizes: List[int] = []          # pool size per layer of the CURRENT forward
        self.track_cov = False              # accumulate per-row pool coverage (off => bit-identical)
        self.cov_sum: Optional[torch.Tensor] = None
        self.cov_n = 0

    def configure(self, M: Optional[int], rule: str = "full"):
        assert rule in POOL_RULES, rule
        self.M, self.rule = (None if M is None else int(M)), rule
        return self

    @property
    def on(self) -> bool:
        return self.M is not None

    def begin(self, enabled: bool):
        self.enabled = bool(enabled)
        self.sizes = []
        self.cov_sum, self.cov_n = None, 0

    def coverage(self) -> Optional[torch.Tensor]:
        """Mean over layers of each row's ORIGINAL top-k router mass that survived into the pool.

        1.0 => this row's routing was untouched by pooling, so its logits are what the unpooled
        forward would have produced; low => most of its experts were pruned and its prediction is
        a substitute computed from experts the router did not want.  None when not tracked.
        """
        if self.cov_sum is None or not self.cov_n:
            return None
        return self.cov_sum / float(self.cov_n)

    def end(self) -> int:
        """The pool size actually used by this forward (0 when no layer was pooled)."""
        self.enabled = False
        sizes = self.sizes
        self.sizes = []
        if not sizes:
            return 0
        assert len(set(sizes)) == 1, f"layers disagreed on the pool size: {sorted(set(sizes))}"
        return int(sizes[0])


POOL = PoolCtrl()


def build_pool(w: torch.Tensor, valid: torch.Tensor, M: int, rule: str, top_k: int) -> torch.Tensor:
    """Top-M pool [E] bool from the votes of the VALID rows of the fp32 router softmax `w` [N, E].

    "full" / "top8" are `train_forward.expert_pool` verbatim (dMoE sum-of-softmax, and DES's
    Algorithm-3 term RENORMALISED, which is what the trainer samples pools with).  "des" is
    `sdar_harness/desvote.py:96-99` exactly: the row's UNNORMALISED top-k weights, zeros elsewhere,
    summed over the valid rows.  Ties break on the lowest expert id (stable sort), as desvote.py:133.
    """
    assert rule in POOL_RULES, rule
    if rule != "des":
        return expert_pool(w, valid, M, rule, top_k)
    E = w.shape[1]
    vals, ids = torch.topk(w, top_k, dim=-1)
    contrib = torch.zeros_like(w).scatter_(1, ids, vals)                     # desvote._topk_masked
    votes = (contrib * valid.to(contrib.dtype).unsqueeze(1)).sum(0)          # [E]
    order = torch.sort(votes, descending=True, stable=True).indices
    pool = torch.zeros(E, dtype=torch.bool, device=w.device)
    pool[order[:min(int(M), E)]] = True
    return pool


def pool_moe_forward(self, hidden_states: torch.Tensor):
    """`moe_instr.instrumented_moe_forward` + the per-forward pool of `train_forward.moe_forward`.

    The pool is applied by multiplying the fp32 softmax by a 0/1 mask AFTER the softmax (exact for
    1.0), so with every expert in the pool the top-k, the renormalisation and the dispatch see the
    very same numbers the unrestricted forward sees -- bit-identical.  The ids written to the SINK
    are the RESTRICTED `selected_experts`, i.e. the experts the dispatch below actually indexes.
    """
    batch_size, sequence_length, hidden_dim = hidden_states.shape
    hidden_states = hidden_states.view(-1, hidden_dim)
    router_logits = self.gate(hidden_states)

    w = F.softmax(router_logits, dim=1, dtype=torch.float)
    E = self.num_experts
    restrict = POOL.enabled and POOL.on and (POOL.M < E or POOL.force_restrict)
    if restrict:
        assert POOL.M >= self.top_k, f"pool M={POOL.M} < top_k={self.top_k}"
        valid = POOL.valid
        if valid is None:
            valid = torch.ones(hidden_states.shape[0], dtype=torch.bool, device=hidden_states.device)
        assert valid.numel() == hidden_states.shape[0], \
            f"pool vote mask {valid.numel()} != {hidden_states.shape[0]} rows"
        pool = build_pool(w, valid, POOL.M, POOL.rule, self.top_k)
        if POOL.track_cov:                                     # per-row survival of the ORIGINAL routing
            ov, oi = torch.topk(w, self.top_k, dim=-1)
            cov = (ov * pool[oi].to(ov.dtype)).sum(1) / ov.sum(1).clamp_min(1e-9)
            POOL.cov_sum = cov if POOL.cov_sum is None else POOL.cov_sum + cov
            POOL.cov_n += 1
        w_use = w * pool.to(w.dtype).unsqueeze(0)
        POOL.sizes.append(int(pool.sum()))
    else:
        w_use = w
        if POOL.enabled:
            POOL.sizes.append(E)
    routing_weights, selected_experts = torch.topk(w_use, self.top_k, dim=-1)

    cap = SINK.active                                          # moe_instr.py:79-82, before renormalisation
    if cap is not None:
        cap.ids.append(selected_experts.detach().to(torch.uint8).cpu().clone())
        cap.probs.append(routing_weights.detach().half().cpu().clone())

    if self.norm_topk_prob:
        routing_weights = routing_weights / routing_weights.sum(dim=-1, keepdim=True)
    routing_weights = routing_weights.to(hidden_states.dtype)

    final_hidden_states = torch.zeros((batch_size * sequence_length, hidden_dim),
                                      dtype=hidden_states.dtype, device=hidden_states.device)
    expert_mask = F.one_hot(selected_experts, num_classes=E).permute(2, 1, 0)
    for expert_idx in torch.unique(selected_experts).tolist():
        expert_layer = self.experts[expert_idx]
        idx, top_x = torch.where(expert_mask[expert_idx])
        current_state = hidden_states[None, top_x].reshape(-1, hidden_dim)
        current_hidden_states = expert_layer(current_state) * routing_weights[top_x, idx, None]
        final_hidden_states.index_add_(0, top_x, current_hidden_states.to(hidden_states.dtype))

    final_hidden_states = final_hidden_states.reshape(batch_size, sequence_length, hidden_dim)
    return final_hidden_states, router_logits


def enable_pool_moe(model) -> int:
    """Install `pool_moe_forward` on every MoE block (replaces moe_instr's patch; it captures too)."""
    blocks = moe_blocks(model)
    for blk in blocks:
        assert getattr(blk, "norm_topk_prob", False), "the pool path assumes norm_topk_prob=True"
        if not hasattr(blk, "_stock_forward"):
            blk._stock_forward = blk.forward
        blk.forward = pool_moe_forward.__get__(blk, type(blk))
    return len(blocks)


def disable_pool_moe(model) -> int:
    n = 0
    for blk in moe_blocks(model):
        if hasattr(blk, "_stock_forward"):
            blk.forward = blk._stock_forward
            del blk._stock_forward
            n += 1
    return n


# ---------------------------------------------------------------------------
# metering: one SeqCache + the moe_instr SINK -> per-forward [kind, ms, uniq, layer_forwards, npos]
# ---------------------------------------------------------------------------
class MoEMeter:
    """Wraps a SeqCache; arms `sink` (sdar_harness.moe_instr.SINK) around every forward and reads the
    hit-expert sets back: uniq = sum over layers of |unique(selected_experts)|, lf = layers seen.
    Without an instrumented model (sink None / not armed) uniq = lf = 0.

    `pool` (a `PoolCtrl`, normally the module-global `POOL`) is armed around every BLOCK forward whose
    kind is in POOLED_KINDS -- and around the kv flush only when `pool_flush` -- and never around the
    prefill.  `set_valid` gives it the block's voting rows.  Per forward the pool size actually used
    is stored as the 6th field of the record.

    `draft_flag` (on only for a FLAG-GATED adapter, `adapter.is_flag_gated`) arms `adapter`'s
    per-position context around every forward: the caller's flag for the full judge's draft-filled
    passes, an ALL-FALSE flag for everything else (prefill, kv flush, stock denoise, halves / blind
    judges).  All-False is the right "untouched" value, not `None`: such an adapter runs UN-merged,
    so a `None` (ungated) context would apply the LoRA delta at every position -- exactly what
    training excluded -- while under an all-False flag every projection is bit-identical to the
    frozen base and no `draft_embed` is added.  `self.flags` keeps the flag of every forward (cpu)
    for the tests and for auditing."""

    def __init__(self, seq: SeqCache, sink=None, pool: "Optional[PoolCtrl]" = None, pool_flush: bool = False,
                 draft_flag: bool = False):
        self.seq, self.sink = seq, sink
        self.pool, self.pool_flush = pool, bool(pool_flush)
        self.draft_flag = bool(draft_flag)
        self.records: List[list] = []
        self.flags: List[Optional[torch.Tensor]] = []      # per forward: the flag armed (None = ungated)
        self.last_cap = None                # the MoECapture of the most recent forward (or None)

    @property
    def bl(self) -> int:
        return self.seq.bl

    def reset(self):
        self.records = []
        self.flags = []
        self.last_cap = None

    @contextmanager
    def _flag_scope(self, flag: Optional[torch.Tensor], ids: torch.Tensor, npos: int,
                    conf: Optional[torch.Tensor] = None):
        """Arm the draft flag for one forward; yields the extra model kwargs (`{}` or inputs_embeds).
        `conf` [npos] uint8 = the drafter's confidence per slot, used only by an adapter with a confidence
        embedding (the 1B corpus's 32M test); every other adapter ignores it."""
        if not self.draft_flag:
            self.flags.append(None)
            yield {}
            return
        dev = ids.device if ids is not None else self.seq.dev
        f = (torch.zeros(1, int(npos), dtype=torch.bool, device=dev) if flag is None
             else flag.reshape(1, -1).to(device=dev, dtype=torch.bool))
        assert f.shape[1] == int(npos), f"flag {tuple(f.shape)} does not cover {npos} positions"
        self.flags.append(f[0].detach().cpu().clone())
        cu8 = None
        if conf is not None:
            cu8 = conf.reshape(1, -1).to(device=dev, dtype=torch.uint8)
        elif flag is not None:
            cu8 = torch.zeros(1, int(npos), dtype=torch.uint8, device=dev)
        with draft_flag_scope(self.seq.model, ids, f, conf_u8=cu8) as extra:
            yield extra

    def set_valid(self, valid: Optional[torch.Tensor]):
        """The block rows that vote for the pool (the generated slots)."""
        if self.pool is not None:
            self.pool.valid = valid

    def _pooled(self, kind: str) -> bool:
        if self.pool is None or not self.pool.on:
            return False
        return kind in POOLED_KINDS or (kind == "kvflush" and self.pool_flush)

    def _arm(self, kind: str):
        if self.sink is None:
            return None
        from sdar_harness.moe_instr import MoECapture
        cap = MoECapture(tag=kind, step=len(self.records))
        self.sink.arm(cap)
        return cap

    def _disarm(self):
        if self.sink is not None:
            self.sink.disarm()

    def _record(self, cap, kind: str, npos: int, pool_size: int = 0):
        """Called after a successful forward: seq.timings[-1] is that forward."""
        uniq = sum(int(torch.unique(ids).numel()) for ids in cap.ids) if cap is not None else 0
        lf = len(cap.ids) if cap is not None else 0
        self.last_cap = cap
        ms = self.seq.timings[-1][1]
        self.records.append([MOE_KIND_CODE[kind], round(ms, 3), uniq, lf, int(npos), int(pool_size)])

    def prefill(self, prompt_ids: torch.Tensor) -> int:
        cap = self._arm("prefill")
        if self.pool is not None:
            self.pool.begin(False)                    # the prefill is NEVER restricted
        pl_planned = (int(prompt_ids.shape[1]) // self.seq.bl) * self.seq.bl
        try:
            if pl_planned == 0:                       # no prompt block: no forward, so no flag record
                pl = self.seq.prefill(prompt_ids)
            else:
                with self._flag_scope(None, prompt_ids[:, :pl_planned].to(self.seq.dev), pl_planned) as extra:
                    pl = self.seq.prefill(prompt_ids, extra=extra)
        finally:
            self._disarm()
            if self.pool is not None:
                self.pool.end()
        if pl > 0:
            self._record(cap, "prefill", pl)
        return pl

    def block(self, block_ids: torch.Tensor, lo: int, store_kv: bool, kind: str,
              flag: Optional[torch.Tensor] = None, conf: Optional[torch.Tensor] = None) -> torch.Tensor:
        cap = self._arm(kind)
        pooled = self._pooled(kind)
        if self.pool is not None:
            self.pool.begin(pooled)
        ids = block_ids if block_ids.dim() == 2 else block_ids.unsqueeze(0)
        try:
            with self._flag_scope(flag, ids.to(self.seq.dev), self.seq.bl, conf=conf) as extra:
                logits = self.seq.block_forward(block_ids, lo, store_kv=store_kv, kind=kind, extra=extra)
        finally:
            self._disarm()
            psize = self.pool.end() if self.pool is not None else 0
        self._record(cap, kind, self.seq.bl, psize)
        return logits

    def by_kind(self) -> Dict[str, dict]:
        inv = {v: k for k, v in MOE_KIND_CODE.items()}
        out = {k: {"n": 0, "ms": 0.0, "uniq": 0, "lf": 0, "pool": 0} for k in MOE_KIND_CODE}
        for code, ms, u, lf, _, ps in self.records:
            k = inv[code]
            out[k]["n"] += 1; out[k]["ms"] += ms; out[k]["uniq"] += u; out[k]["lf"] += lf
            out[k]["pool"] += ps
        return out


def drafter_records(dr_seq: Optional[SeqCache]) -> List[list]:
    """[kind_code, ms] per drafter forward, in call order (kinds draft_<setting> -> 'draft')."""
    if dr_seq is None:
        return []
    out = []
    for kind, ms in dr_seq.timings:
        k = "draft" if kind.startswith("draft_") else kind
        out.append([DRAFTER_KIND_CODE[k], round(ms, 3)])
    return out


# ---------------------------------------------------------------------------
# results
# ---------------------------------------------------------------------------
@dataclass
class DABlock(BlockTrace):
    """BlockTrace (per STOCK pass: committed / confidence / proposed) + the draft/judge of this block."""
    draft_tokens: Optional[torch.Tensor] = None   # [bl] long, first draft (fixed slots = block tokens)
    p_draft: Optional[torch.Tensor] = None        # [bl] fp32 drafter confidence at commit
    judge_argmax: Optional[torch.Tensor] = None   # [bl] long, -1 outside valid
    judge_p: Optional[torch.Tensor] = None        # [bl] fp32 top-1 (MASK suppressed), nan outside valid
    judge_q: Optional[torch.Tensor] = None        # [bl] fp32 p(D_i), nan outside valid
    judge_code: Optional[torch.Tensor] = None     # [bl] int8: CODE_* per slot
    n_judge: int = 0                              # MoE judge forwards (first judge)
    n_draft_fwd: int = 0                          # drafter forwards (first draft)
    judge_raw_mask_argmax: int = 0
    rejudge_rounds: int = 0
    n_rejudge: int = 0                            # MoE re-judge forwards
    n_redraft_fwd: int = 0                        # drafter forwards spent on redrafts
    rejudge_committed: int = 0
    rejudge_accepted: int = 0
    rejudges: List[dict] = field(default_factory=list)   # per round: {open, draft, argmax, p, q, code} (cpu)
    judge_mode: str = "none"                      # none | halves | blind | full
    n_blind_accept: int = 0                       # blind mode: draft slots accepted (first pass + later passes)
    # -- anchored drafting (blind, --draft-after-pass N > 0) -----------------
    anchored: Optional[torch.Tensor] = None       # [bl] bool: slots committed by the N stock passes BEFORE the draft
    n_anchor: int = 0                             # int(anchored.sum()); 0 on every non-anchored path
    # -- full judge --------------------------------------------------------
    n_tentative: int = 0                          # full: uncommitted open slots that KEPT the draft token (a_i == D_i)
    n_remask: int = 0                             # full: uncommitted open slots set back to [MASK]
    full_commit_eq_draft: int = 0                 # full: committed slots whose a_i was the draft token
    full_fallback: int = 0                        # full: open slots handed to the stock rule at the pass cap
    full_passes: List[dict] = field(default_factory=list)   # per judge pass {commit, tentative, remask, forced}
    # -- re-draft between judge passes (full, full_redraft_every K > 0; 0 on every other path) --
    n_redraft_rounds: int = 0                     # drafter re-draft calls in this block
    n_redraft_slots: int = 0                      # [MASK] slots re-drafted, summed over rounds
    n_redraft_eq_judge: int = 0                   # re-drafted tokens equal to the judge's argmax at the pass before
    n_redraft_eq_old: int = 0                     # re-drafted tokens equal to the draft the judge had rejected
    # -- judge diagnostic (judge_diag): next-slot copy at open slots ---------
    copy_flag_hit: int = 0                        # flagged (draft) open slots whose argmax == the next slot's token
    copy_flag_n: int = 0                          # flagged open slots where that comparison is defined
    copy_mask_hit: int = 0                        # the same for [MASK] open slots
    copy_mask_n: int = 0

    # -- derived ---------------------------------------------------------
    @property
    def accepted(self) -> torch.Tensor:
        """Draft tokens taken by the judge: halves = first judge (codes 2, 3); blind = every blind accept (3, 5)."""
        if self.judge_code is None:
            return torch.zeros(self.valid.numel(), dtype=torch.bool)
        return (self.judge_code == CODE_ACCEPT_EQ) | (self.judge_code == CODE_ACCEPT_Q) | (self.judge_code == CODE_ACCEPT_LATE)

    @property
    def committed_judge(self) -> torch.Tensor:
        if self.judge_code is None:
            return torch.zeros(self.valid.numel(), dtype=torch.bool)
        return (self.judge_code == CODE_COMMIT) | (self.judge_code == CODE_FORCED)

    @property
    def forced(self) -> bool:
        return self.judge_code is not None and bool((self.judge_code == CODE_FORCED).any())

    @property
    def block_forwards_ex_flush(self) -> int:
        """Every block forward of this block except the kv flush: judge + rejudge + stock denoise."""
        return int(self.n_judge) + int(self.n_rejudge) + int(self.n_steps)

    @property
    def draft_agreement(self) -> float:
        if self.draft_tokens is None or self.tokens is None or not bool(self.valid.any()):
            return float("nan")
        return float((self.draft_tokens == self.tokens)[self.valid].float().mean())


@dataclass
class DAResult:
    x: torch.Tensor
    prompt_length: int
    total_length: int
    block_length: int
    prefill_blocks: int
    num_blocks: int
    blocks: List[DABlock]
    stopped_early: bool
    n_forward: int                    # MoE forwards incl. prefill (== stock n_forward when draft is None)
    draft: Optional[str]
    judge: Optional[str] = None       # halves | blind | None (stock)
    draft_after_pass: int = 0         # blind: stock passes run BEFORE the draft (0 = draft first, the default)
    judge_passes: int = 0             # full: judge passes before the stock hand-off (0 = the unbounded loop)
    full_redraft_every: int = 0       # full: re-draft the [MASK] slots after every K judge passes (0 = off)
    judge_diag: bool = False          # full: next-slot copy counters recorded

    def generated_ids(self) -> torch.Tensor:
        return self.x[:, self.prompt_length:]


# ---------------------------------------------------------------------------
# pieces
# ---------------------------------------------------------------------------
@torch.no_grad()
def judge_halves(moe: MoEMeter, cur: torch.Tensor, slots: torch.Tensor, D: torch.Tensor, lo: int,
                 mask_id: int, kind: str = "judge") -> dict:
    """Two complementary-halves forwards over `slots` (bool [bl], must hold [MASK] in `cur`).
    Returns device tensors argmax [bl] long (-1 outside slots), p / q [bl] fp32 (nan outside),
    n_fwd, raw_mask_argmax.  A half with no masked slot is skipped."""
    bl = cur.numel()
    dev = cur.device
    argmax = torch.full((bl,), -1, dtype=torch.long, device=dev)
    p = torch.full((bl,), float("nan"), dtype=torch.float32, device=dev)
    q = torch.full((bl,), float("nan"), dtype=torch.float32, device=dev)
    n_fwd, raw = 0, 0
    for mode in ("half_a", "half_b"):
        ids, masked = build_block_state(cur, slots, D, mode, mask_id)
        read = masked & slots
        if not bool(read.any()):
            continue
        logits = moe.block(ids, lo, store_kv=False, kind=kind)
        m = slot_metrics(logits, D, D, D, mask_id, read)
        argmax = torch.where(read, m["argmax"], argmax)
        p = torch.where(read, m["top1"], p)
        q = torch.where(read, m["p_draft"], q)
        raw += int(m["raw_mask_argmax"])
        n_fwd += 1
        del logits
    assert bool((argmax[slots] >= 0).all()), "a judged slot was read from no forward"
    return {"argmax": argmax, "p": p, "q": q, "n_fwd": n_fwd, "raw_mask_argmax": raw}


def apply_accept_rule(cur: torch.Tensor, argmax: torch.Tensor, p: torch.Tensor, q: torch.Tensor,
                      D: torch.Tensor, slots: torch.Tensor, tau_commit: float, tau_acc: float,
                      tau_acc_q: float, force_progress: bool = True):
    """Returns (new block ids [bl], code [bl] int8).  Slots outside `slots` are untouched (code MASK=0).
    commit -> a_i if p_i > tau_commit; accept D_i if (a_i == D_i and p_i > tau_acc) or q_i > tau_acc_q;
    else [MASK].  force_progress: if nothing was committed/accepted, commit the best slot by p_i."""
    pz = torch.nan_to_num(p, nan=-1.0)
    qz = torch.nan_to_num(q, nan=-1.0)
    commit = slots & (pz > tau_commit)
    acc_eq = slots & ~commit & (argmax == D) & (pz > tau_acc)
    acc_q = slots & ~commit & ~acc_eq & (qz > tau_acc_q)
    code = torch.zeros(cur.numel(), dtype=torch.int8, device=cur.device)
    code = torch.where(commit, torch.full_like(code, CODE_COMMIT), code)
    code = torch.where(acc_eq, torch.full_like(code, CODE_ACCEPT_EQ), code)
    code = torch.where(acc_q, torch.full_like(code, CODE_ACCEPT_Q), code)
    if force_progress and bool(slots.any()) and not bool((commit | acc_eq | acc_q).any()):
        best = torch.where(slots, pz, torch.full_like(pz, float("-inf"))).argmax()
        commit = commit.clone(); commit[best] = True
        code[best] = CODE_FORCED
    new = torch.where(commit, argmax, torch.where(acc_eq | acc_q, D, cur))
    return new, code


@torch.no_grad()
def stock_pass(moe: MoEMeter, cur: torch.Tensor, lo: int, mask_id: int, threshold: float, n_transfer: int,
               temperature: float = 1.0, top_k: int = 1, top_p: float = 1.0, greedy_exact: bool = True,
               kind: str = "denoise"):
    """One STOCK denoising pass on cur [1, bl] (decode.py:228-258 verbatim; bf16 confidence, strict >).
    Returns (x0 [1, bl], x0_p [1, bl], transfer_index [1, bl] bool, logits [1, bl, V]); the caller writes
    the commits (and, in blind mode, reads q from the same logits)."""
    mask_index = (cur == mask_id)
    logits = moe.block(cur, lo, store_kv=False, kind=kind)
    x0, x0_p = sample_with_confidence(logits, temperature=temperature, top_k=top_k, top_p=top_p,
                                      greedy_exact=greedy_exact)
    x0 = torch.where(mask_index, x0, cur)
    confidence = torch.where(mask_index, x0_p, torch.tensor(float("-inf"), device=cur.device, dtype=x0_p.dtype))
    transfer_index = torch.zeros_like(x0, dtype=torch.bool)
    if threshold < 1.0:
        for j in range(confidence.shape[0]):
            high_conf = confidence[j] > threshold
            if high_conf.sum() >= n_transfer:
                transfer_index[j] = high_conf
            else:
                _, idx = torch.topk(confidence[j], n_transfer)
                transfer_index[j, idx] = True
    else:
        for j in range(confidence.shape[0]):
            _, idx = torch.topk(confidence[j], k=n_transfer)
            transfer_index[j, idx] = True
    return x0, x0_p, transfer_index, logits


@torch.no_grad()
def blind_read(logits: torch.Tensor, D: torch.Tensor, read: torch.Tensor, mask_id: int) -> dict:
    """fp32 softmax (MASK suppressed) of a stock pass's logits at the slots `read` (masked at that forward):
    argmax a_i (-1 elsewhere), p_i top-1 and q_i = p_i(D_i) (nan elsewhere)."""
    m = slot_metrics(logits, D, D, D, mask_id, read)
    nan = torch.full_like(m["top1"], float("nan"))
    return {"argmax": torch.where(read, m["argmax"], torch.full_like(m["argmax"], -1)),
            "p": torch.where(read, m["top1"], nan), "q": torch.where(read, m["p_draft"], nan),
            "raw_mask_argmax": int(m["raw_mask_argmax"])}


def blind_accept(cur: torch.Tensor, q: torch.Tensor, D: torch.Tensor, open_: torch.Tensor, tau_acc_q: float,
                 p_draft: Optional[torch.Tensor] = None, tau_draft: float = 0.0):
    """Accept D_i at the STILL-OPEN slots `open_` with q_i > tau_acc_q (and p_draft_i > tau_draft if tau_draft > 0).
    Returns (new block ids [bl], accept mask [bl])."""
    acc = open_ & (torch.nan_to_num(q, nan=-1.0) > tau_acc_q)
    if tau_draft > 0.0:
        assert p_draft is not None
        acc = acc & (p_draft > tau_draft)
    return torch.where(acc, D, cur), acc


# ---------------------------------------------------------------------------
# full judge (the trained regime): one draft-filled forward per pass, read at every OPEN slot
# ---------------------------------------------------------------------------
def full_commit_rule(cur: torch.Tensor, argmax: torch.Tensor, p: torch.Tensor, D: torch.Tensor,
                     open_: torch.Tensor, tau_commit: float, mask_id: int, remask_only: bool = False,
                     tau_override: Optional[float] = None, cov: Optional[torch.Tensor] = None,
                     tau_cov: float = 0.0):
    """One full-judge decision over the OPEN slots of `cur` [bl].

    commit -> a_i where p_i > tau_commit (strict, as stock).  If nothing passed, the single highest
    p_i among the open slots is committed anyway (progress guarantee -> the loop always terminates).
    Every other open slot keeps D_i as tentative context if a_i == D_i, else becomes [MASK];
    `remask_only` re-masks every uncommitted slot (the ablation).  `tau_override` (optional) is a
    separate, usually stricter threshold for commits that OVERRIDE the draft (a_i != D_i); confirmations
    keep tau_commit.  None or equal to tau_commit -> the symmetric rule above, unchanged.
    Returns (new ids [bl], commit [bl], tentative [bl], remask [bl], forced bool).
    """
    pz = torch.nan_to_num(p, nan=-1.0)
    if tau_override is None or float(tau_override) == float(tau_commit):
        commit = open_ & (pz > tau_commit)
    else:   # asymmetric rule: confirmations (a_i == D_i) at tau_commit, overrides (a_i != D_i) at tau_override
        agree = argmax == D
        commit = open_ & ((agree & (pz > tau_commit)) | (~agree & (pz > float(tau_override))))
    if cov is not None and tau_cov > 0.0:
        # POOL-COVERAGE GATE.  Pooling leaves the confidence scale intact while degrading the logits
        # of rows whose routing was pruned, so p alone cannot tell a clean prediction from a
        # substitute one.  Hold back commits on poorly-covered rows; they get another pass.
        commit = commit & (cov > float(tau_cov))
    forced = False
    if bool(open_.any()) and not bool(commit.any()):
        best = torch.where(open_, pz, torch.full_like(pz, float("-inf"))).argmax()
        commit = commit.clone(); commit[best] = True
        forced = True
    rest = open_ & ~commit
    tentative = rest & (argmax == D) if not remask_only else torch.zeros_like(rest)
    remask = rest & ~tentative
    new = torch.where(commit, argmax,
                      torch.where(tentative, D,
                                  torch.where(remask, torch.full_like(cur, mask_id), cur)))
    return new, commit, tentative, remask, forced


def copy_diag(bt: DABlock, inp: torch.Tensor, argmax: torch.Tensor, open_: torch.Tensor,
              flag: torch.Tensor, mask_id: int) -> None:
    """Next-slot copy at the open slots of one judge pass (adds to `bt`'s copy_* counters).

    A slot counts when the NEXT slot of the block held a real token different from this slot's input;
    it is a hit when the judge's argmax equals that next token.  Flagged (draft) and [MASK] slots are
    counted apart.  Changes no decision."""
    nxt = torch.full_like(inp, -1)
    nxt[:-1] = inp[1:]
    cand = open_ & (nxt >= 0) & (nxt != mask_id) & (nxt != inp)
    hit = cand & (argmax == nxt)
    f = cand & flag
    m = cand & (inp == mask_id)
    bt.copy_flag_n += int(f.sum()); bt.copy_flag_hit += int((hit & f).sum())
    bt.copy_mask_n += int(m.sum()); bt.copy_mask_hit += int((hit & m).sum())


@torch.no_grad()
def judge_full_block(moe: MoEMeter, cur: torch.Tensor, valid: torch.Tensor, D: torch.Tensor, lo: int,
                     mask_id: int, tau_commit: float, bt: DABlock, max_passes: int = FULL_MAX_PASSES,
                     remask_only: bool = False, kind: str = "judge", tau_override: Optional[float] = None,
                     tau_pool_cov: float = 0.0, p_draft: Optional[torch.Tensor] = None,
                     redraft_every: int = 0, dr_seq: Optional[SeqCache] = None, redraft_rate: int = 4,
                     redraft_setting: str = "s8", diag: bool = False) -> torch.Tensor:
    """Run the full judge on block `cur` [bl] until every valid slot is committed (or the cap fires).

    The block enters with EVERY valid slot holding the drafter's token -- no masks.  Returns the new
    block ids; slots left open at the cap are [MASK] and the caller's stock loop finishes them.
    `bt` is updated in place (n_judge / n_forward / judge_* arrays / tentative-remask counters).

    Each pass is flagged (`MoEMeter.block(..., flag=...)`) with its TENTATIVE DRAFT slots -- open and
    not [MASK], i.e. exactly what a trained state's flag marks: the committed slots, the re-masked
    slots and the prompt tail are unflagged.  With no flag-gated adapter loaded the flag is ignored.

    `redraft_every` = K > 0 (phase 3): after every K-th pass the drafter `dr_seq` re-fills the [MASK]
    slots from the committed tokens only (tentative slots hidden as [MASK] in its input; their tokens are
    kept), in ceil(#[MASK] / redraft_rate) steps (max 8); see the module docstring.  `diag` adds the
    next-slot copy counters.  K = 0 and diag False run exactly the original loop.
    """
    cur = torch.where(valid, D, cur)                       # every open valid slot = the draft, no masks
    committed = torch.zeros_like(valid)
    Dc = D                                                 # the CURRENT draft per slot (re-drafts replace it)
    # drafter confidence per slot as the 1B corpus stores it (uint8, round(255 p)); read only by an adapter
    # that has a confidence embedding (32M test), ignored by every other adapter
    conf_u8 = None if p_draft is None else torch.nan_to_num(p_draft.float(), nan=0.0).mul(255.0).round() \
        .clamp(0, 255).to(torch.uint8)
    rde = int(redraft_every)
    if rde:
        assert dr_seq is not None, "re-draft needs the drafter's cache"
        assert int(redraft_rate) >= 1, redraft_rate
    for it in range(int(max_passes)):
        open_ = valid & ~committed
        if not bool(open_.any()):
            break
        flag = open_ & (cur != mask_id)                    # the tentative draft slots of THIS pass
        conf = None if conf_u8 is None else torch.where(flag, conf_u8, torch.zeros_like(conf_u8))
        logits = moe.block(cur.unsqueeze(0), lo, store_kv=False, kind=kind, flag=flag, conf=conf)
        cov = POOL.coverage() if tau_pool_cov > 0.0 else None   # [bl], aligned with this block's rows
        r = blind_read(logits, Dc, open_, mask_id)         # fp32, [MASK] logit suppressed, read at open slots
        del logits
        if diag:
            copy_diag(bt, cur, r["argmax"], open_, flag, mask_id)
        bt.n_judge += 1; bt.n_forward += 1
        new, commit, tentative, remask, forced = full_commit_rule(
            cur, r["argmax"], r["p"], Dc, open_, tau_commit, mask_id, remask_only, tau_override=tau_override,
            cov=cov, tau_cov=tau_pool_cov)
        cur = new
        committed = committed | commit
        # `forced` <=> nothing passed tau_commit, so `commit` holds exactly the one forced slot
        if bt.judge_code is not None:
            bt.judge_code[commit.cpu()] = CODE_FORCED if forced else CODE_COMMIT
        bt.n_tentative += int(tentative.sum()); bt.n_remask += int(remask.sum())
        bt.full_commit_eq_draft += int((commit & (r["argmax"] == Dc)).sum())
        pass_rec = {"commit": int(commit.sum()), "tentative": int(tentative.sum()),
                    "remask": int(remask.sum()), "forced": bool(forced)}
        if rde:
            # RE-DRAFT: fill the [MASK] slots again with the drafter, from verified tokens only
            n_h = 0
            if (it + 1) % rde == 0:
                holes = valid & ~committed & (cur == mask_id)
                n_h = int(holes.sum())
                if n_h:
                    tent = valid & ~committed & (cur != mask_id)
                    inp = torch.where(tent, torch.full_like(cur, mask_id), cur)   # the drafter never sees a tentative token
                    steps_h = min(8, -(-n_h // int(redraft_rate)))
                    d = draft_block(dr_seq, inp, holes, lo, redraft_setting, mask_id,
                                    static_steps=steps_h, kind="redraft")
                    newtok = d["tokens"]
                    bt.n_redraft_rounds += 1; bt.n_redraft_slots += n_h
                    bt.n_redraft_eq_judge += int((holes & (newtok == r["argmax"])).sum())
                    bt.n_redraft_eq_old += int((holes & (newtok == Dc)).sum())
                    bt.n_redraft_fwd += int(d["n_fwd"])
                    cur = torch.where(holes, newtok, cur)
                    Dc = torch.where(holes, newtok, Dc)
                    if conf_u8 is not None:
                        c_new = torch.nan_to_num(d["p_commit"].float(), nan=0.0).mul(255.0).round().clamp(0, 255).to(torch.uint8)
                        conf_u8 = torch.where(holes, c_new, conf_u8)
            pass_rec["redraft"] = n_h
        bt.full_passes.append(pass_rec)
        if it == 0:
            bt.judge_argmax = r["argmax"].cpu().clone(); bt.judge_p = r["p"].cpu().clone()
            bt.judge_q = r["q"].cpu().clone(); bt.judge_raw_mask_argmax = r["raw_mask_argmax"]
    open_ = valid & ~committed
    if bool(open_.any()):                                   # cap reached -> fall back to the STOCK rule
        bt.full_fallback = int(open_.sum())
        cur = torch.where(open_, torch.full_like(cur, mask_id), cur)
    return cur


# ---------------------------------------------------------------------------
# decode
# ---------------------------------------------------------------------------
@torch.no_grad()
def da_generate(moe: MoEMeter, dr_seq: Optional[SeqCache], input_ids: torch.Tensor, *, mask_id: int,
                gen_length: int, block_length: int = 32, denoising_steps: Optional[int] = None,
                threshold: float = 0.95, draft: Optional[str] = "s8", tau_commit: float = 0.95,
                tau_acc: float = 0.70, tau_acc_q: float = 0.50, rejudge: bool = False, rejudge_k: int = 8,
                judge: str = "halves", tau_draft: float = 0.0, rejudge_redraft: bool = False,
                full_max_passes: int = FULL_MAX_PASSES, full_remask_only: bool = False,
                tau_override: Optional[float] = None, draft_after_pass: int = 0, judge_passes: int = 0,
                tau_pool_cov: float = 0.0, full_redraft_every: int = 0, full_redraft_rate: int = 4,
                judge_diag: bool = False,
                stopping_criteria_idx: Optional[Sequence[int]] = None, temperature: float = 1.0,
                top_k: int = 1, top_p: float = 1.0, greedy_exact: bool = True,
                max_new_blocks: Optional[int] = None) -> DAResult:
    """Draft-Verify decode of one prompt.  `draft=None` -> the stock decode (no drafter, no judge).
    judge: "halves" (2 judge forwards per block) | "blind" (q read from the first stock pass, 0 extra
    forwards) | "full" (draft-filled judge passes until every slot is committed; the trained regime)."""
    assert input_ids.shape[0] == 1, "single-sequence decoding only"
    assert judge in JUDGE_MODES, judge
    blind = (judge == "blind")
    full = (judge == "full")
    assert int(full_max_passes) >= 1, full_max_passes
    if blind and rejudge and rejudge_redraft:
        raise NotImplementedError("blind rejudge with redraft is not implemented; only the no-redraft variant")
    if full and rejudge:
        raise NotImplementedError("the full judge already re-judges every pass; --rejudge is halves/blind only")
    # -- the two OFF-by-default decode-rule variants ------------------------
    da_pass = int(draft_after_pass)
    assert da_pass >= 0, draft_after_pass
    if da_pass and not (blind and draft is not None):
        raise NotImplementedError("draft_after_pass (anchored drafting) is the blind rule's variant: "
                                  "it needs judge='blind' and a drafter")
    jp = int(judge_passes)
    assert jp >= 0, judge_passes
    if jp and not (full and draft is not None):
        raise NotImplementedError("judge_passes (the one-pass hybrid) is the full judge's variant: "
                                  "it needs judge='full' and a drafter")
    # the hybrid is the full judge capped at K passes: after them every uncommitted slot is re-masked
    # and the STOCK loop finishes the block (exactly what `full_max_passes` already does).
    eff_full_passes = min(int(full_max_passes), jp) if jp else int(full_max_passes)
    # phase 3: re-draft the [MASK] slots between judge passes (0 = off, the original loop)
    rde = int(full_redraft_every)
    assert rde >= 0, full_redraft_every
    if rde and not (full and draft is not None):
        raise NotImplementedError("full_redraft_every (re-draft between judge passes) is the full judge's variant: "
                                  "it needs judge='full' and a drafter")
    if rde and jp:
        raise NotImplementedError("full_redraft_every is not combined with judge_passes")
    if rde and SETTINGS[draft]["mode"] != "static":
        raise NotImplementedError("full_redraft_every needs a static drafter setting (s4 / s8)")
    assert int(full_redraft_rate) >= 1, full_redraft_rate
    if judge_diag and not (full and draft is not None):
        raise NotImplementedError("judge_diag is for the full judge")
    bl = int(block_length)
    assert moe.bl == bl
    steps = bl if denoising_steps is None else int(denoising_steps)
    assert bl % steps == 0 and bl >= steps
    if draft is not None:
        assert draft in SETTINGS, draft
        assert dr_seq is not None and dr_seq.bl == bl
        assert steps == bl, "DV assumes the stock 1-per-pass schedule (denoising_steps == block_length)"
    dev = moe.seq.dev
    input_ids = input_ids.to(dev)
    prompt_length = int(input_ids.shape[1])
    num_blocks = (prompt_length + gen_length + bl - 1) // bl
    total_length = num_blocks * bl
    x = torch.full((1, total_length), mask_id, dtype=torch.long, device=dev)
    x[:, :prompt_length] = input_ids

    moe.seq.reset(); moe.reset()
    pl = moe.prefill(input_ids)
    prefill_blocks = pl // bl
    assert prefill_blocks == prompt_length // bl
    if draft is not None:
        dr_seq.reset()
        assert dr_seq.prefill(input_ids) == pl, "drafter prefill geometry differs"
    num_transfer = get_num_transfer_tokens(bl, steps)
    stop_ids = list(stopping_criteria_idx or [])
    last_block = num_blocks if max_new_blocks is None else min(num_blocks, prefill_blocks + max_new_blocks)

    blocks: List[DABlock] = []
    stopped_early = False
    for nb in range(prefill_blocks, last_block):
        lo, hi = nb * bl, (nb + 1) * bl
        cur = x[:, lo:hi]                                   # view into x, as in decode.py
        valid = (torch.arange(lo, hi, device=dev) >= prompt_length)
        bt = DABlock(block_index=nb, start=lo, valid=valid.cpu())
        moe.set_valid(valid)                                # the pool votes over the generated slots only

        D = pD = None
        anchored = (draft is not None and da_pass > 0)     # blind: draft AFTER `da_pass` stock passes
        if draft is not None and not anchored:
            # 1. draft the valid slots (prompt tail fixed) against the drafter's prefix cache
            d = draft_block(dr_seq, cur[0].clone(), valid, lo, draft, mask_id)
            D, pD = d["tokens"], d["p_commit"].float()
            bt.n_draft_fwd = int(d["n_fwd"]); bt.judge_mode = judge
            bt.draft_tokens = D.cpu().clone(); bt.p_draft = pD.cpu().clone()
            bt.judge_code = torch.zeros(bl, dtype=torch.int8)
        elif anchored:
            # 1'. the draft is deferred to the end of stock pass `da_pass` (below); the block starts
            #     as the STOCK block (all-[MASK] valid slots) and its first passes are stock passes.
            bt.judge_mode = judge
            bt.judge_code = torch.zeros(bl, dtype=torch.int8)
        if draft is not None and full:
            # 2'. the FULL judge: draft-filled forwards, read at every open slot, until all committed
            cur[0] = judge_full_block(moe, cur[0], valid, D, lo, mask_id, tau_commit, bt,
                                      max_passes=eff_full_passes, remask_only=full_remask_only,
                                      tau_override=tau_override, tau_pool_cov=tau_pool_cov, p_draft=pD,
                                      redraft_every=rde, dr_seq=dr_seq, redraft_rate=int(full_redraft_rate),
                                      redraft_setting=draft, diag=bool(judge_diag))
        elif draft is not None and not blind:
            # 2. judge with complementary halves; 3. accept rule (+ progress guarantee)
            j = judge_halves(moe, cur[0], valid, D, lo, mask_id, "judge")
            new, code = apply_accept_rule(cur[0], j["argmax"], j["p"], j["q"], D, valid,
                                          tau_commit, tau_acc, tau_acc_q, force_progress=True)
            cur[0] = new
            bt.n_judge = j["n_fwd"]; bt.n_forward += j["n_fwd"]; bt.judge_raw_mask_argmax = j["raw_mask_argmax"]
            bt.judge_argmax = j["argmax"].cpu().clone(); bt.judge_p = j["p"].cpu().clone()
            bt.judge_q = j["q"].cpu().clone(); bt.judge_code = code.cpu().clone()

        # 4. stock denoising from the current state (decode.py:217-264)
        finished = False
        for step in range(steps + 1):
            mask_index = (cur == mask_id)
            if mask_index.sum() == 0:
                moe.block(cur, lo, store_kv=True, kind="kvflush")
                bt.n_forward += 1
                finished = True
                break
            x0, x0_p, transfer_index, logits = stock_pass(moe, cur, lo, mask_id, threshold, int(num_transfer[step]),
                                                          temperature, top_k, top_p, greedy_exact, "denoise")
            bt.n_forward += 1
            bt.committed.append(transfer_index[0].detach().cpu().clone())
            bt.confidence.append(x0_p[0].detach().float().cpu().clone())
            bt.proposed.append(x0[0].detach().cpu().clone())
            cur[transfer_index] = x0[transfer_index]

            if blind and draft is not None and D is not None and (step == da_pass or rejudge):
                # read a_i / p_i / q_i from THIS forward at the slots it saw masked; accept only still-open slots
                # (with anchored drafting the accepting pass is pass `da_pass` + 1, i.e. step == da_pass)
                read = mask_index[0] & valid
                r = blind_read(logits, D, read, mask_id)
                open_ = (cur[0] == mask_id) & valid
                new, acc = blind_accept(cur[0], r["q"], D, open_, tau_acc_q, pD, tau_draft)
                cur[0] = new
                n_acc = int(acc.sum())
                bt.n_blind_accept += n_acc
                if step == da_pass:
                    bt.judge_argmax = r["argmax"].cpu().clone(); bt.judge_p = r["p"].cpu().clone(); bt.judge_q = r["q"].cpu().clone()
                    bt.judge_raw_mask_argmax = r["raw_mask_argmax"]
                    bt.judge_code[acc.cpu()] = CODE_ACCEPT_Q
                elif bool(read.any()):
                    bt.rejudge_rounds += 1; bt.rejudge_accepted += n_acc
                    bt.judge_code[acc.cpu()] = CODE_ACCEPT_LATE
            del logits

            if anchored and step == da_pass - 1:
                # ANCHORED DRAFT: the `da_pass` stock passes above have committed some slots; draft only
                # the STILL-OPEN ones with those commits held fixed as anchors (draft_block masks and
                # fills `valid`, and keeps `final`'s tokens everywhere else -- anchors and prompt tail).
                open_ = (cur[0] == mask_id) & valid
                anchors = valid & ~open_
                d = draft_block(dr_seq, cur[0].clone(), open_, lo, draft, mask_id)
                D, pD = d["tokens"], d["p_commit"].float()
                bt.n_draft_fwd = int(d["n_fwd"])
                bt.draft_tokens = D.cpu().clone(); bt.p_draft = pD.cpu().clone()
                bt.anchored = anchors.cpu().clone(); bt.n_anchor = int(anchors.sum())
                # defaults, so a block that is already finished here still has full judge arrays
                bt.judge_argmax = torch.full((bl,), -1, dtype=torch.long)
                bt.judge_p = torch.full((bl,), float("nan"), dtype=torch.float32)
                bt.judge_q = torch.full((bl,), float("nan"), dtype=torch.float32)

            if rejudge and draft is not None and not blind:
                open_ = (cur[0] == mask_id)
                if int(open_.sum()) >= rejudge_k:
                    d2 = draft_block(dr_seq, cur[0].clone(), open_, lo, draft, mask_id)
                    D2 = d2["tokens"]
                    j2 = judge_halves(moe, cur[0], open_, D2, lo, mask_id, "rejudge")
                    new, code2 = apply_accept_rule(cur[0], j2["argmax"], j2["p"], j2["q"], D2, open_,
                                                   tau_commit, tau_acc, tau_acc_q, force_progress=False)
                    cur[0] = new
                    bt.rejudge_rounds += 1; bt.n_rejudge += j2["n_fwd"]; bt.n_forward += j2["n_fwd"]
                    bt.n_redraft_fwd += int(d2["n_fwd"])
                    bt.rejudge_committed += int((code2 == CODE_COMMIT).sum())
                    bt.rejudge_accepted += int(((code2 == CODE_ACCEPT_EQ) | (code2 == CODE_ACCEPT_Q)).sum())
                    bt.rejudges.append({"open": open_.cpu().clone(), "draft": D2.cpu().clone(),
                                        "argmax": j2["argmax"].cpu().clone(), "p": j2["p"].cpu().clone(),
                                        "q": j2["q"].cpu().clone(), "code": code2.cpu().clone()})
        assert finished, "block did not reach the kv flush"

        bt.tokens = cur[0].detach().cpu().clone()
        if draft is not None:
            dr_seq.flush(cur[0], lo)
        blocks.append(bt)

        for sid in stop_ids:
            if (x[:, prompt_length:] == sid).any():
                stopped_early = True
                break
        if stopped_early:
            break

    return DAResult(x=x, prompt_length=prompt_length, total_length=total_length, block_length=bl,
                    prefill_blocks=prefill_blocks, num_blocks=num_blocks, blocks=blocks,
                    stopped_early=stopped_early, n_forward=len(moe.records), draft=draft,
                    judge=None if draft is None else judge,
                    draft_after_pass=(da_pass if draft is not None else 0),
                    judge_passes=(jp if draft is not None else 0),
                    full_redraft_every=(rde if draft is not None else 0),
                    judge_diag=bool(judge_diag and draft is not None))


# ---------------------------------------------------------------------------
# records (same fields as run_research_baselines.decode_item, plus the DV extras)
# ---------------------------------------------------------------------------
def make_record(res: DAResult, tok, item: dict, prompt_ids: torch.Tensor, moe: MoEMeter,
                dr_seq: Optional[SeqCache], eos_ids: Sequence[int], mask_id: int, wall_s: float,
                peak_mem_gib: Optional[float] = None, adapter: Optional[str] = None,
                adapter_hash: Optional[str] = None) -> dict:
    gen = res.generated_ids()[0].cpu()
    nonmask = gen[gen != mask_id]
    eos_pos = [int(i) for i in torch.nonzero(torch.isin(nonmask, torch.tensor(list(eos_ids)))).flatten().tolist()]
    n_to_eos = (eos_pos[0] + 1) if eos_pos else int(nonmask.numel())
    text = tok.decode(nonmask.tolist(), skip_special_tokens=True)
    by_kind = moe.by_kind()
    denoise_lf = by_kind["denoise"]["lf"]
    judge_lf = by_kind["judge"]["lf"] + by_kind["rejudge"]["lf"]
    uniq_all = sum(v["uniq"] for v in by_kind.values())
    lf_all = sum(v["lf"] for v in by_kind.values())
    blocks = res.blocks
    dr_by_kind: Dict[str, dict] = {k: {"n": 0, "ms": 0.0} for k in DRAFTER_KIND_CODE}
    dr_recs = drafter_records(dr_seq)
    inv = {v: k for k, v in DRAFTER_KIND_CODE.items()}
    for code, ms in dr_recs:
        dr_by_kind[inv[code]]["n"] += 1; dr_by_kind[inv[code]]["ms"] += ms
    moe_ms = sum(v["ms"] for v in by_kind.values())
    dr_ms = sum(v["ms"] for v in dr_by_kind.values())
    rec = {
        "idx": item["idx"], "rank": item.get("rank"), "split": item["split"],
        "prompt_tokens": int(prompt_ids.shape[1]),
        "pred": text, "gold": item["gold"], "gen_ids": nonmask.tolist(),
        "n_gen_nonmask": int(nonmask.numel()), "n_gen_to_eos": n_to_eos,
        "stopped_eos": bool(res.stopped_early),
        "truncated": bool(not res.stopped_early and len(blocks) == res.num_blocks - res.prefill_blocks),
        "n_blocks": len(blocks), "n_forward": res.n_forward,
        "n_prefill": by_kind["prefill"]["n"], "n_denoise": by_kind["denoise"]["n"], "n_flush": by_kind["kvflush"]["n"],
        "n_judge": by_kind["judge"]["n"], "n_rejudge": by_kind["rejudge"]["n"],
        # every block forward except the kv flush (judge + rejudge + stock denoise); in stock and
        # blind mode n_judge == n_rejudge == 0, so this is the stock passes/block of the reference cells
        "passes_per_block": [b.block_forwards_ex_flush for b in blocks],
        "stock_passes_per_block": [b.n_steps for b in blocks],
        "n_valid_per_block": [int(b.valid.sum()) for b in blocks],
        "commits_per_pass": [int(c.sum()) for b in blocks for c in b.committed],
        "unique_expert_layer_loads": uniq_all, "layer_forwards": lf_all,
        "uniq_per_layer_forward_denoise": (by_kind["denoise"]["uniq"] / denoise_lf) if denoise_lf else None,
        "uniq_per_layer_forward_judge": ((by_kind["judge"]["uniq"] + by_kind["rejudge"]["uniq"]) / judge_lf) if judge_lf else None,
        "uniq_per_layer_forward_all": (uniq_all / lf_all) if lf_all else None,
        "seconds": round(wall_s, 3),
        "moe_seconds": round(moe_ms / 1e3, 3), "drafter_seconds": round(dr_ms / 1e3, 3),
        "ms_by_kind": {k: round(v["ms"], 1) for k, v in by_kind.items()},
        "uniq_by_kind": {k: v["uniq"] for k, v in by_kind.items()},
        "forwards": moe.records,
        "peak_mem_gib": peak_mem_gib,
        # -- DV extras ----------------------------------------------------
        "draft": res.draft,
        "judge": res.judge,
        "judge_mode": res.judge or "stock",
        "pool_M": (moe.pool.M if (moe.pool is not None and moe.pool.on) else None),
        "pool_rule": (moe.pool.rule if (moe.pool is not None and moe.pool.on) else None),
        "pool_flush": bool(moe.pool_flush) if (moe.pool is not None and moe.pool.on) else False,
        "pool_by_kind": {k: v["pool"] for k, v in by_kind.items()},
        "adapter": adapter, "adapter_hash": adapter_hash,
        "tentative_per_block": [b.n_tentative for b in blocks],
        "remask_per_block": [b.n_remask for b in blocks],
        "full_commit_eq_draft_per_block": [b.full_commit_eq_draft for b in blocks],
        "full_fallback_per_block": [b.full_fallback for b in blocks],
        "blind_accept_per_block": [b.n_blind_accept for b in blocks],
        # -- the OFF-by-default decode-rule variants (0 / all-zero on every earlier cell) --
        "draft_after_pass": int(res.draft_after_pass),
        "judge_passes": int(res.judge_passes),
        "anchor_per_block": [b.n_anchor for b in blocks],
        "moe_forwards_per_block": [b.n_forward for b in blocks],
        "judge_forwards_per_block": [b.n_judge for b in blocks],
        "drafter_forwards_per_block": [b.n_draft_fwd for b in blocks],
        "accepted_per_block": [int(b.accepted.sum()) for b in blocks],
        "accepted_eq_per_block": [int((b.judge_code == CODE_ACCEPT_EQ).sum()) if b.judge_code is not None else 0 for b in blocks],
        "accepted_q_per_block": [int((b.judge_code == CODE_ACCEPT_Q).sum()) if b.judge_code is not None else 0 for b in blocks],
        "accepted_late_per_block": [int((b.judge_code == CODE_ACCEPT_LATE).sum()) if b.judge_code is not None else 0 for b in blocks],
        "committed_judge_per_block": [int(b.committed_judge.sum()) for b in blocks],
        "forced_per_block": [bool(b.forced) for b in blocks],
        "full_passes_per_block": [list(b.full_passes) for b in blocks],   # per judge pass: commit / tentative / remask / forced
        "draft_agreement_per_block": [None if np.isnan(b.draft_agreement) else round(b.draft_agreement, 5) for b in blocks],
        "judge_raw_mask_argmax": sum(b.judge_raw_mask_argmax for b in blocks),
        "rejudge_rounds_per_block": [b.rejudge_rounds for b in blocks],
        "rejudge_accepted_per_block": [b.rejudge_accepted for b in blocks],
        "rejudge_committed_per_block": [b.rejudge_committed for b in blocks],
        "redraft_forwards_per_block": [b.n_redraft_fwd for b in blocks],
        "drafter_n_by_kind": {k: v["n"] for k, v in dr_by_kind.items()},
        "drafter_ms_by_kind": {k: round(v["ms"], 1) for k, v in dr_by_kind.items()},
        "drafter_forwards": dr_recs,
    }
    # phase 3 fields: written ONLY by a re-draft or judge-diag run, so every other cell's records keep
    # exactly the fields (and the bytes) they have always had
    if int(getattr(res, "full_redraft_every", 0) or 0) or bool(getattr(res, "judge_diag", False)):
        rec.update({
            "full_redraft_every": int(getattr(res, "full_redraft_every", 0) or 0),
            "redraft_rounds_per_block": [b.n_redraft_rounds for b in blocks],
            "redraft_slots_per_block": [b.n_redraft_slots for b in blocks],
            "redraft_eq_judge_per_block": [b.n_redraft_eq_judge for b in blocks],
            "redraft_eq_old_per_block": [b.n_redraft_eq_old for b in blocks],
        })
    if bool(getattr(res, "judge_diag", False)):
        rec["judge_diag"] = {
            "copy_flag": [sum(b.copy_flag_hit for b in blocks), sum(b.copy_flag_n for b in blocks)],
            "copy_mask": [sum(b.copy_mask_hit for b in blocks), sum(b.copy_mask_n for b in blocks)]}
    if "task_id" in item:
        rec["task_id"] = item["task_id"]
    return rec


def save_trace(path: str, res: DAResult, block: int) -> None:
    """run_research_baselines.save_trace's arrays (per STOCK pass) + draft / judge arrays per block."""
    blocks = res.blocks
    nb = len(blocks)
    if nb == 0:
        return
    Pn = max(max(b.n_steps for b in blocks), 1)
    proposed = np.full((nb, Pn, block), -1, np.int32)
    conf = np.full((nb, Pn, block), np.nan, np.float32)
    committed = np.zeros((nb, Pn, block), bool)
    valid = np.zeros((nb, block), bool)
    n_pass = np.zeros(nb, np.int32); start = np.zeros(nb, np.int32)
    tokens = np.full((nb, block), -1, np.int32)
    draft_tokens = np.full((nb, block), -1, np.int32)
    judge_argmax = np.full((nb, block), -1, np.int32)
    judge_p = np.full((nb, block), np.nan, np.float32)
    judge_q = np.full((nb, block), np.nan, np.float32)
    judge_code = np.zeros((nb, block), np.int8)
    accepted = np.zeros((nb, block), bool)
    committed_judge = np.zeros((nb, block), bool)
    p_draft = np.full((nb, block), np.nan, np.float32)
    anchored = np.zeros((nb, block), bool)      # anchored drafting: slots committed BEFORE the draft
    for i, b in enumerate(blocks):
        n_pass[i] = b.n_steps; start[i] = b.start; valid[i] = b.valid.numpy()
        tokens[i] = b.tokens.numpy()
        for s in range(b.n_steps):
            proposed[i, s] = b.proposed[s].numpy(); conf[i, s] = b.confidence[s].numpy()
            committed[i, s] = b.committed[s].numpy()
        if b.draft_tokens is not None:
            draft_tokens[i] = b.draft_tokens.numpy(); p_draft[i] = b.p_draft.numpy()
            judge_argmax[i] = b.judge_argmax.numpy(); judge_p[i] = b.judge_p.numpy(); judge_q[i] = b.judge_q.numpy()
            judge_code[i] = b.judge_code.numpy(); accepted[i] = b.accepted.numpy(); committed_judge[i] = b.committed_judge.numpy()
        if b.anchored is not None:
            anchored[i] = b.anchored.numpy()
    os.makedirs(os.path.dirname(path), exist_ok=True)
    # `anchored` is written ONLY by an anchored-drafting run, so every other cell's trace keeps
    # exactly the arrays (and the bytes) it has always had.
    extra = {"anchored": anchored} if any(b.anchored is not None for b in blocks) else {}
    np.savez_compressed(path, proposed=proposed, confidence=conf, committed=committed, valid=valid,
                        n_pass=n_pass, block_start=start, tokens=tokens,
                        prompt_length=np.int32(res.prompt_length), block_length=np.int32(block),
                        draft_tokens=draft_tokens, p_draft=p_draft, judge_argmax=judge_argmax, judge_p=judge_p,
                        judge_q=judge_q, judge_code=judge_code, accepted=accepted, committed_judge=committed_judge,
                        **extra)


def load_trace(path: str) -> dict:
    d = np.load(path)
    return {k: d[k] for k in d.files}


# ---------------------------------------------------------------------------
# one item, timed (used by the runner)
# ---------------------------------------------------------------------------
def decode_item(moe: MoEMeter, dr_seq: Optional[SeqCache], tok, item: dict, prompt_ids: torch.Tensor, *,
                mask_id: int, eos_ids: Sequence[int], gen_length: int,
                adapter: Optional[str] = None, adapter_hash: Optional[str] = None, **gen_kw):
    dev = moe.seq.dev
    cuda = dev.type == "cuda"
    if cuda:
        torch.cuda.reset_peak_memory_stats(dev); torch.cuda.synchronize(dev)
    t0 = time.perf_counter()
    res = da_generate(moe, dr_seq, prompt_ids, mask_id=mask_id, gen_length=gen_length,
                      stopping_criteria_idx=list(eos_ids), **gen_kw)
    if cuda:
        torch.cuda.synchronize(dev)
    wall = time.perf_counter() - t0
    peak = round(torch.cuda.max_memory_allocated(dev) / 2**30, 2) if cuda else None
    rec = make_record(res, tok, item, prompt_ids, moe, dr_seq, eos_ids, mask_id, wall, peak,
                      adapter=adapter, adapter_hash=adapter_hash)
    return rec, res