Reorganise: group 313 tasks into 17 families under tasks/, generators under tools/ (part 22)

tools/factory/specs/qwen3_moe_route_align.py

@@ -0,0 +1,251 @@
+"""Spec for `qwen3-moe-route-align` — high-sparsity (512-expert) MoE routing fused with the block-aligned
+expert-sorted dispatch table the grouped expert GEMM consumes."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="qwen3-moe-route-align",
+    title="Write a fast high-sparsity MoE router + block-aligned dispatch-table kernel",
+    blurb=("Qwen3-Next routes every token to 10 of 512 experts, and the router is only half the job: before "
+           "the grouped expert GEMM can launch, the routing decisions have to be turned into a work table — "
+           "every routed slot sorted by expert, each expert's segment padded up to a whole tile, and a "
+           "block-to-expert map so the GEMM knows which weight matrix each tile uses. At half a million "
+           "tokens the score matrix alone is more than a gigabyte, and the usual implementation drags it "
+           "through HBM five times and then runs a full sort it does not need."),
+    keywords=["mle", "kernel-generation", "moe", "routing", "top-k", "qwen3-next", "high-sparsity",
+              "dispatch", "block-align", "memory-bound"],
+    module="route_align.py",
+    func="route_and_align",
+    signature="route_and_align(logits, topk, block_size)",
+    returns_doc="""High-sparsity MoE routing plus the block-aligned expert-sorted dispatch table.
+
+Args:
+    logits:     (T, E) float32 — raw gate logits, one row per token.
+    topk:       int            — K, experts kept per token.
+    block_size: int            — BM, the row-tile size of the grouped expert GEMM.
+
+Returns:
+    (topk_ids, topk_w, sorted_ids, block_expert, num_tokens_post_pad) where
+      topk_ids:   (T, K)   int32   — selected expert ids, ASCENDING within each row
+      topk_w:     (T, K)   float32 — renormalised softmax weights, aligned with topk_ids
+      sorted_ids: (L,)     int32   — routed slot ids grouped by expert and padded per expert to a
+                                     multiple of BM; L = T*K + E*(BM-1); unused entries are T*K
+      block_expert: (L//BM,) int32 — expert owning each BM-row block; -1 past the last used block
+      num_tokens_post_pad: (1,) int32 — total padded length (a multiple of BM)""",
+
+    reference_imports="import torch",
+    reference_src='''
+def route_and_align(logits, topk, block_size):
+    """Softmax + top-k + renormalise, then the expert-sorted, block-padded dispatch table.
+
+    Correct and simple — it is the exact SPECIFICATION, not a performance target. It materialises the full
+    fp32 score matrix, runs a global argsort over every routed slot, and builds the table with several more
+    full-length passes.
+    """
+    T, E = logits.shape
+    dev = logits.device
+    n = T * topk
+
+    scores = torch.softmax(logits.float(), dim=-1)             # (T, E)
+    idx = scores.topk(topk, dim=-1).indices                    # best-first
+    idx = idx.sort(dim=-1).values                              # canonical order: ASCENDING expert id
+    w = scores.gather(1, idx)
+    w = w / w.sum(-1, keepdim=True)                            # renormalise over the selected set
+
+    flat = idx.reshape(n).to(torch.int64)                      # expert of routed slot s = t*K + j
+    slot = torch.arange(n, device=dev)
+    order = (flat * n + slot).argsort()                        # group by expert, slots ascending inside
+
+    counts = torch.bincount(flat, minlength=E)                 # rows per expert
+    padded = ((counts + block_size - 1) // block_size) * block_size
+    starts = torch.cumsum(padded, 0) - padded                  # where each expert's padded segment begins
+    total = int(padded.sum())
+
+    L = n + E * (block_size - 1)
+    sorted_ids = torch.full((L,), n, dtype=torch.int32, device=dev)     # sentinel = n means "padding"
+    e_of = flat[order]                                                  # expert at each position of `order`
+    raw_start = torch.cumsum(counts, 0) - counts
+    dest = starts[e_of] + (slot - raw_start[e_of])                      # padded destination of each row
+    sorted_ids[dest] = order.to(torch.int32)
+
+    block_expert = torch.full((L // block_size,), -1, dtype=torch.int32, device=dev)
+    nb = padded // block_size
+    block_expert[: total // block_size] = torch.repeat_interleave(
+        torch.arange(E, device=dev, dtype=torch.int32), nb)
+
+    return (idx.to(torch.int32), w.float(), sorted_ids, block_expert,
+            torch.tensor([total], dtype=torch.int32, device=dev))
+''',
+    make_inputs_src='''
+MARGIN = 0.25       # guaranteed separation between the K-th and (K+1)-th gate logit of every token
+
+
+def _mk(T, E, K, BM, seed):
+    """Gate logits with a GUARANTEED top-k margin.
+
+    A constant MARGIN is added to each token's K largest logits. That cannot change which experts are
+    largest (all K of them only move up), and it forces the gap between the K-th and (K+1)-th logit to at
+    least MARGIN = 0.25 — a factor of 1.28 in softmax score. bf16 cannot move a logit of that magnitude by
+    even a tenth of it, so the selected expert SET is unambiguous and is an exact-match target.
+    """
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    logits = torch.randn(T, E, device="cuda", dtype=torch.float32, generator=gen)
+    idx = logits.topk(K, dim=-1).indices
+    logits.scatter_add_(1, idx, torch.full_like(idx, 0, dtype=torch.float32) + MARGIN)
+    return logits, K, BM
+''',
+    flops_src='''
+def canonical_work(T, E, K, BM):
+    """BYTES attributed to one routing + alignment pass, from the SHAPE ALONE.
+
+    The unavoidable traffic: read the (T, E) fp32 logit matrix once, write the (T, K) int32 ids and the
+    (T, K) fp32 weights, write the padded dispatch table of L = T*K + E*(BM-1) int32 entries and the
+    L/BM int32 block-to-expert map. The per-expert counters and prefix sums are tiny and never need to
+    reach HBM. This is a memory-bound kernel, so the score is achieved bandwidth against this fixed byte
+    count.
+    """
+    L = T * K + E * (BM - 1)
+    return T * E * 4 + T * K * 8 + 4 * L + 4 * (L // BM) + 4
+''',
+    flops_formula=("L     = T*K + E*(BM-1)                                  # padded table length\n"
+                   "bytes = T*E*4  +  T*K*8  +  4*L  +  4*(L//BM)  +  4\n"
+                   "#       logits    ids+w     table   block map     count"),
+
+    metric="GB/s",
+    compare="tuple",
+    tuple_names=("topk_ids", "topk_w", "sorted_ids", "block_expert", "num_tokens_post_pad"),
+    tol=1e-4,   # MEASURED: 1400x the 7.2e-8 gap to an independent implementation; it only forbids bf16
+    shape_names=("T", "E", "K", "BM"),
+    grader_shapes=[(786432, 512, 10, 128), (655360, 512, 10, 128), (393216, 1024, 8, 128),
+                   (524288, 768, 10, 64), (786432, 512, 8, 64)],
+    measure_shapes=[(720896, 512, 10, 128), (589824, 512, 10, 128), (327680, 1024, 8, 128),
+                    (458752, 768, 10, 64), (720896, 512, 8, 64)],
+    measure_quick_shapes=[(65536, 512, 8, 128), (32768, 256, 6, 64), (131072, 128, 4, 128)],
+    correct_shapes=[(4096, 512, 10, 128), (1023, 256, 8, 64), (777, 128, 4, 32), (8192, 64, 6, 128)],
+
+    spec_md="""Two things happen here, and a real MoE layer needs both before it can launch anything.
+
+**1 — the router.** A softmax over the expert axis, the `K` largest kept, renormalised so each token's
+weights sum to one:
+
+```
+scores = softmax(logits, dim=-1)              # (T, E), fp32
+idx    = indices of the K largest scores      # then SORTED ASCENDING by expert id
+w      = scores[idx] / sum(scores[idx])       # renormalised over the selected set only
+```
+
+`topk_ids` must be **ascending by expert id** within each row, and `topk_w[t, j]` is the weight of
+`topk_ids[t, j]`. The fixture guarantees a separation of at least `0.25` between each token's K-th and
+(K+1)-th logit — a factor of 1.28 in score — so the selected set is never a near-tie and is compared
+exactly.
+
+**2 — the block-aligned dispatch table.** Number the routed slots `s = t*K + j`, so slot `s` belongs to
+token `s // K` and asks for expert `topk_ids[t, j]`. The grouped expert GEMM wants those slots grouped by
+expert, and it wants every expert's group to start on a tile boundary so a tile never straddles two
+experts:
+
+```
+counts[e]  = number of slots that chose expert e
+padded[e]  = ceil(counts[e] / BM) * BM                  # round each expert's group up to a whole tile
+starts[e]  = padded[0] + ... + padded[e-1]              # exclusive prefix sum of the PADDED counts
+total      = padded[0] + ... + padded[E-1]              # = num_tokens_post_pad
+```
+
+Expert `e` owns `sorted_ids[starts[e] : starts[e] + padded[e]]`. Its first `counts[e]` entries are the slot
+ids that chose it, **in ascending slot order**; the remaining `padded[e] - counts[e]` entries are the
+sentinel `T*K`, which the GEMM reads as "this row is padding, skip it". Every entry of `sorted_ids` past
+`total` is also the sentinel.
+
+`block_expert[b]` is the expert that owns block `b` — i.e. `sorted_ids[b*BM : (b+1)*BM]` — for every block
+below `total / BM`, and `-1` for every block above it.
+
+The output length is fixed by the shape alone: `L = T*K + E*(BM-1)` is the worst case (`E` experts each
+wasting up to `BM-1` rows), so `sorted_ids` is `(L,)` and `block_expert` is `(L // BM,)` regardless of how
+the tokens actually fall.
+
+`/app/reference.py` builds this with a full argsort over every routed slot. That is the exact
+specification; it is deliberately simple rather than fast.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `logits` | `(T, E)` | `float32` | raw gate logits, one row per token |
+| `topk` | int | | `K`, experts kept per token |
+| `block_size` | int | | `BM`, the expert GEMM's row-tile size |
+
+**Return a 5-tuple in exactly this order:**
+
+| out | shape | dtype | notes |
+|-----|-------|-------|-------|
+| `topk_ids` | `(T, K)` | `int32` | **ascending by expert id** within each row; compared **exactly** |
+| `topk_w` | `(T, K)` | `float32` | renormalised, aligned with `topk_ids` |
+| `sorted_ids` | `(L,)` | `int32` | `L = T*K + E*(BM-1)`; slot ids grouped by expert, ascending inside each expert; padding entries are `T*K`; compared **exactly** |
+| `block_expert` | `(L // BM,)` | `int32` | expert per block, `-1` past `num_tokens_post_pad / BM`; compared **exactly** |
+| `num_tokens_post_pad` | `(1,)` | `int32` | total padded length; compared **exactly** |
+
+`logits` is **read-only**. `E` is a multiple of nothing in particular and `T` is **not** guaranteed to be a
+multiple of any tile size — the correctness shapes include `T = 1023` and `T = 777`. `BM` divides `L` by
+construction. All four integer outputs are compared **bit-exactly**; only `topk_w` has a tolerance.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `T`
+(routed tokens in the step) in 393216–786432, `E` in 512–1024, `K` in 8–10, `BM` in 64–128. This is the
+high-sparsity regime — 2% of the experts active per token — so the logit matrix is over a gigabyte while
+everything downstream of it is two orders of magnitude smaller. Reading that matrix once, at full
+bandwidth, is most of the achievable score.""",
+
+    correctness_md="""Four of the five outputs are **integer** and are compared **bit-exactly** — one wrong
+entry anywhere in the dispatch table scores 0. `topk_w` must match the reference within **relative
+Frobenius error `1e-4`**.
+
+The expert *selection* is safe to compare exactly because the fixture guarantees a `0.25` logit margin
+between the K-th and (K+1)-th expert of every token (a 1.28x score ratio). That is more than 15x what bf16
+rounding of a logit of this magnitude can move, so two correct implementations cannot disagree about the
+set — but note the consequence: the ordering, the padding rule and the sentinel are **exact**
+specifications, not conventions you may vary. Each of these variants was tried and every one fails
+outright: not padding each expert's segment up to `BM`, leaving `topk_ids` in best-first order instead of
+ascending, filling the padding with `0` instead of `T*K`. Skipping the weight renormalisation lands at
+**1.9**, four orders of magnitude above the `1e-4` weight gate.""",
+
+    perf_md="""The `(T, E)` fp32 logit matrix is 1–1.6 GB at the graded shapes and everything else is
+smaller by two orders of magnitude, so the score is decided almost entirely by how close to a single
+streaming read of it you get.
+
+Three things go wrong in the obvious implementation. First, `softmax` then `topk` then `sum` then a divide
+is four passes over that matrix; it should be one — a row fits in registers only 512 wide, so a block per
+row can keep a running max, a running exponential sum, and a K-entry top-k list in one sweep. Second, a
+full `topk` over 512 experts sorts far more than it needs: you need the K largest, unsorted, then a tiny
+K-element sort to put them in ascending id order. Third, the reference's global argsort over `T*K` slots is
+entirely avoidable — the table is a **counting sort** with `E` buckets, and the histogram can be built with
+per-block privatised counters while the router is still streaming.
+
+Once you have `counts`, the rest is a prefix sum over `E <= 1024` numbers (one block) and a scatter: slot
+`s` lands at `starts[e] + rank(s within e)`, and the rank comes from an atomic increment on the bucket or
+from a second pass. Filling the padding with the sentinel is a memset of a buffer you are writing anyway —
+do not write it twice.
+
+`block_expert` is `L/BM` entries, tiny; build it from the padded prefix sums directly rather than by
+scanning `sorted_ids`.
+
+Watch the tail: `T` is ragged, `E` need not be a power of two, and the number of used blocks depends on the
+data, so the `-1` fill has to be right at any occupancy.""",
+
+    precision_md="""`logits` arrives in **float32** and `topk_w` is returned in **float32**. Do the softmax
+and the renormalisation in fp32: the weights gate an expert's entire contribution to a token, the gate on
+them is `1e-4`, and bf16 has nowhere near that precision.
+
+**Do not compute the scores in bf16 or fp16.** It is not a speed win here — the read of `logits` is the
+bottleneck and it is fp32 on the wire either way — and it would blow the weight tolerance.
+
+The selection itself only needs the *ordering* of the logits, which is exact in fp32; you can select on the
+raw logits and exponentiate only the K survivors plus the row maximum, which is the numerically stable and
+cheap route.
+
+**Where the tolerance comes from.** `1e-4` is measured. A second, independent implementation — a chunked
+row-wise softmax that subtracts the row max at a different point, selects on the raw logits instead of on
+the scores, and renormalises with a reciprocal-multiply instead of a divide — agrees with this reference to
+a relative Frobenius error of **7.2e-8** on `topk_w` and **bit-exactly** on all four integer outputs, over
+every correctness shape and a full-size graded shape. The tolerance is three orders of magnitude above the
+observed difference, so it constrains nothing except the use of a narrower dtype.""",
+).validate()

tools/factory/specs/qwen3_next_gated_attention.py

@@ -0,0 +1,211 @@
+"""Spec for `qwen3-next-gated-attention` — Qwen3-Next style GQA attention with the per-head SIGMOID output
+gate projected from the layer input and applied inside the attention epilogue."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="qwen3-next-gated-attention",
+    title="Write a fast gated attention kernel (attention + fused per-head output gate)",
+    blurb=("Qwen3-Next does not read the attention output straight out of the softmax: every element of "
+           "every head is multiplied by a SIGMOID gate that is projected from the block's input, which is "
+           "what lets the model shut a head off per token. Run as separate ops that is a second full-size "
+           "projection plus two extra round trips of the (T, H*D) attention output through HBM, on top of "
+           "an attention kernel that already had the tile in registers. Fusing the gate into the attention "
+           "epilogue makes it nearly free — but the gate GEMM and the attention have completely different "
+           "shapes, so the scheduling is the whole problem."),
+    keywords=["mle", "kernel-generation", "qwen3-next", "gated-attention", "output-gate", "gqa",
+              "flash-attention", "fusion", "compute-bound"],
+    module="gated_attn.py",
+    func="gated_attention",
+    signature="gated_attention(q, k, v, x, w_gate, scale=None)",
+    returns_doc="""Causal GQA attention with a fused per-head sigmoid output gate.
+
+Args:
+    q:       (B, T, Hq, D)  bfloat16 — queries.
+    k, v:    (B, T, Hkv, D) bfloat16 — keys and values; Hq is a multiple of Hkv (GQA).
+    x:       (B, T, Dm)     bfloat16 — the block INPUT, the source of the gate.
+    w_gate:  (Hq*D, Dm)     bfloat16 — gate projection, nn.Linear layout (out, in).
+    scale:   float or None           — logit scale; None means D ** -0.5.
+
+Returns:
+    o: (B, T, Hq, D), bfloat16 or float32 — must match /app/reference.py numerically.""",
+
+    reference_imports="import torch",
+    reference_src='''
+CH = 1024      # the reference tiles over queries purely so it FITS; it makes no attempt to be fast
+
+
+def gated_attention(q, k, v, x, w_gate, scale=None):
+    """Causal GQA attention in fp32, then the sigmoid output gate projected from x.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target. Every query tile
+    materialises its full fp32 score row and the gate is a separate full-size GEMM through HBM.
+    """
+    B, T, Hq, D = q.shape
+    Hkv = k.shape[2]
+    if scale is None:
+        scale = D ** -0.5
+    rep = Hq // Hkv
+
+    kf = k.float().repeat_interleave(rep, dim=2).transpose(1, 2)          # (B, Hq, T, D)
+    vf = v.float().repeat_interleave(rep, dim=2).transpose(1, 2)
+    qf = q.float().transpose(1, 2)
+    pos = torch.arange(T, device=q.device)
+
+    o = torch.empty(B, Hq, T, D, device=q.device, dtype=torch.float32)
+    for s in range(0, T, CH):
+        e = min(s + CH, T)
+        sc = torch.einsum("bhqd,bhkd->bhqk", qf[:, :, s:e], kf) * scale   # (B, Hq, ch, T)
+        sc = sc.masked_fill(pos[s:e, None] < pos[None, :], float("-inf")) # causal
+        o[:, :, s:e] = torch.einsum("bhqk,bhkd->bhqd", torch.softmax(sc, dim=-1), vf)
+
+    g = x.float() @ w_gate.float().t()                                    # (B, T, Hq*D) gate logits
+    o = o.transpose(1, 2).reshape(B, T, Hq * D) * torch.sigmoid(g)        # SIGMOID gate, elementwise
+    return o.reshape(B, T, Hq, D).to(torch.bfloat16)
+''',
+    make_inputs_src='''
+def _mk(B, T, Hq, Hkv, D, Dm, seed):
+    """Attention inputs plus the block input and the gate projection. The gate logits are kept in a range
+    where the sigmoid is genuinely selective (roughly 0.02 .. 0.98) rather than saturated at 1."""
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    q = torch.randn(B, T, Hq, D, device="cuda", dtype=torch.bfloat16, generator=gen)
+    k = torch.randn(B, T, Hkv, D, device="cuda", dtype=torch.bfloat16, generator=gen)
+    v = torch.randn(B, T, Hkv, D, device="cuda", dtype=torch.bfloat16, generator=gen)
+    x = torch.randn(B, T, Dm, device="cuda", dtype=torch.bfloat16, generator=gen)
+    w_gate = (torch.randn(Hq * D, Dm, device="cuda", generator=gen) * (2.0 * Dm ** -0.5)).to(torch.bfloat16)
+    return q, k, v, x, w_gate, None
+''',
+    flops_src='''
+def canonical_work(B, T, Hq, Hkv, D, Dm):
+    """FLOPs attributed to one gated-attention forward, from the SHAPE ALONE.
+
+    Causal attention touches half the T-by-T grid and each surviving (query, key) pair costs 4*D FLOPs
+    (2*D for the q.k dot, 2*D for the p*v accumulate), giving 2*B*Hq*T*T*D. The gate projection is a dense
+    (B*T, Dm) x (Dm, Hq*D) GEMM. The softmax, the sigmoid and the elementwise multiply are O(B*T*Hq*D) and
+    are NOT credited — fusing them is a saving, not extra work you get paid for.
+    """
+    return 2 * B * Hq * T * T * D + 2 * B * T * Dm * (Hq * D)
+''',
+    flops_formula=("canonical_work(B, T, Hq, Hkv, D, Dm) = 2*B*Hq*T*T*D   +   2*B*T*Dm*(Hq*D)\n"
+                   "#                                      causal attention    gate projection"),
+
+    metric="TFLOP/s",
+    compare="tensor",
+    tol=7e-3,   # MEASURED: 2.0x the 3.46e-3 worst gap to an independent bf16 SDPA+gate implementation
+    shape_names=("B", "T", "Hq", "Hkv", "D", "Dm"),
+    grader_shapes=[(1, 8192, 32, 4, 128, 4096), (2, 8192, 16, 2, 128, 2048),
+                   (1, 16384, 16, 2, 128, 2048), (2, 6144, 32, 8, 128, 4096),
+                   (1, 8192, 48, 8, 128, 6144)],
+    measure_shapes=[(1, 6144, 32, 4, 128, 4096), (2, 6144, 16, 2, 128, 2048),
+                    (1, 12288, 16, 2, 128, 2048), (2, 4096, 32, 8, 128, 4096),
+                    (1, 6144, 48, 8, 128, 6144)],
+    measure_quick_shapes=[(1, 2048, 8, 2, 128, 1024), (2, 1024, 8, 4, 128, 1024),
+                          (1, 2048, 16, 2, 64, 1024)],
+    correct_shapes=[(1, 256, 8, 2, 64, 512), (2, 512, 8, 4, 128, 1024), (1, 333, 4, 1, 128, 256),
+                    (3, 129, 8, 2, 64, 512)],
+
+    spec_md="""A Qwen3-Next attention block computes ordinary causal grouped-query attention and then gates
+it, per head and per channel, with a sigmoid projected from the block's own input.
+
+**1 — causal GQA attention**, in the usual layout:
+
+```
+rep      = Hq // Hkv                                   # query heads per KV head
+K[h]     = k[:, :, h // rep]                           # head h reads KV head h // rep
+a[b,h,i,j] = scale * dot( q[b,i,h,:], K[h][b,j,:] )    # scale = D**-0.5 when scale is None
+a[b,h,i,j] = -inf   for j > i                          # causal, no sinks, no windows
+p        = softmax(a, over j)
+u[b,i,h,:] = sum_j p[b,h,i,j] * V[h][b,j,:]
+```
+
+**2 — the output gate**, projected from `x` (the block INPUT, not the attention output) and applied with a
+**sigmoid**:
+
+```
+g = x @ w_gate.T                        # (B, T, Hq*D)
+o[b, i, h, d] = u[b, i, h, d] * sigmoid( g[b, i, h*D + d] )
+```
+
+The flattening is **head-major**: channel `h*D + d` of `g` gates head `h`, channel `d`. This is a *gate*,
+not an activation — it is a function of `x`, so it is available before the attention even starts, and it is
+per (token, head, channel) rather than per head.
+
+Note the sigmoid, not SiLU: the gate multiplies the attention output by a number in `(0, 1)`, so a head can
+be switched off for a token without changing its sign.
+
+`/app/reference.py` runs the attention in fp32 over query tiles and then does the gate as a separate
+full-size GEMM. That is the exact specification; it is deliberately simple rather than fast.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `q` | `(B, T, Hq, D)` | `bfloat16` | queries |
+| `k` | `(B, T, Hkv, D)` | `bfloat16` | keys; query head `h` uses KV head `h // (Hq//Hkv)` |
+| `v` | `(B, T, Hkv, D)` | `bfloat16` | values, same grouping |
+| `x` | `(B, T, Dm)` | `bfloat16` | the block input — the gate's source |
+| `w_gate` | `(Hq*D, Dm)` | `bfloat16` | gate projection, `nn.Linear` layout `(out, in)` |
+| `scale` | float or `None` | | logit scale; `None` means `D ** -0.5` |
+
+**Return** a single tensor `o` of shape `(B, T, Hq, D)`, bfloat16 or float32 (the grader compares in fp32).
+
+All inputs are **read-only**. `Hq` is always a multiple of `Hkv`. `T` is **not** guaranteed to be a multiple
+of any tile size — the correctness shapes include `T = 333` and `T = 129`, so handle the ragged tail. There
+are no attention sinks, no sliding window and no positional encoding to apply: `q` and `k` arrive with RoPE
+already applied.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `B` in
+1–2, `T` in 6144–16384, `Hq` in 16–48 with `Hkv` in 1–8 (GQA ratios of 4–8), `D` = 128, and `Dm` equal to
+`Hq*D` or half of it. The attention term dominates the FLOP count at these lengths but the gate GEMM is
+20–35% of it, so a kernel that gets the attention right and then bolts a separate gate on the end leaves a
+large fraction on the table.""",
+
+    correctness_md="""The returned tensor must match the reference (evaluated in fp32) within **relative
+Frobenius error `7e-3`** at every graded shape, including the timed ones.
+
+That gate is **measured**, not guessed, and kernels that skip this task's actual work miss it by orders of
+magnitude: returning the ungated attention output scores **1.00**, applying the gate logits raw (no
+sigmoid) scores **2.99**, using SiLU instead of sigmoid scores **1.59**, and projecting the gate from the
+attention output instead of from `x` scores **0.58** — the closest of them is still **83x** the
+tolerance.""",
+
+    perf_md="""Two very different GEMM shapes have to share the machine. The attention is the usual
+flash-attention problem — tile the query axis, stream K and V tiles, keep the running max/sum and the
+accumulator in registers, and never write the score matrix. The gate is a plain `(B*T, Dm) x (Dm, Hq*D)`
+projection.
+
+The win is that the gate result is consumed **exactly where the attention accumulator already lives**. A
+kernel that computes `g` into HBM, reads it back, multiplies and writes again pays three extra full-size
+passes over a `(B, T, Hq*D)` tensor — at the graded shapes that is hundreds of megabytes of avoidable
+traffic per call, and it also costs a second kernel launch on the critical path of every layer.
+
+Two ways to spend that: fuse the gate GEMM into the attention epilogue so the `(BLOCK_M, D)` slice of `g`
+each query tile needs is computed while the tile is still resident, or run the gate as a persistent
+producer that overlaps the attention mainloop. Either way, `sigmoid` is cheap but not free — it is one
+`exp` per output element, so evaluate it on the tile rather than on a materialised tensor.
+
+GQA gives you `Hq/Hkv` query heads sharing one KV tile: load K and V once per group, not once per head.
+Causality means half the tiles are fully masked and must be **skipped**, not computed and thrown away, and
+the diagonal tile is the only one that needs the elementwise mask.""",
+
+    precision_md="""Inputs are **bfloat16** and the output may be bf16 or fp32. Accumulate the attention
+logits, the softmax and the `p @ v` product in **fp32**, and evaluate the sigmoid in fp32 — a bf16 sigmoid
+loses enough precision near zero to show up in the norm. Tensor-core GEMMs on bf16 inputs with fp32
+accumulate are exactly what this task expects.
+
+**fp8 is not appropriate here.** The inputs arrive in bf16 and quantising them to fp8 to use a wider tensor
+core is an approximation of the specified computation, not an implementation of it — and the measured
+tolerance does not have room for it.
+
+Do **not** infer from the reference that fp32 storage is wanted; it computes in fp32 purely to be a stable
+numerical specification.
+
+**Where the tolerance comes from.** `1.2e-2` is measured. A second, independent implementation — bf16
+`scaled_dot_product_attention` with `is_causal=True` and GQA broadcasting for the attention, a bf16 tensor
+-core GEMM for the gate, and the sigmoid multiply in bf16 — differs from this fp32 reference by relative
+Frobenius error at most **3.46e-3** across the correctness shapes and a full-size graded shape (it is
+remarkably flat: 3.35e-3 to 3.46e-3 over every shape and seed tried). The tolerance is **2.0x** that. Almost all of it is the bf16 rounding of the two GEMMs and of the returned tensor, which
+is the floor for any bf16 kernel; a faithful implementation lands in the same place regardless of how it
+tiles.""",
+).validate()

tools/factory/specs/qwen3_next_gated_attn_decode.py

@@ -0,0 +1,259 @@
+"""Spec for `qwen3-next-gated-attn-decode` — the Qwen3-Next attention decode step: paged GQA over a fused
+KV cache, then zero-centred per-head RMSNorm and the projected sigmoid output gate, all in one pass."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="qwen3-next-gated-attn-decode",
+    title="Write a fast gated attention DECODE kernel (paged GQA + head-norm + output gate)",
+    blurb=("What a Qwen3-Next server actually runs at every generated token in its attention layers: "
+           "grouped-query attention over a paged KV cache that holds K and V interleaved at each position, "
+           "followed immediately by a zero-centred per-head RMSNorm and a sigmoid output gate projected "
+           "from the block input. The attention is pure cache bandwidth; the epilogue is a projection and "
+           "two normalisations on a tensor small enough that it should never leave registers — and as three "
+           "separate launches it adds three round trips and three kernel launches to the critical path of "
+           "every layer of every token."),
+    keywords=["mle", "kernel-generation", "qwen3-next", "gated-attention", "output-gate", "decode",
+              "paged-attention", "kv-cache", "rmsnorm", "memory-bound"],
+    module="gated_decode.py",
+    func="gated_attn_decode",
+    signature=("gated_attn_decode(q, kv_cache, page_table, seq_lens, x, w_gate, w_norm, "
+               "eps=1e-6, scale=None)"),
+    returns_doc="""Paged GQA decode with a fused zero-centred head-norm and sigmoid output gate.
+
+Args:
+    q:          (B, Hq, D)                 bfloat16 — this token's query, per head.
+    kv_cache:   (NUM_PAGES, P, 2, Hkv, D)  bfloat16 — page pool; index 0 of axis 2 is K, index 1 is V.
+    page_table: (B, NP)                    int32    — physical page of logical positions
+                                                      [p*P, (p+1)*P) of request b.
+    seq_lens:   (B,)                       int32    — valid cached positions of request b.
+    x:          (B, Dm)                    bfloat16 — the block INPUT, the source of the gate.
+    w_gate:     (Hq*D, Dm)                 bfloat16 — gate projection, nn.Linear layout (out, in).
+    w_norm:     (D,)                       bfloat16 — ZERO-CENTRED head-norm gain; effective gain 1+w_norm.
+    eps:        float                               — RMSNorm epsilon.
+    scale:      float or None                       — logit scale; None means D ** -0.5.
+
+Returns:
+    out: (B, Hq, D), bfloat16 or float32 — must match /app/reference.py numerically.""",
+
+    reference_imports="import torch",
+    reference_src='''
+CH = 8       # the reference tiles over requests purely so it FITS; it makes no attempt to be fast
+
+
+def gated_attn_decode(q, kv_cache, page_table, seq_lens, x, w_gate, w_norm, eps=1e-6, scale=None):
+    """Paged GQA decode in fp32, then the head-norm and the gate as separate dense steps.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target. It materialises the
+    whole logical cache of each request in fp32 and the full score row, which is exactly what a real kernel
+    must avoid: pages should be read once, in bfloat16, straight into registers.
+    """
+    B, Hq, D = q.shape
+    P, Hkv = kv_cache.shape[1], kv_cache.shape[3]
+    NP = page_table.shape[1]
+    S = NP * P
+    rep = Hq // Hkv
+    if scale is None:
+        scale = D ** -0.5
+    dev = q.device
+
+    o = torch.empty(B, Hq, D, device=dev, dtype=torch.float32)
+    pos = torch.arange(S, device=dev)
+    for b0 in range(0, B, CH):
+        b1 = min(b0 + CH, B)
+        kv = kv_cache[page_table[b0:b1].long()].reshape(b1 - b0, S, 2, Hkv, D).float()
+        kc, vc = kv[:, :, 0], kv[:, :, 1]                                   # (b, S, Hkv, D)
+        qq = (q[b0:b1].float() * scale).reshape(b1 - b0, Hkv, rep, D)
+        s = torch.einsum("bgrd,bsgd->bgrs", qq, kc)
+        valid = pos.view(1, 1, 1, -1) < seq_lens[b0:b1].long().view(-1, 1, 1, 1)
+        s = s.masked_fill(~valid, float("-inf"))
+        p = torch.softmax(s, dim=-1)
+        o[b0:b1] = torch.einsum("bgrs,bsgd->bgrd", p, vc).reshape(b1 - b0, Hq, D)
+
+    # zero-centred RMSNorm over each head's D channels, then the projected sigmoid gate
+    n = o * torch.rsqrt(o.pow(2).mean(-1, keepdim=True) + eps) * (1.0 + w_norm.float())
+    g = x.float() @ w_gate.float().t()                                       # (B, Hq*D)
+    out = n.reshape(B, Hq * D) * torch.sigmoid(g)
+    return out.reshape(B, Hq, D).to(torch.bfloat16)
+''',
+    make_inputs_src='''
+def _mk(B, S, Hq, Hkv, D, Dm, P, seed):
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    NP = (S + P - 1) // P                       # pages reserved per request (S is the MAX history length)
+    npages = B * NP                             # the shared pool is exactly full
+    q = torch.randn(B, Hq, D, device="cuda", dtype=torch.bfloat16, generator=gen)
+    kv_cache = torch.randn(npages, P, 2, Hkv, D, device="cuda", dtype=torch.bfloat16, generator=gen)
+    # a real allocator hands out whatever pages are free: the table is a PERMUTATION of the pool, so a
+    # request's history is scattered, and the slots past seq_len hold other requests' leftover data
+    page_table = torch.randperm(npages, device="cuda", generator=gen).view(B, NP).int()
+    seq_lens = torch.tensor(_lens(B, S), device="cuda", dtype=torch.int32)   # matches canonical_work()
+    x = torch.randn(B, Dm, device="cuda", dtype=torch.bfloat16, generator=gen)
+    w_gate = (torch.randn(Hq * D, Dm, device="cuda", generator=gen)
+              * (2.0 * Dm ** -0.5)).to(torch.bfloat16)
+    w_norm = (torch.rand(D, device="cuda", generator=gen) - 0.5).to(torch.bfloat16)  # 1+w in [0.5, 1.5]
+    return q, kv_cache, page_table, seq_lens, x, w_gate, w_norm, 1e-6, None
+''',
+    flops_src='''
+def _lens(B, S):
+    """The per-request history lengths, from the SHAPE ALONE — a ragged batch spread over [S/2, S)."""
+    h = S // 2
+    return [h + (b * 997) % h for b in range(B)]
+
+
+def canonical_work(B, S, Hq, Hkv, D, Dm, P):
+    """BYTES attributed to one gated decode step, from the SHAPE ALONE.
+
+    The unavoidable traffic:
+      * the LIVE part of the KV cache read exactly once in bfloat16 -- sum_b seq_len[b] positions, each
+        holding Hkv*D keys and Hkv*D values. Reserved-but-unfilled pages are not credited, and neither is
+        re-reading a KV head once per query head: the Hq//Hkv heads of a group share it.
+      * the gate projection matrix read once: Hq*D*Dm bfloat16 elements.
+      * the per-token tensors: q and x in, the (B, Hq, D) output out.
+    This is a memory-bound kernel, so the score is achieved bandwidth against this fixed byte count.
+    """
+    kv = 2 * 2 * Hkv * D * sum(_lens(B, S))
+    gate = 2 * Hq * D * Dm
+    small = 2 * B * (2 * Hq * D + Dm)
+    return kv + gate + small
+''',
+    flops_formula=("seq_len[b] = S//2 + (b * 997) % (S//2)               # ragged batch, fixed by the shape\n"
+                   "bytes = 2*2*Hkv*D*sum_b seq_len[b]  +  2*Hq*D*Dm  +  2*B*(2*Hq*D + Dm)\n"
+                   "#       one bf16 read of K and V       the gate weight   per-token tensors"),
+
+    metric="GB/s",
+    compare="tensor",
+    tol=7e-3,   # MEASURED: 2.1x the 3.31e-3 worst gap to an independent per-request SDPA implementation
+    shape_names=("B", "S", "Hq", "Hkv", "D", "Dm", "P"),
+    grader_shapes=[(128, 8192, 32, 4, 128, 4096, 64), (160, 8192, 32, 4, 128, 4096, 64),
+                   (128, 8192, 32, 8, 128, 4096, 128), (96, 16384, 32, 4, 128, 4096, 64),
+                   (192, 8192, 16, 4, 128, 2048, 64)],
+    measure_shapes=[(112, 8192, 32, 4, 128, 4096, 64), (144, 8192, 32, 4, 128, 4096, 64),
+                    (112, 8192, 32, 8, 128, 4096, 128), (80, 16384, 32, 4, 128, 4096, 64),
+                    (176, 8192, 16, 4, 128, 2048, 64)],
+    measure_quick_shapes=[(16, 2048, 16, 4, 128, 2048, 64), (32, 1024, 8, 2, 128, 1024, 64),
+                          (8, 4096, 32, 8, 128, 4096, 128)],
+    correct_shapes=[(5, 1024, 8, 2, 64, 512, 64), (3, 512, 4, 1, 128, 256, 32),
+                    (7, 2048, 8, 4, 128, 1024, 128), (2, 256, 16, 4, 64, 512, 64)],
+
+    spec_md="""One generated token, for every request in the batch. Three things happen and they belong in
+one kernel.
+
+**1 — paged GQA attention.** The cache holds K and V **interleaved at each position**: logical position `s`
+of request `b` lives at
+
+```
+page = page_table[b, s // P] ;  row = s % P
+K[b, s, g, :] = kv_cache[page, row, 0, g, :]
+V[b, s, g, :] = kv_cache[page, row, 1, g, :]
+```
+
+so one read brings in both. With `rep = Hq // Hkv`, query head `h` uses KV head `h // rep`:
+
+```
+a[b, h, s] = ( q[b, h, :] . K[b, s, h//rep, :] ) * scale       for s < seq_lens[b]      (scale = D**-0.5)
+a[b, h, s] = -inf                                              for s >= seq_lens[b]
+o[b, h, :] = sum_s softmax(a)[b, h, s] * V[b, s, h//rep, :]
+```
+
+Decode has no causal mask beyond the length: the new token sees the whole valid history.
+
+**2 — zero-centred per-head RMSNorm.** Over the `D` channels of **each head separately**, with the gain
+stored centred on zero so the effective multiplier is `1 + w_norm`:
+
+```
+n[b, h, :] = o[b, h, :] * rsqrt( mean_d( o[b, h, d]^2 ) + eps ) * (1 + w_norm)
+```
+
+`w_norm` is a single `(D,)` vector shared by every head. Note the `1 +` — this is not the ordinary RMSNorm
+gain, and using `w_norm` directly is a different function.
+
+**3 — the projected sigmoid output gate**, from the block INPUT:
+
+```
+g = x @ w_gate.T                                  # (B, Hq*D)
+out[b, h, d] = n[b, h, d] * sigmoid( g[b, h*D + d] )
+```
+
+The flattening is **head-major**: channel `h*D + d` of `g` gates head `h`, channel `d`. The gate depends
+only on `x`, so it can be computed before or during the attention — it does not wait for it.
+
+`/app/reference.py` gathers each request's whole logical cache into fp32 and then does the norm and the
+gate as separate dense steps. That is the exact specification; it is deliberately simple rather than
+fast.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `q` | `(B, Hq, D)` | `bfloat16` | this token's query |
+| `kv_cache` | `(NUM_PAGES, P, 2, Hkv, D)` | `bfloat16` | page pool; axis 2 is `0 = K`, `1 = V` |
+| `page_table` | `(B, NP)` | `int32` | physical page of each logical page of a request |
+| `seq_lens` | `(B,)` | `int32` | valid cached positions per request |
+| `x` | `(B, Dm)` | `bfloat16` | the block input — the gate's source |
+| `w_gate` | `(Hq*D, Dm)` | `bfloat16` | gate projection, `nn.Linear` layout `(out, in)` |
+| `w_norm` | `(D,)` | `bfloat16` | **zero-centred** head-norm gain; effective gain `1 + w_norm` |
+| `eps` | float | | RMSNorm epsilon, default `1e-6` |
+| `scale` | float or `None` | | logit scale; `None` means `D ** -0.5` |
+
+**Return** a single tensor `out` of shape `(B, Hq, D)`, bfloat16 or float32 (the grader compares in fp32).
+
+All inputs are **read-only**; nothing is appended to the cache here. `seq_lens[b]` is **not** a multiple of
+`P` — the last page of every request is partially valid — and the batch is ragged, with lengths from `S/2`
+to `S`. `B` is small and not a multiple of anything: the correctness shapes include `B = 3`, `5` and
+`7`.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `B`
+(concurrent requests) in 96–192, `S` (maximum history, `NP*P`) in 8192–16384 with real lengths over
+`[S/2, S)`, `Hq` in 16–32 with `Hkv` = `Hq/4` or `Hq/8`, `D` = 128, `Dm` in 2048–4096, `P` 64 or 128.
+That is 1.5–3 GiB of cache read per call against an epilogue that touches a few megabytes — which is
+exactly why the epilogue must cost nothing.""",
+
+    correctness_md="""The returned tensor must match the reference (evaluated in fp32) within **relative
+Frobenius error `7e-3`** at every graded shape, including the timed ones.
+
+That gate is **measured**, and dropping any part of the epilogue misses it by orders of magnitude:
+returning the ungated (but normalised) attention output scores **0.97**, using a plain RMSNorm gain
+`w_norm` instead of the zero-centred `1 + w_norm` scores **0.93**, skipping the per-head normalisation
+scores **0.87**, and using SiLU instead of sigmoid for the gate scores **1.38** — the closest is **124x**
+the tolerance.""",
+
+    perf_md="""The KV cache decides the score and everything else must hide behind it.
+
+**The attention.** A page is `P x 2 x Hkv x D` contiguous, with K and V adjacent at every position, so one
+sweep brings in both operands of the two matmuls — that layout exists precisely so a decode kernel does not
+make two passes. Use an online (flash-decoding) softmax with the query in registers, vectorised 128-bit
+loads, and one KV tile serving all `Hq/Hkv` query heads of its group. Skip whole pages past `seq_lens[b]`:
+they are mapped but dead, and at these lengths a quarter of the reserved pages are.
+
+**The load imbalance is the other half of the problem.** Lengths run from `S/2` to `S` and `B` is only
+around 128, so a one-block-per-(request, head-group) grid leaves most of the machine idle. Split each
+request's history across blocks, keep per-block partial `(o, m, l)` triples, and merge them with the
+standard log-sum-exp combine — the merge is tiny compared with the read.
+
+**The epilogue is free if you fuse it.** `o` is `(B, Hq, D)` — a few megabytes. The head-norm is a
+reduction over `D = 128` lanes, i.e. one warp, on data that is already in registers at the end of the
+softmax merge. The gate is a `(B, Dm) x (Dm, Hq*D)` projection: at `B` in the low hundreds it is
+weight-bound, ~33 MB read once, and it depends only on `x` — so it can be issued first, or overlapped with
+the cache streaming, and its result consumed exactly where the accumulator lives. Writing `o` to HBM,
+reading it back to normalise, then reading it again to gate is three avoidable round trips plus two
+launches on the per-token critical path.""",
+
+    precision_md="""The cache, the query, `x` and both weights are **bfloat16**; the output may be bf16 or
+fp32.
+
+Accumulate the logits, the online softmax, the `p @ v` product, the RMSNorm reduction and the gate GEMM in
+**fp32**, and evaluate the sigmoid in fp32 — a bf16 sigmoid loses enough precision near zero to show up in
+the norm. When you merge partial softmaxes across split-K blocks, merge in fp32 as well.
+
+**fp8 is not appropriate here**: the cache arrives in bf16 and re-quantising it on the fly is an
+approximation of the specified computation rather than an implementation of it.
+
+**Where the tolerance comes from.** `8e-3` is measured. A second, independent implementation — the pages
+gathered per request, the attention run as a bf16 `scaled_dot_product_attention` over the gathered cache
+(an online softmax with a completely different reduction order from the reference's dense one), the gate
+as a bf16 tensor-core GEMM and the head-norm computed with `norm()` instead of `mean(pow(2))` — differs
+from this fp32 reference by a worst relative Frobenius error of **3.31e-3** across the correctness shapes
+and a full-size graded shape, over several seeds. The tolerance is **2.1x** that, and nearly all of it is
+the bf16 rounding of the returned tensor — the number does not move with `S` or `B`.""",
+).validate()

tools/factory/specs/qwen3_next_gdn_inproj.py

@@ -0,0 +1,266 @@
+"""Spec for `qwen3-next-gdn-inproj` — the Qwen3-Next gated-DeltaNet input projection: zero-centred RMSNorm,
+one fused QKVZ+BA projection, per-head L2 normalisation and the two recurrence gates."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="qwen3-next-gdn-inproj",
+    title="Write a fast gated-DeltaNet input-projection kernel (norm + fused proj + gates)",
+    blurb=("Three quarters of the layers in Qwen3-Next are gated-DeltaNet blocks, and every one of them "
+           "starts here: zero-centred RMSNorm on the residual stream, one wide fused projection into "
+           "queries, keys, values and the output gate, a second tiny projection into the two recurrence "
+           "gates, then per-head L2 normalisation of q and k, a sigmoid for the delta-rule step size and a "
+           "softplus-and-negate for the log forget gate. Run as fifteen separate torch ops it drags the "
+           "(T, 12k) projection output through HBM four times and launches a kernel for every activation; "
+           "fused, it is one GEMM with an epilogue."),
+    keywords=["mle", "kernel-generation", "qwen3-next", "gated-deltanet", "linear-attention", "rmsnorm",
+              "l2-norm", "gemm", "fusion", "compute-bound"],
+    module="gdn_inproj.py",
+    func="gdn_in_projection",
+    signature=("gdn_in_projection(x, w_norm, w_qkvz, w_ba, a_log, dt_bias, "
+               "num_k_heads, head_k_dim, head_v_dim, eps=1e-6)"),
+    returns_doc="""Gated-DeltaNet input projection: zero-centred RMSNorm, fused projection, gates.
+
+Args:
+    x:       (T, Dm)     bfloat16 — the residual stream entering the block.
+    w_norm:  (Dm,)       bfloat16 — ZERO-CENTRED RMSNorm gain; the effective gain is (1 + w_norm).
+    w_qkvz:  (Wq, Dm)    bfloat16 — fused q|k|v|z projection, nn.Linear layout (out, in), where
+                                    Wq = 2*Hk*Dk + 2*Hv*Dv.
+    w_ba:    (2*Hv, Dm)  bfloat16 — fused b|a projection, nn.Linear layout (out, in).
+    a_log:   (Hv,)       float32  — log of the per-head base decay rate; Hv is taken from its length.
+    dt_bias: (Hv,)       float32  — per-head bias added before the softplus.
+    num_k_heads: int              — Hk.
+    head_k_dim:  int              — Dk.
+    head_v_dim:  int              — Dv.
+    eps:     float                — RMSNorm epsilon.
+
+Returns:
+    (q, k, v, z, beta, g) where
+      q:    (T, Hk, Dk) bfloat16 — L2-normalised per head
+      k:    (T, Hk, Dk) bfloat16 — L2-normalised per head
+      v:    (T, Hv, Dv) bfloat16
+      z:    (T, Hv, Dv) bfloat16 — the block's output gate, passed through un-activated
+      beta: (T, Hv)     float32  — delta-rule step size, sigmoid(b)
+      g:    (T, Hv)     float32  — log forget gate, -exp(a_log) * softplus(a + dt_bias)""",
+
+    reference_imports="import torch\nimport torch.nn.functional as F",
+    reference_src='''
+def gdn_in_projection(x, w_norm, w_qkvz, w_ba, a_log, dt_bias,
+                      num_k_heads, head_k_dim, head_v_dim, eps=1e-6):
+    """Norm, project, split, normalise, gate — as separate fp32 steps.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target. The full (T, Wq)
+    projection output is materialised in fp32 and then read again by every split.
+    """
+    T = x.shape[0]
+    Hk, Dk, Dv = num_k_heads, head_k_dim, head_v_dim
+    Hv = a_log.shape[0]
+
+    xf = x.float()
+    h = xf * torch.rsqrt(xf.pow(2).mean(-1, keepdim=True) + eps) * (1.0 + w_norm.float())  # ZERO-CENTRED
+    p = h @ w_qkvz.float().t()                                          # (T, 2*Hk*Dk + 2*Hv*Dv)
+
+    o = 0
+    q = p[:, o:o + Hk * Dk].reshape(T, Hk, Dk); o += Hk * Dk
+    k = p[:, o:o + Hk * Dk].reshape(T, Hk, Dk); o += Hk * Dk
+    v = p[:, o:o + Hv * Dv].reshape(T, Hv, Dv); o += Hv * Dv
+    z = p[:, o:o + Hv * Dv].reshape(T, Hv, Dv)
+
+    q = q * torch.rsqrt(q.pow(2).sum(-1, keepdim=True) + 1e-12)         # per-head L2 normalisation
+    k = k * torch.rsqrt(k.pow(2).sum(-1, keepdim=True) + 1e-12)
+
+    ba = h @ w_ba.float().t()                                           # (T, 2*Hv)
+    beta = torch.sigmoid(ba[:, :Hv])
+    g = -torch.exp(a_log.float()) * F.softplus(ba[:, Hv:] + dt_bias.float())
+    return (q.to(torch.bfloat16), k.to(torch.bfloat16), v.to(torch.bfloat16), z.to(torch.bfloat16),
+            beta.float(), g.float())
+''',
+    make_inputs_src='''
+def _mk(T, Dm, Hk, Dk, Hv, Dv, seed):
+    """Residual stream, the two projections and the gate parameters. `dt_bias` is centred so the softplus
+    argument spans roughly (-2, 2) — the regime where the forget gate is actually data-dependent rather
+    than saturated."""
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+
+    def r(*sh, s=1.0):
+        return (torch.randn(*sh, device="cuda", dtype=torch.float32, generator=gen) * s).to(torch.bfloat16)
+
+    Wq = 2 * Hk * Dk + 2 * Hv * Dv
+    x = r(T, Dm)
+    w_norm = (torch.rand(Dm, device="cuda", generator=gen) - 0.5).to(torch.bfloat16)   # (1 + w) in [.5,1.5]
+    w_qkvz = r(Wq, Dm, s=Dm ** -0.5)
+    w_ba = r(2 * Hv, Dm, s=Dm ** -0.5)
+    a_log = torch.rand(Hv, device="cuda", dtype=torch.float32, generator=gen) * 2.0 - 1.0
+    dt_bias = torch.randn(Hv, device="cuda", dtype=torch.float32, generator=gen) * 0.5
+    return x, w_norm, w_qkvz, w_ba, a_log, dt_bias, Hk, Dk, Dv, 1e-6
+''',
+    flops_src='''
+def canonical_work(T, Dm, Hk, Dk, Hv, Dv):
+    """FLOPs attributed to one input projection, from the SHAPE ALONE.
+
+    Two GEMMs at 2 FLOPs per multiply-add against the same normalised activation: the wide q|k|v|z
+    projection of width 2*Hk*Dk + 2*Hv*Dv, and the tiny b|a projection of width 2*Hv. The RMSNorm, the
+    per-head L2 normalisation, the sigmoid and the softplus are O(T * width) elementwise work and are NOT
+    credited — fusing them is a saving, not extra work you get paid for.
+    """
+    return 2 * T * Dm * (2 * Hk * Dk + 2 * Hv * Dv) + 2 * T * Dm * (2 * Hv)
+''',
+    flops_formula=("canonical_work(T, Dm, Hk, Dk, Hv, Dv) = 2*T*Dm*(2*Hk*Dk + 2*Hv*Dv)  +  2*T*Dm*(2*Hv)\n"
+                   "#                                        q|k|v|z projection            b|a projection"),
+
+    metric="TFLOP/s",
+    compare="tuple",
+    tuple_names=("q", "k", "v", "z", "beta", "g"),
+    tol=7e-3,   # MEASURED: 2.1x the 3.31e-3 worst gap to an independent fused-GEMM implementation
+    shape_names=("T", "Dm", "Hk", "Dk", "Hv", "Dv"),
+    grader_shapes=[(32768, 2048, 16, 128, 32, 128), (16384, 4096, 16, 128, 32, 128),
+                   (49152, 2048, 8, 128, 16, 128), (24576, 2048, 16, 128, 32, 128),
+                   (32768, 2048, 32, 64, 32, 128)],
+    measure_shapes=[(28672, 2048, 16, 128, 32, 128), (12288, 4096, 16, 128, 32, 128),
+                    (40960, 2048, 8, 128, 16, 128), (20480, 2048, 16, 128, 32, 128),
+                    (28672, 2048, 32, 64, 32, 128)],
+    measure_quick_shapes=[(4096, 1024, 8, 128, 8, 128), (2048, 2048, 4, 128, 8, 128),
+                          (8192, 512, 4, 64, 8, 64)],
+    correct_shapes=[(256, 512, 4, 64, 8, 64), (129, 256, 2, 32, 4, 64), (512, 1024, 8, 128, 8, 128),
+                    (64, 128, 1, 64, 2, 64)],
+
+    spec_md="""Everything a gated-DeltaNet block needs, produced from the residual stream in one pass.
+
+**1 — zero-centred RMSNorm.** The gain is stored *centred on zero* and the effective multiplier is
+`1 + w_norm`, so an untrained parameter is the identity and weight decay pulls towards it:
+
+```
+h[t, :] = x[t, :] * rsqrt( mean_c( x[t, c]^2 ) + eps ) * (1 + w_norm)
+```
+
+The mean runs over the full `Dm` feature axis. Note the `1 +`: this is **not** the ordinary RMSNorm gain.
+
+**2 — the two projections**, both from `h`:
+
+```
+p  = h @ w_qkvz.T          # (T, 2*Hk*Dk + 2*Hv*Dv)
+ba = h @ w_ba.T            # (T, 2*Hv)
+```
+
+`p` is split along its last axis, **in this order**, into four contiguous blocks:
+
+```
+q = p[:,                       : Hk*Dk           ].view(T, Hk, Dk)
+k = p[:, Hk*Dk                 : 2*Hk*Dk         ].view(T, Hk, Dk)
+v = p[:, 2*Hk*Dk               : 2*Hk*Dk + Hv*Dv ].view(T, Hv, Dv)
+z = p[:, 2*Hk*Dk + Hv*Dv       :                 ].view(T, Hv, Dv)
+```
+
+`ba` splits into `b = ba[:, :Hv]` and `a = ba[:, Hv:]`.
+
+**3 — per-head L2 normalisation of q and k** (this is what keeps the delta rule stable; it is an L2
+normalisation, **not** an RMSNorm and there is no learned gain):
+
+```
+q[t, h, :] <- q[t, h, :] * rsqrt( sum_d q[t, h, d]^2 + 1e-12 )
+k[t, h, :] <- k[t, h, :] * rsqrt( sum_d k[t, h, d]^2 + 1e-12 )
+```
+
+`v` and `z` are **not** normalised and `z` is **not** activated — the output gate's SiLU happens later, in
+the block's output path, not here.
+
+**4 — the two recurrence gates**, per token and per value head:
+
+```
+beta[t, h] = sigmoid( b[t, h] )                                   # delta-rule step size, in (0, 1)
+g[t, h]    = -exp( a_log[h] ) * softplus( a[t, h] + dt_bias[h] )  # LOG forget gate, <= 0
+```
+
+`softplus(u) = log(1 + exp(u))`, and `exp(g)` is the multiplicative decay the recurrence applies — so `g`
+is always negative and must be produced in fp32, not bf16: it is fed to an exponential downstream and bf16
+rounding of a log-decay is a visible change in the decay itself.
+
+`/app/reference.py` materialises the whole fp32 projection output and then slices it. That is the exact
+specification; it is deliberately simple rather than fast.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `x` | `(T, Dm)` | `bfloat16` | residual stream entering the block |
+| `w_norm` | `(Dm,)` | `bfloat16` | **zero-centred** RMSNorm gain; effective gain is `1 + w_norm` |
+| `w_qkvz` | `(2*Hk*Dk + 2*Hv*Dv, Dm)` | `bfloat16` | fused q\\|k\\|v\\|z projection, `(out, in)` |
+| `w_ba` | `(2*Hv, Dm)` | `bfloat16` | fused b\\|a projection, `(out, in)` |
+| `a_log` | `(Hv,)` | `float32` | log of the per-head base decay |
+| `dt_bias` | `(Hv,)` | `float32` | per-head bias inside the softplus |
+| `num_k_heads` | int | | `Hk` |
+| `head_k_dim` | int | | `Dk` |
+| `head_v_dim` | int | | `Dv`; `Hv` is `len(a_log)` |
+| `eps` | float | | RMSNorm epsilon, default `1e-6` |
+
+**Return a 6-tuple in exactly this order:**
+
+| out | shape | dtype | notes |
+|-----|-------|-------|-------|
+| `q` | `(T, Hk, Dk)` | bf16 | L2-normalised per head |
+| `k` | `(T, Hk, Dk)` | bf16 | L2-normalised per head |
+| `v` | `(T, Hv, Dv)` | bf16 | not normalised |
+| `z` | `(T, Hv, Dv)` | bf16 | not normalised, not activated |
+| `beta` | `(T, Hv)` | **fp32** | |
+| `g` | `(T, Hv)` | **fp32** | negative |
+
+`Hk` divides `Hv` in practice but nothing in the kernel needs that. All inputs are **read-only**. `T` is
+**not** guaranteed to be a multiple of any tile size — the correctness shapes include `T = 129` and
+`T = 64`.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `T`
+(tokens in the micro-batch) in 16384–49152, `Dm` in 2048–4096, `Hk` in 8–32 with `Dk` 64–128, `Hv` in
+16–32 with `Dv` = 128. The fused projection is 3–6x wider than the model dimension, so its output is the
+largest tensor in the block — which is exactly why the epilogue has to stay fused.""",
+
+    correctness_md="""**All six** returned tensors must match the reference (evaluated in fp32) within
+**relative Frobenius error `7e-3`** at every graded shape, including the timed ones; the grader scores the
+**worst** of the six.
+
+That gate is **measured**, and dropping any single piece of this kernel misses it by orders of magnitude:
+skipping the per-head L2 normalisation of `q` and `k` scores **4.8**, using a plain RMSNorm gain `w_norm`
+instead of the zero-centred `1 + w_norm` scores **1.15**, dropping the `-exp(a_log)` head scale from the
+forget gate scores **0.41**, and using `exp` instead of `softplus` inside it scores **2.1** — the closest
+of them is **59x** the tolerance.""",
+
+    perf_md="""One wide GEMM, one skinny GEMM, and an epilogue that a framework implementation turns into
+a dozen full-size passes over HBM.
+
+The wide projection is `(T, Dm) x (Dm, 2*Hk*Dk + 2*Hv*Dv)` and dominates the FLOP count. The skinny one is
+`(T, Dm) x (Dm, 2*Hv)` — 64 output columns against 2048 reduction steps, so on its own it is pure latency;
+it wants to be concatenated onto the wide one (they share the operand `h`) or run as a tail wave rather
+than as its own launch.
+
+`h` itself is worth computing once and keeping: both GEMMs read it, and the RMSNorm that produces it is a
+row reduction over `Dm` that fits in a block. Writing `h` to HBM and reading it back twice is one avoidable
+round trip of a `(T, Dm)` tensor.
+
+The epilogue is where the naive version loses. Splitting `p` into four views and normalising two of them
+means, done separately, four reads and four writes of a tensor several times larger than `x`. Fused, the
+L2 normalisation is a reduction over `Dk = 64..128` contiguous lanes of an accumulator tile that is
+**already in registers** when the GEMM epilogue runs — one warp-level reduction, no HBM round trip at all.
+
+`beta` and `g` come out of only 64 columns; compute them in the same launch, and remember `softplus` needs
+the numerically stable form (`max(u,0) + log1p(exp(-|u|))`) because `a + dt_bias` is unbounded.""",
+
+    precision_md="""Inputs are **bfloat16** and the four projected outputs are returned in bf16, but
+`beta` and `g` **must be fp32**: they parameterise a recurrence that runs for thousands of steps, and `g`
+in particular is a log-decay that gets exponentiated downstream, so bf16 rounding of it is a change to the
+model, not a rounding of an activation.
+
+Do the RMSNorm reduction, the L2 reduction, the sigmoid and the softplus in **fp32**; bf16 tensor-core
+GEMMs with fp32 accumulate are exactly what this task expects.
+
+**fp8 is not appropriate here**: the activations and weights arrive in bf16 and re-quantising them is an
+approximation of the specified computation, not an implementation of it.
+
+**Where the tolerance comes from.** `1e-2` is measured, not inherited. A second, independent implementation
+— one fused `[w_qkvz ; w_ba]` GEMM instead of two, bf16 operands with fp32 accumulate, the RMSNorm computed
+from a `float()` upcast in a different order, and the L2 normalisation done as a `norm()` divide rather
+than an `rsqrt` multiply — differs from this fp32 reference by a worst relative Frobenius error of
+**3.31e-3** across the correctness shapes and a full-size graded shape, over several seeds. The tolerance
+is **2.1x** that. It is flat in the problem size (3.19e-3 to 3.31e-3 everywhere tried) because it is
+nothing but the bf16 rounding of the returned tensors; an error that *grows* with `T` means an accumulator
+is too narrow, not that the gate is too tight.""",
+).validate()

tools/factory/specs/qwen3_next_gdn_inproj_backward.py

@@ -0,0 +1,286 @@
+"""Spec for `qwen3-next-gdn-inproj-backward` — the training-side backward of the Qwen3-Next gated-DeltaNet
+input projection (zero-centred RMSNorm, fused projection, per-head L2 norm, sigmoid/softplus gates)."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+_FWD = '''
+def _gdn_in_projection(x, w_norm, w_qkvz, w_ba, a_log, dt_bias, Hk, Dk, Dv, eps):
+    """The fp32 forward of `qwen3-next-gdn-inproj`, differentiable. Autograd through THIS defines
+    every gradient this task asks for."""
+    T = x.shape[0]
+    Hv = a_log.shape[0]
+    h = x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + eps) * (1.0 + w_norm)   # ZERO-CENTRED RMSNorm
+    p = h @ w_qkvz.t()
+    o = 0
+    q = p[:, o:o + Hk * Dk].reshape(T, Hk, Dk); o += Hk * Dk
+    k = p[:, o:o + Hk * Dk].reshape(T, Hk, Dk); o += Hk * Dk
+    v = p[:, o:o + Hv * Dv].reshape(T, Hv, Dv); o += Hv * Dv
+    z = p[:, o:o + Hv * Dv].reshape(T, Hv, Dv)
+    q = q * torch.rsqrt(q.pow(2).sum(-1, keepdim=True) + 1e-12)                   # per-head L2 norm
+    k = k * torch.rsqrt(k.pow(2).sum(-1, keepdim=True) + 1e-12)
+    ba = h @ w_ba.t()
+    beta = torch.sigmoid(ba[:, :Hv])
+    g = -torch.exp(a_log) * F.softplus(ba[:, Hv:] + dt_bias)
+    return q, k, v, z, beta, g
+
+
+def gdn_in_projection_backward(x, w_norm, w_qkvz, w_ba, a_log, dt_bias,
+                               dq, dk, dv, dz, dbeta, dg,
+                               num_k_heads, head_k_dim, head_v_dim, eps=1e-6):
+    """The baseline re-runs the fp32 forward under autograd and lets it differentiate itself."""
+    ins = [t.detach().clone().float().requires_grad_(True)
+           for t in (x, w_norm, w_qkvz, w_ba, a_log, dt_bias)]
+    outs = _gdn_in_projection(*ins, num_k_heads, head_k_dim, head_v_dim, eps)
+    gs = [t.float() for t in (dq, dk, dv, dz, dbeta, dg)]
+    return torch.autograd.grad(outs, ins, gs)
+'''
+
+SPEC = TaskSpec(
+    name="qwen3-next-gdn-inproj-backward",
+    title="Write a fast backward kernel for the gated-DeltaNet input projection",
+    blurb=("Differentiating the Qwen3-Next gated-DeltaNet input projection is four separate backward "
+           "problems glued together: a per-head L2 normalisation (whose Jacobian is a rank-1 correction, "
+           "not a scale), a sigmoid and a softplus feeding a log-decay gate, one wide and one skinny "
+           "projection, and a zero-centred RMSNorm whose gain gradient is a reduction over every token. "
+           "Autograd runs it as thirty kernels and rebuilds the (T, 12k) projection output twice."),
+    keywords=["mle", "kernel-generation", "qwen3-next", "gated-deltanet", "backward", "training",
+              "rmsnorm", "l2-norm", "gemm", "compute-bound"],
+    module="gdn_inproj_bwd.py",
+    func="gdn_in_projection_backward",
+    signature=("gdn_in_projection_backward(x, w_norm, w_qkvz, w_ba, a_log, dt_bias, "
+               "dq, dk, dv, dz, dbeta, dg, num_k_heads, head_k_dim, head_v_dim, eps=1e-6)"),
+    returns_doc="""Backward of the gated-DeltaNet input projection.
+
+Args:
+    x:       (T, Dm)     bfloat16 — the residual stream saved by the forward.
+    w_norm:  (Dm,)       bfloat16 — zero-centred RMSNorm gain; effective gain is (1 + w_norm).
+    w_qkvz:  (Wq, Dm)    bfloat16 — fused q|k|v|z projection, Wq = 2*Hk*Dk + 2*Hv*Dv.
+    w_ba:    (2*Hv, Dm)  bfloat16 — fused b|a projection.
+    a_log:   (Hv,)       float32  — log of the per-head base decay.
+    dt_bias: (Hv,)       float32  — per-head bias inside the softplus.
+    dq, dk:  (T, Hk, Dk) bfloat16 — incoming gradients w.r.t. the L2-NORMALISED q and k.
+    dv, dz:  (T, Hv, Dv) bfloat16 — incoming gradients w.r.t. v and z.
+    dbeta:   (T, Hv)     float32  — incoming gradient w.r.t. beta.
+    dg:      (T, Hv)     float32  — incoming gradient w.r.t. the log forget gate g.
+    num_k_heads, head_k_dim, head_v_dim: int — Hk, Dk, Dv.  Hv is len(a_log).
+    eps:     float                — RMSNorm epsilon.
+
+Returns:
+    (dx, dw_norm, dw_qkvz, dw_ba, da_log, ddt_bias) with shapes
+    (T, Dm), (Dm,), (Wq, Dm), (2*Hv, Dm), (Hv,), (Hv,).""",
+
+    reference_imports="import torch\nimport torch.nn.functional as F",
+    reference_src=_FWD,
+    make_inputs_src='''
+def _mk(T, Dm, Hk, Dk, Hv, Dv, seed):
+    """Saved forward inputs plus the six incoming gradients.
+
+    `dq` and `dk` are NOT pure noise: each is given a component ALONG the (normalised) q or k it belongs
+    to, because that radial component is exactly what the L2-normalisation Jacobian annihilates. A
+    gradient drawn from isotropic noise would put only 1/sqrt(Dk) of its energy there and would barely
+    exercise the term. `dt_bias` is centred so the softplus argument spans roughly (-2, 2), the regime
+    where the forget gate is genuinely data-dependent.
+    """
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+
+    def r(*sh, s=1.0):
+        return (torch.randn(*sh, device="cuda", dtype=torch.float32, generator=gen) * s).to(torch.bfloat16)
+
+    Wq = 2 * Hk * Dk + 2 * Hv * Dv
+    x = r(T, Dm)
+    w_norm = (torch.rand(Dm, device="cuda", generator=gen) - 0.5).to(torch.bfloat16)
+    w_qkvz = r(Wq, Dm, s=Dm ** -0.5)
+    w_ba = r(2 * Hv, Dm, s=Dm ** -0.5)
+    a_log = torch.rand(Hv, device="cuda", dtype=torch.float32, generator=gen) * 2.0 - 1.0
+    dt_bias = torch.randn(Hv, device="cuda", dtype=torch.float32, generator=gen) * 0.5
+
+    # the forward q/k directions, so the incoming gradient can be given a radial component
+    xf = x.float()
+    h = (xf * torch.rsqrt(xf.pow(2).mean(-1, keepdim=True) + 1e-6) * (1.0 + w_norm.float())).to(
+        torch.bfloat16)
+    qk = (h @ w_qkvz[:2 * Hk * Dk].t()).float().reshape(T, 2 * Hk, Dk)
+    direction = qk * torch.rsqrt(qk.pow(2).sum(-1, keepdim=True) + 1e-12)
+    base = torch.randn(T, 2 * Hk, Dk, device="cuda", dtype=torch.float32, generator=gen)
+    gqk = base + direction * base.norm(dim=-1, keepdim=True)          # ~half the energy is radial
+    dq = gqk[:, :Hk].contiguous().to(torch.bfloat16)
+    dk = gqk[:, Hk:].contiguous().to(torch.bfloat16)
+    del xf, h, qk, direction, base, gqk
+
+    dv, dz = r(T, Hv, Dv), r(T, Hv, Dv)
+    dbeta = torch.randn(T, Hv, device="cuda", dtype=torch.float32, generator=gen)
+    dg = torch.randn(T, Hv, device="cuda", dtype=torch.float32, generator=gen)
+    return (x, w_norm, w_qkvz, w_ba, a_log, dt_bias, dq, dk, dv, dz, dbeta, dg, Hk, Dk, Dv, 1e-6)
+''',
+    flops_src='''
+def canonical_work(T, Dm, Hk, Dk, Hv, Dv):
+    """FLOPs attributed to one backward call, from the SHAPE ALONE.
+
+    THREE passes of each projection shape, at 2 FLOPs per multiply-add:
+      1. recomputing p = h @ w_qkvz.T and ba = h @ w_ba.T (the pre-normalisation q and k are NOT
+         arguments, and the L2 backward needs them)
+      2. dh      = dp @ w_qkvz  +  dba @ w_ba
+      3. dw_qkvz = dp.T @ h     and dw_ba = dba.T @ h
+    Everything else — the L2-normalisation Jacobian, the sigmoid and softplus derivatives, the RMSNorm
+    backward and the dw_norm / da_log / ddt_bias reductions — is O(T * width) elementwise work and is NOT
+    credited.
+    """
+    return 6 * T * Dm * (2 * Hk * Dk + 2 * Hv * Dv + 2 * Hv)
+''',
+    flops_formula=("canonical_work(T, Dm, Hk, Dk, Hv, Dv) = 6 * T * Dm * (2*Hk*Dk + 2*Hv*Dv + 2*Hv)\n"
+                   "#   = 3 passes (recompute p/ba, dh, dw) over both projection shapes"),
+
+    metric="TFLOP/s",
+    compare="tuple",
+    tuple_names=("dx", "dw_norm", "dw_qkvz", "dw_ba", "da_log", "ddt_bias"),
+    tol=2e-2,   # MEASURED: 2.4x the 8.4e-3 worst gap to an independent hand-written bf16 backward
+    shape_names=("T", "Dm", "Hk", "Dk", "Hv", "Dv"),
+    grader_shapes=[(16384, 2048, 16, 128, 32, 128), (8192, 4096, 16, 128, 32, 128),
+                   (24576, 2048, 8, 128, 16, 128), (12288, 2048, 16, 128, 32, 128),
+                   (16384, 2048, 32, 64, 32, 128)],
+    measure_shapes=[(14336, 2048, 16, 128, 32, 128), (7168, 4096, 16, 128, 32, 128),
+                    (20480, 2048, 8, 128, 16, 128), (10240, 2048, 16, 128, 32, 128),
+                    (14336, 2048, 32, 64, 32, 128)],
+    measure_quick_shapes=[(2048, 1024, 8, 128, 8, 128), (1024, 2048, 4, 128, 8, 128),
+                          (4096, 512, 4, 64, 8, 64)],
+    correct_shapes=[(256, 512, 4, 64, 8, 64), (257, 256, 2, 32, 4, 64), (512, 1024, 8, 128, 8, 128),
+                    (192, 128, 2, 64, 4, 64)],
+
+    spec_md="""The forward being differentiated is the gated-DeltaNet input projection:
+
+```
+h        = x * rsqrt(mean_c(x^2) + eps) * (1 + w_norm)         # ZERO-CENTRED RMSNorm
+p        = h @ w_qkvz.T                                        # (T, 2*Hk*Dk + 2*Hv*Dv)
+ba       = h @ w_ba.T                                          # (T, 2*Hv)
+qr,kr,v,z= split(p)  in that order, widths Hk*Dk, Hk*Dk, Hv*Dv, Hv*Dv
+q        = qr * rsqrt(sum_d qr^2 + 1e-12)                      # per-head L2 normalisation
+k        = kr * rsqrt(sum_d kr^2 + 1e-12)
+beta     = sigmoid(ba[:, :Hv])
+g        = -exp(a_log) * softplus(ba[:, Hv:] + dt_bias)
+```
+
+You get `dq, dk, dv, dz, dbeta, dg` and must return the gradient w.r.t. `x`, `w_norm`, `w_qkvz`, `w_ba`,
+`a_log` and `dt_bias`.
+
+**The L2 normalisation is the piece that catches people.** With `r = rsqrt(sum_d qr^2 + 1e-12)` and `q` the
+*normalised* output, the Jacobian is a rank-1 correction, not a scale:
+
+```
+dqr[t,h,:] = r[t,h] * ( dq[t,h,:] - q[t,h,:] * dot( dq[t,h,:], q[t,h,:] ) )
+```
+
+Multiplying `dq` by `r` and stopping is wrong by a term of the same magnitude.
+
+**The gates**, with `u = ba[:, Hv:] + dt_bias`:
+
+```
+db[t,h]      = dbeta[t,h] * beta[t,h] * (1 - beta[t,h])
+da[t,h]      = dg[t,h] * ( -exp(a_log[h]) ) * sigmoid(u[t,h])       # d softplus / du = sigmoid(u)
+da_log[h]    = sum_t dg[t,h] * g[t,h]                               # since dg/d a_log = g itself
+ddt_bias[h]  = sum_t da[t,h]
+```
+
+**The projections**, with `dp = concat(dqr, dkr, dv, dz)` and `dba = concat(db, da)`:
+
+```
+dh      = dp @ w_qkvz + dba @ w_ba          # (T, Dm)
+dw_qkvz = dp.T @ h                          # (Wq, Dm)
+dw_ba   = dba.T @ h                         # (2*Hv, Dm)
+```
+
+**The zero-centred RMSNorm**, with `rstd[t] = rsqrt(mean_c(x[t]^2) + eps)` and `xhat = x * rstd`:
+
+```
+dw_norm[c]  = sum_t dh[t,c] * xhat[t,c]                             # gain is (1 + w_norm), so d/dw = xhat
+dxhat[t,c]  = dh[t,c] * (1 + w_norm[c])
+dx[t,c]     = ( dxhat[t,c] - xhat[t,c] * mean_c( dxhat[t,:] * xhat[t,:] ) ) * rstd[t]
+```
+
+Note what is **not** an argument: `h`, `p`, and the pre-normalisation `qr`/`kr` were all forward
+temporaries. They must be recomputed — `h` is cheap, `p` costs a full matmul, and the L2 backward cannot be
+written without `qr` (or equivalently without `q` and `r`).
+
+`/app/reference.py` re-runs the fp32 forward under autograd and differentiates it. That is the exact
+specification; it is deliberately simple rather than fast.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `x` | `(T, Dm)` | `bfloat16` | residual stream saved by the forward |
+| `w_norm` | `(Dm,)` | `bfloat16` | zero-centred gain; effective gain is `1 + w_norm` |
+| `w_qkvz` | `(Wq, Dm)` | `bfloat16` | fused projection, `Wq = 2*Hk*Dk + 2*Hv*Dv` |
+| `w_ba` | `(2*Hv, Dm)` | `bfloat16` | fused gate projection |
+| `a_log`, `dt_bias` | `(Hv,)` | `float32` | forget-gate parameters |
+| `dq`, `dk` | `(T, Hk, Dk)` | `bfloat16` | gradients w.r.t. the **normalised** q and k |
+| `dv`, `dz` | `(T, Hv, Dv)` | `bfloat16` | gradients w.r.t. v and z |
+| `dbeta`, `dg` | `(T, Hv)` | `float32` | gradients w.r.t. the two gates |
+| `num_k_heads`, `head_k_dim`, `head_v_dim` | int | | `Hk`, `Dk`, `Dv`; `Hv = len(a_log)` |
+| `eps` | float | | RMSNorm epsilon, default `1e-6` |
+
+**Return a 6-tuple in exactly this order:** `dx (T, Dm)`, `dw_norm (Dm,)`, `dw_qkvz (Wq, Dm)`,
+`dw_ba (2*Hv, Dm)`, `da_log (Hv,)`, `ddt_bias (Hv,)`.
+
+`dx` may be bf16 or fp32; the five parameter gradients should be **fp32** — each is a reduction over every
+token in the micro-batch. All inputs are **read-only**. `T` is **not** guaranteed to be a multiple of any
+tile size (the correctness shapes include `T = 129`).""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `T` in
+8192–24576, `Dm` in 2048–4096, `Hk` in 8–32 with `Dk` 64–128, `Hv` in 16–32 with `Dv` = 128. The projection
+is 3–6x wider than the model dimension, so `dp` is the largest tensor in the problem and every pass over it
+that you can avoid is worth more than any single matmul optimisation.""",
+
+    correctness_md="""**All six** returned tensors must match the reference (evaluated in fp32) within
+**relative Frobenius error `2e-2`** at every graded shape, including the timed ones; the grader scores the
+**worst** of the six, so a perfect `dw_qkvz` does not rescue a wrong `da_log`.
+
+That gate is **measured**, and dropping a piece of this backward misses it by orders of magnitude:
+multiplying `dq` by the L2 scale without the rank-1 `- q * dot(dq, q)` correction scores **0.59**, using a
+plain RMSNorm gain instead of the zero-centred `1 + w_norm` scores **2.0**, and using `softplus(u)` where
+`g` itself belongs in `da_log` scores **1.5** — the closest is **29x** the tolerance.""",
+
+    perf_md="""Three passes over the wide projection shape and a large amount of elementwise work that a
+framework implementation spills to HBM between every step.
+
+The `(T, Wq)` tensors are the problem. `p` has to be rebuilt (the L2 backward needs the *pre*-normalisation
+q and k), `dp` has to be formed, and both are 3–6x wider than `x`. A fused kernel recomputes the slice of
+`p` a tile needs, applies the L2 Jacobian, and hands the resulting `dp` tile straight to the next matmul
+without ever writing it; the naive version writes `p`, reads it, writes `dp`, reads it twice more.
+
+`dh = dp @ w_qkvz + dba @ w_ba` is one accumulation, not two matmuls plus an add — the two right-hand
+operands can be concatenated exactly as the forward's two projections can.
+
+`dw_qkvz = dp.T @ h` is the transposed-A GEMM that dominates: `Wq x Dm` output, `T` reduction. Split-K
+across token tiles with an fp32 accumulator is the usual answer; be careful that the split-K reduction
+stays in fp32.
+
+The L2 Jacobian is a per-head dot product over `Dk = 64..128` contiguous lanes — a warp reduction on a tile
+that is already in registers, not a separate kernel. `da_log` and `ddt_bias` are reductions over `T` into
+`Hv <= 32` numbers: a per-block partial then one cross-block pass, never an atomic per element.
+
+`dw_norm` and the `dx` row projection both need `xhat`, which is cheap to recompute from `x` — cheaper than
+storing it.""",
+
+    precision_md="""Inputs are **bfloat16** for the activations and **float32** for the gate parameters and
+their gradients. Do every accumulation, the sigmoid, the softplus derivative and both normalisation
+backwards in **fp32**; bf16 tensor-core matmuls with fp32 accumulate are what this task expects.
+
+The parameter gradients (`dw_norm`, `dw_qkvz`, `dw_ba`, `da_log`, `ddt_bias`) are reductions over up to
+24576 tokens. Accumulate them in fp32 — a bf16 accumulator loses the tail of that sum, and the error would
+*grow* with `T`, which is exactly the signature the faithfulness clause below rejects.
+
+**fp8 is not appropriate here**: the saved activations arrive in bf16 and re-quantising them is an
+approximation of the specified computation.
+
+**Where the tolerance comes from.** `1e-2` is measured, not inherited. A second, independent implementation
+— the analytic backward written out by hand, one fused `[w_qkvz ; w_ba]` matmul instead of two, bf16
+operands with fp32 accumulate, and the reductions ordered differently from autograd's — differs from this
+fp32 autograd reference by a worst relative Frobenius error of **8.4e-3** over 20 seeds at the correctness
+shapes and 6 seeds at a full-size graded shape. The tolerance is **2.4x** that.
+
+That worst case is always `da_log` or `ddt_bias` at the *smallest* correctness shapes, where the reduction
+runs over only a few hundred tokens and partial cancellation inflates the relative norm of a `(Hv,)`
+vector. At graded sizes every output sits at **3.0e-3 or below** — `dx` at 1.7e-3, `dw_qkvz` at 2.4e-3 —
+which is the plain bf16 rounding floor. If your error *grows* with `T` you have a narrow accumulator, not
+a tight gate.""",
+).validate()

tools/factory/specs/qwen3_next_output_gate_backward.py

@@ -0,0 +1,229 @@
+"""Spec for `qwen3-next-output-gate-backward` — the training-side backward of the Qwen3-Next gated attention
+output path (per-head RMSNorm -> SiLU output gate -> output projection)."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+# the forward, written once and used as the differentiable spec the reference backprops through
+_FWD = '''
+def _gated_output(attn_out, x, w_norm, w_gate, w_out, eps=1e-6):
+    """Per-head RMSNorm, SiLU output gate, output projection — the fp32 forward, differentiable.
+
+    Autograd through THIS defines every gradient this task asks for.
+    """
+    T, H, Dh = attn_out.shape
+    a = attn_out.float()
+    n = a * torch.rsqrt(a.pow(2).mean(-1, keepdim=True) + eps) * w_norm.float()   # RMSNorm over Dh, per head
+    g = x.float() @ w_gate.float().t()                                           # (T, H*Dh) gate logits
+    y = n.reshape(T, H * Dh) * (g * torch.sigmoid(g))                            # SiLU gate
+    return y @ w_out.float().t()                                                 # (T, Dm)
+
+
+def gated_output_backward(attn_out, x, w_norm, w_gate, w_out, do, eps=1e-6):
+    """The baseline runs the fp32 forward again under autograd and lets it differentiate itself."""
+    ins = [t.detach().clone().requires_grad_(True) for t in (attn_out, x, w_norm, w_gate, w_out)]
+    o = _gated_output(*ins, eps=eps)
+    return torch.autograd.grad(o, ins, do.float())
+'''
+
+SPEC = TaskSpec(
+    name="qwen3-next-output-gate-backward",
+    title="Write a fast backward kernel for the gated attention-output path",
+    blurb=("The training-side counterpart of the Qwen3-Next gated attention output: an attention result is "
+           "RMS-normalised per head, multiplied by a SiLU gate projected from the block input, and "
+           "projected back to the model width. Differentiating it means pushing one gradient back through "
+           "a projection, splitting it between the normalised activation and the gate, and then back "
+           "through BOTH a per-head normaliser and a second projection — five matmuls and two reductions "
+           "that autograd runs as two dozen full-size kernels with the gate logits recomputed in the "
+           "middle."),
+    keywords=["mle", "kernel-generation", "qwen3-next", "gated-attention", "output-gate", "backward",
+              "rmsnorm", "silu", "training", "gemm", "compute-bound"],
+    module="gate_bwd.py",
+    func="gated_output_backward",
+    signature="gated_output_backward(attn_out, x, w_norm, w_gate, w_out, do, eps=1e-6)",
+    returns_doc="""Backward pass of RMSNorm -> SiLU output gate -> output projection.
+
+Args:
+    attn_out: (T, H, Dh)   bfloat16 — per-head attention output saved by the forward.
+    x:        (T, Dm)      bfloat16 — the block input, the gate's source, saved by the forward.
+    w_norm:   (Dh,)        bfloat16 — per-head RMSNorm gain, shared by all H heads.
+    w_gate:   (H*Dh, Dm)   bfloat16 — gate projection, nn.Linear layout (out, in).
+    w_out:    (Dm, H*Dh)   bfloat16 — output projection, nn.Linear layout (out, in).
+    do:       (T, Dm)      bfloat16 — incoming gradient w.r.t. the forward output.
+    eps:      float                 — the RMSNorm epsilon used by the forward.
+
+Returns:
+    (d_attn_out, dx, dw_norm, dw_gate, dw_out) with shapes
+    (T, H, Dh), (T, Dm), (Dh,), (H*Dh, Dm), (Dm, H*Dh).""",
+
+    reference_imports="import torch",
+    reference_src=_FWD,
+    make_inputs_src='''
+def _mk(T, Dm, H, Dh, seed):
+    """Saved forward activations, weights and the incoming gradient. Each head gets its OWN magnitude
+    (a spread of e^-1.5 .. e^1.5), which is what a real attention output looks like and what makes the
+    per-head normaliser's gradient different from a whole-row one's."""
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+
+    def r(*sh, s=1.0):
+        return (torch.randn(*sh, device="cuda", dtype=torch.float32, generator=gen) * s).to(torch.bfloat16)
+
+    hs = torch.exp(1.5 * (2 * torch.rand(H, 1, device="cuda", generator=gen) - 1))
+    attn_out = (torch.randn(T, H, Dh, device="cuda", generator=gen) * hs).to(torch.bfloat16)
+    x = r(T, Dm)
+    w_norm = (0.5 + torch.rand(Dh, device="cuda", generator=gen)).to(torch.bfloat16)
+    w_gate = r(H * Dh, Dm, s=Dm ** -0.5)
+    w_out = r(Dm, H * Dh, s=(H * Dh) ** -0.5)
+    do = r(T, Dm)
+    return attn_out, x, w_norm, w_gate, w_out, do, 1e-6
+''',
+    flops_src='''
+def canonical_work(T, Dm, H, Dh):
+    """FLOPs attributed to one backward call, from the SHAPE ALONE.
+
+    FIVE (T, Dm) x (Dm, H*Dh)-shaped matmuls at 2 FLOPs per multiply-add, all of the same size:
+      1. recomputing the gate logits g = x @ w_gate.T  (g is NOT an argument, so it must be rebuilt)
+      2. dy      = do @ w_out
+      3. dw_out  = do.T @ y
+      4. dx      = dg @ w_gate
+      5. dw_gate = dg.T @ x
+    The per-head RMSNorm backward, the SiLU derivative and the dw_norm reduction are O(T*H*Dh) elementwise
+    work and are NOT credited — fusing them is a saving, not extra work you get paid for.
+    """
+    return 10 * T * Dm * (H * Dh)
+''',
+    flops_formula=("canonical_work(T, Dm, H, Dh) = 10 * T * Dm * (H*Dh)\n"
+                   "#   = 5 matmuls of that shape: recompute g, dy, dw_out, dx, dw_gate"),
+
+    metric="TFLOP/s",
+    compare="tuple",
+    tuple_names=("d_attn_out", "dx", "dw_norm", "dw_gate", "dw_out"),
+    tol=8e-3,   # MEASURED: 2.25x the 3.55e-3 worst gap to an independent hand-written bf16 backward
+    shape_names=("T", "Dm", "H", "Dh"),
+    grader_shapes=[(16384, 4096, 32, 128), (8192, 8192, 32, 128), (16384, 6144, 24, 128),
+                   (12288, 4096, 48, 128), (24576, 4096, 16, 128)],
+    measure_shapes=[(14336, 4096, 32, 128), (7168, 8192, 32, 128), (14336, 6144, 24, 128),
+                    (10240, 4096, 48, 128), (20480, 4096, 16, 128)],
+    measure_quick_shapes=[(2048, 2048, 16, 128), (4096, 1024, 8, 128), (1024, 4096, 16, 64)],
+    correct_shapes=[(256, 512, 4, 64), (129, 256, 6, 32), (512, 1024, 8, 128), (64, 128, 1, 64)],
+
+    spec_md="""The forward this differentiates is the Qwen3-Next gated attention output path:
+
+```
+n[t, h, :] = attn_out[t, h, :] * rsqrt( mean_d( attn_out[t, h, d]^2 ) + eps ) * w_norm   # per HEAD
+g          = x @ w_gate.T                                   # (T, H*Dh) gate logits
+y          = n.reshape(T, H*Dh) * silu(g)                   # silu(z) = z * sigmoid(z)
+out        = y @ w_out.T                                    # (T, Dm)
+```
+
+The RMS mean runs over the `Dh` channels of **one head**, not over the flattened row, and `w_norm` is a
+single `(Dh,)` gain shared by every head. The head-major flattening lines `g`'s channel `h*Dh + d` up with
+head `h`, channel `d`.
+
+You are given `do = dL/dout` and must return the gradient w.r.t. **everything the forward consumed**:
+
+```
+dy         = do @ w_out                                     # (T, H*Dh)
+dw_out     = do.T @ y                                       # (Dm, H*Dh)
+dg         = dy * n * dsilu(g)      where dsilu(z) = sigmoid(z) * (1 + z * (1 - sigmoid(z)))
+dx         = dg @ w_gate                                    # (T, Dm)
+dw_gate    = dg.T @ x                                       # (H*Dh, Dm)
+dn         = dy * silu(g)                                   # (T, H*Dh) -> view (T, H, Dh)
+```
+
+and then back through the per-head RMSNorm. Writing `r[t,h] = rsqrt(mean_d(a[t,h,d]^2) + eps)` and
+`xhat[t,h,d] = a[t,h,d] * r[t,h]`:
+
+```
+dxhat[t,h,d]     = dn[t,h,d] * w_norm[d]
+c[t,h]           = mean_d( dxhat[t,h,:] * xhat[t,h,:] )
+d_attn_out[t,h,d]= ( dxhat[t,h,d] - xhat[t,h,d] * c[t,h] ) * r[t,h]
+dw_norm[d]       = sum over t and h of dn[t,h,d] * xhat[t,h,d]
+```
+
+Note what is **not** an argument: the gate logits `g`, the normalised activation `n` and the gated product
+`y` were all forward temporaries. They have to be recomputed — `g` costs a full matmul, `n` and `y` are
+elementwise on top of it.
+
+`dw_norm` is a reduction over **both** `t` and `h`: every head contributes to the same `(Dh,)` gain.
+
+`/app/reference.py` re-runs the fp32 forward under autograd and differentiates it. That is the exact
+specification; it is deliberately simple rather than fast.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `attn_out` | `(T, H, Dh)` | `bfloat16` | per-head attention output saved by the forward |
+| `x` | `(T, Dm)` | `bfloat16` | block input, the gate's source |
+| `w_norm` | `(Dh,)` | `bfloat16` | per-head RMSNorm gain, **shared** by all `H` heads |
+| `w_gate` | `(H*Dh, Dm)` | `bfloat16` | gate projection, `nn.Linear` layout `(out, in)` |
+| `w_out` | `(Dm, H*Dh)` | `bfloat16` | output projection, `nn.Linear` layout `(out, in)` |
+| `do` | `(T, Dm)` | `bfloat16` | incoming gradient w.r.t. the forward output |
+| `eps` | float | | RMSNorm epsilon, default `1e-6` |
+
+**Return a 5-tuple in exactly this order:**
+
+| out | shape | notes |
+|-----|-------|-------|
+| `d_attn_out` | `(T, H, Dh)` | bf16 or fp32 |
+| `dx` | `(T, Dm)` | bf16 or fp32 |
+| `dw_norm` | `(Dh,)` | fp32 recommended — it is a reduction over `T*H` terms |
+| `dw_gate` | `(H*Dh, Dm)` | fp32 recommended |
+| `dw_out` | `(Dm, H*Dh)` | fp32 recommended |
+
+All inputs are **read-only**; nothing is updated in place. `T` is **not** guaranteed to be a multiple of any
+tile size — the correctness shapes include `T = 129` and `T = 64` — and `H` may be as small as 1.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `T`
+(tokens in the micro-batch) in 8192–24576, `Dm` in 4096–8192, `H` in 16–48, `Dh` = 128, with `H*Dh` between
+2048 and 6144. All five matmuls are the same `(T, Dm) x (Dm, H*Dh)` shape, so this is a compute-bound task
+where the entire question is how much of the elementwise work you can hide inside them.""",
+
+    correctness_md="""**All five** returned tensors must match the reference (evaluated in fp32) within
+**relative Frobenius error `8e-3`** at every graded shape, including the timed ones; the grader scores the
+**worst** of the five, so a perfect `dx` does not rescue a wrong `dw_norm`.
+
+That gate is **measured**, and implementations that skip a piece of this backward miss it by orders of
+magnitude: using `silu(g)` where the SiLU *derivative* belongs scores **0.66**, dropping the
+`- xhat * c` projection term from the RMSNorm backward scores **0.088**, normalising over the flattened
+`H*Dh` row instead of per head scores **0.40**, and forming `dw_norm` without the `xhat` factor scores
+**1.23** — the closest of them is still **11x** the tolerance.""",
+
+    perf_md="""Five matmuls of identical shape and a pile of elementwise work between them. The elementwise
+work is what decides the score, because done naively it costs more HBM traffic than the matmuls do.
+
+The dependency chain is short: `g` (recompute), then `dy` and `dw_out`, then `dg`, then `dx` and `dw_gate`.
+`dy = do @ w_out` and `dw_out = do.T @ y` share the operand `do`; `dx = dg @ w_gate` and `dw_gate = dg.T @ x`
+share `dg`. Each pair wants to be a single pass over its shared operand, not two.
+
+Everything in the middle — recomputing `n` from `attn_out`, `silu(g)` and its derivative, the products that
+form `dn` and `dg`, the per-head RMSNorm backward and the `dw_norm` reduction — touches `(T, H*Dh)` tensors.
+An autograd-shaped implementation writes each of those to HBM and reads it back; a fused one produces `dg`
+in registers directly from the `dy` tile and never materialises `n`, `y` or `silu(g)` at all.
+
+Two reductions need care. `dw_norm` sums over `T*H` — a per-head partial in registers, then a cross-block
+reduction; do **not** run it as an atomic per element. The RMSNorm backward's `c[t,h]` is a reduction over
+only `Dh = 128` lanes, so it belongs inside a warp, not in a separate kernel.
+
+Recomputing `g` is unavoidable but it is also an opportunity: it is the same operand `x` that `dw_gate`
+consumes, so a kernel that keeps `x` tiles resident pays for the load once.""",
+
+    precision_md="""Inputs are **bfloat16**; do every accumulation, the sigmoid and the SiLU derivative in
+**fp32**. bf16 tensor-core matmuls with fp32 accumulate are exactly what this task expects.
+
+`dw_norm` is a sum over `T*H` terms — at the graded shapes that is up to a million contributions to each of
+128 numbers, and a bf16 accumulator loses it. Accumulate in fp32 (or better, pairwise/tree in fp32).
+
+**fp8 is not appropriate here**: the saved activations arrive in bf16, and re-quantising them to fp8 is an
+approximation of the specified computation rather than an implementation of it.
+
+**Where the tolerance comes from.** `2e-2` is measured, not inherited. A second, independent implementation
+— the analytic backward written out by hand, matmuls in bf16 with fp32 accumulate, the RMSNorm backward
+reduced in a different order, `dw_norm` accumulated as a two-stage fp32 tree — differs from this fp32
+autograd reference by a worst relative Frobenius error of **3.55e-3** across the correctness shapes and a
+full-size graded shape, over several seeds. The tolerance is **2.25x** that. The number is flat in the
+problem size (3.37e-3 to 3.55e-3 everywhere tried), because it is the bf16 rounding of the matmul operands
+and of the returned tensors and nothing else — which is the floor for any bf16 kernel. An error that
+*grows* with `T` means an accumulator somewhere is too narrow, not that the tolerance is too tight.""",
+).validate()

tools/factory/specs/rmsnorm_quant_transpose.py

@@ -0,0 +1,242 @@
+"""Spec for `rmsnorm-quant-transpose-fused` — RMSNorm fused with the FP8 cast-transpose an FP8 training step needs."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="rmsnorm-quant-transpose-fused",
+    title="Write a fast fused RMSNorm + FP8 cast-transpose kernel",
+    blurb=("An FP8 training step needs each normalised activation matrix twice: quantised along the feature "
+           "axis for the forward GEMM, and transposed and quantised along the token axis for the weight "
+           "gradient. Both copies come from the SAME RMS-normalised values, so the column-group scales "
+           "depend on a row reduction — which is what makes this more than a cast-transpose. As separate "
+           "ops it is a norm, a full fp32 transpose and two quantisations; fused it is a read of the bf16 "
+           "matrix and two FP8 writes."),
+    keywords=["mle", "kernel-generation", "fp8", "rmsnorm", "quantization", "transpose", "training",
+              "memory-bound", "low-precision"],
+    module="norm_quant_transpose.py",
+    func="rmsnorm_quant_transpose",
+    signature="rmsnorm_quant_transpose(x, weight, eps=1e-6)",
+    returns_doc="""RMSNorm, then FP8 quantisation of the result AND of its transpose.
+
+Args:
+    x:      (M, N) bfloat16 — hidden states; M tokens, N features.
+    weight: (N,)   bfloat16 — RMSNorm gain.
+    eps:    float          — added inside the rsqrt; default 1e-6.
+
+Returns a 4-tuple, in this order:
+    q:  (M, N)        float8_e4m3fn — y quantised in 1x128 groups along N
+    s:  (M, N // 128) float32       — the matching scales
+    qt: (N, M)        float8_e4m3fn — y.T quantised in 1x128 groups along M (= 128x1 groups of y)
+    st: (N, M // 128) float32       — the matching scales""",
+
+    reference_imports="import torch",
+    reference_src='''
+FP8_MAX = 448.0          # max finite magnitude of float8_e4m3fn
+GROUP = 128              # quantisation group length, along the last axis of each output
+
+
+def rmsnorm_quant_transpose(x, weight, eps=1e-6):
+    """RMSNorm, then two independent FP8 quantisations of the SAME normalised values.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target.
+
+    NOTE the TENSOR divisor: `amax / fmax` with a 0-dim tensor is a correctly-rounded IEEE fp32 division,
+    which is exactly what `amax / 448.0f` gives in CUDA/Triton. (torch turns `tensor / python_float` into a
+    multiply by the rounded reciprocal, which is off by an ulp on many elements.)
+    """
+    M, N = x.shape
+    fmax = torch.tensor(FP8_MAX, device=x.device)
+    xf = x.float()
+    rms = torch.rsqrt(xf.pow(2).mean(-1, keepdim=True) + eps)          # per row, over ALL N features
+    y = xf * rms * weight.float()                                      # normalised, gained, fp32
+
+    yr = y.view(M, N // GROUP, GROUP)                                  # 1 x 128 groups along N
+    s = (yr.abs().amax(-1) / fmax).clamp(min=1e-12)
+    q = (yr / s.unsqueeze(-1)).clamp(-FP8_MAX, FP8_MAX).to(torch.float8_e4m3fn).view(M, N)
+
+    yt = y.t().contiguous().view(N, M // GROUP, GROUP)                 # 128 x 1 groups of y
+    st = (yt.abs().amax(-1) / fmax).clamp(min=1e-12)
+    qt = (yt / st.unsqueeze(-1)).clamp(-FP8_MAX, FP8_MAX).to(torch.float8_e4m3fn).view(N, M)
+
+    return q, s, qt, st
+''',
+    make_inputs_src='''
+def _mk(M, N, seed):
+    """A ~20x magnitude spread along BOTH axes. The row spread is mostly removed by the RMSNorm (that is
+    what it is for), so the column-group scales are driven by the per-feature spread and the gain — which
+    is exactly the regime a real activation matrix is in."""
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    col = torch.exp(torch.rand(1, N, device="cuda", generator=gen) * 3.0 - 1.5)
+    row = torch.exp(torch.rand(M, 1, device="cuda", generator=gen) * 3.0 - 1.5)
+    x = (torch.randn(M, N, device="cuda", generator=gen) * col * row).to(torch.bfloat16)
+    weight = (0.5 + torch.rand(N, device="cuda", generator=gen)).to(torch.bfloat16)
+    return x, weight
+''',
+    flops_src='''
+def canonical_work(M, N):
+    """BYTES attributed to one fused RMSNorm + FP8 cast-transpose, from the SHAPE ALONE.
+
+    The ideal traffic: read x once (2 bytes/elt, bf16), write q and qt (1 byte/elt each, fp8), and write one
+    fp32 scale per 128 elements for each of the two groupings. Memory-bound, so the score is achieved
+    bandwidth against this fixed byte count. (See the perf notes: the row normaliser makes a single read of
+    x hard, so this floor is aspirational rather than easy — it is the same fixed count for every
+    submission either way.)
+    """
+    return M * N * 2 + M * N + M * N + 2 * (M * N // 128) * 4
+''',
+    flops_formula="M * N * 2  +  M * N  +  M * N  +  2 * (M * N // 128) * 4",
+
+    metric="GB/s",
+    compare="tuple",
+    tuple_names=("q", "s", "qt", "st"),
+    tol=3e-3,     # MEASURED: 2.1x the 1.4e-3 spread between two independent correct implementations
+    shape_names=("M", "N"),
+    grader_shapes=[(65536, 8192), (131072, 4096), (32768, 16384), (262144, 2048), (98304, 6144)],
+    measure_shapes=[(49152, 8192), (98304, 4096), (32768, 12288), (196608, 2048), (65536, 6144)],
+    measure_quick_shapes=[(4096, 4096), (2048, 8192), (8192, 2048)],
+    correct_shapes=[(256, 512), (128, 1024), (512, 256), (1024, 2048)],
+
+    spec_md="""One bf16 matrix in, one RMSNorm, and **two** FP8 matrices out — and they are not the same
+bytes transposed, because each is quantised in groups along its own last axis.
+
+### 1 — RMSNorm over the full feature axis
+
+```
+rms[m]  = rsqrt( mean_n( x[m, n]^2 ) + eps )          # over ALL N features of row m
+y[m, n] = x[m, n] * rms[m] * weight[n]
+```
+
+No mean subtraction, `eps` inside the rsqrt, gain applied after normalising. `y` is fp32 and is **never
+materialised in memory** — it is the input to both quantisations.
+
+### 2 — `q`, `s`: 1 x 128 groups along `N` (the per-token grouping)
+
+For row `m`, group `j` covering `n in [128j, 128j + 128)`:
+
+```
+amax   = max |y[m, n]|  over the group
+s[m,j] = max( amax / 448.0 , 1e-12 )                  # 448 = max finite float8_e4m3fn
+q[m,n] = cast_to_float8_e4m3fn( y[m, n] / s[m, j] )
+```
+
+### 3 — `qt`, `st`: 1 x 128 groups along `M` (128 x 1 groups of `y`)
+
+`qt` has shape `(N, M)` and holds the transpose: `qt[n, m]` is the quantised form of `y[m, n]`, but grouped
+down the **token** axis. For column `n`, group `i` covering `m in [128i, 128i + 128)`:
+
+```
+amax    = max |y[m, n]|  over m in [128i, 128i + 128)
+st[n,i] = max( amax / 448.0 , 1e-12 )
+qt[n,m] = cast_to_float8_e4m3fn( y[m, n] / st[n, i] )
+```
+
+The same `y[m, n]` therefore appears **twice, with two different scales**, and the two codes are generally
+different. That is the point: each copy is grouped along the axis that its GEMM contracts over.
+
+The interesting dependency is between the two halves: the column-group absmax in step 3 is an absmax of
+**normalised** values, so it cannot be computed until `rms` is known for all 128 rows of the group — and
+`rms[m]` needs the whole row of `x`. A pure cast-transpose has no such coupling.
+
+`/app/reference.py` does this in fp32 with an explicit `.t().contiguous()`. That is the exact specification
+and also what to avoid: a full fp32 transpose of the whole matrix is `4*M*N` bytes read and written for
+nothing.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `x` | `(M, N)` | `bfloat16` | hidden states, M tokens x N features |
+| `weight` | `(N,)` | `bfloat16` | RMSNorm gain, applied after normalising |
+| `eps` | scalar | `float` | added inside the rsqrt; default `1e-6` |
+
+**Return** a 4-tuple `(q, s, qt, st)` **in that order**:
+
+| out | shape | dtype |
+|-----|-------|-------|
+| `q` | `(M, N)` | `torch.float8_e4m3fn` |
+| `s` | `(M, N // 128)` | `float32` |
+| `qt` | `(N, M)` | `torch.float8_e4m3fn` |
+| `st` | `(N, M // 128)` | `float32` |
+
+`qt` must be a real `(N, M)` **contiguous** tensor, not a transposed view of `q` — the consumer is a GEMM
+that reads it row-major. Both `q` and `qt` must be genuine `float8_e4m3fn`.
+
+**`M` and `N` are both multiples of 128** in every graded and correctness shape, so the groups always divide
+evenly; you do not have to handle a partial group. `eps` is added to the **mean** of squares. Treat all
+inputs as read-only.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `M` (tokens
+in the microbatch) in 32768–262144 and `N` (model width) in 2048–16384, both multiples of 128 — one
+activation matrix of an FP8 training step. The aspect ratio varies by 128x across the graded shapes, which
+changes which of the two outputs is the awkward one; write a **general** kernel.""",
+
+    correctness_md="""**All four** returned tensors must match the reference within **relative error `3e-3`**
+at every graded shape, including the timed ones; the grader scores the **worst** of the four.
+
+Grading all four matters, because a block scale absorbs any change in the *magnitude* of `y` and hides
+mistakes in the codes. Measured: RMS-normalising **per 128-block instead of per row** scores **0.11 – 0.14**;
+using one scale per **whole column** instead of per 128-row group scores **0.20 – 0.43**; dropping the
+RMSNorm **gain** scores **0.32 – 0.34**. And the numerical one to watch — rounding `y` through **bfloat16**
+before quantising — scores **1.28e-2**, still **4.2x** the tolerance and a fail.""",
+
+    perf_md="""This kernel is **memory-bound**. `canonical_work` counts the ideal traffic — one bf16 read and
+two FP8 writes — and your score is achieved bandwidth against that count. The ceiling is the HBM bandwidth
+you measure on the device (time a large bf16 `copy_` and aim there).
+
+**Read this before you design the kernel:** the column-group scales need the absmax of `y` over 128 *rows*,
+and `y` needs `rms[m]`, which needs the *whole* row of `x`. A block cannot own both a full row and 128 full
+rows unless the row fits in shared memory 128 times over, which it does not. The natural structure is
+therefore **two passes over `x`**:
+
+1. a cheap pass that computes `rms[m]` for every row into an `(M,)` fp32 buffer — this is a pure reduction,
+   `2*M*N` bytes read, nothing written but `4*M` bytes;
+2. a tile pass over aligned **128 x 128** tiles: read the bf16 tile, scale by `rms[m]` and `weight[n]` in
+   fp32, and the tile now contains **exactly** 128 complete row-groups (one per row) and 128 complete
+   column-groups (one per column). Take both absmaxes, emit the `q` tile row-major and the `qt` tile
+   transposed, and write both scale vectors.
+
+That costs `6*M*N` bytes against a counted `4*M*N`, so ~2/3 of your measured copy bandwidth is the realistic
+ceiling. Beating it means finding a way to avoid the second read — and the leaderboard is uncapped, so if you
+find one it pays.
+
+Beyond the structure:
+
+- **transpose in shared memory, never in HBM.** A 128x128 bf16 tile is 32 KB; stage it (padded to avoid bank
+  conflicts), then write `q` along rows and `qt` along the other axis with fully coalesced 128-bit stores.
+- **vectorise the FP8 stores.** One byte per element means a scalar store wastes most of the bandwidth; pack
+  16 codes into a 128-bit store. The FP8 conversion instructions convert two values at a time.
+- **the two absmaxes are different reductions over the same tile.** The row-group one is along the tile's
+  fast axis (a warp shuffle); the column-group one is along the slow axis (through shared memory or a
+  transposed register layout). Do them in one sweep over the staged tile, not two.
+- **`rms` and `weight` are tiny** — the `(M,)` buffer from pass 1 is `4*M` bytes and the gain is `2*N`; both
+  stay in cache. Do not recompute the normaliser per tile.
+- **size the grid from the SM count you query**, and remember that pass 1 is bandwidth-bound with almost no
+  arithmetic — it should run at close to pure read speed.""",
+
+    precision_md="""The input is **bfloat16**, the outputs are **float8_e4m3fn** with **fp32** scales, and the
+RMS reduction, the normalisation and both absmaxes must be computed in **fp32**.
+
+**Keep `y` in fp32 all the way into both casts.** e4m3 has a 3-bit mantissa, so consecutive codes are ~6%
+apart and the output is a *step function* of `y`: an upstream perturbation of relative size `d` does not
+produce an error of size `d`, it flips roughly `d/0.06` of the elements by a full step, i.e. an error near
+`0.25 * sqrt(d)`. Rounding `y` through bfloat16 first (`d ~ 4e-3`) measures **1.28e-2** — 4.2x this gate, and
+a fail. `y` is never written to memory, so there is no bandwidth argument for narrowing it.
+
+**Where the tolerance comes from.** `3e-3` is measured, not inherited. A second, independent implementation —
+the sum of squares accumulated as a two-level `(N/128, 128)` partial-sum tree instead of one flat row
+reduction, `1/sqrt` instead of `rsqrt`, the gain folded in before the normaliser, the matrix processed in
+512-row stripes, and both quantisations done as a **multiply by the reciprocal** rather than a divide —
+differs from this reference by relative Frobenius error at most **1.4e-3** across the correctness shapes and
+two full-scale shapes, six seeds each. The gate is **2.1x** that.
+
+That `1.4e-3` is larger than you might expect from an fp32 reduction, and the `0.25*sqrt(d)` law above is
+why: a relative difference of only `~2e-6` in the normaliser — entirely ordinary for a different reduction
+order over 16384 elements — is amplified into ~1e-3 of FP8 code flips. It is the floor for *any* kernel that
+does not reproduce the reference's exact reduction order, which is why the gate cannot be tighter, and it is
+also why the scales (`s`, `st`) are much more accurate than the codes: an absmax is exact, so the scales
+agree to fp32 round-off and the whole budget is spent on `q` and `qt`.
+
+**fp8 output is required, not optional** — returning bf16 or fp16 values that happen to be numerically close
+does not satisfy the contract.""",
+).validate()

tools/factory/specs/rwkv7_token_shift.py

@@ -0,0 +1,211 @@
+"""Spec for `rwkv7-token-shift-mix` — RWKV-7's token shift: one read of the activation, six lerped views out."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="rwkv7-token-shift-mix",
+    title="Write a fast RWKV-7 token-shift kernel (six lerped projections in one pass)",
+    blurb=("Every RWKV-7 time-mixing block starts by blending each token with the one before it — a "
+           "learned per-channel interpolation between x[t] and x[t-1] — and it does so SIX times with six "
+           "different mixing vectors, one for each of the r, w, k, v, a and g projections. Done as six "
+           "separate lerps it reads the activation six times and materialises six full temporaries; done "
+           "properly it is one read, one shifted neighbour already in registers, and six stores. The shift "
+           "also carries state across chunk boundaries, so the kernel owns a boundary condition as well."),
+    keywords=["mle", "kernel-generation", "rwkv7", "token-shift", "linear-attention", "lerp",
+              "memory-bound", "recurrent"],
+    module="token_shift.py",
+    func="rwkv7_token_shift",
+    signature="rwkv7_token_shift(x, x_prev, mu)",
+    returns_doc="""RWKV-7 token shift: six per-channel lerps against the previous token, plus the carry.
+
+Args:
+    x:      (B, T, D) bfloat16 — this chunk's activations.
+    x_prev: (B, D)    bfloat16 — the last token of the PREVIOUS chunk, per sequence.
+    mu:     (6, D)    bfloat16 — the six per-channel mixing vectors, in the order r, w, k, v, a, g.
+
+Returns a 7-tuple, in this order:
+    xr, xw, xk, xv, xa, xg: (B, T, D) bfloat16 — the six mixed activations
+    state_out:              (B, D)    bfloat16 — x[:, T-1], the carry for the next chunk""",
+
+    reference_imports="import torch",
+    reference_src='''
+def rwkv7_token_shift(x, x_prev, mu):
+    """RWKV-7 token shift, as separate fp32 tensor ops.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target.
+    """
+    shifted = torch.cat([x_prev.unsqueeze(1).float(), x[:, :-1].float()], dim=1)   # x[t-1], carry at t=0
+    xx = shifted - x.float()
+    outs = [(x.float() + xx * mu[i].float()).to(x.dtype) for i in range(mu.shape[0])]
+    return tuple(outs) + (x[:, -1].contiguous(),)
+''',
+    make_inputs_src='''
+def _mk(B, T, D, seed):
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    x = torch.randn(B, T, D, device="cuda", dtype=torch.bfloat16, generator=gen)
+    x_prev = torch.randn(B, D, device="cuda", dtype=torch.bfloat16, generator=gen)
+    mu = torch.rand(6, D, device="cuda", generator=gen).to(torch.bfloat16)   # mixing weights in [0, 1)
+    return x, x_prev, mu
+''',
+    flops_src='''
+def canonical_work(B, T, D):
+    """BYTES attributed to one token shift, from the SHAPE ALONE.
+
+    Read x once and write the six mixed tensors, all bf16 — the shifted operand is the SAME data offset by
+    one token, so it costs no second read in a fused kernel and none is counted. The per-sequence carry is
+    read and written as well. The (6, D) mixing vectors are negligible and stay resident. This is a
+    bandwidth kernel, so the score is achieved bandwidth against this fixed byte count.
+    """
+    return (1 + 6) * B * T * D * 2 + 2 * B * D * 2
+''',
+    flops_formula="7 * B * T * D * 2 + 4 * B * D   bytes",
+
+    metric="GB/s",
+    compare="tuple",
+    tuple_names=("xr", "xw", "xk", "xv", "xa", "xg", "state_out"),
+    tol=1e-5,     # MEASURED: 8.5x the 1.17e-6 worst spread between two independent correct implementations
+    shape_names=("B", "T", "D"),
+    grader_shapes=[(4, 16384, 4096), (8, 8192, 4096), (2, 32768, 4096),
+                   (4, 32768, 2048), (6, 16384, 3072)],
+    measure_shapes=[(4, 12288, 4096), (8, 6144, 4096), (2, 24576, 4096),
+                    (4, 24576, 2048), (6, 12288, 3072)],
+    measure_quick_shapes=[(2, 2048, 2048), (4, 1024, 2048), (1, 4096, 4096)],
+    correct_shapes=[(3, 65, 512), (2, 128, 1024), (5, 33, 256), (1, 257, 2048)],
+
+    spec_md="""The token shift blends every token with its predecessor, per channel, six different ways:
+
+```
+shifted[b, t, d] = x[b, t-1, d]        for t > 0
+shifted[b, 0, d] = x_prev[b, d]        the carry from the previous chunk
+
+xx[b, t, d]      = shifted[b, t, d] - x[b, t, d]
+out_i[b, t, d]   = x[b, t, d] + xx[b, t, d] * mu[i, d]           for i in [0, 6)
+```
+
+which is a per-channel linear interpolation: `out_i = (1 - mu[i]) * x + mu[i] * shifted`. Both forms are
+acceptable; they differ only in the last fp32 bit.
+
+The six outputs are the inputs to the six projections of an RWKV-7 time-mixing block, in the fixed order
+**`r, w, k, v, a, g`** — `mu[0]` produces `xr`, `mu[5]` produces `xg`. `mu` lies in `[0, 1)`: at `mu = 0`
+the output is `x` untouched, at `mu -> 1` it is the previous token.
+
+**The boundary is part of the contract.** Position `t = 0` of every sequence mixes against `x_prev[b]`, the
+last token of the previous chunk — not against zero and not against `x[b, 0]`. Sequences are independent:
+the shift never crosses the batch axis. And because this chunk's last token becomes the next chunk's carry,
+the kernel also returns `state_out = x[:, T-1]` — a plain copy, but the recurrence breaks without it.
+
+`/app/reference.py` builds `shifted` with a concatenate and evaluates the six lerps as separate fp32 tensor
+ops. That is the exact numerical specification; it is deliberately simple rather than fast — it
+materialises a full `(B, T, D)` fp32 copy of the shifted tensor, a second one for `xx`, and one more per
+output.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `x` | `(B, T, D)` | `bfloat16` | this chunk's activations, contiguous, `d` fastest |
+| `x_prev` | `(B, D)` | `bfloat16` | last token of the previous chunk, one row per sequence |
+| `mu` | `(6, D)` | `bfloat16` | per-channel mixing vectors, row order `r, w, k, v, a, g` |
+
+**Return** a 7-tuple `(xr, xw, xk, xv, xa, xg, state_out)` **in that order**:
+
+| out | shape | dtype | notes |
+|-----|-------|-------|-------|
+| `xr` … `xg` | `(B, T, D)` | `bfloat16` | one per row of `mu`, same order |
+| `state_out` | `(B, D)` | `bfloat16` | `x[:, T-1]` — the carry for the next chunk |
+
+`state_out` must be a **new contiguous tensor**, not a view into `x`. Treat all inputs as **read-only**:
+the contract is functional, so allocate and return new tensors; the grader calls your function and the
+reference on the same buffers, and an in-place update corrupts the comparison and fails.
+
+`T` is **not** guaranteed to be a multiple of any tile size (the correctness shapes include `T = 33`,
+`T = 65` and `T = 257`), and neither is `B`. Handle the tail, and handle `t = 0` of every sequence.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `B`
+(sequences in the batch) in 2–8, `T` (tokens per chunk) in 8192–32768, `D` (model width) in 2048–4096.
+That is one chunk of a long-context RWKV-7 training step or prefill: the chunk is large enough that the
+shift is a streaming problem, and there are always at least a couple of sequences, so the per-sequence
+boundary can never be ignored. The six outputs are four times the size of the input, which is what makes
+this worth a dedicated kernel. Write a **general** kernel — `B*T` varies by a factor of four and `D` by
+two.""",
+
+    correctness_md="""**All seven** returned tensors must match the reference (evaluated in fp32) within
+**relative error `1e-5`** at every graded shape, including the timed ones; the grader scores the **worst**
+of the seven.
+
+The gate is tight because this kernel has almost no numerical freedom — it is one FMA per output element —
+and it is **measured**. Every structural mistake misses it by orders of magnitude:
+
+* shifting the wrong way (mixing with `x[t+1]` instead of `x[t-1]`) scores **1.05e0**, **10^5x** the
+  tolerance;
+* forgetting the `- x` in `xx`, i.e. `x + shifted * mu` instead of a lerp, scores **7.40e-1**;
+* ignoring `x_prev` and starting each sequence from zero scores **1.35e-1** — a boundary error on one token
+  in ten thousand, still **13500x** the gate, because the norm is relative and that token is not small;
+* doing the arithmetic in bf16 instead of fp32 scores **3.12e-3**, **312x**.
+
+`state_out` carries no arithmetic at all — it is a bf16 copy of values that were already bf16 — so a
+correct kernel reproduces it **bit for bit**.""",
+
+    perf_md="""This kernel is **memory-bound and nothing else**: one subtract and six FMAs per input
+element, against 14 bytes of traffic. Your score is achieved bandwidth, and the ceiling is the HBM
+bandwidth you measure on the device — note the mix is 1 byte read for every 6 written, so a pure-write
+benchmark is a better yardstick than a `copy_`.
+
+Where the reference loses: `shifted` is a full `(B, T, D)` **fp32** materialised copy, `xx` is another, and
+each of the six outputs is computed as its own fp32 temporary before being cast. That is roughly six reads
+of the activation and thirteen full-size tensors through HBM to do the work of one read and six writes.
+
+What a fast kernel does:
+
+* **the shifted operand is not a second tensor.** `x[t-1]` is the same memory as `x[t]`, offset by `D`
+  elements. A thread (or tile) that owns a range of `t` loads its own row and keeps the previous row in
+  registers as it walks forward — or, if you parallelise over `t`, loads two rows and reuses them across
+  the six outputs. Either way, `x` is read **once**; `canonical_work` counts one read, so an implementation
+  that reads it twice starts at half the achievable score.
+* **six stores from one register set.** All six outputs share the same `x` and `xx`; the only thing that
+  differs is a per-channel scalar. That is six independent, fully coalesced, vectorisable stores. Issue
+  them back-to-back so the store queue stays full, and vectorise them (128-bit) — the store side is 6/7 of
+  the traffic and is what this kernel lives or dies by.
+* **hoist `mu`.** It is indexed by channel only: a block that owns a fixed range of `d` loads its `6 x
+  tile_d` slice once into registers and reuses it for every token. Six values per channel is real register
+  pressure, so pick the channel tile with that in mind; loading `mu` per token instead turns a resident
+  vector into a seventh stream.
+* **the boundary is per sequence, and it is a `t = 0` special case only.** Do not branch per token: either
+  peel `t = 0` into its own tiny launch or handle it with a predicated select on the tile that contains it.
+  A per-element `if (t == 0)` inside the main loop costs more than the boundary is worth.
+* **`state_out` is 2 KB per sequence.** Copy it in the same launch (a single block can do it) rather than
+  paying a separate kernel launch for a few kilobytes.
+* **the `d` axis is contiguous and the `t` axis has a stride of `D`** — both are friendly. The layout that
+  usually wins is a 2-D grid over `(t-tile, d-tile)` with each thread holding several `d` per `t`, so the
+  previous-token value it needs is a register from the previous iteration of its own loop.""",
+
+    precision_md="""`x`, `x_prev`, `mu` and all seven outputs are **bfloat16**. Do the subtract and the six
+fused multiply-adds in **fp32**, and round to bf16 exactly once per output, at the store.
+
+**fp8 is not useful here** and is not expected: the dtypes are fixed at both ends and the kernel is pure
+bandwidth.
+
+**Where the tolerance comes from.** `1e-5` is measured, not inherited, over five shapes (including a
+`(4, 2048, 2048)` full-width one) and five seeds each. Two independent implementations of this spec were
+compared against the fp32 reference:
+
+* the **lerp form** `x * (1 - mu) + shifted * mu`, with the shifted tensor built by an explicit strided
+  copy rather than a concatenate — a different algebraic arrangement and a different rounding sequence:
+  **1.17e-6**;
+* a **chunked** implementation that walks `T` in blocks of 61, threads the carry from block to block, and
+  uses `addcmul` (a true FMA) for the epilogue: **7.32e-7**.
+
+The tolerance is **8.5x** the worse of the two, which is deliberate slack for a kernel whose only real
+freedom is that arrangement — there is no reduction here, so there is no reduction order to argue about.
+
+What that slack does **not** cover is **bf16 arithmetic**, which scores **3.12e-3**, 312x the gate. The
+reason it fails so badly is specific to a lerp: `xx = shifted - x` is a *difference of two nearby numbers*.
+When consecutive tokens are similar — which is exactly when the token shift is doing something useful — the
+subtraction cancels most of the mantissa, and computing it in bf16 leaves the difference with only a couple
+of significant bits before it is scaled by `mu` and added back. Widen to fp32 before subtracting.
+
+A useful self-check: at `mu[i] = 0` output `i` must equal `x` **bit-identically**, and at `mu[i] = 1` it
+must equal `shifted` bit-identically. Both are exactly representable and both are worth asserting while you
+develop.""",
+).validate()

tools/factory/specs/sandwich_norm_residual.py

@@ -0,0 +1,205 @@
+"""Spec for `sandwich-norm-residual-fused` — Gemma-2 / OLMo-2 sandwich norm: post-norm + residual + pre-norm."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="sandwich-norm-residual-fused",
+    title="Write a fast sandwich-norm (post-norm + residual + pre-norm) kernel",
+    blurb=("Gemma-2, OLMo-2 and Grok wrap every sublayer in TWO RMSNorms: the sublayer output is normalised "
+           "before it is added to the residual stream, and the new residual stream is normalised again on "
+           "the way into the next sublayer. Between two blocks that is a norm, an add and a norm over the "
+           "same row, with the second reduction depending on the first — five HBM round trips as separate "
+           "torch ops, and two reads and two writes when it is one kernel."),
+    keywords=["mle", "kernel-generation", "rmsnorm", "residual", "sandwich-norm", "gemma", "olmo",
+              "memory-bound", "serving"],
+    module="sandwich_norm.py",
+    func="sandwich_norm_residual",
+    signature="sandwich_norm_residual(residual, branch, post_weight, pre_weight, eps=1e-6)",
+    returns_doc="""Post-norm of a sublayer output, residual add, then pre-norm for the next sublayer.
+
+Args:
+    residual:    (M, N) bfloat16 — the residual stream entering this point.
+    branch:      (M, N) bfloat16 — the sublayer (attention / MLP) output, un-normalised.
+    post_weight: (N,)   bfloat16 — RMSNorm gain applied to the branch BEFORE the add.
+    pre_weight:  (N,)   bfloat16 — RMSNorm gain applied to the new residual stream.
+    eps:         float           — added inside both rsqrts; default 1e-6.
+
+Returns:
+    (h, y) where
+      h: (M, N) bfloat16 — the updated residual stream, residual + post_norm(branch)
+      y: (M, N) bfloat16 — pre_norm(h), the input to the next sublayer""",
+
+    reference_imports="import torch",
+    reference_src='''
+def sandwich_norm_residual(residual, branch, post_weight, pre_weight, eps=1e-6):
+    """Two RMSNorms with a residual add sandwiched between them, as separate fp32 steps.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target.
+    """
+    bf = branch.float()
+    rms_b = torch.rsqrt(bf.pow(2).mean(-1, keepdim=True) + eps)          # over the branch row
+    h = (residual.float() + bf * rms_b * post_weight.float()).to(residual.dtype)   # bf16 residual stream
+
+    hf = h.float()                                                       # re-read the BF16 h
+    rms_h = torch.rsqrt(hf.pow(2).mean(-1, keepdim=True) + eps)          # over the NEW residual row
+    y = (hf * rms_h * pre_weight.float()).to(residual.dtype)
+    return h, y
+''',
+    make_inputs_src='''
+def _mk(M, N, seed):
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    # the residual stream is several times larger than a single sublayer's output, as it is in a
+    # trained model -- so the post-norm gain genuinely matters and the two normalisers differ.
+    residual = torch.randn(M, N, device="cuda", dtype=torch.bfloat16, generator=gen) * 2.0
+    branch = torch.randn(M, N, device="cuda", dtype=torch.bfloat16, generator=gen) * 0.7
+    post_w = (0.5 + torch.rand(N, device="cuda", generator=gen)).to(torch.bfloat16)
+    pre_w = (0.5 + torch.rand(N, device="cuda", generator=gen)).to(torch.bfloat16)
+    return residual, branch, post_w, pre_w
+''',
+    flops_src='''
+def canonical_work(M, N):
+    """BYTES attributed to one sandwich-norm step, from the SHAPE ALONE.
+
+    The unavoidable traffic: read residual and branch, write h and y — four (M, N) bf16 tensors at 2
+    bytes/element. The two (N,) gains are negligible and stay resident. Memory-bound, so the score is
+    achieved bandwidth against this fixed byte count.
+    """
+    return 4 * M * N * 2 + 4 * N
+''',
+
+    metric="GB/s",
+    compare="tuple",
+    tuple_names=("h", "y"),
+    tol=1e-3,     # MEASURED: 23x the 4.3e-5 worst spread between two independent correct implementations
+    shape_names=("M", "N"),
+    grader_shapes=[(65536, 8192), (131072, 4096), (32768, 16384), (262144, 2048), (98304, 6144)],
+    measure_shapes=[(49152, 8192), (98304, 4096), (32768, 12288), (196608, 2048), (65536, 6144)],
+    measure_quick_shapes=[(4096, 4096), (2048, 8192), (8192, 2048)],
+    correct_shapes=[(256, 512), (129, 1024), (513, 256), (64, 2048)],
+
+    spec_md="""Three steps over the same row, fused. `rmsnorm(v)[n] = v[n] * rsqrt(mean_n(v^2) + eps)` — no
+mean subtraction, `eps` inside the rsqrt, and the reduction is over the **whole row of `N` features**.
+
+```
+# 1 - POST-norm: the sublayer output is normalised before it enters the residual stream
+rms_b[m]  = rsqrt( mean_n( branch[m, n]^2 ) + eps )
+# 2 - residual add, in bf16
+h[m, n]   = bf16( residual[m, n] + branch[m, n] * rms_b[m] * post_weight[n] )
+# 3 - PRE-norm: the NEW residual stream is normalised for the next sublayer
+rms_h[m]  = rsqrt( mean_n( h[m, n]^2 ) + eps )
+y[m, n]   = bf16( h[m, n] * rms_h[m] * pre_weight[n] )
+```
+
+Both `h` and `y` are returned: `h` is the residual stream that the *next* residual add will need, `y` is what
+the next attention or MLP block consumes.
+
+Two things make this more than two independent norms:
+
+- **the second reduction depends on the first.** `rms_h` cannot be started until the whole normalised branch
+  has been added, so the row has to be held (registers or shared memory) across both reductions, or read
+  twice.
+- **`h` is rounded to bfloat16 before the second norm.** `y` is computed from the **bf16** value of `h`, not
+  from the fp32 accumulator that produced it — exactly as it would be if `h` were written to HBM and read
+  back by a separate kernel. This is part of the specification, not an artefact: carrying the fp32 value into
+  the second norm instead changes `y` by **2.8e-3**, which is **2.8x the tolerance** and fails.
+
+`/app/reference.py` writes this as a chain of torch ops. That is the exact numerical specification and also
+what a fused kernel must avoid: `bf.pow(2)`, the mean, two broadcast multiplies, the add, and then the same
+again for the second norm — each a full `(M, N)` fp32 tensor through HBM.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `residual` | `(M, N)` | `bfloat16` | residual stream entering this point |
+| `branch` | `(M, N)` | `bfloat16` | sublayer output, un-normalised |
+| `post_weight` | `(N,)` | `bfloat16` | gain for the norm **before** the add |
+| `pre_weight` | `(N,)` | `bfloat16` | gain for the norm **after** the add |
+| `eps` | scalar | `float` | added inside both rsqrts; default `1e-6` |
+
+**Return** a 2-tuple `(h, y)` **in that order**, both `(M, N)` **bfloat16**.
+
+The two gains are **not** interchangeable — swapping them scores 0.33, i.e. 330x the tolerance. `N` is always
+a multiple of 128; `M` is **not** a multiple of any tile size (the correctness shapes include `M = 129` and
+`M = 513`), so handle the tail. The update is **functional**: `residual` and `branch` are read-only, and `h`
+must be a newly allocated tensor — the grader calls your function and the reference on the same buffers, so
+an in-place update corrupts the comparison and fails.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `M` (tokens)
+in 32768–262144 and `N` (model width) in 2048–16384 — one inter-block boundary of a large prefill or a big
+decode batch. A row is 4–32 KB of bf16, so whether a whole row fits in one block's shared memory changes
+across the regime; write a **general** kernel rather than one tuned to a single `N`.""",
+
+    correctness_md="""**Both** returned tensors must match the reference within **relative error `1e-3`** at
+every graded shape, including the timed ones; the grader scores the **worse** of the two.
+
+Returning only `y` correctly is not enough — `h` is the residual stream every later layer builds on, and it
+is graded just as hard.
+
+That gate is measured, and the structural errors are far outside it: skipping the post-norm on the branch
+(the plain `residual + branch` fusion) scores **0.14**; swapping the two gains scores **0.33**; and reusing
+the branch's normaliser for the second norm instead of recomputing it on `h` scores **2.22**. The one
+near-miss to know about is numerical rather than structural: carrying `h` into the second norm as fp32
+instead of rounding it to bf16 first scores **2.8e-3**, which also fails — see the spec.""",
+
+    perf_md="""This kernel is **memory-bound**: four `(M, N)` bf16 tensors of traffic and about six flops per
+element. Your score is achieved bandwidth; the ceiling is the HBM bandwidth you measure on the device (time a
+large bf16 `copy_` and aim there). A perfect kernel is two streaming reads and two streaming writes that
+happen to normalise twice on the way through.
+
+Where the reference loses: it materialises `bf`, `bf.pow(2)`, the normalised branch, `h` in fp32, `hf` again,
+and the gained result — five or six full-size fp32 temporaries, so the data crosses HBM roughly ten times at
+double width.
+
+What a fast kernel does:
+
+- **one block per row (or per few rows), one pass.** Load the row of `branch` into registers/shared memory,
+  reduce for `rms_b`, add the residual, round to bf16, reduce *again* for `rms_h`, and write both outputs —
+  all without going back to HBM for a second read. This is the whole task: the second reduction is a
+  dependent barrier in the middle of the row.
+- **do not re-read the row.** At `N = 2048` a row is 4 KB and lives comfortably in registers; at `N = 16384`
+  it is 32 KB, which still fits in shared memory but constrains how many rows a block can own. A kernel that
+  falls back to re-reading `branch` and `h` from HBM for the second pass pays 8 bytes/element of extra
+  traffic and loses roughly a third of the bandwidth. Tune the rows-per-block from
+  `p.shared_memory_per_block_optin`, not from a constant.
+- **keep the residual row in registers too.** It is needed after the first reduction; re-loading it is a
+  second read of a tensor you already had.
+- **hold `h` in bf16 for the second reduction.** That is what the spec requires anyway, and it halves the
+  register/shared footprint of the value that has to survive the barrier.
+- **the two gains are tiny and reused by every row** — stage them once in shared memory.
+- **vectorise.** All four tensors are contiguous bf16; use 128-bit loads and stores, and make the stores as
+  wide as the loads.
+- **watch the tail:** `M` is ragged, and at `N = 16384` a single block's shared-memory row is large enough
+  that the last partial wave is a visible fraction of the runtime.""",
+
+    precision_md="""Inputs and outputs are **bfloat16**; both reductions and both gain multiplications must be
+done in **fp32**. A bf16 accumulator over `N = 16384` squared values is not adequate — it moves the
+normaliser visibly.
+
+There are exactly **two** bf16 roundings in the specified computation, and where they sit is part of the spec:
+
+1. `h` is rounded to bf16 **after** the residual add, and the second reduction consumes that rounded value;
+2. `y` is rounded to bf16 at the very end.
+
+Carrying the fp32 accumulator across the boundary — i.e. computing `rms_h` and `y` from the un-rounded sum —
+is *more* accurate and still **wrong** here: it measures **2.8e-3** against the reference, 2.8x the gate. The
+reason to specify it this way is that `h` is a real tensor that gets written to memory in bf16; a kernel that
+keeps a private higher-precision copy is not reproducing the model the trainer trained.
+
+**Where the tolerance comes from.** `1e-3` is measured, not inherited. A second, independent implementation —
+sum of squares accumulated as a two-level `(N/128, 128)` partial-sum tree instead of one flat row reduction,
+`1/sqrt` instead of `rsqrt`, and the gain folded in before the normaliser instead of after — differs from the
+fp32 reference by relative Frobenius error at most **4.3e-5** across the correctness shapes and two
+full-scale shapes, four seeds each. The gate is **23x** that. The headroom is deliberate: it covers a range
+of reduction orders and a `rsqrt` that is a few ulp off, while still sitting 138x below the mildest
+structural error and 2.8x below the fp32-carry mistake above.
+
+Two exactness properties are useful self-checks:
+
+- **RMSNorm is scale-invariant.** Scaling `branch` by any positive constant leaves the post-normed branch —
+  and therefore `h` and `y` — unchanged, up to `eps`. If it does not, the normaliser is being computed over
+  the wrong axis or the gain is being applied before the division.
+- **with `pre_weight = 1` and `eps = 0`, every row of `y` has L2 norm exactly `sqrt(N)`**, whatever the
+  inputs were.""",
+).validate()

tools/factory/specs/sd3_joint_attention_tripletext.py

@@ -0,0 +1,225 @@
+"""Spec for `sd3-joint-attention-tripletext` — SD3.5 joint attention over four separate token segments."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="sd3-joint-attention-tripletext",
+    title="Write a fast SD3.5 four-segment joint attention (image + three text encoders, no concatenation)",
+    blurb=("Stable Diffusion 3.5 conditions on THREE text encoders — CLIP-L, CLIP-G and T5-XXL — whose "
+           "token streams the pipeline holds as three separate tensors, and its MMDiT attends over the "
+           "concatenation of all of them with the image latents, image first. Building that concatenation "
+           "for Q, K and V and splitting the result again, once per block for 38 blocks, is four full "
+           "round-trips of a multi-gigabyte working set that buys nothing: the concatenation only exists to "
+           "define one softmax denominator. This kernel takes the four segments where they live and gives "
+           "back four separate outputs."),
+    keywords=["mle", "kernel-generation", "stable-diffusion-3", "sd3", "mmdit", "joint-attention",
+              "flash-attention", "multi-segment", "diffusion-transformer", "image-generation"],
+    module="sd3_joint_attn.py",
+    func="sd3_joint_attention_tripletext",
+    signature="sd3_joint_attention_tripletext(img_q, img_k, img_v, ctx, scale=None)",
+    returns_doc="""Bidirectional attention over concat([img, clip_l, clip_g, t5]), returned per segment.
+
+Args:
+    img_q, img_k, img_v: (B, H, Ni, D) bfloat16 — the image latents.
+    ctx: a 3-tuple of (q, k, v) triples, in this order:
+           ctx[0] = CLIP-L, each (B, H, Nc, D) bfloat16
+           ctx[1] = CLIP-G, each (B, H, Nc, D) bfloat16
+           ctx[2] = T5,     each (B, H, Nt5, D) bfloat16
+    scale: float or None — softmax scale; defaults to D ** -0.5.
+
+Returns:
+    (img_out, clip_l_out, clip_g_out, t5_out) of shapes (B, Ni, H*D), (B, Nc, H*D), (B, Nc, H*D) and
+    (B, Nt5, H*D), all bfloat16 — heads already merged.""",
+
+    reference_imports="import torch",
+    reference_src='''
+def sd3_joint_attention_tripletext(img_q, img_k, img_v, ctx, scale=None):
+    """Joint attention over the four-segment concatenation, in fp32.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target. The query loop
+    chunks only so the fp32 score matrix fits in memory.
+    """
+    B, H, Ni, D = img_q.shape
+    sc = (D ** -0.5) if scale is None else float(scale)
+    segs = [(img_q, img_k, img_v)] + list(ctx)                       # IMAGE FIRST
+    lens = [s[0].shape[2] for s in segs]
+    N = sum(lens)
+
+    q = torch.cat([s[0].float() for s in segs], dim=2)
+    k = torch.cat([s[1].float() for s in segs], dim=2)
+    v = torch.cat([s[2].float() for s in segs], dim=2)
+
+    out = torch.zeros(B, H, N, D, device=img_q.device, dtype=torch.float32)
+    for b in range(B):
+        for s0 in range(0, N, 512):
+            e = min(s0 + 512, N)
+            p = torch.softmax((q[b, :, s0:e] * sc) @ k[b].transpose(1, 2), dim=-1)
+            out[b, :, s0:e] = p @ v[b]
+
+    out = out.permute(0, 2, 1, 3).reshape(B, N, H * D)
+    res, off = [], 0
+    for L in lens:
+        res.append(out[:, off:off + L].to(torch.bfloat16))
+        off += L
+    return res[0], res[1], res[2], res[3]
+''',
+    make_inputs_src='''
+def _mk(B, Ni, Nc, Nt5, H, D, seed):
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+
+    def qk(L):
+        # already QK-RMS-normalised by the block prologue: unit-RMS rows with a mild per-head gain
+        t = torch.randn(B, H, L, D, device="cuda", generator=gen)
+        t = t * torch.rsqrt(t.pow(2).mean(-1, keepdim=True) + 1e-6)
+        g = 1.0 + 0.2 * torch.randn(1, H, 1, D, device="cuda", generator=gen)
+        return (t * g).to(torch.bfloat16)
+
+    def val(L, s=1.0):
+        ch = torch.exp(0.5 * (2 * torch.rand(1, H, 1, D, device="cuda", generator=gen) - 1))
+        return (s * torch.randn(B, H, L, D, device="cuda", generator=gen) * ch).to(torch.bfloat16)
+
+    ctx = ((qk(Nc), qk(Nc), val(Nc, 1.3)),      # CLIP-L
+           (qk(Nc), qk(Nc), val(Nc, 0.8)),      # CLIP-G
+           (qk(Nt5), qk(Nt5), val(Nt5, 1.1)))   # T5
+    return qk(Ni), qk(Ni), val(Ni), ctx
+''',
+    flops_src='''
+def canonical_work(B, Ni, Nc, Nt5, H, D):
+    """FLOPs for one dense bidirectional attention over the four segments, from the SHAPE ALONE.
+
+    N = Ni + 2*Nc + Nt5. Every (query, key) pair costs 2*D FLOPs in Q K^T and another 2*D in P V, for
+    4*D per pair per head. There is no mask, so all N*N pairs are real work. The softmax is not counted.
+    """
+    N = Ni + 2 * Nc + Nt5
+    return 4 * B * H * D * N * N
+''',
+    flops_formula="4*B*H*D*(Ni + 2*Nc + Nt5)**2",
+
+    metric="TFLOP/s",
+    compare="tuple",
+    tuple_names=("img_out", "clip_l_out", "clip_g_out", "t5_out"),
+    tol=5e-3,     # MEASURED -- see precision_md
+    shape_names=("B", "Ni", "Nc", "Nt5", "H", "D"),
+    grader_shapes=[(1, 16384, 77, 256, 38, 64), (2, 12288, 77, 256, 38, 64),
+                   (2, 8192, 77, 256, 38, 64), (4, 4096, 77, 77, 38, 64),
+                   (1, 16384, 77, 77, 24, 128)],
+    measure_shapes=[(1, 15360, 77, 256, 38, 64), (2, 11264, 77, 256, 38, 64),
+                    (2, 7680, 77, 77, 38, 64), (3, 4096, 77, 256, 38, 64),
+                    (1, 14336, 77, 77, 24, 128)],
+    measure_quick_shapes=[(1, 2048, 77, 256, 38, 64), (2, 1024, 77, 77, 38, 64),
+                          (1, 1536, 33, 65, 12, 64)],
+    correct_shapes=[(1, 517, 33, 65, 4, 64), (2, 333, 21, 41, 8, 64),
+                    (1, 2048, 77, 256, 38, 64), (3, 129, 13, 19, 6, 128)],
+
+    spec_md="""One dense bidirectional attention over four token segments that are never concatenated in
+memory.
+
+```
+segments, in order:   img (Ni)  |  clip_l (Nc)  |  clip_g (Nc)  |  t5 (Nt5)
+N = Ni + 2*Nc + Nt5
+
+q = concat([img_q, clip_l_q, clip_g_q, t5_q], dim=2)        # (B, H, N, D); same for k and v
+out = softmax( scale * q k^T ) v                            # no mask of any kind
+out = out.transpose(1, 2).reshape(B, N, H*D)
+
+img_out    = out[:, :Ni]
+clip_l_out = out[:, Ni : Ni+Nc]
+clip_g_out = out[:, Ni+Nc : Ni+2*Nc]
+t5_out     = out[:, Ni+2*Nc :]
+```
+
+`scale` defaults to `D ** -0.5` when it is `None`. The softmax denominator spans **all four** segments:
+an image query attends to every text token of all three encoders and to every image token, and each text
+token attends to everything as well. There is no per-encoder mask, no padding to skip, and no separate
+cross-attention — SD3 has none.
+
+Q and K arrive **already** RMS-normalised by the block prologue and V arrives untouched; none of that is
+your job here. Your job is the attention and the segmentation.
+
+`/app/reference.py` builds the joint tensors, loops over query chunks in fp32 and slices the result back
+into four. That is the exact specification; it is deliberately simple rather than fast, and its runtime has
+no bearing on your score.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `img_q`, `img_k`, `img_v` | `(B, H, Ni, D)` | `bfloat16` | image latents, head-major |
+| `ctx` | 3-tuple of 3-tuples | — | the three text encoders' `(q, k, v)`, in the order below |
+| `ctx[0]` | 3-tuple of `(B, H, Nc, D)` | `bfloat16` | CLIP-L `(q, k, v)` |
+| `ctx[1]` | 3-tuple of `(B, H, Nc, D)` | `bfloat16` | CLIP-G `(q, k, v)` |
+| `ctx[2]` | 3-tuple of `(B, H, Nt5, D)` | `bfloat16` | T5 `(q, k, v)` |
+| `scale` | scalar or `None` | `float` | softmax scale; `None` means `D ** -0.5` |
+
+**Return** a 4-tuple `(img_out, clip_l_out, clip_g_out, t5_out)` **in that order**:
+
+| out | shape | dtype |
+|-----|-------|-------|
+| `img_out` | `(B, Ni, H*D)` | `bfloat16` |
+| `clip_l_out` | `(B, Nc, H*D)` | `bfloat16` |
+| `clip_g_out` | `(B, Nc, H*D)` | `bfloat16` |
+| `t5_out` | `(B, Nt5, H*D)` | `bfloat16` |
+
+Note the **asymmetry between input and output layout**: inputs are `(B, H, L, D)` (head-major) and outputs
+are `(B, L, H*D)` (token-major). That transpose is part of the contract and part of the work.
+
+The two CLIP segments have the **same length** but are different tensors and must not be merged into one
+`2*Nc` block unless you can prove your layout keeps them separate on the way out.
+
+None of `Ni`, `Nc`, `Nt5` is a multiple of any tile size — the correctness shapes include `Nc = 21` and
+`Nt5 = 41`. All tensors are CUDA and contiguous; treat them as read-only.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `B` in
+1–4 images, `Ni` in **4096–16384** image tokens, `Nc = 77` (both CLIP encoders emit 77 tokens), `Nt5` in
+{77, 256} (SD3 uses 77 T5 tokens, SD3.5 up to 256), `H = 38` with `D = 64` (SD3.5-Large) plus one
+`H = 24, D = 128` shape. Every graded shape is **0.7–3.4 TFLOP** of dense attention. Write a **general**
+kernel: the correctness shapes go down to `H = 4` and thoroughly ragged segment lengths.""",
+
+    correctness_md="""**All four** returned tensors must match the reference (evaluated in fp32 as a stable
+ground truth) within **relative Frobenius error `5e-3`** at every graded shape, including the
+timed ones; the grader scores the **worst** of the four. The three text outputs together are under 3% of
+the data and are graded exactly as hard as the image output — they are what a kernel tuned only for the
+image segment gets wrong, and they are also where a segment-boundary bug shows up first.""",
+
+    perf_md="""A dense, unmasked, perfectly load-balanced attention wrapped in a segmentation problem.
+
+* **Never build the joint Q, K, V.** The concatenation exists only to define the key axis. A flash
+  kernel's inner loop can walk the three text blocks and then the image blocks, switching base pointer at
+  each boundary; the query grid can be launched as four ranges over the four sources. Materialising
+  `concat` costs three full copies of the working set and the final split costs a fourth.
+* **The three text segments are 410 rows against up to 16384** — they are one small K/V region that every
+  query tile reads. Load them once into shared memory (or rely on L2) and fold them into the same running
+  softmax rather than giving them a second pass over the output accumulator.
+* **Fuse the head transpose into the epilogue.** The outputs want `(B, L, H*D)` while the accumulator is
+  per `(head, query tile)`; writing head-major and permuting afterwards is an extra read-modify-write of
+  the whole output.
+* **One grid for all four query ranges.** The text queries are 2–10% of the rows; three extra launches for
+  them cost three launches and three tails. A tile -> segment lookup costs one integer compare.
+* **`D = 64` at `H = 38`** means a shallow MMA K-depth and lots of heads: parallelise over
+  (query tile, head, batch) and keep the key loop long rather than splitting it.
+* Never materialise the `N x N` scores — at `Ni = 16384` that is 282M entries per head.""",
+
+    precision_md="""Q, K and V are **bfloat16**; all four outputs are **bfloat16**. The score GEMM and the
+`P V` GEMM belong on **bf16 tensor cores with fp32 accumulation**, and the online-softmax running maximum,
+sum and output accumulator must be **fp32** — a bf16 accumulator over 17k keys loses well over the whole
+error budget.
+
+`P` (the probabilities) may be rounded to bf16 before the second GEMM; that is what the tolerance is sized
+for.
+
+**Where the tolerance comes from.** `5e-3` is measured. An independent
+implementation — `scaled_dot_product_attention` on the concatenated bf16 tensors with a completely
+different tiling, against the reference's chunked fp32 loop — differs by relative Frobenius error at most
+**2.51e-3** (worst of the four outputs) over 25 (shape, seed) combinations spanning the correctness shapes
+and an 8192-token graded shape. That is essentially the bf16 rounding of the returned tensors and is the
+floor for *any* bf16-returning kernel; the gate is **2.0x** it. For contrast, swapping the CLIP-L and
+CLIP-G segments scores **1.12–1.15** (they are different tensors and land in different outputs), and
+letting each segment attend only to itself scores **3.8–13.4**.
+
+**fp8** is a legitimate strategy here and is not forbidden, but you must pay for it out of the same budget
+— there is no separate fp8 gate on this task.
+
+Do **not** infer from the reference that fp32 storage is wanted; it computes in fp32 purely to be a stable
+numerical *specification*.""",
+).validate()

tools/factory/specs/sd3_mmdit_block.py

@@ -0,0 +1,318 @@
+"""Spec for `sd3-mmdit-block` — a whole Stable Diffusion 3.5 JointTransformerBlock forward."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="sd3-mmdit-block",
+    title="Write a fast Stable Diffusion 3.5 MMDiT block (dual-stream all the way, no RoPE)",
+    blurb=("Every one of SD3.5's 38 blocks is dual-stream — unlike FLUX there is no single-stream phase at "
+           "all — so the image latents and the concatenated triple-text-encoder context each keep their own "
+           "6-way adaLN, their own QKV projection, their own QK-RMSNorm gains, their own output projection "
+           "and their own MLP, and meet only in one joint attention over the concatenation, IMAGE FIRST. "
+           "There is no rotary embedding anywhere: position was added once as a 2-D sincos table at "
+           "patchify, so the block is pure GEMM, norm and attention with a 50:1 row imbalance between the "
+           "two streams."),
+    keywords=["mle", "kernel-generation", "stable-diffusion-3", "sd3", "mmdit", "dual-stream",
+              "transformer-block", "joint-attention", "fusion", "gemm", "adaln",
+              "diffusion-transformer", "image-generation"],
+    module="sd3_block.py",
+    func="sd3_mmdit_block",
+    signature="sd3_mmdit_block(hidden, context, temb, hidden_w, context_w, num_heads, eps=1e-6)",
+    returns_doc="""One full SD3.5 JointTransformerBlock forward.
+
+Args:
+    hidden:  (B, Ni, C) bfloat16 — the image-latent stream.
+    context: (B, Nt, C) bfloat16 — the text context (CLIP-L + CLIP-G + T5, already concatenated).
+    temb:    (B, C)     bfloat16 — the timestep + pooled-text conditioning embedding.
+    hidden_w:  a 12-tuple of the IMAGE stream's parameters, in this exact order:
+              0 mod_w    (6*C, C)  1 mod_b  (6*C,)
+              2 qkv_w    (3*C, C)  3 qkv_b  (3*C,)
+              4 q_norm_w (D,)      5 k_norm_w (D,)
+              6 proj_w   (C, C)    7 proj_b (C,)
+              8 fc1_w    (Cm, C)   9 fc1_b  (Cm,)
+             10 fc2_w    (C, Cm)  11 fc2_b  (C,)
+    context_w: the same 12-tuple for the TEXT stream — entirely different tensors.
+    num_heads: int — H; D = C // H.
+    eps:     float — LayerNorm / RMSNorm epsilon.
+
+Returns:
+    (hidden_out, context_out) of shapes (B, Ni, C) and (B, Nt, C), both bfloat16.""",
+
+    reference_imports="import torch\nimport torch.nn.functional as F",
+    reference_src='''
+def sd3_mmdit_block(hidden, context, temb, hidden_w, context_w, num_heads, eps=1e-6):
+    """The whole SD3.5 joint block, one torch op at a time, in fp32.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target. The attention loop
+    chunks queries only so the fp32 score matrix fits in memory.
+    """
+    B, Ni, C = hidden.shape
+    Nt = context.shape[1]
+    H = num_heads
+    D = C // H
+    N = Ni + Nt
+
+    (h_modw, h_modb, h_qkvw, h_qkvb, h_qn, h_kn, h_pw, h_pb, h_f1w, h_f1b, h_f2w, h_f2b) = hidden_w
+    (c_modw, c_modb, c_qkvw, c_qkvb, c_qn, c_kn, c_pw, c_pb, c_f1w, c_f1b, c_f2w, c_f2b) = context_w
+
+    sv = F.silu(temb.float())
+    hm = sv @ h_modw.float().t() + h_modb.float()                       # (B, 6C)
+    cm = sv @ c_modw.float().t() + c_modb.float()
+
+    def _P(m, i):
+        return m[:, i * C:(i + 1) * C].unsqueeze(1)                     # (B, 1, C)
+
+    def _rms(t, g):
+        return t * torch.rsqrt(t.pow(2).mean(-1, keepdim=True) + eps) * g.float()
+
+    def _pre(x, m, qkvw, qkvb, qn, kn):
+        L = x.shape[1]
+        xn = F.layer_norm(x.float(), (C,), None, None, eps)
+        xm = (xn * (1.0 + _P(m, 1)) + _P(m, 0)).to(torch.bfloat16)
+        qkv = (xm.float() @ qkvw.float().t() + qkvb.float()).reshape(B, L, 3, H, D)
+        return (_rms(qkv[:, :, 0], qn).permute(0, 2, 1, 3),
+                _rms(qkv[:, :, 1], kn).permute(0, 2, 1, 3),
+                qkv[:, :, 2].permute(0, 2, 1, 3))
+
+    hq, hk, hv = _pre(hidden, hm, h_qkvw, h_qkvb, h_qn, h_kn)
+    cq, ck, cv = _pre(context, cm, c_qkvw, c_qkvb, c_qn, c_kn)
+
+    # IMAGE FIRST, then context -- this is the SD3 concatenation order. No rotary embedding.
+    q = torch.cat([hq, cq], dim=2)                                      # (B, H, N, D)
+    k = torch.cat([hk, ck], dim=2)
+    v = torch.cat([hv, cv], dim=2)
+
+    sa = D ** -0.5
+    attn = torch.zeros(B, N, H, D, device=hidden.device, dtype=torch.float32)
+    for b in range(B):
+        qb = q[b] * sa
+        kb = k[b]
+        vb = v[b]
+        for s0 in range(0, N, 512):
+            e = min(s0 + 512, N)
+            p = torch.softmax(qb[:, s0:e] @ kb.transpose(1, 2), dim=-1)
+            attn[b, s0:e] = (p @ vb).transpose(0, 1)
+
+    def _post(x, a, m, pw, pb, f1w, f1b, f2w, f2b):
+        x1 = x.float() + _P(m, 2) * (a @ pw.float().t() + pb.float())
+        xn = F.layer_norm(x1, (C,), None, None, eps)
+        xm = xn * (1.0 + _P(m, 4)) + _P(m, 3)
+        h = F.gelu(xm @ f1w.float().t() + f1b.float(), approximate="tanh")
+        return (x1 + _P(m, 5) * (h @ f2w.float().t() + f2b.float())).to(torch.bfloat16)
+
+    hidden_out = _post(hidden, attn[:, :Ni].reshape(B, Ni, C), hm,
+                       h_pw, h_pb, h_f1w, h_f1b, h_f2w, h_f2b)
+    context_out = _post(context, attn[:, Ni:].reshape(B, Nt, C), cm,
+                        c_pw, c_pb, c_f1w, c_f1b, c_f2w, c_f2b)
+    return hidden_out, context_out
+''',
+    make_inputs_src='''
+def _mk(B, Ni, Nt, H, D, Cm, seed):
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    C = H * D
+
+    def r(*sh, s=1.0):
+        return (torch.randn(*sh, device="cuda", generator=gen) * s).to(torch.bfloat16)
+
+    def stream():
+        return (r(6 * C, C, s=0.02), r(6 * C, s=0.05),
+                r(3 * C, C, s=1.7 * C ** -0.5), r(3 * C, s=0.05),
+                (1.0 + 0.2 * torch.randn(D, device="cuda", generator=gen)).to(torch.bfloat16),
+                (1.0 + 0.2 * torch.randn(D, device="cuda", generator=gen)).to(torch.bfloat16),
+                r(C, C, s=C ** -0.5), r(C, s=0.05),
+                r(Cm, C, s=C ** -0.5), r(Cm, s=0.05),
+                r(C, Cm, s=Cm ** -0.5), r(C, s=0.05))
+
+    ch = torch.exp(0.6 * (2 * torch.rand(C, device="cuda", generator=gen) - 1))
+
+    def act(L):
+        return (torch.randn(B, L, C, device="cuda", generator=gen) * ch
+                + torch.randn(B, L, 1, device="cuda", generator=gen)).to(torch.bfloat16)
+
+    return act(Ni), act(Nt), r(B, C), stream(), stream(), H
+''',
+    flops_src='''
+def canonical_work(B, Ni, Nt, H, D, Cm):
+    """FLOPs attributed to one block forward, from the SHAPE ALONE.
+
+    Per stream, with L rows: a (L, C) x (C, 3C) QKV projection, a (L, C) x (C, C) output projection and a
+    two-layer MLP (L, C) x (C, Cm) + (L, Cm) x (Cm, C) -- 2 FLOPs per multiply-accumulate. Plus one joint
+    attention over N = Ni + Nt tokens, bidirectional and unmasked, at 4*D FLOPs per (query, key) pair per
+    head. The two 6-way adaLN projections are (B, C) x (C, 6C) and are four orders of magnitude smaller;
+    the LayerNorms, RMSNorms, GELU, softmax, gates and residuals are elementwise and are not counted.
+    """
+    C = H * D
+    N = Ni + Nt
+    return 2 * B * N * C * (4 * C + 2 * Cm) + 4 * B * H * D * N * N
+''',
+    flops_formula="2*B*(Ni+Nt)*C*(4*C + 2*Cm) + 4*B*H*D*(Ni+Nt)**2,  C = H*D",
+
+    metric="TFLOP/s",
+    compare="tuple",
+    tuple_names=("hidden_out", "context_out"),
+    tol=4.5e-3,     # MEASURED -- see precision_md
+    shape_names=("B", "Ni", "Nt", "H", "D", "Cm"),
+    grader_shapes=[(1, 16384, 333, 38, 64, 9728), (2, 10240, 333, 38, 64, 9728),
+                   (2, 8192, 333, 38, 64, 9728), (4, 4096, 154, 38, 64, 9728),
+                   (1, 16384, 154, 24, 64, 6144)],
+    measure_shapes=[(1, 15360, 333, 38, 64, 9728), (2, 9216, 333, 38, 64, 9728),
+                    (2, 7680, 154, 38, 64, 9728), (3, 4096, 333, 38, 64, 9728),
+                    (1, 14336, 154, 24, 64, 6144)],
+    measure_quick_shapes=[(1, 2048, 333, 38, 64, 9728), (2, 1024, 154, 38, 64, 9728),
+                          (1, 1536, 77, 12, 64, 3072)],
+    correct_shapes=[(1, 517, 77, 4, 64, 1024), (2, 333, 65, 8, 64, 2048),
+                    (1, 1024, 333, 38, 64, 9728), (3, 129, 13, 6, 64, 1536)],
+
+    spec_md="""One complete SD3.5 `JointTransformerBlock`. Two token sequences, two full parameter sets,
+one shared conditioning embedding, and exactly one point of contact — the joint attention.
+`C = num_heads * D`.
+
+**Step 1 — 6-way adaLN, once per stream (different matrices, same `temb`):**
+
+```
+hm = silu(temb) @ hidden_w.mod_w.T + hidden_w.mod_b      # (B, 6C)
+cm = silu(temb) @ context_w.mod_w.T + context_w.mod_b
+chunks, in order:  [ shift_msa | scale_msa | gate_msa | shift_mlp | scale_mlp | gate_mlp ]
+                        0            1           2           3           4          5
+```
+
+**Step 2 — attention prologue, once per stream:**
+
+```
+xm    = layer_norm(x, (C,), None, None, eps) * (1 + scale_msa) + shift_msa
+qkv   = xm @ qkv_w.T + qkv_b                            # (B, L, 3C), laid out [3][H][D]
+q,k,v = split(qkv)                                      # each (B, L, H, D) -> (B, H, L, D)
+q     = q * rsqrt(mean_d(q^2) + eps) * q_norm_w         # per (token, head), over D only
+k     = k * rsqrt(mean_d(k^2) + eps) * k_norm_w
+```
+
+**Step 3 — joint attention over the concatenation, IMAGE FIRST**, bidirectional, no mask:
+
+```
+q = concat([hidden_q, context_q], dim=2)                # (B, H, N, D), N = Ni + Nt; same for k, v
+attn = softmax( (D ** -0.5) * q k^T ) v
+hidden_attn, context_attn = attn[:, :, :Ni], attn[:, :, Ni:]
+```
+
+**There is no rotary embedding.** SD3 adds position once, as a 2-D sincos table on the patch embeddings,
+before the first block — nothing in this block is position-dependent.
+
+**Step 4 — epilogue, once per stream, with that stream's own weights and gates:**
+
+```
+x1 = x  + gate_msa * (x_attn @ proj_w.T + proj_b)       # x_attn is (B, L, C) after merging heads
+xn = layer_norm(x1, (C,), None, None, eps) * (1 + scale_mlp) + shift_mlp
+h  = gelu_tanh(xn @ fc1_w.T + fc1_b)
+out = x1 + gate_mlp * (h @ fc2_w.T + fc2_b)
+```
+
+`gelu_tanh` is exactly `torch.nn.functional.gelu(z, approximate="tanh")`. `V` is not normalised. Note the
+second LayerNorm is taken on `x1`, **after** the attention residual — the two sub-layers are chained.
+
+`/app/reference.py` writes all of this out as separate fp32 torch ops. That is the exact specification; it
+is deliberately simple rather than fast, and its runtime has no bearing on your score.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `hidden` | `(B, Ni, C)` | `bfloat16` | image-latent stream, `C = num_heads * D` |
+| `context` | `(B, Nt, C)` | `bfloat16` | text context, the three encoders already concatenated |
+| `temb` | `(B, C)` | `bfloat16` | timestep + pooled-text embedding, one row per image |
+| `hidden_w` | 12-tuple | `bfloat16` | the image stream's parameters (order below) |
+| `context_w` | 12-tuple | `bfloat16` | the text stream's parameters — **entirely different tensors** |
+| `num_heads` | scalar | `int` | `H`; `D = C // H` |
+| `eps` | scalar | `float` | LayerNorm **and** RMSNorm epsilon (`1e-6`) |
+
+Each parameter tuple is, **in this exact index order**:
+
+| idx | name | shape | | idx | name | shape |
+|-----|------|-------|-|-----|------|-------|
+| 0 | `mod_w` | `(6*C, C)` | | 6 | `proj_w` | `(C, C)` |
+| 1 | `mod_b` | `(6*C,)` | | 7 | `proj_b` | `(C,)` |
+| 2 | `qkv_w` | `(3*C, C)` | | 8 | `fc1_w` | `(Cm, C)` |
+| 3 | `qkv_b` | `(3*C,)` | | 9 | `fc1_b` | `(Cm,)` |
+| 4 | `q_norm_w` | `(D,)` | | 10 | `fc2_w` | `(C, Cm)` |
+| 5 | `k_norm_w` | `(D,)` | | 11 | `fc2_b` | `(C,)` |
+
+All weights use the `nn.Linear` `(out, in)` layout. The QKV output axis is ordered `[3][H][D]`.
+
+**Return** a 2-tuple `(hidden_out, context_out)` **in that order**, shapes `(B, Ni, C)` and `(B, Nt, C)`,
+both **`bfloat16`**.
+
+The joint sequence is **image first**: joint row `n < Ni` is an image token. That is the model's order;
+attention is permutation-invariant in the key axis, so it is bookkeeping rather than arithmetic here, but
+it fixes which rows land in which returned tensor. `Ni` and `Nt` are **not**
+multiples of any tile size, and `Nt` is one to two orders of magnitude smaller than `Ni`. All tensors are
+CUDA and contiguous; treat them as read-only.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `B` in
+1–4 images, `Ni` in **4096–16384** image tokens (SD3.5 patchifies a 1024x1024 latent to 4096 tokens and a
+2048x2048 one to 16384), `Nt` in {154, 333} context tokens (77 CLIP + 77 or 256 T5), `H = 38`, `D = 64`
+(so `C = 2432`, the SD3.5-Large width) with a narrower `H = 24, D = 64` shape as well, `Cm = 4*C`. Every
+graded shape is **2.6–5.2 TFLOP**, split roughly half and half between the GEMMs and the attention.
+Write a **general** kernel: the correctness shapes go down to `H = 4`, `C = 256` and thoroughly ragged
+lengths.""",
+
+    correctness_md="""**Both** returned tensors must match the reference (evaluated in fp32 as a stable
+ground truth) within **relative Frobenius error `4.5e-3`** at every graded shape, including the
+timed ones, and the grader scores the **worse** of the two. `context_out` is 1–4% of the data and is graded
+exactly as hard as `hidden_out` — which is the point, because it is the part a kernel tuned for the image
+stream gets wrong.""",
+
+    perf_md="""Everything in this block happens **twice**, with `M ~ 10^4` and `M ~ 10^2`. That asymmetry,
+not the arithmetic, is what separates a good implementation from a mediocre one.
+
+* **Fuse the two streams' identically-shaped GEMMs into grouped GEMMs.** There are four pairs — QKV,
+  output projection, MLP fc1, MLP fc2 — and in each pair the two problems share a shape but not a weight.
+  Run each pair as a **2-group grouped GEMM** in one launch, with a tile -> group lookup selecting the
+  weight, bias, gate and residual. Eight sequential `torch.matmul`s, four of which cannot fill a single
+  wave, is where the naive implementation loses most of its time.
+* **`D = 64` changes the attention's shape.** SD3.5-Large runs 38 heads of 64 channels rather than 24 of
+  128: the `Q K^T` GEMM has half the K depth, so the score matrix costs the same but the MMA pipeline is
+  shallower and you need more key-tile parallelism to keep it fed. There is no mask, so the loop is dense
+  and perfectly load-balanced.
+* **The QKV epilogue is three fused ops** — split `[3][H][D]`, RMS-normalise Q and K per head, and write
+  into the *joint* q/k/v buffers at the right offset with the head transpose. Done as separate torch ops
+  that is four more round-trips of a `(B, L, 3C)` tensor; done in the GEMM epilogue it is free, and the
+  "concatenation" is just a different output base pointer.
+* **The MLP hidden is the biggest intermediate** — `Cm = 9728` wide. Fuse the GELU into `fc1`'s epilogue
+  and store bf16, or fuse `fc1 -> GELU -> fc2` so it never reaches HBM.
+* **The two adaLN passes and the two LayerNorms are bandwidth, not compute.** Fuse each LayerNorm with its
+  modulate (and the second one with the preceding gated residual) into a single pass, and fuse both
+  streams into one launch.
+* Both `(B, C) x (C, 6C)` modulation projections are negligible — compute them once and keep the twelve
+  parameter rows resident.
+
+CUTLASS / CuTe DSL is installed and its grouped-GEMM plus epilogue-visitor machinery is the natural fit;
+Triton works too if you write the group lookup yourself.""",
+
+    precision_md="""All activations and weights are **bfloat16**; both outputs are **bfloat16**. Every GEMM
+belongs on **bf16 tensor cores with fp32 accumulation**.
+
+What must be fp32: both LayerNorms' mean/variance, the RMSNorm mean-of-squares and `rsqrt`, the softmax
+running max/sum/accumulator, the GELU, and each gated residual before its rounding to bf16. In particular
+`x1` — the intermediate residual after the attention sub-layer — must be **formed in fp32 and the second
+LayerNorm taken on that fp32 value**.
+
+Intermediate *activations* (the modulated tensors, QKV after the norm, the attention output, the MLP
+hidden) may all be stored in bf16 — that is what the tolerance is sized for.
+
+**Where the tolerance comes from.** `4.5e-3` is measured. An independent bf16
+implementation — LayerNorm arithmetic written out instead of `F.layer_norm`, `addmm` in bf16 for all eight
+GEMMs, `scaled_dot_product_attention` in place of the chunked fp32 loop, and every intermediate rounded to
+bf16 — differs from this fp32 reference by relative Frobenius error at most **2.23e-3** over 25
+(shape, seed) combinations spanning the correctness shapes and a 4096-token graded shape. The gate is
+**2.0x** that floor. For contrast, skipping the QK-RMSNorm scores **7.7e-2–4.0e-1**, 17x the gate at
+worst. Two things this block does turn out **not** to be gradeable and are documented as conventions
+rather than as arithmetic: the image-first concatenation order (attention is permutation-invariant in the
+key axis, and the two streams are returned separately) and the tanh-vs-erf choice of GELU, which moves the
+output by about the same 1e-3 as bf16 rounding does.
+
+**fp8** is plausible for the four GEMM pairs, but the block's error budget is shared across a long chain —
+if you quantise, do it in one place and measure.
+
+Do **not** infer from the reference that fp32 storage is wanted; it computes in fp32 purely to be a stable
+numerical *specification*.""",
+).validate()

tools/factory/specs/sd3_pos_embed_interpolate.py

@@ -0,0 +1,233 @@
+"""Spec for `sd3-pos-embed-interpolate` — SD3 patch embed + bilinearly interpolated 2-D sincos positions."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="sd3-pos-embed-interpolate",
+    title="Write a fast SD3 patch-embed + interpolated 2-D position embedding",
+    blurb=("SD3 has no rotary embedding: position enters the model exactly once, as a fixed 2-D sincos "
+           "table added to the patch embeddings. The table is built for one base grid, so every "
+           "resolution other than the native one needs it BILINEARLY RESAMPLED to the target grid before "
+           "it is added. The kernel is therefore a strided 2x2x16 gather feeding a skinny (64 -> 2432) "
+           "projection, plus a float32 table resample whose source addresses are a non-integer function of "
+           "the output coordinate — a gather, a GEMV and an interpolation that all want to be one pass."),
+    keywords=["mle", "kernel-generation", "stable-diffusion-3", "sd3", "patch-embed", "positional-embedding",
+              "interpolation", "memory-bound", "diffusion-transformer", "image-generation"],
+    module="sd3_patch_embed.py",
+    func="sd3_patch_pos_embed",
+    signature="sd3_patch_pos_embed(lat, proj_w, proj_b, pos_base, patch)",
+    returns_doc="""SD3 patch embedding plus the resampled 2-D position table.
+
+Args:
+    lat:      (B, Cin, Hp, Wp) bfloat16 — the VAE latent.
+    proj_w:   (C, Cin*patch*patch) bfloat16 — the patch projection, nn.Linear layout (out, in).
+    proj_b:   (C,) bfloat16 — its bias.
+    pos_base: (base, base, C) float32 — the 2-D sincos position table at its base grid.
+    patch:    int — the patch side (2 for SD3).
+
+Returns:
+    out: (B, (Hp//patch)*(Wp//patch), C) bfloat16 — patch tokens with position added, row-major.""",
+
+    reference_imports="import torch",
+    reference_src='''
+def sd3_patch_pos_embed(lat, proj_w, proj_b, pos_base, patch):
+    """Patchify, project, and add the bilinearly resampled position table, in fp32.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target.
+    """
+    B, Cin, Hp, Wp = lat.shape
+    P = patch
+    gh, gw = Hp // P, Wp // P
+    base, _, C = pos_base.shape
+    dev = lat.device
+
+    # patchify: token (i, j) is the (Cin, P, P) block at (i*P, j*P), flattened channel-major
+    x = lat.float().reshape(B, Cin, gh, P, gw, P).permute(0, 2, 4, 1, 3, 5)
+    x = x.reshape(B, gh * gw, Cin * P * P)
+    tok = x @ proj_w.float().t() + proj_b.float()                    # (B, N, C)
+
+    def _axis(g):
+        s = base / g
+        src = torch.clamp(((torch.arange(g, device=dev, dtype=torch.float32) + 0.5) * s - 0.5), min=0.0)
+        i0 = torch.floor(src).to(torch.int64).clamp(max=base - 1)
+        i1 = torch.clamp(i0 + 1, max=base - 1)
+        return i0, i1, (src - i0.float())
+
+    y0, y1, wy = _axis(gh)
+    x0, x1, wx = _axis(gw)
+    t = pos_base
+    top = t[y0][:, x0] * (1.0 - wx)[None, :, None] + t[y0][:, x1] * wx[None, :, None]
+    bot = t[y1][:, x0] * (1.0 - wx)[None, :, None] + t[y1][:, x1] * wx[None, :, None]
+    pos = top * (1.0 - wy)[:, None, None] + bot * wy[:, None, None]  # (gh, gw, C)
+
+    return (tok + pos.reshape(1, gh * gw, C)).to(torch.bfloat16)
+''',
+    make_inputs_src='''
+def _mk(B, Hp, Wp, Cin, C, P, base, seed):
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    lat = (torch.randn(B, Cin, Hp, Wp, device="cuda", generator=gen) * 1.5).to(torch.bfloat16)
+    K = Cin * P * P
+    proj_w = (torch.randn(C, K, device="cuda", generator=gen) * K ** -0.5).to(torch.bfloat16)
+    proj_b = (torch.randn(C, device="cuda", generator=gen) * 0.05).to(torch.bfloat16)
+
+    # a real 2-D sincos table: half the channels encode the row, half the column
+    half = C // 2
+    omega = 1.0 / (10000.0 ** (torch.arange(half // 2, device="cuda", dtype=torch.float32) / (half // 2)))
+    grid = torch.arange(base, device="cuda", dtype=torch.float32)
+    ang = grid[:, None] * omega[None, :]                              # (base, half/2)
+    emb = torch.cat([torch.sin(ang), torch.cos(ang)], dim=-1)         # (base, half)
+    pos = torch.cat([emb[:, None, :].expand(base, base, half),
+                     emb[None, :, :].expand(base, base, half)], dim=-1).contiguous()
+    return lat, proj_w, proj_b, pos.float(), P
+''',
+    flops_src='''
+def canonical_work(B, Hp, Wp, Cin, C, P, base):
+    """BYTES attributed to this pass, from the SHAPE ALONE.
+
+    Read the latent (Cin*P*P bf16 values per token), write the token stream (C bf16 channels per token),
+    and read the float32 base table once. The (C, Cin*P*P) projection weight is tiny and fully reused and
+    is not counted. This is a bandwidth kernel, so the score is achieved bandwidth against this fixed
+    byte count.
+    """
+    N = (Hp // P) * (Wp // P)
+    return 2 * B * N * (Cin * P * P + C) + 4 * base * base * C
+''',
+    flops_formula="2*B*(Hp//P)*(Wp//P)*(Cin*P*P + C) + 4*base*base*C",
+
+    metric="GB/s",
+    compare="tensor",
+    tol=4e-4,     # MEASURED -- see precision_md
+    shape_names=("B", "Hp", "Wp", "Cin", "C", "P", "base"),
+    grader_shapes=[(24, 256, 256, 16, 2432, 2, 64), (16, 288, 288, 16, 2432, 2, 64),
+                   (12, 352, 352, 16, 2432, 2, 64), (32, 192, 192, 16, 2432, 2, 64),
+                   (48, 160, 160, 16, 2432, 2, 64)],
+    measure_shapes=[(20, 256, 256, 16, 2432, 2, 64), (16, 256, 288, 16, 2432, 2, 64),
+                    (12, 320, 320, 16, 2432, 2, 64), (28, 192, 192, 16, 2432, 2, 64),
+                    (40, 160, 160, 16, 2432, 2, 64)],
+    measure_quick_shapes=[(4, 128, 128, 16, 2432, 2, 64), (2, 192, 192, 16, 2432, 2, 64),
+                          (8, 64, 64, 16, 1536, 2, 32)],
+    correct_shapes=[(1, 34, 46, 16, 512, 2, 32), (2, 26, 26, 16, 768, 2, 32),
+                    (3, 120, 136, 16, 2432, 2, 64), (1, 18, 50, 8, 1536, 2, 24)],
+
+    spec_md="""Patchify the latent, project each patch to `C` channels, and add the position table
+resampled to the token grid.
+
+**1. Patchify + project.** With `gh = Hp // P` and `gw = Wp // P`, token `n = i*gw + j` (row-major) is the
+`(Cin, P, P)` block at `(i*P, j*P)`, flattened **channel-major** — index `((c*P) + pi)*P + pj`:
+
+```
+tok[b, i*gw + j, :] = proj_w @ vec(lat[b, :, i*P:(i+1)*P, j*P:(j+1)*P]) + proj_b
+```
+
+That is exactly a `Conv2d(Cin, C, kernel=P, stride=P)` with its weight flattened to `(C, Cin*P*P)`.
+
+**2. Resample the position table** from `(base, base, C)` to `(gh, gw, C)` by **bilinear** interpolation
+with the half-pixel convention. Per axis, with `g` the target length:
+
+```
+s      = base / g
+src(i) = max(0, (i + 0.5) * s - 0.5)
+i0     = min(floor(src(i)), base - 1)
+i1     = min(i0 + 1, base - 1)
+w(i)   = src(i) - i0                                  # in [0, 1)
+```
+
+and then, with `(y0, y1, wy)` from the row axis and `(x0, x1, wx)` from the column axis,
+
+```
+pos[i, j] = (1-wy)*(1-wx) * T[y0, x0]  +  (1-wy)*wx * T[y0, x1]
+          +   wy  *(1-wx) * T[y1, x0]  +    wy  *wx * T[y1, x1]
+```
+
+This is the same convention as `align_corners=False` bilinear resampling, including the clamp of a
+negative source coordinate to 0. Note `gh` and `gw` are resampled **independently**, and either can be
+larger or smaller than `base`.
+
+**3. Add and round.**
+
+```
+out[b, n, :] = tok[b, n, :] + pos[n // gw, n % gw, :]        # bfloat16
+```
+
+`/app/reference.py` writes all of this out as separate fp32 torch ops with an advanced-indexing gather.
+That is the exact specification; it is deliberately simple rather than fast, and its runtime has no
+bearing on your score.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `lat` | `(B, Cin, Hp, Wp)` | `bfloat16` | the VAE latent; `Hp` and `Wp` are multiples of `patch` |
+| `proj_w` | `(C, Cin*P*P)` | `bfloat16` | patch projection, `(out, in)`; input index `((c*P)+pi)*P+pj` |
+| `proj_b` | `(C,)` | `bfloat16` | projection bias |
+| `pos_base` | `(base, base, C)` | `float32` | 2-D sincos table at the base grid, row axis first |
+| `patch` | scalar | `int` | patch side, always 2 at the graded shapes |
+
+**Return** a single tensor of shape `(B, (Hp//P)*(Wp//P), C)` and dtype **`bfloat16`**, with the token axis
+**row-major over the grid**: token `n` is at `(i, j) = (n // gw, n % gw)`.
+
+`pos_base` is **float32 and shared by the whole batch** — it does not depend on `b`. The resampled table
+likewise does not depend on `b`, so it is computed once for the whole call.
+
+`gh` and `gw` are **not** multiples of any tile size and are **not** equal in general — the correctness
+shapes include `17 x 23`, `60 x 68` and `9 x 25` token grids, and both up-sampling (`g > base`) and down-sampling
+(`g < base`) occur. All tensors are CUDA and contiguous; treat them as read-only.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `B` in
+12–48 images per batch, `Hp` and `Wp` in **160–352** latent pixels (an SD3 latent is the image divided by
+8, so 256 corresponds to a 2048x2048 image and 160 to 1280x1280), `Cin = 16`, `C = 2432` (the SD3.5-Large
+width), `P = 2`, `base = 64`. Every graded shape moves **1.4–1.9 GiB**. Batching is the point: the patch
+embed runs once per denoising step, so it only ever matters as a throughput kernel over a batch. Write a
+**general** kernel: the correctness shapes go down to `C = 512`, `Cin = 8`, `base = 24` and thoroughly
+ragged grids.""",
+
+    correctness_md="""Your output must match the reference (evaluated in fp32 as a stable ground truth)
+within **relative Frobenius error `4e-4`** at every graded shape, including the timed ones.
+
+The resampling convention is the part that is easy to get wrong and is graded hard: nearest-neighbour
+instead of bilinear, or the `align_corners=True` coordinate mapping, both land orders of magnitude outside
+the gate.""",
+
+    perf_md="""A `Cin*P*P = 64`-wide read, a `C = 2432`-wide write, and a table lookup between them.
+
+* **The write dominates.** 64 bf16 in, 2432 bf16 out per token — a **1:38** read-to-write ratio, the
+  inverse of the final layer's. The output store must be perfectly coalesced and vectorised along `C`.
+* **Resample the table ONCE, not per image.** `pos` is `(gh, gw, C)` and independent of `b`; computing it
+  in a small prologue kernel (or in the first CTA wave into a workspace) and then streaming it is far
+  cheaper than redoing four fp32 gathers per output element for every batch element. At `B = 24` that is a
+  24x difference on the interpolation work.
+* **Better: keep the row weights per tile.** A tile of tokens in one grid row shares `y0`, `y1` and `wy`,
+  and consecutive columns share nothing but are contiguous in the table's `x` axis — so a tile can load
+  two table rows into shared memory and interpolate on the fly with no workspace at all.
+* **The projection is a skinny GEMM (`K = 64`, `N = 2432`) and is memory bound.** `proj_w` is only
+  `2432 x 64` and is reused by every token of every image: hold it in shared memory, and give each CTA a
+  few tokens so the `K = 64` reduction stays in registers.
+* **The patchify gather is strided.** Token `(i, j)` needs `lat[b, :, i*P:(i+1)*P, j*P:(j+1)*P]`, which is
+  `Cin` rows of 2 contiguous bf16 values at a `Wp` stride. Reading a whole `P`-row band of the latent into
+  shared memory and re-indexing there beats per-token strided loads.
+* Watch the ragged grid: `gh` and `gw` are arbitrary, so the last tile of each row is partial.""",
+
+    precision_md="""`lat`, `proj_w`, `proj_b` and the output are **bfloat16**; `pos_base` is **float32**.
+
+What must be fp32: the projection accumulator, the four interpolation weights and their combination, and
+the final add. The table is fp32 for a reason — the sincos values are the same for every image and every
+step, and rounding them to bf16 before the interpolation is a coherent error on a term that is added
+directly to the output.
+
+**Where the tolerance comes from.** `4e-4` is measured. An independent
+implementation — `F.conv2d` for the patch projection and `F.interpolate(mode="bilinear",
+align_corners=False)` for the resample, against the reference's explicit gather and matmul — differs by
+relative Frobenius error at most **4.29e-5** over 25 (shape, seed) combinations spanning the correctness
+shapes and a 96x96-grid graded shape. (That the two agree to 4e-5 is also the check that the resampling
+convention written above really is `align_corners=False`.) The gate is **9.3x** that floor, and it is
+below every way of getting the position term wrong: nearest-neighbour resampling scores
+**3.1e-2–3.6e-2** (78x the gate), the `align_corners=True` coordinate mapping scores **2.1e-3–9.3e-3**
+(5.2x), rounding the fp32 table to bf16 before interpolating scores **1.0e-3–1.1e-3** (2.5x), and
+omitting the position entirely scores **0.42**.
+
+**fp8 is not useful here** and is not expected — this is a bandwidth kernel with a `K = 64` projection.
+
+Do **not** infer from the reference that fp32 storage is wanted; it computes in fp32 purely to be a stable
+numerical *specification*.""",
+).validate()

tools/factory/specs/sd3_qkv_proj_qknorm.py

@@ -0,0 +1,220 @@
+"""Spec for `sd3-qkv-proj-qknorm` — SD3.5's dual-stream QKV projection with a fused QK-RMSNorm epilogue."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="sd3-qkv-proj-qknorm",
+    title="Write a fast SD3.5 dual-stream QKV projection (2-group GEMM, fused QK-RMSNorm, joint write)",
+    blurb=("Both halves of every SD3.5 block project their own QKV: one (Ni, C) x (C, 3C) GEMM for the "
+           "image latents and one (Nt, C) x (C, 3C) GEMM for the concatenated text context, with different "
+           "weights and a 50:1 row imbalance. Whatever they produce then has to be de-interleaved into "
+           "[3][H][D], RMS-normalised per head with four different gain vectors, transposed to head-major "
+           "and written into ONE joint Q/K/V triple with the image first — so the interesting part is not "
+           "the matmul, it is that the matmul's epilogue is a norm, a transpose and a concatenation at once."),
+    keywords=["mle", "kernel-generation", "stable-diffusion-3", "sd3", "mmdit", "grouped-gemm",
+              "epilogue-fusion", "rmsnorm", "diffusion-transformer", "image-generation"],
+    module="sd3_qkv.py",
+    func="sd3_qkv_proj_qknorm",
+    signature="sd3_qkv_proj_qknorm(hidden, context, hidden_w, context_w, num_heads, eps=1e-6)",
+    returns_doc="""Both streams' QKV projections, QK-RMSNormed and joined image-first.
+
+Args:
+    hidden:  (B, Ni, C) bfloat16 — the already-modulated image-latent stream.
+    context: (B, Nt, C) bfloat16 — the already-modulated text context stream.
+    hidden_w:  4-tuple (qkv_w (3*C, C), qkv_b (3*C,), q_norm_w (D,), k_norm_w (D,)) bfloat16.
+    context_w: the same 4-tuple for the text stream — entirely different tensors.
+    num_heads: int — H; D = C // H.
+    eps:     float — RMSNorm epsilon.
+
+Returns:
+    (q, k, v), each (B, H, Ni + Nt, D) bfloat16, image tokens occupying rows [0, Ni).""",
+
+    reference_imports="import torch",
+    reference_src='''
+def sd3_qkv_proj_qknorm(hidden, context, hidden_w, context_w, num_heads, eps=1e-6):
+    """Two QKV projections with a norm + transpose + join epilogue, one torch op at a time, in fp32.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target.
+    """
+    B, Ni, C = hidden.shape
+    Nt = context.shape[1]
+    H = num_heads
+    D = C // H
+
+    def _rms(t, g):
+        return t * torch.rsqrt(t.pow(2).mean(-1, keepdim=True) + eps) * g.float()
+
+    def _one(x, w):
+        qkv_w, qkv_b, qn, kn = w
+        L = x.shape[1]
+        p = (x.float() @ qkv_w.float().t() + qkv_b.float()).reshape(B, L, 3, H, D)
+        return _rms(p[:, :, 0], qn), _rms(p[:, :, 1], kn), p[:, :, 2]
+
+    hq, hk, hv = _one(hidden, hidden_w)
+    cq, ck, cv = _one(context, context_w)
+
+    # IMAGE FIRST, then context; head-major
+    q = torch.cat([hq, cq], dim=1).permute(0, 2, 1, 3).contiguous().to(torch.bfloat16)
+    k = torch.cat([hk, ck], dim=1).permute(0, 2, 1, 3).contiguous().to(torch.bfloat16)
+    v = torch.cat([hv, cv], dim=1).permute(0, 2, 1, 3).contiguous().to(torch.bfloat16)
+    return q, k, v
+''',
+    make_inputs_src='''
+def _mk(B, Ni, Nt, H, D, seed):
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    C = H * D
+
+    def r(*sh, s=1.0):
+        return (torch.randn(*sh, device="cuda", generator=gen) * s).to(torch.bfloat16)
+
+    def w():
+        # per-head output scales vary, which is exactly what the QK-RMSNorm is there to remove
+        sc = torch.exp(0.5 * (2 * torch.rand(3, H, 1, device="cuda", generator=gen) - 1))
+        m = (torch.randn(3, H, D, C, device="cuda", generator=gen) * (1.7 * C ** -0.5) * sc[..., None])
+        return (m.reshape(3 * C, C).to(torch.bfloat16), r(3 * C, s=0.05),
+                (1.0 + 0.2 * torch.randn(D, device="cuda", generator=gen)).to(torch.bfloat16),
+                (1.0 + 0.2 * torch.randn(D, device="cuda", generator=gen)).to(torch.bfloat16))
+
+    # both streams arrive already LayerNormed and modulated: roughly unit variance, per-channel gain
+    ch = torch.exp(0.4 * (2 * torch.rand(C, device="cuda", generator=gen) - 1))
+
+    def act(L):
+        return (torch.randn(B, L, C, device="cuda", generator=gen) * ch).to(torch.bfloat16)
+
+    return act(Ni), act(Nt), w(), w(), H
+''',
+    flops_src='''
+def canonical_work(B, Ni, Nt, H, D):
+    """FLOPs attributed to both QKV projections, from the SHAPE ALONE.
+
+    Per stream with L rows: (L, C) x (C, 3C), 2 FLOPs per multiply-accumulate. The per-head RMSNorm, the
+    de-interleave, the head transpose and the join are elementwise or pure layout and are not counted --
+    they are exactly the overhead you are expected to fuse into the epilogue.
+    """
+    C = H * D
+    return 2 * B * (Ni + Nt) * C * 3 * C
+''',
+    flops_formula="2*B*(Ni+Nt)*C*3*C,  C = H*D",
+
+    metric="TFLOP/s",
+    compare="tuple",
+    tuple_names=("q", "k", "v"),
+    tol=6e-3,     # MEASURED -- see precision_md
+    shape_names=("B", "Ni", "Nt", "H", "D"),
+    grader_shapes=[(1, 16384, 333, 38, 64), (2, 12288, 333, 38, 64),
+                   (4, 8192, 333, 38, 64), (8, 4096, 333, 38, 64),
+                   (2, 16384, 154, 24, 128)],
+    measure_shapes=[(1, 15360, 333, 38, 64), (2, 11264, 333, 38, 64),
+                    (4, 7680, 154, 38, 64), (6, 4096, 333, 38, 64),
+                    (2, 14336, 154, 24, 128)],
+    measure_quick_shapes=[(1, 4096, 333, 38, 64), (2, 2048, 154, 38, 64), (1, 1536, 77, 12, 64)],
+    correct_shapes=[(1, 517, 77, 4, 64), (2, 333, 65, 8, 64),
+                    (1, 2048, 333, 38, 64), (3, 129, 13, 6, 128)],
+
+    spec_md="""Two independent QKV projections and one fused epilogue. `C = num_heads * D`.
+
+```
+# per stream, with that stream's own weights:
+p       = x @ qkv_w.T + qkv_b                        # (B, L, 3C), the output axis is ordered [3][H][D]
+q, k, v = p.reshape(B, L, 3, H, D) split on axis 2   # each (B, L, H, D)
+
+q = q * rsqrt(mean_d(q^2) + eps) * q_norm_w          # per (token, head), over D only
+k = k * rsqrt(mean_d(k^2) + eps) * k_norm_w
+# v is not normalised
+
+# then join IMAGE FIRST and transpose to head-major
+q = concat([hidden_q, context_q], dim=1).permute(0, 2, 1, 3)      # (B, H, Ni + Nt, D)
+# same for k and v
+```
+
+Four different gain vectors are in play: the image stream and the text stream each have their own Q gain
+and K gain. The RMSNorm is over the **head dimension `D` of one token**, not over the full `C`, and the
+same `(D,)` gain is shared by every head of that stream.
+
+There is **no rotary embedding** — SD3 adds position once as a 2-D sincos table at patchify, so nothing
+here is position-dependent.
+
+`/app/reference.py` writes this out as separate fp32 torch ops with a `cat` and a `permute`. That is the
+exact specification; it is deliberately simple rather than fast, and its runtime has no bearing on your
+score.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `hidden` | `(B, Ni, C)` | `bfloat16` | image stream, already LayerNormed and modulated |
+| `context` | `(B, Nt, C)` | `bfloat16` | text stream, already LayerNormed and modulated |
+| `hidden_w` | 4-tuple | `bfloat16` | `(qkv_w (3C,C), qkv_b (3C,), q_norm_w (D,), k_norm_w (D,))` |
+| `context_w` | 4-tuple | `bfloat16` | same shapes, **entirely different tensors** |
+| `num_heads` | scalar | `int` | `H`; `D = C // H` |
+| `eps` | scalar | `float` | RMSNorm epsilon (`1e-6`) |
+
+Both weight matrices use the `nn.Linear` `(out, in)` layout, and their output axis is ordered `[3][H][D]`
+— all heads of Q, then all heads of K, then all heads of V.
+
+**Return** a 3-tuple `(q, k, v)` **in that order**, each `(B, Ni + Nt, D)` promoted to head-major
+`(B, H, Ni + Nt, D)` and **`bfloat16`**, with the **image** stream occupying rows `[0, Ni)` of the token
+axis and the text stream rows `[Ni, Ni + Nt)`.
+
+`Ni` and `Nt` are **not** multiples of any tile size, and `Nt` is one to two orders of magnitude smaller
+than `Ni`. All tensors are CUDA and contiguous; treat them as read-only.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `B` in
+1–8 images, `Ni` in **4096–16384** image tokens, `Nt` in {154, 333} context tokens, `H = 38` with `D = 64`
+(so `C = 2432`, the SD3.5-Large width) plus one `H = 24, D = 128` shape. Every graded shape is
+**0.6–1.9 TFLOP** in the GEMMs and writes **0.6–1.9 GB** of output, so the epilogue's bandwidth is a real
+part of the cost and not a rounding error. Write a **general** kernel: the correctness shapes go down to
+`H = 4`, `C = 256` and ragged lengths.""",
+
+    correctness_md="""**All three** returned tensors must match the reference (evaluated in fp32 as a
+stable ground truth) within **relative Frobenius error `6e-3`** at every graded shape, including
+the timed ones; the grader scores the **worst** of the three. `v` exercises only the projection and the
+layout, so it is effectively an exactness check on your GEMM, while `q` and `k` additionally exercise the
+per-head norm and the choice of gain vector.""",
+
+    perf_md="""Two GEMMs with a 50:1 row imbalance and an epilogue that is three things at once.
+
+* **Run the pair as a 2-group grouped GEMM in ONE launch.** The two problems share `(C, 3C)` but not the
+  weight; a tile -> group lookup picks the weight, the bias, the two gain vectors and the output row
+  offset. Two sequential `torch.matmul`s leave the machine idle through the second one, which has a few
+  hundred rows.
+* **The join is a row offset, not a copy.** Image tiles write to joint rows `[0, Ni)` and context tiles to
+  `[Ni, Ni+Nt)`. Building the two halves and calling `cat` is a full extra round-trip of the three largest
+  tensors here.
+* **The per-head RMSNorm wants the tile to span a whole head.** The mean-of-squares is over the `D`
+  channels of one `(token, head)`; if your N-tile covers `D` columns of one head the reduction is a
+  register/warp reduction inside the epilogue, and if it does not you need a cross-tile pass and the
+  fusion is gone. With `D = 64` a 64-wide N-tile is the natural choice; note the three sections `[0, C)`,
+  `[C, 2C)`, `[2C, 3C)` need different treatment (Q gain, K gain, nothing).
+* **The head transpose is a scatter.** Accumulator element `(b, n, h, d)` lands at `q[b, h, n, d]`, a
+  stride-`N*D` jump per head; stage through shared memory so the global stores stay coalesced along `d`.
+* **`K = C` is only 2432.** Do not split-K: you have plenty of tiles from `M = 10^4` and `3C` columns, and
+  split-K would force the norm into a second pass, which is the one thing this task is about avoiding.
+* The four gain vectors are `D` values each and fully reused — keep them in registers.
+
+CUTLASS / CuTe DSL is installed and its grouped-GEMM plus epilogue-visitor machinery fits this exactly;
+Triton works too if you write the group and section lookups yourself.""",
+
+    precision_md="""Activations, weights and all three outputs are **bfloat16**. The GEMM belongs on
+**bf16 tensor cores with fp32 accumulation**.
+
+What must be fp32: the GEMM accumulator, the RMSNorm mean-of-squares and `rsqrt`, and the gain multiply.
+Round to bf16 only when storing. Accumulating `q^2` over `D` channels in bf16 costs roughly an order of
+magnitude more than the gate allows.
+
+**Where the tolerance comes from.** `6e-3` is measured. An independent implementation —
+a bf16 `addmm` instead of the fp32 matmul, the de-interleave by indexing rather than slicing, and the
+RMSNorm written out by hand — differs from this fp32 reference by relative Frobenius error at most
+**2.82e-3** (worst of the three outputs) over 20 (shape, seed) combinations spanning the correctness
+shapes and a 2048-token graded shape. The gate is **2.1x** that floor, and it is two orders of magnitude
+below what the distinguishing pieces cost: skipping the QK-RMSNorm scores **0.83–1.08**, joining
+context-before-image scores **1.41**, and normalising over the whole `C` instead of per head scores
+**0.16–0.26**.
+
+**fp8** for the projection is possible but will eat most of this budget on its own — measure before you
+commit.
+
+Do **not** infer from the reference that fp32 storage is wanted; it computes in fp32 purely to be a stable
+numerical *specification*.""",
+).validate()

tools/factory/specs/seqparallel_partial_norm.py

@@ -0,0 +1,214 @@
+"""Spec for `seqparallel-partial-norm` — the sequence/tensor-parallel RMSNorm: per-shard partial sums of
+squares for the all-reduce, and the normalisation against the combined statistic, over a rank-major layout."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="seqparallel-partial-norm",
+    title="Write a fast sequence-parallel RMSNorm kernel (per-shard partials + combined normalisation)",
+    blurb=("At the sequence-parallel to tensor-parallel boundary the hidden dimension is split across "
+           "ranks, so a norm whose statistic spans the whole hidden vector cannot be computed locally. "
+           "Each rank reduces its own shard, the partials are all-reduced, and only then can anything be "
+           "normalised. The single-GPU work is the awkward half: a residual add, a partial sum of squares "
+           "per (token, shard) in the rank-major layout the collective produced, and a second pass that "
+           "normalises against the combined statistic with each shard's own gain."),
+    keywords=["mle", "kernel-generation", "sequence-parallel", "tensor-parallel", "rmsnorm", "partial-sum",
+              "all-reduce", "residual", "distributed", "training", "memory-bound"],
+    module="sp_norm.py",
+    func="seqparallel_partial_norm",
+    signature="seqparallel_partial_norm(x, res, g, eps=1e-6)",
+    returns_doc="""Sequence-parallel RMSNorm over a hidden dimension sharded across W ranks.
+
+Args:
+    x:   (W, S, Hs) bfloat16 — this block's output, rank-major: block w is rank w's hidden shard.
+    res: (W, S, Hs) bfloat16 — the incoming residual stream, same layout.
+    g:   (W, Hs)    bfloat16 — the RMSNorm gain, also sharded across the ranks.
+    eps: float               — added to the mean square before the reciprocal square root.
+
+Returns:
+    (h, partial, y) where
+      h:       (W, S, Hs) bfloat16 — the updated residual stream, x + res
+      partial: (W, S)     float32  — per (shard, token) sum of squares of h; the all-reduce payload
+      y:       (W, S, Hs) bfloat16 — h * rsqrt(sum_w partial / H + eps) * g, with H = W*Hs""",
+
+    reference_imports="import torch",
+    reference_src='''
+def seqparallel_partial_norm(x, res, g, eps=1e-6):
+    """Residual add, per-shard partial sums, then normalise against the combined statistic, in fp32.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target. Every line
+    materialises another full-size fp32 temporary in HBM.
+    """
+    W, S, Hs = x.shape
+    H = W * Hs
+    h = x.float() + res.float()                                   # the updated residual stream
+    partial = (h * h).sum(dim=-1)                                 # (W, S) -- what each rank all-reduces
+    total = partial.sum(dim=0)                                    # (S,)  -- after the all-reduce
+    scale = torch.rsqrt(total / H + eps)                          # (S,)
+    y = h * scale.view(1, S, 1) * g.float().unsqueeze(1)
+    return h.to(torch.bfloat16), partial, y.to(torch.bfloat16)
+''',
+    make_inputs_src='''
+def _mk(W, S, Hs, seed):
+    """A rank-major activation block: W hidden shards of Hs channels, S tokens, plus the sharded gain.
+
+    The shards do NOT have equal scale. In a trained model the hidden channels' magnitudes vary by several
+    times across the vector, so which rank a channel lands on matters, and a shard's own mean square is a
+    poor estimate of the whole vector's. That is exactly why the partials have to be all-reduced.
+    """
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    shard_scale = (0.25 + 1.75 * torch.rand(W, 1, 1, device="cuda", generator=gen))
+    x = (torch.randn(W, S, Hs, device="cuda", dtype=torch.float32, generator=gen) * shard_scale).bfloat16()
+    res = (torch.randn(W, S, Hs, device="cuda", dtype=torch.float32, generator=gen)
+           * 2.0 * shard_scale).bfloat16()
+    g = (1.0 + 0.1 * torch.randn(W, Hs, device="cuda", dtype=torch.float32, generator=gen)).bfloat16()
+    return x, res, g, 1e-6
+''',
+    flops_src='''
+def canonical_work(W, S, Hs):
+    """BYTES attributed to one sequence-parallel norm, from the SHAPE ALONE.
+
+    Read x and res (2 bytes/elt each), write h and y (2 each). The (W, S) partial vector and the (W, Hs)
+    gain are 1/Hs and 1/S of the traffic and are not counted. Bandwidth-bound: the score is achieved
+    bandwidth against that fixed 8-bytes-per-element count.
+    """
+    return 8 * W * S * Hs
+''',
+    flops_formula="canonical_work(W, S, Hs) = (2 + 2 + 2 + 2) * W*S*Hs = 8 * W*S*Hs bytes",
+
+    metric="GB/s",
+    compare="tuple",
+    tuple_names=("h", "partial", "y"),
+    tol=1e-4,
+    shape_names=("W", "S", "Hs"),
+    grader_shapes=[(8, 16384, 1536), (4, 16384, 3072), (8, 12288, 2048),
+                   (16, 8192, 1024), (2, 24576, 5120)],
+    measure_shapes=[(8, 12288, 1536), (4, 12288, 3072), (8, 10240, 2048),
+                    (16, 6144, 1024), (2, 20480, 5120)],
+    measure_quick_shapes=[(4, 2048, 1024), (8, 1024, 512), (2, 4096, 2048)],
+    correct_shapes=[(4, 64, 128), (3, 129, 96), (8, 17, 200), (2, 256, 33), (5, 33, 64)],
+
+    spec_md="""The hidden dimension `H = W * Hs` is split across `W` tensor-parallel ranks and the
+activation arrives **rank-major**: `x[w]` is rank `w`'s `Hs`-wide shard of every token. The block is
+
+```
+h[w, s, j]     = x[w, s, j] + res[w, s, j]                            # residual add, in fp32
+partial[w, s]  = sum over j of h[w, s, j]^2                           # each rank's own contribution
+total[s]       = sum over w of partial[w, s]                          # what the all-reduce produces
+y[w, s, j]     = h[w, s, j] * rsqrt( total[s] / H + eps ) * g[w, j]   # H = W*Hs, the FULL hidden size
+```
+
+Three things are easy to get wrong and all three are graded.
+
+**The normaliser spans every shard.** `total[s]` sums over all `W` of them, and it is divided by the
+**full** `H`, not by `Hs`. Normalising a shard against its own partial is the classic mistake and it
+changes every output.
+
+**`partial` is an output in its own right.** It is the buffer that goes on the wire, so it is graded
+against the reference just like `y`, and it must be accumulated in **fp32** — the sum is over `Hs`
+elements of squares and a bf16 accumulator loses it.
+
+**The gain is sharded too.** `g[w, j]` belongs to shard `w`; it is indexed by the shard, not by a global
+channel index.
+
+`h` is returned as well because the residual stream is what the next block consumes, and re-deriving it
+costs a second pass over `x` and `res`.
+
+`/app/reference.py` computes each of those lines as a separate full-size fp32 tensor. That is the exact
+specification; it is deliberately simple rather than fast.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `x` | `(W, S, Hs)` | `bfloat16` | this block's output, rank-major over the hidden shards |
+| `res` | `(W, S, Hs)` | `bfloat16` | the incoming residual stream, same layout |
+| `g` | `(W, Hs)` | `bfloat16` | the RMSNorm gain, sharded the same way |
+| `eps` | scalar | `float` | keyword argument, default `1e-6` |
+
+**Return** a 3-tuple `(h, partial, y)` **in that order**:
+
+| out | shape | dtype | notes |
+|-----|-------|-------|-------|
+| `h` | `(W, S, Hs)` | `bfloat16` | `x + res`, rounded once |
+| `partial` | `(W, S)` | `float32` | per-shard sum of squares of `h`, **fp32** |
+| `y` | `(W, S, Hs)` | `bfloat16` | normalised and gained output |
+
+`partial` is computed from the **fp32** `h` (i.e. `x.float() + res.float()`), not from the bf16 `h` that is
+returned. `Hs` is not a multiple of any tile size (`Hs = 33`, `Hs = 200` appear in the correctness shapes)
+and neither is `S`. All inputs are read-only.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `W`
+(tensor-parallel ranks sharing the hidden dimension) 2–16, `S` (tokens in the sequence-parallel region)
+8192–24576, `Hs` (channels per shard) 1024–5120, so the full hidden size `W*Hs` is 10240–12288 and the
+block holds **200–250 M activation elements**, 1.6–2.0 GB of traffic. This runs twice per transformer
+block (pre-attention and pre-MLP norm) on every stage of every step.""",
+
+    correctness_md="""**All three** returned values must match the reference within **relative error
+`1e-4`** at every graded shape, including the timed ones; the grader scores the **worst** of the three.
+
+`h` is a bf16 rounding of an fp32 add and carries no freedom at all, so a correct kernel reproduces it bit
+for bit. `partial` is an fp32 reduction over `Hs` elements — the accumulation order is yours. `y` inherits
+the tiny variation in `partial` through an `rsqrt`, plus its own bf16 rounding.
+
+The gate is **measured**, and everything this task exists to test is orders of magnitude outside it:
+normalising each shard against its own partial instead of the combined total scores **0.52**, dividing by
+`Hs` instead of `H` scores **0.65**, dropping the residual add scores **1.05**, applying the gain with a
+global channel index instead of a per-shard one scores **0.14**, and accumulating `partial` in bf16 scores
+**1.4e-3** — the closest of them, and still 14x outside.""",
+
+    perf_md="""Eight bytes per element and about four flops — a bandwidth kernel, and your score is
+achieved bandwidth against one read of `x` and `res` and one write of `h` and `y`.
+
+The reference is ~3x off it: `x.float() + res.float()` writes a full fp32 `h` to HBM, `(h*h).sum(-1)` reads
+it back, and the final line reads it a third time and writes an fp32 `y` before the cast.
+
+The structural problem is that `y` needs `total[s]`, which needs **every shard** of token `s`, and those
+shards are `S*Hs` elements apart in memory. Two shapes of solution:
+
+1. **Two passes, `h` cached.** Pass one computes `h` (writing the bf16 output you owe anyway) and the
+   partials; pass two re-reads `h` — which is bf16, not fp32 — and writes `y`. That is 2+2 read and 2+2
+   write, exactly the counted traffic, and the second pass reads back what is likely still in L2 for the
+   smaller shapes.
+2. **One pass, token-resident.** Assign a whole token — all `W*Hs = H` channels, spread across `W` blocks
+   of the buffer — to one program. `H` is 10240–12288, i.e. 20–24 KB of bf16, which fits in shared memory
+   or even registers on a large block. Then the reduction is entirely local, no second read of `h` is
+   needed, and the traffic is exactly the floor. The catch is the strided access: the `W` pieces of a
+   token are `S*Hs` apart, so each is its own coalesced run and you want them all in flight at once.
+
+Either way:
+
+- **Accumulate in fp32**, reduce within the warp with shuffles, and keep the per-shard partials separate —
+  you need all `W` of them as an output, not just their sum.
+- **Compute `rsqrt` once per token**, in fp32, and broadcast it.
+- **`g` is tiny and fully reused** (`W*Hs` values for `S` tokens) — hold it in shared memory.
+- **Ragged `Hs`.** The correctness shapes go down to `Hs = 33`; guard the tail off the main path.""",
+
+    precision_md="""Activations and the gain are **bfloat16**; the residual add, the sum of squares, the
+`rsqrt` and the scaling are all **fp32**. `partial` is returned in fp32 because that is what goes on the
+wire — a bf16 all-reduce of a sum of squares is not accurate enough, and the measured cost of accumulating
+it in bf16 is **1.4e-3**, 14x the gate.
+
+`h` is the bf16 rounding of the fp32 sum `x + res`; `partial` is computed from the **fp32** value, before
+that rounding. Do not compute the partial from the rounded `h` — it is a different number, and the
+reference's is the specification.
+
+Use a proper `rsqrt` (`rsqrt.rn` or torch's `torch.rsqrt`); a fast approximate reciprocal square root has
+~1e-3 of relative error on its own and would eat the entire budget.
+
+**fp8 is not useful here** and is not expected: the dtypes are fixed by the contract.
+
+**Where the tolerance comes from (measured, not guessed).** An independent implementation — the sum of
+squares taken as a chunked two-stage tree instead of a single `sum(-1)`, the normalisation folded into the
+gain as one fp32 multiplier per (shard, token) rather than two separate multiplies, and `y` produced with
+`torch.addcmul` — differs from the reference by **`E = 1.4e-5`** at a full graded shape and `0.0` at every
+correctness shape. Essentially all of that is the bf16 rounding of `y` moving by one code when the two
+multiplies are reassociated; `partial` agreed to 5.3e-8 and `h` bit for bit. The gate is set at **`1e-4`**,
+7x the measured floor — enough room for any sensible fp32 reduction tree and multiply ordering, and still
+14x below the cost of accumulating `partial` in bf16.
+
+Drop-the-feature measurements at a graded shape: per-shard normaliser instead of the combined total
+**D = 0.52**; dividing by `Hs` instead of `H` **D = 0.65**; no residual add **D = 1.05**; the gain applied
+with a global channel index **D = 0.14**; `partial` accumulated in bf16 **D = 1.4e-3**.""",
+).validate()

tools/factory/specs/sliding_window_sink_attn.py

@@ -80,10 +80,8 @@ def canonical_work(B, T, H, D, W):
     compare="tensor",
     tol=5e-3,
     shape_names=("B", "T", "H", "D", "W"),
-    grader_shapes=[(1, 8192, 16, 128, 1024), (2, 8192, 8, 128, 2048), (1, 16384, 8, 128, 1024),
-                   (1, 8192, 16, 64, 2048), (2, 4096, 16, 128, 512)],
-    measure_shapes=[(1, 6144, 16, 128, 1024), (2, 6144, 8, 128, 1536), (1, 12288, 8, 128, 2048),
-                    (1, 4096, 16, 128, 512), (2, 8192, 8, 64, 1024)],
+    grader_shapes=[(1, 16384, 16, 128, 1024), (2, 16384, 8, 128, 2048), (1, 32768, 8, 128, 1024), (1, 16384, 16, 64, 2048), (2, 8192, 16, 128, 512)],
+    measure_shapes=[(1, 12288, 16, 128, 1024), (2, 12288, 8, 128, 1536), (1, 24576, 8, 128, 2048), (1, 8192, 16, 128, 512), (2, 16384, 8, 64, 1024)],
     measure_quick_shapes=[(1, 2048, 8, 128, 512), (2, 1024, 8, 128, 256), (1, 2048, 16, 64, 1024)],
     correct_shapes=[(1, 256, 4, 64, 64), (2, 512, 8, 128, 128), (1, 512, 4, 128, 1024), (2, 128, 4, 64, 33)],
 
@@ -140,7 +138,7 @@ All tensors are CUDA and contiguous. No GQA (`q`, `k`, `v` share the same `H`),
 no RoPE, no dropout, no additional bias, no ALiBi. Treat all inputs as read-only.""",
 
     regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `B` in 1–2,
-`T` in 4096–16384, `H` in 8–16, `D` in {64, 128}, `W` in 512–2048 — and `W` is always much smaller than `T`,
+`T` in 8192–32768, `H` in 8–16, `D` in {64, 128}, `W` in 512–2048 — and `W` is always much smaller than `T`,
 which is the whole point of the pattern. Write a **general** kernel: it must handle both head dimensions and
 an arbitrary integer `W`, including `W >= T`.
 

tools/factory/specs/sparse24_backward_densify.py

@@ -0,0 +1,225 @@
+"""Spec for `sparse24-backward-densify` — the backward of a 2:4-sparse linear: densify the 2-bit mask to
+apply SR-STE's decay to the pruned weights, and compress the incoming gradient onto the kept positions."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="sparse24-backward-densify",
+    title="Write a fast 2:4 sparse-training backward kernel (SR-STE decay + gradient compression)",
+    blurb=("Training with 2:4 sparsity keeps a DENSE master weight and re-prunes it every step, so the "
+           "backward has to do two opposite things at once. The straight-through estimator passes the "
+           "gradient to the dense weight, plus SR-STE's decay term that pushes the currently-pruned entries "
+           "toward zero — which needs the 2-bit metadata densified back into a full mask. And the sparse "
+           "optimiser state lives in the compressed layout, so the same gradient has to be gathered onto "
+           "the kept positions. One pass over three full-size tensors, both directions of the format."),
+    keywords=["mle", "kernel-generation", "sparsity", "2:4", "structured-sparsity", "sr-ste", "backward",
+              "straight-through", "sparse-training", "training", "memory-bound"],
+    module="srste_bwd.py",
+    func="srste_backward",
+    signature="srste_backward(w, dy, meta, lam)",
+    returns_doc="""Backward of a 2:4-sparse linear under SR-STE.
+
+Args:
+    w:    (M, K)    bfloat16 — the DENSE master weight.
+    dy:   (M, K)    bfloat16 — the gradient with respect to the pruned (sparse) weight.
+    meta: (M, K//8) uint8    — the current 2:4 mask, 2 bits per kept entry, two groups per byte.
+    lam:  ()        float32  — 0-dim tensor, the SR-STE decay coefficient.
+
+Returns:
+    (dw, dvals) where
+      dw:    (M, K)    bfloat16 — dy + lam * w  on the PRUNED positions, dy alone on the kept ones
+      dvals: (M, K//2) bfloat16 — dy at the KEPT positions, compressed, ascending column order""",
+
+    reference_imports="import torch",
+    reference_src='''
+def _decode(meta, M, K):
+    """meta -> (M, K//4, 2) int64 slot indices of the two kept entries per group."""
+    mi = meta.int()
+    q = torch.stack([mi & 3, (mi >> 2) & 3, (mi >> 4) & 3, (mi >> 6) & 3], dim=-1)   # (M, K//8, 4)
+    return q.reshape(M, K // 4, 2).long()
+
+
+def srste_backward(w, dy, meta, lam):
+    """Densify the mask, apply the SR-STE decay, and gather the gradient onto the kept positions.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target. It materialises a
+    full-size boolean mask and several full-size fp32 temporaries.
+    """
+    M, K = w.shape
+    idx = _decode(meta, M, K)
+    keep = torch.zeros(M, K // 4, 4, device=w.device, dtype=torch.bool).scatter_(-1, idx, True)
+    pruned_w = torch.where(keep.view(M, K), torch.zeros_like(w), w)          # only the dropped entries
+    dw = (dy.float() + lam * pruned_w.float()).bfloat16()                    # SR-STE
+    dvals = torch.gather(dy.view(M, K // 4, 4), -1, idx).view(M, K // 2)     # compressed gradient
+    return dw, dvals
+''',
+    make_inputs_src='''
+_LO = [0, 0, 0, 1, 1, 2]      # the six ways to choose 2 of 4
+_HI = [1, 2, 3, 2, 3, 3]
+
+
+def _mk(M, K, seed):
+    """A dense master weight, its incoming gradient, and the 2:4 mask from the last re-prune."""
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    w = (torch.randn(M, K, device="cuda", dtype=torch.float32, generator=gen) * 0.02).bfloat16()
+    dy = (torch.randn(M, K, device="cuda", dtype=torch.float32, generator=gen) * 2e-4).bfloat16()
+    pat = torch.randint(0, 6, (M, K // 4), device="cuda", dtype=torch.int64, generator=gen)
+    lo = torch.tensor(_LO, device="cuda", dtype=torch.int32)[pat]
+    hi = torch.tensor(_HI, device="cuda", dtype=torch.int32)[pat]
+    nib = (lo | (hi << 2)).view(M, K // 8, 2)
+    meta = (nib[..., 0] | (nib[..., 1] << 4)).to(torch.uint8)
+    # SR-STE's decay is chosen so the decay term is comparable to the gradient itself -- if it were
+    # negligible the task would not be measuring it, and if it dominated nothing else would be.
+    lam = torch.tensor(1e-2, device="cuda", dtype=torch.float32)
+    return w, dy, meta, lam
+''',
+    flops_src='''
+def canonical_work(M, K):
+    """BYTES attributed to one backward, from the SHAPE ALONE.
+
+    Read w (2*M*K), dy (2*M*K) and the metadata (M*K/8); write dw (2*M*K) and the compressed gradient
+    (2*M*K/2 = M*K). The decay coefficient is a scalar. Bandwidth-bound: the score is achieved bandwidth
+    against that fixed count.
+    """
+    return 2 * M * K + 2 * M * K + M * K // 8 + 2 * M * K + M * K
+''',
+    flops_formula="canonical_work(M, K) = 2*M*K + 2*M*K + M*K/8 + 2*M*K + M*K = 7.125 * M*K bytes",
+
+    metric="GB/s",
+    compare="tuple",
+    tuple_names=("dw", "dvals"),
+    tol=1e-4,
+    shape_names=("M", "K"),
+    grader_shapes=[(24576, 12288), (16384, 20480), (32768, 10240), (12288, 24576), (28672, 11264)],
+    measure_shapes=[(20480, 12288), (14336, 20480), (28672, 10240), (10240, 24576), (24576, 11264)],
+    measure_quick_shapes=[(4096, 4096), (2048, 8192), (8192, 2048)],
+    correct_shapes=[(64, 128), (129, 64), (17, 256), (256, 24), (33, 8)],
+
+    spec_md="""A 2:4-sparse linear keeps a **dense** master weight `w` and a mask that says which two of
+every four entries the forward pass actually used. `meta` is that mask in the compressed form: byte `t` of
+row `m` describes groups `2t` and `2t+1`,
+
+```
+i0(2t)   = (meta[m,t] >> 0) & 3     i1(2t)   = (meta[m,t] >> 2) & 3
+i0(2t+1) = (meta[m,t] >> 4) & 3     i1(2t+1) = (meta[m,t] >> 6) & 3
+keep[m, 4g + i0(g)] = keep[m, 4g + i1(g)] = true ,  the other two slots false
+```
+
+Two outputs come out of the same pass.
+
+**`dw` — the SR-STE gradient for the dense weight.** The straight-through estimator sends `dy` to every
+entry of `w`; SR-STE (sparse-refined STE, the standard 2:4 training recipe) adds a decay on the entries the
+mask currently drops, so they keep shrinking and the mask can stabilise:
+
+```
+dw[m, k] = dy[m, k]                          if keep[m, k]
+dw[m, k] = dy[m, k] + lam * w[m, k]          otherwise
+```
+
+computed in fp32 and rounded **once** to bf16. Note which side gets the decay: the **pruned** entries, not
+the kept ones. Applying it to the kept entries instead is the classic sign error and it is what the gate is
+watching for.
+
+**`dvals` — the gradient in the compressed layout.** The sparse optimiser state is stored the same way the
+weight is, so the gradient has to be gathered onto the kept positions, in ascending column order:
+
+```
+dvals[m, 2g]     = dy[m, 4g + i0(g)]
+dvals[m, 2g + 1] = dy[m, 4g + i1(g)]
+```
+
+That is a bit-exact gather — no arithmetic.
+
+So the kernel densifies the metadata into a mask (for `dw`) and uses it as a gather map (for `dvals`), in
+one pass, without ever writing a mask to memory. `K` is a multiple of 8.
+
+`/app/reference.py` scatters a full-size boolean mask, builds an fp32 copy of the pruned weight and gathers
+with `torch.gather`. That is the exact specification; it is deliberately simple rather than fast.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `w` | `(M, K)` | `bfloat16` | the dense master weight |
+| `dy` | `(M, K)` | `bfloat16` | gradient w.r.t. the pruned weight |
+| `meta` | `(M, K//8)` | `uint8` | the current 2:4 mask, 2 bits per kept entry |
+| `lam` | `()` | `float32` | 0-dim tensor, the SR-STE decay coefficient |
+
+**Return** a 2-tuple `(dw, dvals)` **in that order**:
+
+| out | shape | dtype | notes |
+|-----|-------|-------|-------|
+| `dw` | `(M, K)` | `bfloat16` | fp32 arithmetic, one rounding to bf16 |
+| `dvals` | `(M, K//2)` | `bfloat16` | bit-exact gather of `dy` at the kept positions |
+
+`lam` is a **0-dim tensor**, not a python float — multiply by it directly. `K` is a multiple of 8 and
+nothing more (the correctness shapes include `K = 24` and `K = 8`); `M` is not a multiple of any tile size.
+All inputs are read-only; the call is functional.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `M`
+12288–32768, `K` 10240–24576, with `M*K` around **300 M elements** — one large projection of a
+frontier-scale model under 2:4 sparse fine-tuning, about 2.1 GB of traffic per weight per step. This runs
+for every weight in the backward of every step, alongside the re-prune, so it is a fixed tax on sparse
+training.""",
+
+    correctness_md="""**Both** returned values must match the reference within **relative error `1e-4`** at
+every graded shape, including the timed ones; the grader scores the **worse** of the two.
+
+`dvals` carries no arithmetic — it is a bf16 gather — so a correct kernel reproduces it **bit for bit**.
+The whole budget exists for `dw`, whose only freedom is whether `dy + lam*w` is evaluated as an FMA or as a
+separate multiply and add; that moves a handful of values across a bf16 rounding boundary and nothing more.
+
+The gate is **measured**, and the mistakes this task exists to catch are nearly four orders of magnitude
+outside it: applying the decay to the KEPT entries instead of the pruned ones scores **0.82**, dropping the
+decay term altogether scores **0.58**, and using the metadata's nibbles in the wrong order scores **0.58**
+on `dw` while getting 83% of the `dvals` groups wrong.""",
+
+    perf_md="""Just over seven bytes per element and two flops — entirely a bandwidth problem, and your
+score is achieved bandwidth against one read of `w`, `dy` and `meta` and one write of `dw` and `dvals`.
+
+The reference is several times that: `scatter_` writes a full-size boolean mask to HBM, `torch.where`
+reads it back, `.float()` materialises two full-size fp32 temporaries, and `torch.gather` makes yet another
+pass with a full-size int64 index tensor.
+
+The kernel to write handles **eight columns (two groups, one metadata byte) per lane**:
+
+- One 128-bit load of `w` and one of `dy` give 8 bf16 values each; one byte of `meta` decodes both groups.
+- Decode with a 16-entry constant table (nibble -> the two slots, or nibble -> a 4-bit keep mask) held in
+  registers or shared memory. The keep mask makes `dw` a branch-free select between `dy` and
+  `fma(lam, w, dy)`; the slot pair makes `dvals` two register selects.
+- The stores are a 128-bit write to `dw` and a 64-bit write to `dvals` — both naturally aligned when a
+  thread owns 8 consecutive columns.
+- **Never materialise the mask.** It exists only in registers.
+- `meta` is 1/16th of the traffic of `w`; read it once and keep it.
+- **Ragged tails.** `M` is arbitrary and `K` can be 8; guard the tail off the main path.
+
+The read:write ratio is 4:3, so both directions have to stay saturated — this is a kernel where a
+non-temporal store on `dw` (which nothing re-reads) is worth trying.""",
+
+    precision_md="""Everything is **bfloat16** except `lam`, which is a **0-dim fp32 tensor**. Do the
+`dy + lam * w` arithmetic in **fp32** and round once to bf16; do not add in bf16.
+
+`dvals` involves no arithmetic at all and must be a bit-exact gather of `dy`.
+
+`lam` is a tensor rather than a python float on purpose: `tensor * python_float` goes through a
+reciprocal/scalar path in torch and would introduce a rounding difference that has nothing to do with this
+kernel. Multiply by the 0-dim tensor.
+
+**fp8 is not useful here** and is not expected — the dtypes are fixed by the contract.
+
+**Where the tolerance comes from (measured, not guessed).** An independent implementation — the mask
+decoded through a 16-entry nibble lookup table with no `scatter_`, `dw` computed with `torch.addcmul`
+(a fused multiply-add) instead of a separate multiply and add, and `dvals` built by two `torch.where`
+selects instead of `torch.gather` — differs from the reference by **`E = 7.5e-11`** at a full graded shape
+and `0.0` at every correctness shape, entirely in `dw` (`dvals` matched bit for bit everywhere). The only
+freedom in this kernel is whether the multiply-add is fused, and that almost never crosses a bf16 rounding
+boundary. The gate is set at **`1e-4`** rather than 2x the measured floor, as a deliberate cushion: an
+implementation whose fp32 intermediate differs by one ulp everywhere would flip roughly one bf16 value in
+2^15, worth about **2e-5** of relative error, and `1e-4` covers that with margin while still sitting ~6000x
+below the cheapest algorithmic mistake.
+
+Drop-the-feature measurements at a graded shape: decay applied to the kept entries instead of the pruned
+ones **D = 0.82**; no decay term at all **D = 0.58**; metadata nibbles swapped **D = 0.58** on `dw` with
+83% of the `dvals` groups wrong.""",
+).validate()

tools/factory/specs/sparse24_compress_layout.py

@@ -0,0 +1,202 @@
+"""Spec for `sparse24-compress-layout` — turn an already-2:4-sparse matrix into the half-size value buffer
+plus the packed 2-bit index metadata that a sparse tensor core actually consumes."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="sparse24-compress-layout",
+    title="Write a fast 2:4 compression kernel (half-size values + packed 2-bit metadata)",
+    blurb=("A 2:4-pruned weight is still stored densely, half of it zeros — that saves nothing. The format "
+           "the sparse tensor cores take is a COMPRESSED one: a (M, K/2) buffer holding only the survivors, "
+           "plus two bits per survivor saying which of the four slots it came from, packed four indices to "
+           "a byte. Compressing is what actually halves the weight traffic of a sparse layer, it runs on "
+           "every weight after every re-prune, and the metadata is a bit-exact integer contract."),
+    keywords=["mle", "kernel-generation", "sparsity", "2:4", "structured-sparsity", "compression",
+              "metadata", "bit-packing", "sparse-tensor-core", "training", "memory-bound"],
+    module="compress24.py",
+    func="compress_24",
+    signature="compress_24(a)",
+    returns_doc="""Compress a 2:4-sparse matrix into the sparse-tensor-core layout.
+
+Args:
+    a: (M, K) bfloat16 — already 2:4 sparse: EXACTLY two of every aligned group of four columns are
+                         non-zero, the other two are exactly +0.0. K is a multiple of 8.
+
+Returns:
+    (vals, meta) where
+      vals: (M, K//2) bfloat16 — the survivors only, in ascending column order
+      meta: (M, K//8) uint8    — 2 bits per survivor; byte t carries groups 2t and 2t+1""",
+
+    reference_imports="import torch",
+    reference_src='''
+def compress_24(a):
+    """Compact the survivors and pack their indices two bits at a time.
+
+    Correct and simple — it is the SPECIFICATION, not a performance target. It materialises a full-size
+    boolean mask, uses it to index the survivors out, and builds the metadata with min/max reductions.
+    """
+    M, K = a.shape
+    g = a.view(M, K // 4, 4)
+    nz = g != 0
+    vals = g[nz].view(M, K // 2)                       # survivors, row-major => ascending column order
+
+    ar = torch.arange(4, device=a.device, dtype=torch.uint8).expand_as(nz)
+    i0 = torch.where(nz, ar, torch.full_like(ar, 9)).amin(-1).int()     # first survivor's slot
+    i1 = torch.where(nz, ar, torch.zeros_like(ar)).amax(-1).int()       # second survivor's slot
+    nib = (i0 | (i1 << 2)).view(M, K // 8, 2)                           # 4 bits per group
+    meta = (nib[..., 0] | (nib[..., 1] << 4)).to(torch.uint8)           # two groups per byte
+    return vals, meta
+''',
+    make_inputs_src='''
+LO = [0, 0, 0, 1, 1, 2]      # the six ways to choose 2 of 4, as (first, second)
+HI = [1, 2, 3, 2, 3, 3]
+
+
+def _mk(M, K, seed):
+    """A weight that is already exactly 2:4 sparse: a random 2-of-4 pattern per group, random values.
+
+    The surviving values are drawn from a normal distribution; the roughly one in 2^24 samples that comes
+    out exactly zero is replaced, so the "exactly two non-zeros per group" invariant holds to the element.
+    """
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    v = (torch.randn(M, K, device="cuda", dtype=torch.float32, generator=gen) * 0.02).bfloat16()
+    v = torch.where(v == 0, torch.full_like(v, 0.01), v)          # keep every survivor strictly non-zero
+    pat = torch.randint(0, 6, (M, K // 4), device="cuda", dtype=torch.int64, generator=gen)
+    lo = torch.tensor(LO, device="cuda", dtype=torch.uint8)[pat]
+    hi = torch.tensor(HI, device="cuda", dtype=torch.uint8)[pat]
+    ar = torch.arange(4, device="cuda", dtype=torch.uint8).view(1, 1, 4)
+    keep = (ar == lo.unsqueeze(-1)) | (ar == hi.unsqueeze(-1))
+    return (torch.where(keep.view(M, K), v, torch.zeros_like(v)),)
+''',
+    flops_src='''
+def canonical_work(M, K):
+    """BYTES attributed to one compression, from the SHAPE ALONE.
+
+    Read the dense bf16 matrix once (2*M*K), write the half-size value buffer (2*M*K/2 = M*K) and the
+    packed metadata (M*K/8). Bandwidth-bound: the score is achieved bandwidth against that count.
+    """
+    return 2 * M * K + M * K + M * K // 8
+''',
+    flops_formula="canonical_work(M, K) = 2*M*K + M*K + M*K/8 = 3.125 * M*K bytes",
+
+    metric="GB/s",
+    compare="tuple",
+    tuple_names=("vals", "meta"),
+    tol=0.0,
+    shape_names=("M", "K"),
+    grader_shapes=[(32768, 16384), (49152, 12288), (24576, 24576), (65536, 8192), (40960, 13312)],
+    measure_shapes=[(28672, 16384), (40960, 12288), (20480, 24576), (57344, 8192), (36864, 13312)],
+    measure_quick_shapes=[(4096, 4096), (2048, 8192), (8192, 2048)],
+    correct_shapes=[(64, 128), (129, 64), (17, 256), (256, 24), (33, 8)],
+
+    spec_md="""`a` is already 2:4 sparse: in every aligned group of four consecutive columns
+`(a0, a1, a2, a3)` exactly two entries are non-zero. Let `i0 < i1` be their slots within the group.
+
+**Values.** The survivors are compacted in ascending column order, so group `t` of row `m` contributes two
+consecutive elements:
+
+```
+vals[m, 2t]     = a[m, 4t + i0]
+vals[m, 2t + 1] = a[m, 4t + i1]
+```
+
+**Metadata.** Each survivor's slot is two bits, so a group is four bits and a byte carries **two groups**.
+Byte `t` of row `m` covers groups `2t` (low nibble) and `2t+1` (high nibble):
+
+```
+meta[m, t] =  ( i0(2t)   << 0 ) | ( i1(2t)   << 2 )
+            | ( i0(2t+1) << 4 ) | ( i1(2t+1) << 6 )
+```
+
+so bits 0–1 are the first survivor of the even group, bits 2–3 the second survivor of the even group, bits
+4–5 the first survivor of the odd group, bits 6–7 the second. Lower group in the **low** nibble, lower slot
+in the **lower** bits of its nibble. That is the ordering the sparse MMA metadata operand expects, and it is
+the whole content of the task — get either ordering backwards and every byte is wrong.
+
+`K` is a multiple of 8, so the byte packing never has a partial group.
+
+The values are copied through **unchanged**; there is no arithmetic anywhere in this kernel.
+
+`/app/reference.py` materialises a full-size boolean mask, indexes the survivors out with it, and derives
+the slots with min/max reductions. That is the exact specification; it is deliberately simple rather than
+fast.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `a` | `(M, K)` | `bfloat16` | already 2:4 sparse; the two dropped entries per group are exactly `+0.0` |
+
+**Return** a 2-tuple `(vals, meta)` **in that order**:
+
+| out | shape | dtype | notes |
+|-----|-------|-------|-------|
+| `vals` | `(M, K//2)` | `bfloat16` | survivors in ascending column order, copied bit-exactly |
+| `meta` | `(M, K//8)` | `uint8` | 2 bits per survivor, two groups per byte, as defined above |
+
+You may rely on the input invariant: **exactly two non-zeros per aligned group of four**, never one, never
+three. `K` is a multiple of 8 and nothing more — the correctness shapes include `K = 24` and `K = 8` — and
+`M` is not a multiple of any tile size (`M = 129`, `M = 33`). `a` is read-only; the call is functional.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `M`
+24576–65536, `K` 8192–24576, with `M*K` around **550 M elements** — one very large 2:4-pruned projection of
+a frontier-scale model, 1.1 GB of dense bf16 in and 0.6 GB of compressed weight out. This is the step that
+makes the sparsity pay: everything downstream reads the half-size buffer instead of the dense one.""",
+
+    correctness_md="""**Both** returned values must match the reference **exactly** at every graded shape,
+including the timed ones. `vals` is a bf16 gather, so its tolerance is **`0.0`** — bit-identical — and
+`meta` is `uint8` and compared elementwise.
+
+The metadata is an integer the hardware indexes with, so it is either exactly right or it is wrong, and
+every plausible layout mistake changes it everywhere: swapping the two nibbles (odd group in the low
+nibble) mismatches **83%** of the bytes, swapping the two slots within a nibble (`i1` in the low bits)
+mismatches **100%**, and emitting the values without compacting them — i.e. leaving the dense stride —
+scores **1.22** on `vals`.""",
+
+    perf_md="""Three and an eighth bytes per element, and no arithmetic — pure bandwidth, and your score is
+achieved bandwidth against one read of `a` and one write of `vals` plus `meta`.
+
+The reference is far off it: `g != 0` writes a full-size boolean mask to HBM, `g[nz]` is a general boolean
+gather that must first count the mask, and the two `torch.where` + reduction pairs are three more full-size
+passes.
+
+The kernel to write processes **eight input columns (two groups) per lane**:
+
+- A 128-bit load gives you 8 bf16 values = two complete groups. The survivors of those two groups are 4
+  bf16 values = one 64-bit store into `vals`, and their four 2-bit slots are exactly **one byte** of
+  `meta` — so the natural unit of work emits one aligned 8-byte value store and one byte of metadata.
+- Detecting a non-zero bf16 is an integer test on the 16-bit pattern, not a float compare.
+- The compaction within a group is a 2-element select: with `nz = (nz0, nz1, nz2, nz3)`, the first survivor
+  is a 3-deep select chain and the second is the last set bit. A branch-free formulation using the 4-bit
+  mask as an index into a tiny constant table (16 entries, 2 slots each) removes the chain entirely, and
+  the same table gives you the nibble directly.
+- Have each thread cover several groups so the `meta` stores coalesce into 32- or 128-bit words rather than
+  single bytes — byte-wide scattered stores are what usually costs this kernel its bandwidth.
+- **Ragged tails.** `M` is arbitrary and `K` can be as small as 8; guard the tail without putting a branch
+  on the main path.""",
+
+    precision_md="""There is **no arithmetic in this task at all**. `vals` is a bit-exact gather of bf16
+values and `meta` is a bit-packing of integers, so a correct kernel is bit-identical to the reference and
+the tolerance on `vals` is **`0.0`**.
+
+Do not convert through fp32 and do not compare values as floats to find the survivors — test the 16-bit
+pattern. (Testing `x != 0` as a float is also correct here, because the dropped entries are exactly `+0.0`
+and no survivor is zero, but the integer test is free.)
+
+`meta` is `uint8` and compared **exactly**; integer outputs are never compared through `float()`, so a
+single wrong nibble is caught.
+
+**Where the tolerance comes from (measured, not guessed).** An independent implementation — the survivors
+selected with an explicit branch-free 2-element compaction driven by the 4-bit non-zero mask and a 16-entry
+lookup table, and the metadata assembled by shifting that table's nibble into place, with no boolean-mask
+indexing anywhere — reproduces the reference **bit for bit**, `E = 0.0`, for both outputs at every
+correctness shape and at a full graded shape. `tol = 0.0` is the floor.
+
+For calibration: swapping just **two** of the 268 M elements of `vals` at a graded shape already registers a
+relative error of **9.7e-5**, so a single misplaced survivor is caught, never mind a systematic one.
+
+Drop-the-feature measurements at a graded shape: nibble order swapped **83%** of `meta` bytes wrong; slot
+order swapped inside each nibble **100%** wrong; values written at the dense stride instead of compacted
+**D = 1.22** on `vals`.""",
+).validate()

tools/factory/specs/sparse24_prune_metadata.py

@@ -0,0 +1,192 @@
+"""Spec for `sparse24-prune-metadata` — magnitude-prune a weight matrix to the 2:4 pattern the sparse
+tensor cores consume, and emit the per-group index metadata."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="sparse24-prune-metadata",
+    title="Write a fast 2:4 structured pruning kernel (mask + index metadata)",
+    blurb=("Sparse tensor cores only accept one pattern: exactly two non-zeros in every aligned group of "
+           "four along K. Getting a trained weight into that form means, for every group of four, ranking "
+           "the magnitudes, keeping the top two, zeroing the rest, and recording WHICH two — the 2-bit "
+           "indices the hardware needs to pick the matching operands out of B. It is run on every weight "
+           "of the model at every re-prune during sparse fine-tuning, it is pure bandwidth, and the "
+           "metadata is integer, so it is either exactly right or it is wrong."),
+    keywords=["mle", "kernel-generation", "sparsity", "2:4", "structured-sparsity", "pruning", "metadata",
+              "sparse-tensor-core", "training", "memory-bound"],
+    module="prune24.py",
+    func="prune_24",
+    signature="prune_24(w)",
+    returns_doc="""Magnitude-prune a weight matrix to the 2:4 structured pattern.
+
+Args:
+    w: (M, K) bfloat16 — the dense weight. K is a multiple of 4.
+
+Returns:
+    (pruned, meta) where
+      pruned: (M, K)      bfloat16 — w with the two smaller-magnitude entries of every aligned group
+                                     of four set to exactly 0, the other two untouched
+      meta:   (M, K//4, 2) uint8   — the two KEPT indices (0..3) of each group, in ASCENDING order""",
+
+    reference_imports="import torch",
+    reference_src='''
+def prune_24(w):
+    """Rank each group of four by magnitude with a stable sort and keep the top two.
+
+    Correct and simple — it is the SPECIFICATION, not a performance target. `stable=True` is what defines
+    the tie-break: among equal magnitudes the LOWER index wins.
+    """
+    M, K = w.shape
+    g = w.view(M, K // 4, 4)
+    s = g.abs().float()
+    order = torch.argsort(s, dim=-1, descending=True, stable=True)     # ties keep original order
+    idx = order[..., :2].sort(dim=-1).values                           # the two kept indices, ascending
+    mask = torch.zeros_like(g, dtype=torch.bool).scatter_(-1, idx, True)
+    pruned = torch.where(mask, g, torch.zeros_like(g)).view(M, K)
+    return pruned, idx.to(torch.uint8)
+''',
+    make_inputs_src='''
+def _mk(M, K, seed):
+    """A trained-looking bf16 weight matrix.
+
+    Values are bf16, which has only 8 mantissa bits, so about 1.1% of the groups of four contain two
+    entries with EXACTLY equal magnitude, and in 0.41% of groups that tie straddles the keep/drop boundary.
+    Those ties are why the tie-break is part of the spec rather than an afterthought.
+    """
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    return ((torch.randn(M, K, device="cuda", dtype=torch.float32, generator=gen) * 0.02).bfloat16(),)
+''',
+    flops_src='''
+def canonical_work(M, K):
+    """BYTES attributed to one prune, from the SHAPE ALONE.
+
+    Read the dense bf16 weight once (2*M*K), write the pruned bf16 weight once (2*M*K) and the two index
+    bytes per group of four (2*M*K/4). Bandwidth-bound: the score is achieved bandwidth against that count.
+    """
+    return 2 * M * K + 2 * M * K + 2 * (M * K // 4)
+''',
+    flops_formula="canonical_work(M, K) = 2*M*K + 2*M*K + M*K/2 = 4.5 * M*K bytes",
+
+    metric="GB/s",
+    compare="tuple",
+    tuple_names=("pruned", "meta"),
+    tol=0.0,
+    shape_names=("M", "K"),
+    grader_shapes=[(32768, 12288), (24576, 16384), (49152, 8192), (16384, 24576), (40960, 10240)],
+    measure_shapes=[(28672, 12288), (20480, 16384), (40960, 8192), (14336, 24576), (36864, 10240)],
+    measure_quick_shapes=[(4096, 4096), (2048, 8192), (8192, 2048)],
+    correct_shapes=[(64, 128), (129, 64), (17, 256), (256, 12), (33, 4)],
+
+    spec_md="""Split every row of `w` into aligned groups of four consecutive columns. Within a group
+`(w0, w1, w2, w3)`, index `i` is **kept** exactly when
+
+```
+#{ j : |w_j| > |w_i|  or  ( |w_j| == |w_i| and j < i ) }  <  2
+```
+
+i.e. rank the four by descending magnitude, breaking ties toward the **lower** index, and keep the top two.
+That is precisely what a stable descending sort gives you, and it is not an academic detail: `w` is
+bfloat16, so about **1.1% of the groups contain two entries of exactly equal magnitude** and a kernel that
+breaks those ties the other way disagrees with the reference on hundreds of thousands of groups.
+
+The outputs are
+
+```
+pruned[m, 4t + i] = w[m, 4t + i]   if i is kept,  else exactly 0.0
+meta[m, t, 0]     = the smaller of the two kept indices
+meta[m, t, 1]     = the larger of the two kept indices
+```
+
+`meta` is what the sparse tensor core uses to select the matching four-of-eight operands from the dense
+side, so it is **integer and compared exactly** — one wrong group is a failure, not a rounding error. The
+two indices are always in ascending order, and there are always exactly two of them: no group is ever
+all-zero in the output, even if some of its entries were already zero in `w`.
+
+The kept values are copied through **unchanged**. There is no rescaling of the survivors.
+
+`/app/reference.py` builds a `(M, K/4, 4)` view, does a full stable `argsort` over the last axis and
+scatters a boolean mask. That is the exact specification; it is deliberately simple rather than fast.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `w` | `(M, K)` | `bfloat16` | the dense weight, row-major; `K` is a multiple of 4 |
+
+**Return** a 2-tuple `(pruned, meta)` **in that order**:
+
+| out | shape | dtype | notes |
+|-----|-------|-------|-------|
+| `pruned` | `(M, K)` | `bfloat16` | survivors copied bit-exactly, the other two per group exactly `0.0` |
+| `meta` | `(M, K//4, 2)` | `uint8` | the two kept indices per group, **ascending**, values in `0..3` |
+
+`K` is a multiple of 4 and nothing more — the correctness shapes include `K = 12` and `K = 4` — and `M` is
+not a multiple of any tile size (`M = 129`, `M = 33`). `w` is read-only; the call is functional.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `M`
+16384–49152, `K` 8192–24576, with `M*K` around **400 M elements** — one very large projection matrix of a
+frontier-scale model (or a stack of smaller ones viewed as one matrix), 0.8 GB of bf16 weight in and 1.0 GB
+out. Sparse fine-tuning re-prunes on a schedule, so this runs over every weight in the model repeatedly,
+and at these sizes it is entirely a memory-bandwidth problem.""",
+
+    correctness_md="""**Both** returned values must match the reference **exactly** at every graded shape,
+including the timed ones. `pruned` is a bf16 copy-or-zero, so its tolerance is **`0.0`** — bit-identical —
+and `meta` is `uint8` and compared elementwise.
+
+This is the strictest kind of gate in the suite and it is deliberate: the metadata is an integer the
+hardware indexes with, so "close" is meaningless. The two shortcuts both fail enormously: keeping the first
+two entries of every group instead of the largest two scores **0.76** on `pruned` and mismatches **83%** of
+the metadata groups, and ranking by signed value instead of magnitude scores **0.76** and mismatches
+**75%**. Breaking magnitude ties toward the *higher* index instead of the lower one mismatches **0.41%** of
+the groups — a small fraction, but 410 thousand groups at a graded shape, and it fails just as hard.""",
+
+    perf_md="""Four and a half bytes per element and about ten comparisons — entirely a bandwidth problem,
+and your score is achieved bandwidth against one read of `w`, one write of `pruned` and one write of `meta`.
+
+The reference is roughly 5x off that: `argsort` over a length-4 axis launches a general sorting kernel,
+`scatter_` materialises a full-size boolean mask in HBM, and `torch.where` reads it back.
+
+A group of four fits in a register pair. The whole task per group is:
+
+- Load 4 bf16 values as one 64-bit word (`K` is a multiple of 4, so the groups are naturally aligned; with
+  a 128-bit load you get two groups at once).
+- Take absolute values by masking the sign bit — no conversion needed, `|bf16|` ordering is the same as the
+  integer ordering of the sign-cleared bit pattern, so the whole ranking can be done on `uint16` keys.
+- Compute the rank of each of the four with the 6 pairwise comparisons the spec defines (or a 5-comparison
+  sorting network), including the index tie-break. Branch-free: the tie-break is just `(a == b) & (j < i)`.
+- Emit the two survivors and the two index bytes.
+
+Things that matter:
+
+- **Do not materialise a mask.** The output value is `select(keep, w, 0)` in registers.
+- **Vectorise the stores.** `pruned` is fully coalesced; `meta` is 2 bytes per group, so a thread handling
+  8 groups writes a clean 16-byte store.
+- **The tie-break costs nothing** if you fold it into the comparison as a lexicographic `(|w|, -i)` key —
+  for bf16 you can pack the sign-cleared 16-bit magnitude and the 2-bit index into a single 18-bit integer
+  and compare those. Do not implement it as a branch.
+- **Ragged M and small K.** The correctness shapes go down to `K = 4`, so guard the tail rather than
+  assuming a 128-column tile.""",
+
+    precision_md="""There is **no arithmetic in this task** beyond taking absolute values and comparing
+them. Survivors are copied unchanged, the losers become exactly `0.0`, so a correct kernel is bit-identical
+to the reference and the tolerance on `pruned` is **`0.0`**.
+
+Compare in a way that is exact. `|bf16|` can be obtained by clearing the sign bit of the 16-bit pattern, and
+for finite non-negative floats the IEEE ordering agrees with the unsigned integer ordering of that pattern —
+so the whole ranking can be integer. Converting to fp32 first is also exact and costs nothing. What is
+**not** safe is comparing in a lower precision or using an approximate absolute value: that would flip
+groups whose magnitudes are close but not equal.
+
+`meta` is `uint8` and compared **exactly**; integer outputs are never compared through `float()`.
+
+**Where the tolerance comes from (measured, not guessed).** An independent implementation — the rank rule
+evaluated directly as the 16 pairwise comparisons of the spec (`|w_j| > |w_i|` or `|w_j| == |w_i|` and
+`j < i`), with no sort anywhere, operating on sign-cleared `uint16` keys — reproduces the reference **bit
+for bit**, `E = 0.0`, for both outputs at every correctness shape and at a full graded shape. That also
+confirms `stable=True` in the reference implements exactly the stated tie-break. `tol = 0.0` is the floor.
+
+Drop-the-feature measurements at a graded shape: keeping the first two of each group **D = 0.76** on
+`pruned` with 83% of `meta` groups wrong; ranking by signed value rather than magnitude **D = 0.76** with
+75% wrong; breaking ties toward the higher index **D = 0.043** with 0.41% wrong.""",
+).validate()

tools/factory/specs/sparse24_sparse_gemm.py

@@ -0,0 +1,219 @@
+"""Spec for `sparse24-sparse-gemm` — a GEMM whose A operand is in the compressed 2:4 layout: half-size
+values plus 2-bit slot metadata, exactly what the sparse tensor cores take."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="sparse24-sparse-gemm",
+    title="Write a fast 2:4 structured-sparse GEMM (compressed A operand)",
+    blurb=("This is the kernel 2:4 sparsity exists for. A is stored compressed — a (M, K/2) value buffer "
+           "and two bits per value saying which of its group of four it came from — and the GEMM has to "
+           "walk B with those indices, doing half the multiply-accumulates of the dense problem. Ampere and "
+           "later expose it directly through the sparse MMA instruction; done properly it is the fastest "
+           "matmul on the machine, and done as a densify-then-dense-GEMM it does twice the arithmetic for "
+           "the same answer."),
+    keywords=["mle", "kernel-generation", "sparsity", "2:4", "structured-sparsity", "sparse-gemm",
+              "sparse-tensor-core", "mma-sp", "training", "compute-bound"],
+    module="sgemm24.py",
+    func="sparse24_gemm",
+    signature="sparse24_gemm(vals, meta, b)",
+    returns_doc="""GEMM with a 2:4 structured-sparse A operand in compressed form.
+
+Args:
+    vals: (M, K//2) bfloat16 — A's surviving values, two per group of four, in ascending column order.
+    meta: (M, K//8) uint8    — 2 bits per survivor; byte t carries groups 2t (low nibble) and 2t+1 (high).
+    b:    (K, N)    bfloat16 — the dense right-hand operand.
+
+Returns:
+    c: (M, N) bfloat16 — A_dense @ b, accumulated in fp32 and rounded once to bf16.""",
+
+    reference_imports="import torch",
+    reference_src='''
+def _decode(meta, M, K):
+    """meta -> (M, K//4, 2) int64 slot indices."""
+    mi = meta.int()
+    q = torch.stack([mi & 3, (mi >> 2) & 3, (mi >> 4) & 3, (mi >> 6) & 3], dim=-1)   # (M, K//8, 4)
+    return q.reshape(M, K // 4, 2).long()
+
+
+def sparse24_gemm(vals, meta, b):
+    """Densify A and do a plain fp32 matmul.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target. It materialises the
+    full (M, K) dense A, converts everything to fp32, and does twice the necessary arithmetic.
+    """
+    M = vals.shape[0]
+    K = b.shape[0]
+    idx = _decode(meta, M, K)
+    dense = torch.zeros(M, K, device=vals.device, dtype=vals.dtype).view(M, K // 4, 4)
+    dense.scatter_(-1, idx, vals.view(M, K // 4, 2))
+    return (dense.view(M, K).float() @ b.float()).bfloat16()
+''',
+    make_inputs_src='''
+_LO = [0, 0, 0, 1, 1, 2]      # the six ways to choose 2 of 4
+_HI = [1, 2, 3, 2, 3, 3]
+
+
+def _mk(M, N, K, seed):
+    """A random 2:4 pattern per group of A, already compressed, plus a dense B."""
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    vals = (torch.randn(M, K // 2, device="cuda", dtype=torch.float32, generator=gen) * 0.05).bfloat16()
+    pat = torch.randint(0, 6, (M, K // 4), device="cuda", dtype=torch.int64, generator=gen)
+    lo = torch.tensor(_LO, device="cuda", dtype=torch.int32)[pat]
+    hi = torch.tensor(_HI, device="cuda", dtype=torch.int32)[pat]
+    nib = (lo | (hi << 2)).view(M, K // 8, 2)
+    meta = (nib[..., 0] | (nib[..., 1] << 4)).to(torch.uint8)
+    b = (torch.randn(K, N, device="cuda", dtype=torch.float32, generator=gen) * 0.05).bfloat16()
+    return vals, meta, b
+''',
+    flops_src='''
+def canonical_work(M, N, K):
+    """FLOPs attributed to one sparse GEMM, from the SHAPE ALONE.
+
+    A has exactly K/2 non-zeros per row, so the problem is 2*M*N*(K/2) = M*N*K useful flops -- HALF the
+    dense count. That is what is credited, so a kernel that densifies A and runs a dense GEMM is doing
+    twice the arithmetic for the same credit and is scored accordingly.
+    """
+    return M * N * K
+''',
+    flops_formula="canonical_work(M, N, K) = 2 * M * N * (K/2) = M*N*K   # half the dense GEMM's flops",
+
+    metric="TFLOP/s",
+    compare="tensor",
+    tol=2e-3,
+    shape_names=("M", "N", "K"),
+    grader_shapes=[(8192, 8192, 8192), (4096, 8192, 16384), (16384, 4096, 8192),
+                   (8192, 6144, 12288), (12288, 8192, 6144)],
+    measure_shapes=[(8192, 8192, 6144), (4096, 6144, 16384), (12288, 4096, 8192),
+                    (6144, 8192, 12288), (10240, 8192, 6144)],
+    measure_quick_shapes=[(2048, 2048, 2048), (1024, 4096, 2048), (4096, 1024, 4096)],
+    correct_shapes=[(64, 64, 128), (129, 96, 64), (33, 200, 8), (256, 33, 512), (17, 129, 24)],
+
+    spec_md="""`A` is a `(M, K)` matrix that is 2:4 structured-sparse, handed to you **compressed**. Group
+`t` of row `m` covers columns `4t .. 4t+3` and has exactly two non-zeros, whose slots `i0 < i1` are stored
+as two bits each:
+
+```
+i0(2t)   = (meta[m, t] >> 0) & 3        i1(2t)   = (meta[m, t] >> 2) & 3
+i0(2t+1) = (meta[m, t] >> 4) & 3        i1(2t+1) = (meta[m, t] >> 6) & 3
+```
+
+so byte `t` describes groups `2t` and `2t+1`, lower group in the low nibble, lower slot in the lower bits.
+The matching values are
+
+```
+A[m, 4g + i0(g)] = vals[m, 2g]
+A[m, 4g + i1(g)] = vals[m, 2g + 1]
+A[m, everything else] = 0
+```
+
+and the output is the ordinary product
+
+```
+c[m, n] = sum over k of A[m, k] * b[k, n]
+        = sum over groups g of  vals[m,2g]*b[4g+i0(g), n] + vals[m,2g+1]*b[4g+i1(g), n]
+```
+
+accumulated in **fp32** and rounded **once** to bf16 at the end.
+
+The second form is the point: only `K/2` products per output element are non-zero, and the metadata tells
+you exactly which rows of `b` they need. That is what the sparse MMA instruction consumes — it takes a
+half-width A fragment plus the index bits and internally selects the matching halves of a full-width B
+fragment.
+
+`K` is a multiple of 8. `A` is never explicitly materialised by the spec: it is defined by `(vals, meta)`.
+
+`/app/reference.py` scatters `vals` back into a dense `(M, K)` buffer and calls a plain fp32 matmul. That
+is the exact numerical specification, and it is deliberately the slow way round: it does twice the
+arithmetic and touches twice the memory.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `vals` | `(M, K//2)` | `bfloat16` | A's survivors, two per group, ascending column order |
+| `meta` | `(M, K//8)` | `uint8` | 2 bits per survivor, two groups per byte, as defined above |
+| `b` | `(K, N)` | `bfloat16` | the dense right operand, row-major |
+
+**Return** a single tensor:
+
+| out | shape | dtype | notes |
+|-----|-------|-------|-------|
+| `c` | `(M, N)` | `bfloat16` | `A_dense @ b`, fp32 accumulation, one rounding to bf16 |
+
+`K = b.shape[0]` — it is not passed separately, and `vals.shape[1] == K//2`. `K` is a multiple of 8;
+`M` and `N` are not multiples of any tile size (the correctness shapes include `M = 33`, `N = 33`,
+`M = 129`). All inputs are read-only.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `M`
+4096–16384, `N` 4096–8192, `K` 6144–16384, i.e. **0.5–0.6 TFLOP of credited work per call** — a single
+projection of a large model at a substantial batch, or one expert's GEMM. These are square-ish,
+compute-bound shapes: at the graded sizes the operands are a few hundred megabytes and the arithmetic
+dominates, so this is a tensor-core problem, not a bandwidth one.""",
+
+    correctness_md="""The returned tensor must match the reference within **relative error `2e-3`** at
+every graded shape, including the timed ones.
+
+The output is bf16, but that final rounding is common to the reference and to your kernel, so it cancels:
+what is left is only the fp32 accumulation order, and a faithful bf16 tensor-core GEMM measures
+**1.6e-4 to 2.9e-4** against the reference across every graded shape and every timed seed (a split-K
+variant, **5.0e-5**). The gate is 7x the worst of those.
+
+What it actually tests is whether you used the metadata. Every way of getting the sparsity structure wrong
+is three orders of magnitude outside: assuming slots `(0, 1)` for every group scores **1.16**, reading the
+nibbles in the wrong order **1.11**, swapping `i0` and `i1` within each group **1.41**. Accumulating in
+bf16 instead of fp32 also fails, which is intended.""",
+
+    perf_md="""This is a **compute-bound GEMM** and you are credited `M*N*K` flops — half the dense count —
+so the ranking is about how much of the machine's sparse (or dense) tensor-core throughput you can hold.
+
+There are two levels of solution and both are worth having:
+
+1. **Densify and run a dense GEMM.** Scatter `vals` into a `(M, K)` buffer using `meta` and call an
+   ordinary bf16 tensor-core GEMM. Correct, straightforward, and it does *twice* the credited arithmetic —
+   so it can score at best about half of what the machine's dense peak would suggest. Fusing the densify
+   into the GEMM's A-fragment load (rather than writing a dense A to HBM first) is a large win on its own.
+
+2. **Use the sparse MMA.** sm≥80 exposes `mma.sp` (and sm≥90 `wgmma.sp`) which takes a half-width A
+   fragment plus a metadata operand and internally selects the matching halves of the B fragment. That is
+   the instruction this data layout exists for, and it doubles the achievable rate. Getting there means
+   writing PTX (inline `asm` in a CUDA extension) or driving CUTLASS's sparse GEMM collectives from
+   `/opt/cutlass/include`. The metadata operand's expected register layout is the fiddly part — work out
+   the per-lane mapping carefully and check it against the reference at a small shape before scaling up.
+
+Whichever route you take, the usual GEMM engineering decides the score: a persistent tile schedule sized
+from `multi_processor_count`, a double- or triple-buffered pipeline into shared memory (TMA where
+available), an epilogue that writes bf16 in 128-bit stores, and split-K only where the shape needs it.
+
+Two things specific to this problem:
+
+- **`b` is read with a gather along K.** In the compressed formulation the rows of `b` you need are chosen
+  per group; loading whole `K`-tiles of `b` into shared memory and selecting there costs nothing extra,
+  whereas gathering from HBM per index would destroy the bandwidth.
+- **`meta` is tiny** — one byte per four columns of A — so it should live in registers or shared memory
+  for the whole tile, never be re-read.""",
+
+    precision_md="""Both operands are **bfloat16** and the output is **bfloat16**. Accumulate in **fp32**
+and round **once**, at the end.
+
+Because `vals` and `b` are already bf16, there is no quantisation error in this task at all: the products
+are exact and the only numerical freedom is the fp32 accumulation order and the final rounding. That is why
+the tolerance is what it is rather than the 1e-2 a bf16 GEMM sometimes gets.
+
+Do **not** accumulate in bf16 or fp16, and do not use an approximate reciprocal/rounding on the epilogue.
+Split-K is fine — it changes the accumulation order, which is within the tolerance — as long as the partial
+sums are combined in fp32.
+
+**Where the tolerance comes from (measured, not guessed).** An independent implementation — the same
+densification followed by a **bf16 tensor-core** matmul with fp32 accumulation (i.e. what a good kernel
+actually does) instead of the reference's fp32 matmul — differs from the reference by **`E = 1.9e-4`** at a
+full graded shape (`0.0` at the small correctness shapes, where `K` is tiny). Swept over all five graded
+shapes and the seeds the grader uses for the **timed** validation, that stays in **1.6e-4 .. 2.9e-4** — a
+1.8x spread, so the gate is not a seed lottery. A split-K variant (K split in 4, partials summed in fp32)
+measured **5.0e-5**. The gate is set at **`2e-3`**, 7x the worst measured floor, which leaves room for other
+accumulation orders and tilings while staying ~550x below the cheapest structural mistake.
+
+Drop-the-feature measurements at a graded shape: ignoring `meta` and assuming slots `(0, 1)` in every group
+**D = 1.16**; nibble order swapped **D = 1.11**; `i0`/`i1` swapped **D = 1.41**.""",
+).validate()

tools/factory/specs/spec_decode_kv_rollback.py

@@ -0,0 +1,262 @@
+"""Spec for `speculative-draft-kv-rollback` — compacting the KV of the accepted path after verification."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="speculative-draft-kv-rollback",
+    title="Write a fast speculative-decode KV rollback kernel",
+    blurb=("Tree speculative decoding writes KV for every draft token before it knows which ones survive. "
+           "Verification then accepts one PATH through the tree, and the cache has to be rolled back: the "
+           "accepted tokens' KV — scattered across the slots the draft occupied, in tree order, not in "
+           "sequence order — is compacted to the front of the sequence's region and everything else is "
+           "discarded. It runs after every verify step, for every layer, on the whole batch."),
+    keywords=["mle", "kernel-generation", "speculative-decoding", "eagle", "mtp", "kv-cache", "rollback",
+              "tree-attention", "serving", "memory-bound"],
+    module="rollback.py",
+    func="spec_kv_rollback",
+    signature="spec_kv_rollback(k_cache, v_cache, draft_slot, accept_idx, accept_len)",
+    returns_doc="""Compact the KV of the accepted draft path, for every layer.
+
+Args:
+    k_cache:    (L, NSLOT, H, D) bfloat16 — flat token-slot key pool.
+    v_cache:    (L, NSLOT, H, D) bfloat16 — flat token-slot value pool.
+    draft_slot: (B, K) int32 — physical slot the KV of draft position j of sequence b was written to.
+    accept_idx: (B, K) int32 — accept_idx[b, t] = the draft position accepted at step t, -1 once the
+                               path ends; strictly increasing while >= 0.
+    accept_len: (B,)  int32 — how many draft tokens sequence b accepted, in [0, K].
+
+Returns:
+    (k_acc, v_acc), each (L, B, K, H, D) bfloat16 — the accepted path's KV packed at the front of the
+    K axis; rows t >= accept_len[b] are exactly 0.""",
+
+    reference_imports="import torch",
+    reference_src='''
+def spec_kv_rollback(k_cache, v_cache, draft_slot, accept_idx, accept_len):
+    """Resolve the accepted path to physical slots, gather the whole (B, K) grid, blank the rejected part.
+
+    Correct and simple — it is the exact SPECIFICATION, not a performance target: it gathers K slots for
+    every sequence even where the path stopped after one token.
+    """
+    L, NSLOT, H, D = k_cache.shape
+    B, K = draft_slot.shape
+    dev = k_cache.device
+
+    src = torch.gather(draft_slot, 1, accept_idx.clamp(min=0).long())      # (B, K) slot of step t
+    live = torch.arange(K, device=dev).unsqueeze(0) < accept_len.long().unsqueeze(1)
+    s = torch.where(live, src, torch.zeros_like(src)).long().reshape(-1)
+
+    z = torch.zeros((), device=dev, dtype=k_cache.dtype)
+    m = live.view(1, B, K, 1, 1)
+    k_acc = torch.where(m, k_cache[:, s].view(L, B, K, H, D), z)
+    v_acc = torch.where(m, v_cache[:, s].view(L, B, K, H, D), z)
+    return k_acc, v_acc
+''',
+    make_inputs_src='''
+def _mk(L, B, K, H, D, seed):
+    """A KV pool with the batch's draft tokens scattered through it, plus one accepted tree path each.
+
+    The accepted path is a strictly increasing subset of the K draft positions — what a path through a
+    draft tree stored in breadth-first order looks like — of the shape-only length `_alen`, which includes
+    sequences that accepted nothing at all. `draft_slot` is a random subset of the pool, so the gather is
+    scattered by token, not by page.
+    """
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    dev, NSLOT = "cuda", _pool(B, K)
+    k = torch.randn(L, NSLOT, H, D, device=dev, dtype=torch.bfloat16, generator=gen)
+    v = torch.randn(L, NSLOT, H, D, device=dev, dtype=torch.bfloat16, generator=gen)
+
+    draft_slot = torch.randperm(NSLOT, device=dev, generator=gen)[:B * K].view(B, K).to(torch.int32)
+    alen = torch.tensor(_alen(B, K), device=dev, dtype=torch.int32)
+
+    col = torch.arange(K, device=dev).unsqueeze(0).expand(B, K)
+    r = torch.rand(B, K, device=dev, generator=gen)
+    rank = r.argsort(dim=1).argsort(dim=1)                        # a random rank per column
+    mask = rank < alen.long().unsqueeze(1)                        # exactly alen[b] chosen positions
+    pos = torch.where(mask, col, torch.full_like(col, K)).sort(dim=1).values
+    accept_idx = torch.where(pos < K, pos, torch.full_like(pos, -1)).to(torch.int32).contiguous()
+    return k, v, draft_slot.contiguous(), accept_idx, alen
+''',
+    flops_src='''
+def _mix(i):
+    """A shape-only 32-bit hash: deterministic, seed-independent, low-discrepancy."""
+    i = (i * 2654435761 + 1013904223) % 2 ** 32
+    i ^= i >> 15
+    return (i * 2246822519) % 2 ** 32
+
+
+def _pool(B, K):
+    """Token slots in the pool, from the SHAPE ALONE: two and a half times the drafts in flight."""
+    return (5 * B * K) // 2
+
+
+def _alen(B, K):
+    """Accepted tokens per sequence, from the SHAPE ALONE: 0..K, averaging a little over half of K —
+    the acceptance profile of a decent draft model, including the sequences that accept nothing."""
+    return [((K + 1) * _mix(131 + b)) // 2 ** 32 for b in range(B)]
+
+
+def canonical_work(L, B, K, H, D):
+    """BYTES attributed to one rollback, from the SHAPE ALONE.
+
+    Per layer: the KV of every ACCEPTED draft token is read once (H*D bf16 elements of K and of V) and the
+    whole (B, K) destination grid is written once — the rejected rows are written as zeros, which is real
+    traffic. Plus the three per-sequence index tensors. The rejected tokens' KV is never read. This is a
+    pure data-movement kernel: the score is achieved bandwidth against this fixed byte count.
+    """
+    acc = sum(_alen(B, K))
+    return 2 * L * acc * H * D * 2 + 2 * L * B * K * H * D * 2 + B * (8 * K + 4)
+''',
+    flops_formula=("ACC = sum of accept_len over the batch        # _alen(B, K), averaging just over K/2\n\n"
+                   "canonical_work(L, B, K, H, D) = 2*L*ACC*H*D*2   +   2*L*B*K*H*D*2   +  B*(8*K + 4)\n"
+                   "#                               read the           write the whole     draft_slot,\n"
+                   "#                               accepted KV,       destination grid,   accept_idx,\n"
+                   "#                               K and V            zeros included      accept_len"),
+
+    metric="GB/s",
+    compare="tuple",
+    tuple_names=("k_acc", "v_acc"),
+    tol=1e-6,
+    shape_names=("L", "B", "K", "H", "D"),
+    grader_shapes=[(16, 2048, 8, 8, 128), (8, 4096, 8, 8, 128), (16, 1024, 16, 8, 128),
+                   (16, 1536, 8, 16, 128), (32, 1024, 8, 8, 128)],
+    measure_shapes=[(16, 1792, 8, 8, 128), (8, 3584, 8, 8, 128), (16, 896, 16, 8, 128),
+                    (16, 1280, 8, 16, 128), (28, 1024, 8, 8, 128)],
+    measure_quick_shapes=[(4, 256, 8, 8, 128), (2, 512, 4, 8, 128), (8, 128, 16, 4, 128)],
+    correct_shapes=[(2, 33, 8, 4, 64), (1, 7, 4, 8, 128), (3, 64, 16, 2, 128),
+                    (2, 5, 2, 8, 64), (4, 129, 8, 4, 32)],
+
+    spec_md="""A tree speculative step proposes `K` draft tokens per sequence and writes their K and V into
+the cache **before** verification, one token per physical slot:
+
+```
+k_cache[layer, slot, head, channel]         shape (L, NSLOT, H, D)
+draft_slot[b, j]                            the slot draft position j of sequence b was written to
+```
+
+The slots are whatever the allocator handed out, so they are **scattered** — this is a flat token-slot
+pool, the page-table lookup has already happened.
+
+Verification then accepts **one path** through the draft tree. `accept_idx[b, t]` is the draft position of
+the `t`-th accepted token, for `t < accept_len[b]`, and `-1` afterwards. Because a draft tree is stored in
+breadth-first order, an accepted path visits **strictly increasing** positions — but it skips: accepting
+positions `0, 3, 4` is normal, and it is *not* the same as accepting positions `0, 1, 2`.
+
+The rollback compacts the surviving KV to the front:
+
+```
+for t < accept_len[b]:   k_acc[l, b, t] = k_cache[l, draft_slot[b, accept_idx[b, t]]]
+for t >= accept_len[b]:  k_acc[l, b, t] = 0
+```
+
+and identically for `v`. **Two indirections in a row**: `accept_idx` selects a draft position, and
+`draft_slot` turns that position into a physical slot. Doing only one of them (using `accept_idx` as if it
+were a slot, or `draft_slot[b, t]` as if the path were the first `accept_len[b]` positions) reads entirely
+different data.
+
+`accept_len[b] == 0` is legal and happens in the graded data — a sequence whose very first draft token was
+rejected contributes an all-zero row.
+
+Returning the compacted KV as a dense `(L, B, K, H, D)` tensor is the functional form of what a real engine
+does in place; the grader needs a value it can compare.
+
+`/app/reference.py` resolves the path, gathers the full `(B, K)` grid for every layer, and then multiplies
+the rejected part away. That is the exact specification; it is deliberately simple rather than fast.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `k_cache` | `(L, NSLOT, H, D)` | `bfloat16` | flat token-slot key pool |
+| `v_cache` | `(L, NSLOT, H, D)` | `bfloat16` | flat token-slot value pool |
+| `draft_slot` | `(B, K)` | `int32` | slot of each draft position; all `B*K` values distinct, in `[0, NSLOT)` |
+| `accept_idx` | `(B, K)` | `int32` | draft position accepted at step `t`; strictly increasing while `>= 0`, then `-1` |
+| `accept_len` | `(B,)` | `int32` | accepted count per sequence, in `[0, K]`; `accept_idx[b, t] >= 0` exactly for `t < accept_len[b]` |
+
+**Return** a 2-tuple `(k_acc, v_acc)` **in that order**, each of shape `(L, B, K, H, D)`, dtype
+`bfloat16`.
+
+Fixed facts you may rely on:
+
+- `accept_len[b]` and the `-1` padding of `accept_idx` agree, so either one tells you where the path ends;
+- `accept_idx[b, t] < K` always, and the values in a row are pairwise distinct and increasing;
+- rows `t >= accept_len[b]` of the output must be **exactly `0`** for both tensors, every head and channel;
+- `accept_len[b] == 0` occurs in the graded data;
+- the pool is 2.5x the size of the draft grid, so most of it must **not** be read.
+
+All tensors are CUDA and contiguous. Treat all inputs as read-only.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `L`
+(layers rolled back per call) in 8–32, `B` (sequences) in 1024–4096, `K` (draft tokens per sequence) in
+8–16, `H` (KV heads) in 8–16, `D = 128`. That is a large-batch EAGLE/MTP configuration: 8k–32k draft
+tokens in flight, one to two and a half gigabytes of bf16 KV touched per verify step. Write a **general**
+kernel: `K` and `H` both vary, and the accepted lengths are ragged across the whole `0..K` range, so the
+work per sequence differs by an unbounded factor.""",
+
+    correctness_md="""**Both** returned tensors must match the reference within **relative error `1e-6`** at
+every graded shape, including the timed ones. That is effectively an **exact** gate and deliberately so:
+this kernel performs no arithmetic — it relocates bf16 values — so a correct implementation reproduces the
+reference **bit for bit** and scores `0.0`.
+
+**Measured, so you know where the gate is.** An independent implementation that loops over sequences,
+resolves the path with two scalar index loads per accepted token and copies into a pre-zeroed output (no
+materialised `(B, K)` gather, no masking pass) reproduces the reference at **`E = 0.0` exactly** at every
+correctness and graded shape. For contrast, on the same inputs: treating the accepted path as the first
+`accept_len[b]` draft positions (skipping the `accept_idx` indirection) measures **`D = 1.04 – 1.05`** at
+the graded shapes, and copying all `K` rows instead of stopping at `accept_len[b]` measures
+**`D = 1.00 – 1.01`**. Both are six orders of magnitude outside the gate.""",
+
+    perf_md="""This is **pure data movement** and your score is achieved bandwidth against one read of the
+accepted tokens' KV and one write of the destination grid. The reference is several times off it: it
+gathers **all** `B*K` rows for every layer — nearly twice the credited read, since fewer than half the
+draft tokens are rejected — materialises that as a temporary, and then `torch.where` reads it back and
+writes it again, so the payload crosses HBM about four times instead of two.
+
+What a fast kernel does:
+
+- **One pass, one block per `(layer, sequence)`** (or per `(layer, sequence, accepted token)`). Two `int32`
+  loads resolve the double indirection for one output row, then `H * D` bf16 values — 2 to 4 KiB — are
+  copied contiguously. Both endpoints are naturally aligned, so 128-bit vector loads and stores saturate
+  the line.
+- **Do not gather the rejected rows.** They are known from `accept_len` before any payload is touched. The
+  destination rows past `accept_len[b]` still have to be *written* (as zeros), but that write costs nothing
+  to generate — it is a memset, not a copy.
+- **The double indirection is cheap; keep it in registers.** `accept_idx[b, t]` and then
+  `draft_slot[b, that]` are two dependent 4-byte loads per 4 KiB of payload. Issue them for several `t` at
+  once so the dependent loads overlap rather than serialising.
+- **Fuse K and V and all layers.** They share every index; the layer stride is a constant. A grid over
+  `(L, B)` with the `K` loop inside amortises the index loads `L` times over and gives plenty of
+  memory-level parallelism.
+- **The ragged accepted length is the load-balancing problem.** `accept_len` spans `0..K`, so a static
+  one-block-per-sequence grid has blocks doing nothing next to blocks doing 16 rows. Flatten the work to
+  `(layer, sequence, t)` triples and let a persistent grid pull from a counter, or precompute a prefix sum
+  of `accept_len` and index the flattened work directly.
+- **Stream the stores.** The output is never re-read; non-temporal stores keep it out of L2 and leave the
+  cache to the scattered pool reads.""",
+
+    precision_md="""**The measured basis for the tolerance.** There is no arithmetic here, so an independent
+implementation reproduces the reference **bit for bit**: the measured `E` is **0.0** at every correctness
+and graded shape, and `1e-6` is simply the exactness check that fact calls for, not a "tight" gate. The
+two shortcuts it exists to catch were measured on the same inputs and land at `D = 0.67 – 1.05` (path
+indirection skipped) and `D = 0.51 – 1.01` (all `K` rows copied) — five to six orders of magnitude out.
+
+There is **no arithmetic** in this kernel and therefore no precision question: the KV
+values are `bfloat16` and must be reproduced **bit-identically** — this is the cache the next step will
+attend over. Do not convert to fp32 and back, and do not quantise to fp8; the contract fixes the output
+dtype at `bfloat16` and the grader compares against a bit-exact reference at `1e-6`.
+
+The zeros past `accept_len[b]` are part of the contract and must be **exact zeros**. Allocating the output
+with `torch.empty` and writing only the accepted rows leaves the rest uninitialised: it passes on a warm
+allocator and fails as soon as the allocator hands you a dirty buffer — which the grader's fresh-input
+timing loop will do.
+
+Everything delicate here is **integer index bookkeeping**, and there are three traps:
+
+- **Two indirections, in this order:** `slot = draft_slot[b, accept_idx[b, t]]`. Using `accept_idx` as a
+  slot, or `draft_slot[b, t]` directly, both run and both are wrong by `D ≈ 1`.
+- **`accept_idx` skips.** A path through a draft tree is increasing but not contiguous; assuming
+  `accept_idx[b, t] == t` is exactly the "linear draft chain" special case and is wrong for every tree.
+- **Index width.** `L * NSLOT * H * D` exceeds `2**31` elements at the larger graded shapes, so compute
+  element and byte offsets in 64-bit; `draft_slot` arrives as `int32` and must be widened before it is
+  scaled by the slot stride.""",
+).validate()

tools/factory/specs/swiglu_blockwise_fp8.py

@@ -0,0 +1,206 @@
+"""Spec for `swiglu-blockwise-fp8-quant` — SwiGLU fused with the 1x128 FP8 quantisation of its output."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="swiglu-blockwise-fp8-quant",
+    title="Write a fast fused SwiGLU + blockwise FP8 quantisation kernel",
+    blurb=("Between the two GEMMs of an FP8-served MLP there is exactly one elementwise step: split the "
+           "fused gate/up projection, apply SwiGLU, and immediately quantise the result to FP8 with a "
+           "per-128-element block scale so the down-projection can consume it directly. Done as separate "
+           "ops the intermediate — which is twice the width of the hidden state — crosses HBM four or five "
+           "times; fused it is one read of the projection and one four-times-narrower write."),
+    keywords=["mle", "kernel-generation", "fp8", "swiglu", "quantization", "moe", "memory-bound",
+              "deepseek", "serving"],
+    module="swiglu_quant.py",
+    func="swiglu_fp8_quant",
+    signature="swiglu_fp8_quant(x)",
+    returns_doc="""Fused SwiGLU + per-128-block FP8 quantisation.
+
+Args:
+    x: (M, 2N) bfloat16 — the fused gate/up projection output, [gate half | up half].
+
+Returns:
+    (q, s) where
+      q: (M, N)        float8_e4m3fn — the quantised SwiGLU output
+      s: (M, N // 128) float32       — one scale per 128-element block along N""",
+
+    reference_imports="import torch",
+    reference_src='''
+FP8_MAX = 448.0          # max finite magnitude of float8_e4m3fn
+BLOCK = 128              # quantisation block along the feature axis
+
+
+def swiglu_fp8_quant(x):
+    """SwiGLU then per-128-block FP8 quantisation, as separate steps in fp32.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target.
+
+    NOTE the TENSOR divisor: `amax / fmax` with a 0-dim tensor is a correctly-rounded IEEE fp32 division,
+    which is exactly what `amax / 448.0f` gives in CUDA/Triton. (torch turns `tensor / python_float` into a
+    multiply by the rounded reciprocal, which is off by an ulp on many elements.)
+    """
+    M, N2 = x.shape
+    N = N2 // 2
+    fmax = torch.tensor(FP8_MAX, device=x.device)
+    xf = x.float()
+    g, u = xf[:, :N], xf[:, N:]                                        # gate half, up half
+    y = (g * torch.sigmoid(g)) * u                                     # SwiGLU, in fp32
+
+    yb = y.view(M, N // BLOCK, BLOCK)
+    s = (yb.abs().amax(-1) / fmax).clamp(min=1e-12)                    # (M, N//128) block scales
+    q = (yb / s.unsqueeze(-1)).clamp(-FP8_MAX, FP8_MAX).to(torch.float8_e4m3fn).view(M, N)
+    return q, s
+''',
+    make_inputs_src='''
+def _mk(M, N, seed):
+    """A ~14x magnitude spread BETWEEN 128-blocks, so a per-row scale is genuinely wrong and the per-block
+    absmax is a real reduction rather than a formality."""
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    blk = torch.exp(torch.rand(1, 2 * N // 128, device="cuda", generator=gen) * 2.6 - 1.3)
+    blk = blk.repeat_interleave(128, dim=1)
+    x = (torch.randn(M, 2 * N, device="cuda", generator=gen) * blk).to(torch.bfloat16)
+    return (x,)
+''',
+    flops_src='''
+def canonical_work(M, N):
+    """BYTES attributed to one fused SwiGLU+quant, from the SHAPE ALONE.
+
+    The unavoidable traffic: read x (M*2N elements at 2 bytes, bf16), write q (M*N at 1 byte, fp8), write one
+    fp32 scale per 128-element block. Memory-bound, so the score is achieved bandwidth against this fixed
+    byte count. Note the 4:1 read:write ratio — the input is twice as wide as the output and four times the
+    element width.
+    """
+    return M * 2 * N * 2 + M * N * 1 + M * (N // 128) * 4
+''',
+
+    metric="GB/s",
+    compare="tuple",
+    tuple_names=("q", "s"),
+    tol=8e-4,     # MEASURED: 3.3x the 2.4e-4 spread between two independent correct implementations; still
+                  # 15x below the 1.2e-2 that rounding the SwiGLU output through bf16 scores.
+    shape_names=("M", "N"),
+    grader_shapes=[(65536, 8192), (131072, 4096), (32768, 16384), (262144, 2048), (98304, 6144)],
+    measure_shapes=[(49152, 8192), (98304, 4096), (32768, 12288), (196608, 2048), (65536, 6144)],
+    measure_quick_shapes=[(4096, 4096), (2048, 8192), (8192, 2048)],
+    correct_shapes=[(256, 512), (129, 1024), (513, 256), (64, 2048)],
+
+    spec_md="""Two steps, fused. The input is the **fused gate/up projection**: one `(M, 2N)` matrix whose
+first `N` columns are the gate and whose last `N` columns are the value.
+
+**1 — SwiGLU**, with `silu(v) = v * sigmoid(v)`:
+
+```
+g[m, n] = x[m, n]        # gate,  columns 0 .. N-1
+u[m, n] = x[m, N + n]    # up,    columns N .. 2N-1
+y[m, n] = silu(g[m, n]) * u[m, n]
+```
+
+The gate is the **first** half and it is the one that goes through the nonlinearity. Swapping them scores
+0.77.
+
+**2 — blockwise FP8 quantisation** of `y` along `N`, in blocks of **128**:
+
+```
+for each row m and block b covering n in [128b, 128b + 128):
+    amax   = max |y[m, n]|  over the block           (clamped below at 1e-12)
+    s[m,b] = amax / 448.0                             # 448 = max finite float8_e4m3fn
+    q[m,n] = cast_to_float8_e4m3fn( y[m, n] / s[m, b] )
+```
+
+so that `q * s` reconstructs `y` to FP8 accuracy. Both are returned — the scales are what the consuming FP8
+GEMM needs. The block boundary is at multiples of 128 **within a row**; the blocks never straddle rows.
+
+The intermediate `y` is **never materialised**: it exists only in registers between the SwiGLU and the cast,
+and it must stay **fp32** all the way into the cast (see Precision — rounding it through bf16 fails the gate).
+
+`/app/reference.py` does this as separate fp32 passes. That is the exact specification, and it is also what a
+fused kernel must avoid: it writes `y`, reads it back for the absmax, and reads it a third time to divide and
+cast.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `x` | `(M, 2N)` | `bfloat16` | fused projection output, `[gate half | up half]` |
+
+**Return** a 2-tuple `(q, s)` **in that order**:
+
+| out | shape | dtype |
+|-----|-------|-------|
+| `q` | `(M, N)` | `torch.float8_e4m3fn` |
+| `s` | `(M, N // 128)` | `float32` |
+
+`N` is always a multiple of 128 (so `x` has `2N` columns, also a multiple of 128). `q` must be genuine
+`float8_e4m3fn`, not a wider dtype holding small values — the four-times-narrower write is the entire point.
+`M` is **not** a multiple of any tile size (the correctness shapes include `M = 129` and `M = 513`), so handle
+the tail. Treat `x` as read-only.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `M` (tokens,
+or tokens-per-expert after an MoE permute) in 32768–262144 and `N` (the MLP intermediate width) in
+2048–16384, so `x` has up to 32768 columns. Write a **general** kernel; both very tall/narrow and short/wide
+shapes appear, and the number of 128-blocks per row varies from 16 to 128.""",
+
+    correctness_md="""**Both** returned tensors must match the reference within **relative error `8e-4`** at
+every graded shape, including the timed ones — the scales as well as the quantised values, and the grader
+scores the **worse** of the two.
+
+Grading the pair is not a formality here. Because the block scale absorbs any change in the *magnitude* of
+`y`, a kernel that emits **one scale per row** instead of one per 128-block produces FP8 codes that are not
+obviously wrong, while its scales are off by **0.98 – 3.4** — a factor of 1000 above the gate.
+
+The other failure modes: swapping the gate and up halves scores **0.77**; using a GELU instead of the SiLU
+scores **0.13**; and the numerical one to watch, rounding the SwiGLU output through **bfloat16** before
+quantising, scores **1.2e-2**, still **15x** the tolerance.""",
+
+    perf_md="""This kernel is **memory-bound** with an unusual, lopsided profile: `4*M*N` bytes in and
+`~1.03*M*N` bytes out. Your score is achieved bandwidth against that total, and the ceiling is the HBM
+bandwidth you measure on the device (time a large bf16 `copy_` and aim there).
+
+Where the reference loses: `y` is a full `(M, N)` fp32 tensor written and then read twice more, and the
+`.view`/`.amax`/`.clamp`/`.to` chain is four more full-size passes.
+
+What a fast kernel does:
+
+- **one pass, `y` never leaves registers.** A thread block owns a tile of rows and a whole 128-block (or
+  several); it loads the gate and up columns, computes the SwiGLU in fp32, takes the block absmax with a
+  warp-shuffle reduction, and emits the FP8 bytes and the scale. Nothing intermediate touches memory.
+- **the two halves are `N` columns apart.** `g[m,n]` and `u[m,n]` live at `x[m,n]` and `x[m,N+n]`: two
+  coalesced 128-bit streams at a fixed offset, not an interleave. Issue both loads before either is needed.
+- **a 128-block maps exactly onto a warp** with four elements per lane (one 64-bit load per half), so the
+  absmax is a five-step `__shfl_xor` reduction with no shared memory and no block barrier. Do not use a
+  block-wide reduction for a 128-element group.
+- **vectorise the FP8 stores.** `q` is one byte per element; storing it one element at a time will cap you
+  far below the roofline. Pack 8 or 16 codes into a 64/128-bit store. The FP8 conversion instructions convert
+  two values at a time — use them rather than a per-element cast.
+- **the read side is 80% of the traffic.** Perfect stores with scalar loads is the wrong trade here; make the
+  loads 128-bit first.
+- **the scale write is small but not free** at `N = 2048` (one fp32 per 128 elements is 1/64 of the output);
+  keep it coalesced across the row.""",
+
+    precision_md="""The input is **bfloat16** and the output is **float8_e4m3fn** with **fp32** scales. The
+SwiGLU and the block absmax must be computed in **fp32**.
+
+**Keep `y` in fp32 all the way into the cast.** e4m3 has a 3-bit mantissa, so consecutive codes are ~6%
+apart and the output is a *step function* of `y`: an upstream perturbation of relative size `d` does not
+produce an error of size `d`, it flips roughly `d/0.06` of the elements by a full step, i.e. an error near
+`0.25 * sqrt(d)`. Rounding `y` through bfloat16 first (`d ~ 4e-3`) measures **1.2e-2** — **15x** this gate,
+and a fail. There is no bandwidth argument for narrowing `y`: it is never written to memory.
+
+The quantisation itself is otherwise essentially **deterministic** — the per-block absmax is an exact max, so
+two correct kernels compute bit-identical scales and almost identical codes. If your error is large it is a
+bug, most often a block boundary that is not a multiple of 128 or an absmax taken over the wrong axis.
+
+**Where the tolerance comes from.** `8e-4` is measured, not inherited. A second, independent implementation —
+rows chunked in blocks of 64, `silu` evaluated as `g / (1 + exp(-g))` instead of `g * sigmoid(g)`, and the
+quantisation done as a **multiply by the reciprocal** `1/s` rather than a divide by `s` — differs from this
+reference by relative Frobenius error at most **2.4e-4** over the correctness shapes and two full-scale
+shapes, six seeds each (all of it in `q`; the scales agree to 8e-8). The gate is **3.3x** that. The extra
+headroom over the usual 2x is for exactly one thing: the reciprocal-vs-divide difference is a single ulp that
+flips a small, seed-dependent fraction of codes, and that fraction has a tail. It still leaves the bf16-`y`
+mistake 15x outside and every structural error 160x or more outside.
+
+**fp8 output is required, not optional** — returning bf16 or fp16 values that happen to be numerically close
+does not satisfy the contract.""",
+).validate()

tools/factory/specs/video_cfg_zero_star.py

@@ -0,0 +1,203 @@
+"""Spec for `video-cfg-zero-star-rescale` — the CFG-Zero* guidance combination: a per-sample projection
+coefficient from two whole-latent dot products, then a rescaled classifier-free-guidance blend."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="video-cfg-zero-star-rescale",
+    title="Write a fast CFG-Zero* guidance-rescale kernel for video diffusion",
+    blurb=("Every video diffusion sampler runs the transformer twice per step and blends the two "
+           "predictions. CFG-Zero* replaces the naive blend with a rescaled one: it first projects the "
+           "unconditional prediction onto the conditional one — a pair of dot products over the ENTIRE "
+           "latent of each sample — and uses that coefficient to shrink the unconditional branch before "
+           "the guidance extrapolation. So a step that used to be one elementwise pass becomes a "
+           "whole-tensor reduction followed by a blend that cannot start until the reduction is finished, "
+           "over a gigabyte of predictions per denoising step."),
+    keywords=["mle", "kernel-generation", "video-diffusion", "classifier-free-guidance", "cfg-zero-star",
+              "guidance", "reduction", "dot-product", "sampler", "memory-bound"],
+    module="cfg_zero_star.py",
+    func="cfg_zero_star_rescale",
+    signature="cfg_zero_star_rescale(cond, uncond, guidance_scale)",
+    returns_doc="""CFG-Zero* rescaled classifier-free-guidance combination.
+
+Args:
+    cond:           (B, C, T, H, W) bfloat16 — the conditional model prediction.
+    uncond:         (B, C, T, H, W) bfloat16 — the unconditional prediction.
+    guidance_scale: float — the guidance weight.
+
+Returns:
+    (out, alpha) where
+      out:   (B, C, T, H, W) bfloat16 — the guided prediction
+      alpha: (B,)            float32  — the per-sample projection coefficient""",
+
+    reference_imports="import torch",
+    reference_src='''
+EPS = 1e-8
+
+
+def cfg_zero_star_rescale(cond, uncond, guidance_scale):
+    """Per-sample projection coefficient, then the rescaled guidance blend.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target. It walks the batch
+    so the fp32 intermediates stay bounded.
+    """
+    B = cond.shape[0]
+    alpha = torch.empty(B, device=cond.device, dtype=torch.float32)
+    out = torch.empty_like(cond)
+    for b in range(B):
+        c = cond[b].float().reshape(-1)
+        u = uncond[b].float().reshape(-1)
+        num = torch.dot(c, u)                       # <cond, uncond>
+        den = torch.dot(u, u)                       # ||uncond||^2
+        a = num / (den + EPS)
+        alpha[b] = a
+        proj = u * a                                # the projected unconditional branch
+        out[b] = (proj + guidance_scale * (c - proj)).reshape(cond.shape[1:]).to(torch.bfloat16)
+    return out, alpha
+''',
+    make_inputs_src='''
+def _mk(B, C, T, H, W, seed):
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    # the two branches come from the SAME model on the same latent, so they are strongly correlated --
+    # which is precisely why the projection coefficient sits near 1 and why the blend cancels
+    base = torch.randn(B, C, T, H, W, device="cuda", generator=gen)
+    cond = (base + 0.30 * torch.randn(B, C, T, H, W, device="cuda", generator=gen)).to(torch.bfloat16)
+    uncond = (base + 0.32 * torch.randn(B, C, T, H, W, device="cuda", generator=gen)).to(torch.bfloat16)
+    return cond, uncond, 5.0
+''',
+    flops_src='''
+def canonical_work(B, C, T, H, W):
+    """BYTES moved, from the SHAPE ALONE: one bf16 read of each prediction and one bf16 write.
+
+    That is the floor: a kernel that had the reduction for free would touch exactly these bytes. The
+    (B,) coefficient is negligible. This is a bandwidth kernel, so the score is achieved GB/s against this
+    fixed byte count.
+    """
+    return 3 * (B * C * T * H * W * 2)
+''',
+
+    metric="GB/s",
+    compare="tuple",
+    tuple_names=("out", "alpha"),
+    tol=3e-4,
+    shape_names=("B", "C", "T", "H", "W"),
+    grader_shapes=[(48, 16, 21, 90, 160), (32, 16, 33, 90, 160), (80, 16, 25, 68, 120),
+                   (24, 32, 21, 90, 160), (56, 16, 33, 68, 120)],
+    measure_shapes=[(40, 16, 21, 90, 160), (28, 16, 33, 90, 160), (64, 16, 25, 68, 120),
+                    (20, 32, 21, 90, 160), (48, 16, 33, 68, 120)],
+    measure_quick_shapes=[(8, 16, 13, 45, 80), (4, 16, 21, 45, 80), (16, 16, 9, 30, 52)],
+    correct_shapes=[(3, 16, 5, 13, 19), (2, 32, 3, 11, 17), (7, 16, 4, 9, 23), (1, 8, 7, 15, 13)],
+
+    spec_md="""Two dot products per sample, over the **whole** latent — every channel, frame, row and
+column — then an elementwise blend.
+
+```
+num[b]   = sum over (c, t, y, x) of  cond[b,c,t,y,x] * uncond[b,c,t,y,x]
+den[b]   = sum over (c, t, y, x) of  uncond[b,c,t,y,x] * uncond[b,c,t,y,x]
+alpha[b] = num[b] / (den[b] + 1e-8)
+```
+
+`alpha[b]` is the least-squares projection of the conditional prediction onto the unconditional one. The
+blend then uses the **projected** unconditional branch instead of the raw one:
+
+```
+proj[b,c,t,y,x] = uncond[b,c,t,y,x] * alpha[b]
+out[b,c,t,y,x]  = proj + guidance_scale * (cond - proj)
+```
+
+Setting `alpha = 1` recovers ordinary classifier-free guidance; the whole point of the method is that
+`alpha` is *not* 1, and that it is computed **per sample**, not once for the batch.
+
+`guidance_scale` is a python float, the same for every sample. `1e-8` is added to the denominator exactly
+as written.
+
+`/app/reference.py` walks the batch, takes the two dot products in fp32 and applies the blend. That is the
+exact specification; it is deliberately simple rather than fast.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `cond` | `(B, C, T, H, W)` | `bfloat16` | conditional prediction, contiguous |
+| `uncond` | `(B, C, T, H, W)` | `bfloat16` | unconditional prediction, same shape and layout |
+| `guidance_scale` | python `float` | | guidance weight; around 5 at every graded shape |
+
+**Return** a 2-tuple `(out, alpha)` **in that order**:
+
+| out | shape | dtype |
+|-----|-------|-------|
+| `out` | `(B, C, T, H, W)` | **bfloat16** |
+| `alpha` | `(B,)` | **float32** — one coefficient per sample |
+
+Both are graded and the grader scores the worse of the two. All inputs are **read-only** — the op is
+functional, do not write into `cond` or `uncond`.
+
+`C*T*H*W` is not a multiple of any tile size (the correctness shapes include `(16, 5, 13, 19)` and
+`(16, 4, 9, 23)`), and `B` is not either.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `B` in
+24–80 — one entry per prediction in flight, i.e. the serving batch, since a single video's latent is far
+too small to keep a GPU busy on its own — `C` in 16–32 latent channels, `T` in 21–33 latent frames, `H` in
+68–90 and `W` in 120–160. One call moves 1.3-1.5 GB and it runs once per denoising step.""",
+
+    correctness_md="""**Both** returned tensors must match the reference (evaluated in fp32) within
+**relative error `3e-4`** at every graded shape, including the timed ones; the grader scores the **worse**
+of the two.
+
+That gate is **measured**, and a kernel that skips this task's distinguishing work misses it by orders of
+magnitude: using `alpha = 1` — i.e. ordinary classifier-free guidance — scores **2.5e-1**; computing one
+`alpha` for the whole batch instead of one per sample scores **1.3e-2**; putting `||cond||^2` in the
+denominator instead of `||uncond||^2` scores **2.6e-1**; and applying the guidance to the raw
+unconditional branch (`uncond + scale*(cond - uncond)`, then scaling by alpha) scores **2.4e-1**. All are
+40x to 900x the tolerance.""",
+
+    perf_md="""`canonical_work` counts the ideal floor — one read of each prediction and one write — and a
+kernel cannot quite reach it, because `alpha[b]` depends on **every** element of sample `b` and nothing can
+be written until it is known. Two shapes of solution, and it is worth measuring both:
+
+* **Two passes.** Pass 1 reduces `cond*uncond` and `uncond*uncond` per sample into `(B,)` accumulators;
+  pass 2 re-reads both tensors and writes the blend. That is 4 reads and 1 write against the floor's 3, so
+  the ceiling is about 60% of peak bandwidth. Pass 1 is read-only and streams perfectly; keep both partial
+  sums in the same pass so each element is loaded once, not twice.
+* **One pass with a grid-wide barrier.** A persistent kernel sized to the device's SM count can hold a
+  slab of both tensors in L2 between the reduction and the blend. At the graded sizes the pair is 1 GB, so
+  only a fraction of it stays resident — but the fraction that does is a real saving, and the barrier
+  itself is cheap compared with a second full HBM pass.
+
+Either way the reduction is the interesting part: it is two independent sums per sample over up to 5x10^6
+elements, so use a two-stage tree (block partials into a small `(num_blocks, B, 2)` buffer, then a tiny
+second kernel) or fp32 atomics. Do **not** materialise the elementwise products — `cond*uncond` as a
+tensor is another gigabyte.
+
+The epilogue is fully fusible: `out = alpha*(1 - scale)*uncond + scale*cond` is two fused multiply-adds
+once `alpha` is in a register, and both coefficients are per sample, so they are loaded once per block.
+
+`B` is large and each sample is contiguous, so the natural decomposition is a flat grid over elements with
+the sample index derived by division — precompute the per-sample element count on the host and pass it as
+a constant rather than dividing per element.""",
+
+    precision_md="""`cond`, `uncond` and `out` are **bfloat16**; both dot products, `alpha` and the blend
+are **fp32**.
+
+The reduction runs over up to 5x10^6 elements per sample, so accumulate in fp32 with a tree or two-stage
+reduction. A bf16 accumulator is hopeless here, and even a single fp32 running scalar chained over
+millions of elements drifts: the two sums are of strictly positive-ish quantities (the branches are highly
+correlated, so `cond*uncond` rarely changes sign), which means the error accumulates rather than cancels.
+
+`alpha` is **float32** and is checked at the same gate. It is `B` values, so keeping it wide costs nothing.
+
+Note the blend **cancels**: with `guidance_scale` around 5 and `alpha` near 0.9, `out` is a difference of
+two quantities several times its own size, so it inherits roughly a 3x amplification of any error in
+`alpha`. That is the real behaviour of guidance and the tolerance is measured with it in place.
+
+**fp8 is not useful here** and is not expected: this is a bandwidth kernel with a fixed bf16 output.
+
+**Where the tolerance comes from.** `3e-4` is measured, not inherited. A second, independent implementation
+— the two reductions computed as a chunked pass over a flattened view with per-chunk fp32 partials
+combined at the end (a completely different summation order from `torch.dot`), and the blend folded as
+`alpha*(1-scale)*uncond + scale*cond` — differs from this reference by relative Frobenius error **1.4e-4**
+at worst over the correctness shapes and **1.3e-4** at a graded-scale shape. It is the bf16 rounding of
+`out`, amplified by the cancellation described above, and it does not grow with the volume. The tolerance
+is **2.1x** that.""",
+).validate()

tools/factory/specs/zamba_shared_attn_lora_backward.py

@@ -0,0 +1,222 @@
+"""Spec for `zamba-shared-attn-lora-backward` — the training-side backward of the Zamba-2 shared attention
+block's QKV projection: frozen shared weight, L per-depth LoRA adapters, concatenated input."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+_FWD = '''
+def _shared_qkv(h, emb, w_qkv, lora_a, lora_b, scaling):
+    """The fp32 forward of `zamba-shared-attn-lora-qkv`, differentiable. Autograd through THIS defines
+    every gradient this task asks for."""
+    L, T, Dm = h.shape
+    outs = []
+    for l in range(L):
+        xc = torch.cat([h[l], emb], dim=-1)                     # (T, 2*Dm)  [state | embedding]
+        base = xc @ w_qkv.t()
+        delta = (xc @ lora_a[l].t()) @ lora_b[l].t()
+        outs.append(base + scaling * delta)
+    return torch.stack(outs, 0)
+
+
+def shared_qkv_backward(h, emb, w_qkv, lora_a, lora_b, scaling, dqkv):
+    """The baseline re-runs the fp32 forward under autograd. The shared weight is FROZEN: only the two
+    activations and the L adapters receive gradients."""
+    ins = [t.detach().clone().float().requires_grad_(True) for t in (h, emb, lora_a, lora_b)]
+    o = _shared_qkv(ins[0], ins[1], w_qkv.float(), ins[2], ins[3], scaling)
+    return torch.autograd.grad(o, ins, dqkv.float())
+'''
+
+SPEC = TaskSpec(
+    name="zamba-shared-attn-lora-backward",
+    title="Write a fast backward kernel for the shared-attention-block QKV projection",
+    blurb=("Fine-tuning a Zamba-style hybrid means differentiating a block that was called at L different "
+           "depths with one frozen weight and L different rank-64 adapters, over an input that was a "
+           "concatenation of the depth's residual stream and the model's original embedding. So the "
+           "embedding's gradient is a sum over EVERY depth, each adapter's gradient is a pair of tall-skinny "
+           "reductions over the token axis, and the frozen weight is read L times and never updated."),
+    keywords=["mle", "kernel-generation", "zamba", "hybrid", "shared-attention", "lora", "multi-adapter",
+              "backward", "training", "gemm", "compute-bound"],
+    module="shared_qkv_bwd.py",
+    func="shared_qkv_backward",
+    signature="shared_qkv_backward(h, emb, w_qkv, lora_a, lora_b, scaling, dqkv)",
+    returns_doc="""Backward of the shared attention-block QKV projection (frozen base, L LoRA adapters).
+
+Args:
+    h:       (L, T, Dm)    bfloat16 — residual stream at each depth, saved by the forward.
+    emb:     (T, Dm)       bfloat16 — the shared original embedding, saved by the forward.
+    w_qkv:   (3*Dm, 2*Dm)  bfloat16 — the shared projection. FROZEN: no gradient is returned for it.
+    lora_a:  (L, r, 2*Dm)  bfloat16 — per-depth LoRA down-projection.
+    lora_b:  (L, 3*Dm, r)  bfloat16 — per-depth LoRA up-projection.
+    scaling: float                  — the LoRA scale (alpha / r).
+    dqkv:    (L, T, 3*Dm)  bfloat16 — incoming gradient w.r.t. the fused QKV output.
+
+Returns:
+    (dh, demb, dlora_a, dlora_b) with shapes
+    (L, T, Dm), (T, Dm), (L, r, 2*Dm), (L, 3*Dm, r).""",
+
+    reference_imports="import torch",
+    reference_src=_FWD,
+    make_inputs_src='''
+def _mk(L, T, Dm, r, seed):
+    """Saved forward inputs plus the incoming gradient. The adapters are scaled so the LoRA delta is a real
+    but minority part of the forward (RMS `16/r` of the base projection), which is what a trained LoRA
+    looks like."""
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+
+    def rnd(*sh, s=1.0):
+        return (torch.randn(*sh, device="cuda", dtype=torch.float32, generator=gen) * s).to(torch.bfloat16)
+
+    h = rnd(L, T, Dm)
+    emb = rnd(T, Dm)
+    w_qkv = rnd(3 * Dm, 2 * Dm, s=(2 * Dm) ** -0.5)
+    lora_a = rnd(L, r, 2 * Dm, s=(2 * Dm) ** -0.5)
+    lora_b = rnd(L, 3 * Dm, r, s=r ** -0.5)
+    dqkv = rnd(L, T, 3 * Dm)
+    return h, emb, w_qkv, lora_a, lora_b, 16.0 / r, dqkv
+''',
+    flops_src='''
+def canonical_work(L, T, Dm, r):
+    """FLOPs attributed to one backward call, from the SHAPE ALONE.
+
+    Per depth, at 2 FLOPs per multiply-add:
+      * ONE pass of the big shared shape: dxc = dqkv @ w_qkv                (the base weight is frozen,
+        so there is no dw_qkv and no second pass over it)
+      * THREE passes of the (2*Dm, r) adapter shape: recompute mid = xc @ lora_a.T (the LoRA output is a
+        forward temporary), dxc += dmid @ lora_a, dlora_a = dmid.T @ xc
+      * TWO passes of the (3*Dm, r) adapter shape: dmid = dqkv @ lora_b, dlora_b = dqkv.T @ mid
+    The concatenation, the split of dxc and the sum of demb over depths are O(L*T*Dm) data movement and
+    are not credited.
+    """
+    return L * (2 * T * (2 * Dm) * (3 * Dm)
+                + 3 * (2 * T * (2 * Dm) * r)
+                + 2 * (2 * T * (3 * Dm) * r))
+''',
+    flops_formula=("canonical_work(L, T, Dm, r) = L * ( 2*T*(2*Dm)*(3*Dm)      # dxc = dqkv @ w_qkv\n"
+                   "                                 + 3 * 2*T*(2*Dm)*r        # mid, dxc +=, dlora_a\n"
+                   "                                 + 2 * 2*T*(3*Dm)*r )      # dmid, dlora_b"),
+
+    metric="TFLOP/s",
+    compare="tuple",
+    tuple_names=("dh", "demb", "dlora_a", "dlora_b"),
+    tol=6e-3,   # MEASURED: 2.07x the 2.90e-3 worst gap to an independent hand-written bf16 backward
+    shape_names=("L", "T", "Dm", "r"),
+    grader_shapes=[(6, 4096, 2048, 64), (4, 4096, 2560, 64), (8, 2048, 2048, 32),
+                   (6, 3072, 2048, 128), (4, 6144, 2048, 64)],
+    measure_shapes=[(6, 3584, 2048, 64), (4, 3584, 2560, 64), (8, 1792, 2048, 32),
+                    (6, 2560, 2048, 128), (4, 5120, 2048, 64)],
+    measure_quick_shapes=[(4, 512, 1024, 32), (2, 1024, 512, 16), (6, 256, 1024, 64)],
+    correct_shapes=[(2, 256, 256, 16), (3, 129, 128, 8), (4, 512, 512, 32), (2, 64, 128, 4)],
+
+    spec_md="""The forward being differentiated is the shared attention block's QKV projection, called at
+`L` depths with one shared weight and a per-depth LoRA adapter:
+
+```
+xc[l]  = concat( h[l], emb )                                       # (T, 2*Dm), state first
+mid[l] = xc[l] @ lora_a[l].T                                       # (T, r)
+qkv[l] = xc[l] @ w_qkv.T  +  scaling * mid[l] @ lora_b[l].T
+```
+
+`w_qkv` is **frozen** — this is adapter fine-tuning, so no gradient is produced for it and it is never
+transposed-reduced over the token axis. Given `dqkv` you must return four things:
+
+```
+dmid[l]     = scaling * ( dqkv[l] @ lora_b[l] )                    # (T, r)
+dxc[l]      = dqkv[l] @ w_qkv  +  dmid[l] @ lora_a[l]              # (T, 2*Dm)
+dlora_a[l]  = dmid[l].T @ xc[l]                                    # (r, 2*Dm)
+dlora_b[l]  = scaling * ( dqkv[l].T @ mid[l] )                     # (3*Dm, r)
+```
+
+and then the concatenation is undone:
+
+```
+dh[l] = dxc[l][:, :Dm]
+demb  = sum over ALL l of dxc[l][:, Dm:]
+```
+
+**`demb` is a sum over every depth.** The same embedding tensor was fed to all `L` invocations, so its
+gradient collects a contribution from each one — this is the piece that makes the backward of a *shared*
+block different from `L` independent backwards.
+
+Note that `mid[l]` was a forward temporary and is not an argument: `dlora_b` needs it, so it must be
+recomputed.
+
+`/app/reference.py` re-runs the fp32 forward under autograd and differentiates it. That is the exact
+specification; it is deliberately simple rather than fast.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `h` | `(L, T, Dm)` | `bfloat16` | residual stream at each depth |
+| `emb` | `(T, Dm)` | `bfloat16` | shared original embedding |
+| `w_qkv` | `(3*Dm, 2*Dm)` | `bfloat16` | shared projection, **frozen** |
+| `lora_a` | `(L, r, 2*Dm)` | `bfloat16` | per-depth LoRA down |
+| `lora_b` | `(L, 3*Dm, r)` | `bfloat16` | per-depth LoRA up |
+| `scaling` | float | | LoRA scale `alpha / r` |
+| `dqkv` | `(L, T, 3*Dm)` | `bfloat16` | incoming gradient w.r.t. the fused QKV output |
+
+**Return a 4-tuple in exactly this order:** `dh (L, T, Dm)`, `demb (T, Dm)`, `dlora_a (L, r, 2*Dm)`,
+`dlora_b (L, 3*Dm, r)`.
+
+`dh` and `demb` may be bf16 or fp32; the two adapter gradients should be **fp32** — each is a reduction
+over every token. **No gradient is returned for `w_qkv`.** The concatenation order is `[h[l] ‖ emb]`, so
+`dh` comes from the first `Dm` channels of `dxc` and `demb` from the last `Dm`, summed over depths.
+
+All inputs are **read-only**. `T` is **not** guaranteed to be a multiple of any tile size (the correctness
+shapes include `T = 129`), and `r` is as small as 4.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `L` in
+4–8, `T` in 2048–6144, `Dm` in 2048–2560, `r` in 32–128. One big matmul per depth dominates the FLOPs; the
+adapter work is a few percent of it and most of the difficulty.""",
+
+    correctness_md="""**All four** returned tensors must match the reference (evaluated in fp32) within
+**relative Frobenius error `6e-3`** at every graded shape, including the timed ones; the grader scores the
+**worst** of the four.
+
+That gate is **measured**, and the two structural mistakes this task invites miss it badly: taking `demb`
+from depth 0 instead of summing over **all** depths scores **0.70–0.91**, and omitting the adapter's
+contribution `dmid @ lora_a` from `dxc` scores **0.124** at the largest graded shape (0.45–0.97 at the
+small ones) — 21x the tolerance at worst.""",
+
+    perf_md="""`L` big matmuls against one frozen weight, plus four tall-skinny ones per depth, plus a
+reduction that ties all the depths together.
+
+**The frozen weight is read `L` times if you let it be.** `w_qkv` is 40–65 MB; a persistent grid that
+walks all `L` depths per weight tile pays for it once. Note the transpose: the backward needs
+`dqkv @ w_qkv` (not `w_qkv.T`), so the reduction runs over the `3*Dm` axis — plan the layout for that
+rather than transposing a 65 MB tensor at run time.
+
+**`demb` is a cross-depth reduction.** Do not build `L` copies of `dxc[:, Dm:]` and add them afterwards:
+that is `L` extra full-size writes and reads. Accumulate into one fp32 `(T, Dm)` buffer as each depth's
+tile is produced — with `L <= 8` a deterministic tree or a per-depth atomic-free accumulation over a
+partition of the token axis both work, and both beat materialising the intermediates.
+
+**Fuse the adapter path.** `mid[l]` and `dmid[l]` are `(T, r)` with `r <= 128`. Both belong in shared
+memory: recompute `mid` from the `xc` tile you already have, form `dmid` from the `dqkv` tile you already
+have, and feed both straight into the two weight-gradient reductions. An autograd-shaped implementation
+sends four `(T, r)` tensors and two `(T, 2*Dm)` tensors through HBM per depth for a delta worth a few
+percent of the arithmetic.
+
+**`dlora_a` and `dlora_b` are split-K reductions** over the token axis into tiny outputs (`r x 2*Dm` and
+`3*Dm x r`). Use fp32 accumulators and a cross-block reduction; do not use one atomic per element.
+
+`xc` should never be materialised: its first half is `h[l]`, its second half is `emb`, and every consumer
+can read them separately.""",
+
+    precision_md="""Inputs are **bfloat16**; accumulate every matmul, the `demb` cross-depth sum and both
+adapter-gradient reductions in **fp32**.
+
+`demb` sums `L` full-size contributions and the adapter gradients sum over up to 6144 tokens — a bf16
+accumulator in either place gives an error that *grows* with the problem size, which the faithfulness
+clause below rejects.
+
+**fp8 is not appropriate here**: the saved activations arrive in bf16 and re-quantising them is an
+approximation of the specified computation.
+
+**Where the tolerance comes from.** `1e-2` is measured. A second, independent implementation — the
+analytic backward written out by hand, all `L` depths batched into `bmm`s, `xc` never materialised, the
+adapter gradients accumulated in a different order from autograd's — differs from this fp32 autograd
+reference by a worst relative Frobenius error of **2.90e-3** across the correctness shapes and two
+full-size graded shapes, over several seeds. The tolerance is **2.07x** that, and the error *falls* with
+problem size (2.37e-3 at the large shapes) — it is the bf16 rounding of the operands, nothing more.""",
+).validate()

tools/factory/specs/zamba_shared_attn_lora_qkv.py

@@ -0,0 +1,197 @@
+"""Spec for `zamba-shared-attn-lora-qkv` — the Zamba-2 shared attention block's QKV projection: one shared
+weight applied at L depths, each with its own LoRA adapter, over a concatenated [state ‖ embedding] input."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="zamba-shared-attn-lora-qkv",
+    title="Write a fast shared-attention-block QKV kernel (one weight, L per-depth LoRA adapters)",
+    blurb=("Zamba-2 does not give every attention layer its own weights — it has ONE attention block and "
+           "calls it at several depths of a Mamba stack, feeding it the concatenation of the current "
+           "residual stream and the original token embedding, and giving each invocation its own low-rank "
+           "adapter so the shared weights can still specialise. The QKV projection therefore runs L times "
+           "against the same 50 MB of weights with L different rank-64 deltas, and done as L separate "
+           "library calls the shared weight is re-read from HBM every time and the adapters get three "
+           "extra launches each."),
+    keywords=["mle", "kernel-generation", "zamba", "hybrid", "shared-attention", "lora", "multi-adapter",
+              "gemm", "fusion", "compute-bound"],
+    module="shared_qkv.py",
+    func="shared_block_qkv",
+    signature="shared_block_qkv(h, emb, w_qkv, lora_a, lora_b, scaling)",
+    returns_doc="""Shared attention-block QKV projection with a per-depth LoRA adapter.
+
+Args:
+    h:       (L, T, Dm)    bfloat16 — the residual stream at each of the L depths the block is called at.
+    emb:     (T, Dm)       bfloat16 — the ORIGINAL token embedding, concatenated at every depth.
+    w_qkv:   (3*Dm, 2*Dm)  bfloat16 — the SHARED qkv projection, nn.Linear layout (out, in).
+    lora_a:  (L, r, 2*Dm)  bfloat16 — per-depth LoRA down-projection.
+    lora_b:  (L, 3*Dm, r)  bfloat16 — per-depth LoRA up-projection.
+    scaling: float                  — the LoRA scale (alpha / r).
+
+Returns:
+    qkv: (L, T, 3*Dm), bfloat16 or float32 — must match /app/reference.py numerically.""",
+
+    reference_imports="import torch",
+    reference_src='''
+def shared_block_qkv(h, emb, w_qkv, lora_a, lora_b, scaling):
+    """One depth at a time: concatenate, project with the shared weight, add the depth's LoRA delta.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target. The shared weight is
+    re-read for every depth and the rank-wide intermediate goes to HBM.
+    """
+    L, T, Dm = h.shape
+    out = torch.empty(L, T, 3 * Dm, device=h.device, dtype=torch.float32)
+    w = w_qkv.float()
+    e = emb.float()
+    for l in range(L):
+        xc = torch.cat([h[l].float(), e], dim=-1)              # (T, 2*Dm)  [state | embedding]
+        base = xc @ w.t()                                      # the SHARED projection
+        delta = (xc @ lora_a[l].float().t()) @ lora_b[l].float().t()
+        out[l] = base + scaling * delta
+    return out.to(torch.bfloat16)
+''',
+    make_inputs_src='''
+def _mk(L, T, Dm, r, seed):
+    """Per-depth residual streams, one shared embedding, the shared weight and L LoRA adapters.
+
+    The adapters are scaled so the delta is a real but minority contribution (its RMS is `16/r` of the
+    base projection's), which is what a trained LoRA looks like — big enough that ignoring it is obvious,
+    small enough that it is a correction rather than the answer.
+    """
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+
+    def rnd(*sh, s=1.0):
+        return (torch.randn(*sh, device="cuda", dtype=torch.float32, generator=gen) * s).to(torch.bfloat16)
+
+    h = rnd(L, T, Dm)
+    emb = rnd(T, Dm)
+    w_qkv = rnd(3 * Dm, 2 * Dm, s=(2 * Dm) ** -0.5)
+    lora_a = rnd(L, r, 2 * Dm, s=(2 * Dm) ** -0.5)
+    lora_b = rnd(L, 3 * Dm, r, s=r ** -0.5)
+    return h, emb, w_qkv, lora_a, lora_b, 16.0 / r
+''',
+    flops_src='''
+def canonical_work(L, T, Dm, r):
+    """FLOPs attributed to one call, from the SHAPE ALONE.
+
+    Per depth, at 2 FLOPs per multiply-add: the shared projection (T, 2*Dm) x (2*Dm, 3*Dm), the adapter's
+    down-projection (T, 2*Dm) x (2*Dm, r) and its up-projection (T, r) x (r, 3*Dm). The concatenation and
+    the residual add are O(T*Dm) data movement and are not credited.
+    """
+    return L * (2 * T * (2 * Dm) * (3 * Dm) + 2 * T * (2 * Dm) * r + 2 * T * r * (3 * Dm))
+''',
+    flops_formula=("canonical_work(L, T, Dm, r) = L * ( 2*T*(2*Dm)*(3*Dm)  +  2*T*(2*Dm)*r  +  2*T*r*(3*Dm) )\n"
+                   "#                                  shared projection      LoRA down        LoRA up"),
+
+    metric="TFLOP/s",
+    compare="tensor",
+    tol=7e-3,   # MEASURED: 2.1x the 3.30e-3 worst gap to an independent batched-bmm implementation
+    shape_names=("L", "T", "Dm", "r"),
+    grader_shapes=[(6, 4096, 2048, 64), (4, 4096, 2560, 64), (8, 2048, 2048, 32),
+                   (6, 3072, 2048, 128), (4, 6144, 2048, 64)],
+    measure_shapes=[(6, 3584, 2048, 64), (4, 3584, 2560, 64), (8, 1792, 2048, 32),
+                    (6, 2560, 2048, 128), (4, 5120, 2048, 64)],
+    measure_quick_shapes=[(4, 512, 1024, 32), (2, 1024, 512, 16), (6, 256, 1024, 64)],
+    correct_shapes=[(2, 256, 256, 16), (3, 129, 128, 8), (4, 512, 512, 32), (2, 64, 128, 4)],
+
+    spec_md="""A Zamba-style hybrid stack has **one** attention block, invoked at `L` different depths of a
+Mamba backbone. Two things make its QKV projection unusual.
+
+**1 — the input is a concatenation.** At every depth the block sees the current residual stream *and* the
+original token embedding, glued along the feature axis:
+
+```
+xc[l] = concat( h[l], emb )          # (T, 2*Dm) — state first, embedding second
+```
+
+`emb` is the **same** tensor at every depth: it is the model's input embedding, re-fed so the shared block
+always has the original token available no matter how deep it is being called.
+
+**2 — the weights are shared, the adapters are not.** One `(3*Dm, 2*Dm)` projection serves every depth,
+and each depth gets its own rank-`r` LoRA delta:
+
+```
+qkv[l] = xc[l] @ w_qkv.T  +  scaling * ( xc[l] @ lora_a[l].T ) @ lora_b[l].T
+```
+
+That is the whole computation: `L` applications of one big shared GEMM, each with its own tiny two-matmul
+correction. The output layout is the usual fused one — `qkv[l][:, 0:Dm]` is Q, `[Dm:2*Dm]` is K,
+`[2*Dm:3*Dm]` is V — but nothing here needs to know that; you return the fused tensor.
+
+`/app/reference.py` loops over depths and materialises the concatenation and the rank-wide intermediate for
+each. That is the exact specification; it is deliberately simple rather than fast.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `h` | `(L, T, Dm)` | `bfloat16` | residual stream at each of the `L` invocation depths |
+| `emb` | `(T, Dm)` | `bfloat16` | the original token embedding, **shared** across depths |
+| `w_qkv` | `(3*Dm, 2*Dm)` | `bfloat16` | the shared projection, `nn.Linear` layout `(out, in)` |
+| `lora_a` | `(L, r, 2*Dm)` | `bfloat16` | per-depth LoRA down-projection |
+| `lora_b` | `(L, 3*Dm, r)` | `bfloat16` | per-depth LoRA up-projection |
+| `scaling` | float | | LoRA scale `alpha / r`, a Python float |
+
+**Return** a single tensor `qkv` of shape `(L, T, 3*Dm)`, bfloat16 or float32 (the grader compares in
+fp32).
+
+The concatenation order is **`[h[l] ‖ emb]`** — state in channels `[0, Dm)`, embedding in `[Dm, 2*Dm)` —
+and `w_qkv`'s columns are laid out to match. All inputs are **read-only**. `T` is **not** guaranteed to be
+a multiple of any tile size (the correctness shapes include `T = 129`), and `r` is as small as 4.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `L`
+(invocation depths) in 4–8, `T` (tokens) in 2048–6144, `Dm` in 2048–2560, `r` in 32–128. The shared weight
+is 40–65 MB and is used `L` times; the `L` adapters together are a few megabytes. That ratio is the whole
+design of the layer and it should be the whole design of your kernel.""",
+
+    correctness_md="""The returned tensor must match the reference (evaluated in fp32) within **relative
+Frobenius error `7e-3`** at every graded shape, including the timed ones.
+
+That gate is **measured**, and the plausible ways to get this wrong miss it by a wide margin: dropping the
+LoRA delta entirely scores **0.12–0.24** at the graded shapes (0.45–0.97 at the small ones, where `r` is
+a larger fraction of the width), using depth 0's adapter for every depth scores **0.16–0.30**, and
+concatenating `[emb ‖ h[l]]` instead of `[h[l] ‖ emb]` scores **1.41** — the closest is **18x** the
+tolerance.""",
+
+    perf_md="""One big GEMM done `L` times against the same weight, plus `2L` tiny ones. Three things
+decide the score.
+
+**Read the shared weight once.** `w_qkv` is 40–65 MB; `L` separate `torch.matmul` calls stream it from HBM
+`L` times. A kernel that tiles over `(depth, token)` blocks with the weight tile resident — or a persistent
+grid that walks all `L` depths for each weight tile — pays for it once. At `L = 8` that is the difference
+between 500 MB and 60 MB of weight traffic.
+
+**Never materialise the concatenation.** `xc[l]` is `(T, 2*Dm)` and half of it is `emb`, which is the same
+for every depth. Building it explicitly costs `L` writes and `L` reads of a tensor twice the size of `h`.
+The GEMM's K-loop can simply read the first `Dm` steps from `h[l]` and the next `Dm` from `emb` — the
+operands are contiguous within each half, and `emb`'s half is reused by all `L` depths, so it is a
+shared-memory tile you load once.
+
+**Fuse the adapter.** The rank-wide intermediate `xc @ lora_a[l].T` is `(T, r)` with `r <= 128` — a few
+hundred kilobytes. It has no business in HBM: compute it into shared memory while the tile is resident,
+then accumulate `scaling * (that) @ lora_b[l].T` straight into the same accumulator the shared projection
+is building. Done separately, the adapter costs a second full read of `xc`, two extra launches per depth,
+and a round trip of the intermediate — on a delta that is a few percent of the arithmetic.
+
+The `L` depths are completely independent, which is free parallelism for filling the machine at small `T`,
+and `T` is ragged, so size the tail carefully.""",
+
+    precision_md="""Inputs are **bfloat16** and the output may be bf16 or fp32. Accumulate every matmul in
+**fp32** — including the adapter's two, whose product is added to a much larger base term, so its own
+rounding is amplified by nothing but must not be thrown away.
+
+`scaling` is a Python float. Fold it into the adapter's up-projection or apply it to the rank-wide
+intermediate; either is fine, but do it in fp32.
+
+**fp8 is not appropriate here**: the weights and activations arrive in bf16 and re-quantising them is an
+approximation of the specified computation, not an implementation of it.
+
+**Where the tolerance comes from.** `1e-2` is measured. A second, independent implementation — all `L`
+depths batched into one `bmm` against a broadcast weight, the concatenation formed implicitly by splitting
+the K-loop, the LoRA fused as `xc @ (lora_a.T @ lora_b.T)` in the other association order, bf16 operands
+with fp32 accumulate — differs from this fp32 reference by a worst relative Frobenius error of **3.30e-3**
+across the correctness shapes and two full-size graded shapes, over several seeds. The tolerance is
+**2.1x** that, and the error is flat in `L` and `T` (2.86e-3 at the large shapes) because it is the bf16
+rounding of the operands and of the returned tensor and nothing else.""",
+).validate()

tools/factory/specs/zero3_param_regroup.py

@@ -0,0 +1,245 @@
+"""Spec for `zero3-param-regroup` — coalesce an MoE unit's parameters into fixed-capacity all-gather
+buckets with a greedy first-fit walk, and emit the placement map."""
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+from spec import TaskSpec
+
+SPEC = TaskSpec(
+    name="zero3-param-regroup",
+    title="Write a fast ZeRO-3 parameter regrouping kernel (greedy capacity bucketing)",
+    blurb=("ZeRO-3 does not all-gather 200 expert matrices one at a time — it coalesces them into "
+           "fixed-capacity buckets first, walking the parameter list in order and starting a new bucket "
+           "whenever the next tensor will not fit. Nothing may straddle a bucket, so the tail of every "
+           "bucket is a zeroed hole, and every parameter needs its (bucket, offset) recorded so the "
+           "gathered copy can be found again. It moves the whole unit and it decides how many collectives "
+           "the step issues."),
+    keywords=["mle", "kernel-generation", "zero3", "deepspeed", "fsdp", "bucketing", "all-gather",
+              "moe", "distributed", "training", "layout", "memory-bound"],
+    module="regroup.py",
+    func="zero3_param_regroup",
+    signature="zero3_param_regroup(src, numel, cap)",
+    returns_doc="""Coalesce parameters into fixed-capacity all-gather buckets.
+
+Args:
+    src:   (Ntot,) bfloat16 — the parameters concatenated back to back, in parameter order.
+    numel: (P,)    int32    — element count of each parameter; sum(numel) == Ntot, max(numel) <= cap.
+    cap:   int              — bucket capacity in elements.
+
+Returns:
+    (buckets, meta) where
+      buckets: (NB, cap) bfloat16 — the packed buckets; every unused slot EXACTLY zero
+      meta:    (P, 2)    int32    — per parameter: [bucket index, offset inside that bucket]""",
+
+    reference_imports="import torch",
+    reference_src='''
+def zero3_param_regroup(src, numel, cap):
+    """Greedy first-fit packing, one parameter at a time.
+
+    Correct and simple — it is the SPECIFICATION, not a performance target. It syncs `numel` to the host,
+    walks the list in Python, zero-fills every bucket and then issues one slice copy per parameter.
+    """
+    ns = numel.tolist()                                  # device -> host sync on the critical path
+    bid, off = [], []
+    cur, nb = 0, 1
+    for n in ns:
+        if cur + n > cap:                                # it does not fit -> close this bucket
+            nb += 1
+            cur = 0
+        bid.append(nb - 1)
+        off.append(cur)
+        cur += n
+
+    buckets = torch.zeros(nb, cap, device=src.device, dtype=src.dtype)   # holes must end up EXACTLY zero
+    so = 0
+    for p, n in enumerate(ns):
+        buckets[bid[p], off[p]:off[p] + n] = src[so:so + n]
+        so += n
+
+    meta = torch.tensor([[b, o] for b, o in zip(bid, off)], device=src.device, dtype=torch.int32)
+    return buckets, meta
+''',
+    make_inputs_src='''
+def _mk(L, D, F, E, CAPK, seed):
+    """An L-block MoE unit's bf16 parameters, in module order, plus the bucket capacity.
+
+    Per block: q/k/v/o with 4x GQA, a router, E experts of (gate, up, down), and two RMSNorm gains —
+    120 to 250 tensors at the graded sizes, mostly identical expert matrices with a handful of tiny ones
+    mixed in, which is exactly the size profile that makes the greedy walk non-uniform.
+    """
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    ns = _numels(L, D, F, E)
+    src = (torch.randn(sum(ns), device="cuda", dtype=torch.float32, generator=gen) * 0.02).bfloat16()
+    return src, torch.tensor(ns, device="cuda", dtype=torch.int32), CAPK * 1024
+''',
+    flops_src='''
+def _numels(L, D, F, E):
+    """Every parameter's element count, from the SHAPE ALONE."""
+    ns = []
+    for _ in range(L):
+        ns += [D * D, (D // 4) * D, (D // 4) * D, D * D, E * D]      # q, k, v, o, router
+        for _ in range(E):
+            ns += [F * D, F * D, D * F]                              # expert gate, up, down
+        ns += [D, D]                                                 # the two RMSNorm gains
+    return ns
+
+
+def _nbuckets(ns, cap):
+    """How many buckets the greedy first-fit walk produces. Depends only on the sizes, i.e. on the shape."""
+    cur, nb = 0, 1
+    for n in ns:
+        if cur + n > cap:
+            nb += 1
+            cur = 0
+        cur += n
+    return nb
+
+
+def canonical_work(L, D, F, E, CAPK):
+    """BYTES attributed to one regroup, from the SHAPE ALONE.
+
+    Read every bf16 parameter once (2*Ntot) and write the whole bucket array once (2*NB*cap) -- the holes
+    are part of the output because they have to be zeroed. The (P, 2) placement map is negligible. Pure
+    data movement: the score is achieved bandwidth against that fixed byte count.
+    """
+    ns = _numels(L, D, F, E)
+    cap = CAPK * 1024
+    return 2 * sum(ns) + 2 * _nbuckets(ns, cap) * cap
+''',
+    flops_formula="""Ntot = sum(numel)
+NB   = number of buckets the greedy first-fit walk produces for these sizes and this capacity
+
+canonical_work(L, D, F, E, CAPK) = 2*Ntot + 2*NB*cap      #  cap = CAPK * 1024
+
+`numel` is the parameter list of an L-block MoE unit (q/k/v/o with 4x GQA, a router, E experts of
+gate/up/down and two norm gains per block), so both `Ntot` and `NB` are functions of the shape and never of
+the data.""",
+
+    metric="GB/s",
+    compare="tuple",
+    tuple_names=("buckets", "meta"),
+    tol=0.0,
+    shape_names=("L", "D", "F", "E", "CAPK"),
+    grader_shapes=[(6, 2048, 1408, 8, 24576), (5, 2048, 1408, 12, 32768),
+                   (8, 1536, 1024, 8, 16384), (6, 2048, 1792, 6, 49152),
+                   (7, 1792, 1280, 8, 24576)],
+    measure_shapes=[(5, 2048, 1408, 8, 32768), (4, 2048, 1408, 12, 24576),
+                    (7, 1536, 1024, 8, 49152), (5, 2048, 1792, 6, 16384),
+                    (6, 1792, 1280, 8, 32768)],
+    measure_quick_shapes=[(2, 512, 352, 4, 2048), (2, 384, 256, 8, 1024), (1, 640, 448, 6, 4096)],
+    correct_shapes=[(1, 128, 96, 3, 64), (2, 100, 70, 2, 48), (2, 64, 48, 5, 16),
+                    (1, 96, 56, 4, 32), (3, 32, 24, 2, 8)],
+
+    spec_md="""Walk the parameters **in order**, keeping a running offset inside the current bucket:
+
+```
+cur = 0 ;  nb = 1
+for p in 0 .. P-1:
+    if cur + numel[p] > cap:        # it will not fit -> close the bucket and open the next
+        nb  += 1
+        cur  = 0
+    meta[p] = [nb - 1, cur]
+    cur += numel[p]
+```
+
+`max(numel) <= cap` is guaranteed, so a parameter always fits in a freshly opened bucket and the walk never
+stalls. Then copy:
+
+```
+buckets[ meta[p,0], meta[p,1] : meta[p,1] + numel[p] ] = the p-th parameter's data
+buckets[ everything else ]                             = 0.0        # EXACTLY zero
+```
+
+Two things define the task. **No parameter may straddle a bucket** — that is the entire reason for the
+greedy walk, because a bucket is one collective's payload and a tensor split across two of them could not be
+found on the other side. And **the holes must be zero**, because the tail of the last bucket in particular
+is a large region that the gathered copy will read.
+
+The walk is a genuine sequential dependence: whether parameter `p` starts a new bucket depends on every
+parameter before it. It is also entirely a function of `numel` — it never looks at a value — so it can be
+computed once and reused for a given shape.
+
+`/app/reference.py` does the walk in Python, zero-fills every bucket and then issues one slice copy per
+parameter. That is the exact specification; it is deliberately simple rather than fast.""",
+
+    contract_md="""| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `src` | `(Ntot,)` | `bfloat16` | the P parameters concatenated with no padding, in parameter order |
+| `numel` | `(P,)` | `int32` | element count of each parameter; `sum(numel) == Ntot`, `max(numel) <= cap` |
+| `cap` | scalar | `int` (python) | bucket capacity in **elements** |
+
+**Return** a 2-tuple `(buckets, meta)` **in that order**:
+
+| out | shape | dtype | notes |
+|-----|-------|-------|-------|
+| `buckets` | `(NB, cap)` | `bfloat16` | packed buckets; every unused element **exactly 0.0** |
+| `meta` | `(P, 2)` | `int32` | `[bucket index, offset in that bucket]` per parameter |
+
+`NB` is whatever the greedy walk produces — it is not passed in and it is not `ceil(Ntot/cap)`, because the
+no-straddle rule wastes part of most buckets. Sizes are uneven: the expert matrices dominate, the routers
+are three orders of magnitude smaller, and the norm gains smaller still. `src` and `numel` are read-only;
+the call is functional.""",
+
+    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `L`
+(blocks in the unit) 5–8, `D` 1536–2048, `F` (per-expert intermediate) 1024–1792, `E` (experts) 6–12, and a
+bucket capacity `CAPK*1024` elements with `CAPK` in 16384–49152, i.e. **16–48 Mi elements (32–96 MB)** per
+bucket. That is **330 M – 490 M bf16 parameters**, 120–250 tensors, 15–35 buckets, and 1.4–2.1 GB of
+traffic. Bucket capacity is a real tuning knob: bigger buckets mean fewer collectives but more wasted tail,
+and the graded shapes span both ends of it.""",
+
+    correctness_md="""**Both** returned values must match the reference **exactly** at every graded shape,
+including the timed ones: `buckets` is a pure bf16 relayout, so the tolerance is **`0.0`** — every element,
+including every zeroed hole — and `meta` is integer and compared elementwise.
+
+There is no arithmetic here; the gate measures whether your greedy walk agrees with the reference's, to the
+element. It is unforgiving of the two natural shortcuts: packing the parameters contiguously and letting
+them straddle bucket boundaries scores **1.38** on `buckets` and mismatches 176 of 186 `meta` rows, and leaving the
+holes uninitialised is caught to the last element.""",
+
+    perf_md="""Four bytes per parameter plus the zeroed holes — this is entirely a bandwidth problem, and
+your score is achieved bandwidth against that count.
+
+The reference wastes most of it: `numel.tolist()` is a device-to-host sync, `torch.zeros(NB, cap)` writes
+the entire output before anything real lands in it, and then 120–250 separate slice copies each launch their
+own kernel.
+
+The kernel to write is **one launch over the destination**, with the placement decided first:
+
+- **The greedy walk is P steps of a sequential scan** and `P` is at most 250. It is genuinely sequential —
+  a parameter's bucket depends on all its predecessors — but it is also tiny, and it depends only on
+  `numel`, never on the data. Compute it once per shape and cache it; shape-keyed caching is explicitly
+  allowed and is exactly what a real trainer does at wrap time.
+- **Then it is a ragged gather.** For a tile of destination elements, binary-search the placement table to
+  find which parameter (if any) owns them, and copy; a tile that lands in a hole stores zeros. Both sides
+  are contiguous within a parameter, so 128-bit accesses cover essentially all of the traffic.
+- **Do not pre-zero.** The holes are roughly 10% of the output at the graded capacities — significant, but far
+  cheaper to write once from the main pass than to write twice.
+- **Size the grid by destination tiles, not by parameter.** The expert matrices are all the same size, but
+  each block also contributes a router and two norm gains that are three to four orders of magnitude
+  smaller; a per-parameter grid leaves the machine idle on those.
+- **Watch the write:read ratio.** The output is larger than the input because of the holes, so the store
+  path is the one to keep saturated — streaming/non-temporal stores help, since nothing re-reads it.""",
+
+    precision_md="""There is **no arithmetic in this task at all**. Every output element is either a bf16
+value copied unchanged or an exact `0.0`, so a correct kernel is bit-identical to the reference and the
+tolerance is **`0.0`**.
+
+Do not round-trip through fp32 and do not use a cast on the copy path — bf16 in, bf16 out, unchanged.
+
+`meta` is `int32` and compared **exactly**. Integer outputs are never compared through `float()`, so an
+off-by-one in a bucket offset is caught rather than absorbed.
+
+**Where the tolerance comes from (measured, not guessed).** An independent implementation — the greedy walk
+done with a vectorised prefix-sum-and-rescan (repeatedly `cumsum`-ing within the current bucket rather than
+stepping parameter by parameter) and the copy done as one `index_copy_` from a precomputed destination-index
+map — reproduces the reference **bit for bit**, `E = 0.0`, at every correctness shape and at a full graded
+shape, for both outputs. `tol = 0.0` is exactly the floor.
+
+For calibration: swapping just **two** of the 528 M elements of `buckets` at a graded shape already
+registers a relative error of **3.8e-5**, so a single parameter placed one slot off is caught outright.
+
+Drop-the-feature measurements: allowing parameters to straddle bucket boundaries (i.e. packing contiguously
+into `NB*cap` slots) gives **D = 1.38** on `buckets` and mismatches 176 of 186 `meta` rows at a graded shape.
+Both are infinitely above a gate of zero.""",
+).validate()