--- /dev/null
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -0,0 +1,180 @@
+"""Paged-attention decode kernel (Triton flash-decoding) for SM120 Blackwell.
+
+Single-query decode. Memory-bound: the KV cache must be streamed exactly once,
+reused across each GQA group. Small-batch shapes are parallelized with split-K
+(flash-decoding) to fill all 188 SMs, then a cheap combine kernel reduces the
+per-split partial softmaxes.
+"""
+import math
+
+import torch
+import torch.nn as nn
+import triton
+import triton.language as tl
+
+
+@triton.jit
+def _paged_decode_phase1(
+    q_ptr,            # (B, H, D) bf16
+    kv_ptr,           # (num_blocks, P, Hkv, 2D) bf16
+    bt_ptr,           # (B, max_blocks) int32
+    sl_ptr,           # (B,) int32
+    o_ptr,            # (B, H, S, D) fp32   partial unnormalized output
+    m_ptr,            # (B, H, S) fp32      partial max
+    l_ptr,            # (B, H, S) fp32      partial sum
+    scale,
+    H: tl.constexpr, Hkv: tl.constexpr, G: tl.constexpr, D: tl.constexpr,
+    P: tl.constexpr, max_blocks: tl.constexpr,
+    S: tl.constexpr,                 # num_splits
+    BLOCK_N: tl.constexpr,           # tokens per inner iteration
+    GP: tl.constexpr,                # padded group (>=16 for tl.dot)
+    PAGES_PER_BLOCK: tl.constexpr,
+):
+    pid = tl.program_id(0)
+    split = pid % S
+    bkv = pid // S
+    b = bkv // Hkv
+    kvh = bkv % Hkv
+
+    L = tl.load(sl_ptr + b)
+    num_pages = (L + P - 1) // P
+    pages_per_split = (num_pages + S - 1) // S
+    page_start = split * pages_per_split
+    page_end = tl.minimum(page_start + pages_per_split, num_pages)
+
+    # Load Q for the group: (GP, D), rows >= G are zero-padded.
+    grow = tl.arange(0, GP)
+    dcol = tl.arange(0, D)
+    q_head = kvh * G + grow
+    q_off = b * (H * D) + q_head[:, None] * D + dcol[None, :]
+    q_mask = (grow[:, None] < G)
+    q = tl.load(q_ptr + q_off, mask=q_mask, other=0.0).to(tl.float32)
+
+    m_i = tl.full((GP,), -float("inf"), dtype=tl.float32)
+    l_i = tl.zeros((GP,), dtype=tl.float32)
+    acc = tl.zeros((GP, D), dtype=tl.float32)
+
+    row = tl.arange(0, BLOCK_N)
+    local_page = row // P
+    within = row % P
+
+    kv2d = 2 * D
+    page_stride = P * Hkv * kv2d
+
+    for pblk in range(page_start, page_end, PAGES_PER_BLOCK):
+        gpage = pblk + local_page                       # (BLOCK_N,)
+        valid_page = gpage < page_end
+        page_id = tl.load(bt_ptr + b * max_blocks + gpage, mask=valid_page, other=0)
+        token = gpage * P + within
+        valid = token < L
+
+        base = page_id * page_stride + within * (Hkv * kv2d) + kvh * kv2d
+        k_off = base[:, None] + dcol[None, :]
+        v_off = base[:, None] + (D + dcol[None, :])
+        k = tl.load(kv_ptr + k_off, mask=valid[:, None], other=0.0).to(tl.float32)
+        v = tl.load(kv_ptr + v_off, mask=valid[:, None], other=0.0).to(tl.float32)
+
+        # scores: (GP, BLOCK_N)
+        s = tl.dot(q, tl.trans(k)) * scale
+        s = tl.where(valid[None, :], s, -float("inf"))
+
+        m_new = tl.maximum(m_i, tl.max(s, axis=1))
+        alpha = tl.exp(m_i - m_new)
+        p = tl.exp(s - m_new[:, None])
+        l_i = l_i * alpha + tl.sum(p, axis=1)
+        acc = acc * alpha[:, None] + tl.dot(p.to(v.dtype), v)
+        m_i = m_new
+
+    # Store partials: (B, H, S, D)
+    out_head = kvh * G + grow
+    valid_g = grow < G
+    o_base = b * (H * S * D) + out_head[:, None] * (S * D) + split * D + dcol[None, :]
+    tl.store(o_ptr + o_base, acc, mask=valid_g[:, None])
+    ml_off = b * (H * S) + out_head * S + split
+    tl.store(m_ptr + ml_off, m_i, mask=valid_g)
+    tl.store(l_ptr + ml_off, l_i, mask=valid_g)
+
+
+@triton.jit
+def _paged_decode_combine(
+    o_ptr,            # (B, H, S, D) fp32
+    m_ptr,            # (B, H, S) fp32
+    l_ptr,            # (B, H, S) fp32
+    out_ptr,          # (B, H, D) bf16
+    H: tl.constexpr, D: tl.constexpr, S: tl.constexpr,
+):
+    pid = tl.program_id(0)          # over B*H
+    b = pid // H
+    h = pid % H
+
+    sidx = tl.arange(0, S)
+    dcol = tl.arange(0, D)
+
+    m = tl.load(m_ptr + (b * H + h) * S + sidx)        # (S,)
+    l = tl.load(l_ptr + (b * H + h) * S + sidx)
+    m_g = tl.max(m, axis=0)
+    scale = tl.exp(m - m_g)
+    l_g = tl.sum(l * scale, axis=0)
+
+    o = tl.load(o_ptr + (b * H + h) * (S * D) + sidx[:, None] * D + dcol[None, :])  # (S, D)
+    o = o * scale[:, None]
+    out = tl.sum(o, axis=0) / l_g
+    tl.store(out_ptr + (b * H + h) * D + dcol, out.to(tl.bfloat16))
+
+
+def _pick_num_splits(batch, num_kv_heads, num_pages):
+    groups = batch * num_kv_heads
+    target = 2048
+    s = max(1, target // groups)
+    s = min(s, num_pages)
+    return s
+
+
+class Model(nn.Module):
+    def __init__(self, batch, num_heads, num_kv_heads, head_dim, seq_len, page_size):
+        super().__init__()
+        self.batch = batch
+        self.num_heads = num_heads
+        self.num_kv_heads = num_kv_heads
+        self.head_dim = head_dim
+        self.seq_len = seq_len
+        self.page_size = page_size
+        self.group_size = num_heads // num_kv_heads
+        self.scale = 1.0 / math.sqrt(head_dim)
+        self.register_buffer("_dummy", torch.zeros(1, dtype=torch.bfloat16), persistent=False)
+
+    def forward(self, query, kv_cache, block_table, seq_lens):
+        B, H, D = query.shape
+        Hkv = self.num_kv_heads
+        G = self.group_size
+        P = self.page_size
+        max_blocks = block_table.shape[1]
+
+        num_pages = (self.seq_len + P - 1) // P
+        S = _pick_num_splits(B, Hkv, num_pages)
+
+        GP = max(16, triton.next_power_of_2(G))
+        BLOCK_N = 64
+        PAGES_PER_BLOCK = BLOCK_N // P
+
+        o_partial = torch.empty(B, H, S, D, dtype=torch.float32, device=query.device)
+        m_partial = torch.empty(B, H, S, dtype=torch.float32, device=query.device)
+        l_partial = torch.empty(B, H, S, dtype=torch.float32, device=query.device)
+
+    

... (591 more chars)

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -75,7 +75,7 @@
         v = tl.load(kv_ptr + v_off, mask=valid[:, None], other=0.0).to(tl.float32)
 
         # scores: (GP, BLOCK_N)
-        s = tl.dot(q, tl.trans(k)) * scale
+        s = tl.dot(q, tl.trans(k), input_precision="ieee") * scale
         s = tl.where(valid[None, :], s, -float("inf"))
 
         m_new = tl.maximum(m_i, tl.max(s, axis=1))

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -82,7 +82,7 @@
         alpha = tl.exp(m_i - m_new)
         p = tl.exp(s - m_new[:, None])
         l_i = l_i * alpha + tl.sum(p, axis=1)
-        acc = acc * alpha[:, None] + tl.dot(p.to(v.dtype), v)
+        acc = acc * alpha[:, None] + tl.dot(p.to(v.dtype), v, input_precision="ieee")
         m_i = m_new
 
     # Store partials: (B, H, S, D)

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -167,7 +167,7 @@
             o_partial, m_partial, l_partial,
             self.scale,
             H, Hkv, G, D, P, max_blocks, S, BLOCK_N, GP, PAGES_PER_BLOCK,
-            num_warps=4, num_stages=2,
+            num_warps=4, num_stages=1,
         )
 
         out = torch.empty(B, H, D, dtype=torch.bfloat16, device=query.device)

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -66,7 +66,7 @@
         valid_page = gpage < page_end
         page_id = tl.load(bt_ptr + b * max_blocks + gpage, mask=valid_page, other=0)
         token = gpage * P + within
-        valid = token < L
+        valid = valid_page & (token < L)
 
         base = page_id * page_stride + within * (Hkv * kv2d) + kvh * kv2d
         k_off = base[:, None] + dcol[None, :]

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -1,2 +1,2 @@
         token = gpage * P + within
-        valid = token < L+        valid = valid_page & (token < L)

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -1,5 +1,6 @@
 def _pick_num_splits(batch, num_kv_heads, num_pages):
     groups = batch * num_kv_heads
-    import sys
-    f=getattr(sys.modules[__name__],'_FORCE',1)
-    return min(f,num_pages)+    target = 2048
+    s = max(1, target // groups)
+    s = min(s, num_pages)
+    return triton.next_power_of_2(s) if s > 1 else 1

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -2,8 +2,9 @@
 
 Single-query decode. Memory-bound: the KV cache must be streamed exactly once,
 reused across each GQA group. Small-batch shapes are parallelized with split-K
-(flash-decoding) to fill all 188 SMs, then a cheap combine kernel reduces the
-per-split partial softmaxes.
+(flash-decoding) to fill the 188 SMs, then a cheap combine kernel reduces the
+per-split partial softmaxes. When a shape needs no split (S==1) the phase-1
+kernel writes the normalized bf16 output directly and the combine is skipped.
 """
 import math
 
@@ -15,20 +16,15 @@
 
 @triton.jit
 def _paged_decode_phase1(
-    q_ptr,            # (B, H, D) bf16
-    kv_ptr,           # (num_blocks, P, Hkv, 2D) bf16
-    bt_ptr,           # (B, max_blocks) int32
-    sl_ptr,           # (B,) int32
-    o_ptr,            # (B, H, S, D) fp32   partial unnormalized output
-    m_ptr,            # (B, H, S) fp32      partial max
-    l_ptr,            # (B, H, S) fp32      partial sum
+    q_ptr, kv_ptr, bt_ptr, sl_ptr,
+    o_ptr,            # partial out (B,H,S,D) fp32  OR final (B,H,D) bf16 if S==1
+    m_ptr, l_ptr,     # (B,H,S) fp32  (unused when S==1)
     scale,
     H: tl.constexpr, Hkv: tl.constexpr, G: tl.constexpr, D: tl.constexpr,
     P: tl.constexpr, max_blocks: tl.constexpr,
-    S: tl.constexpr,                 # num_splits
-    BLOCK_N: tl.constexpr,           # tokens per inner iteration
-    GP: tl.constexpr,                # padded group (>=16 for tl.dot)
+    S: tl.constexpr, BLOCK_N: tl.constexpr, GP: tl.constexpr,
     PAGES_PER_BLOCK: tl.constexpr,
+    NORMALIZE: tl.constexpr,
 ):
     pid = tl.program_id(0)
     split = pid % S
@@ -42,13 +38,12 @@
     page_start = split * pages_per_split
     page_end = tl.minimum(page_start + pages_per_split, num_pages)
 
-    # Load Q for the group: (GP, D), rows >= G are zero-padded.
     grow = tl.arange(0, GP)
     dcol = tl.arange(0, D)
     q_head = kvh * G + grow
     q_off = b * (H * D) + q_head[:, None] * D + dcol[None, :]
-    q_mask = (grow[:, None] < G)
-    q = tl.load(q_ptr + q_off, mask=q_mask, other=0.0).to(tl.float32)
+    q_mask = grow[:, None] < G
+    q = tl.load(q_ptr + q_off, mask=q_mask, other=0.0)
 
     m_i = tl.full((GP,), -float("inf"), dtype=tl.float32)
     l_i = tl.zeros((GP,), dtype=tl.float32)
@@ -57,24 +52,20 @@
     row = tl.arange(0, BLOCK_N)
     local_page = row // P
     within = row % P
-
     kv2d = 2 * D
     page_stride = P * Hkv * kv2d
 
     for pblk in range(page_start, page_end, PAGES_PER_BLOCK):
-        gpage = pblk + local_page                       # (BLOCK_N,)
+        gpage = pblk + local_page
         valid_page = gpage < page_end
         page_id = tl.load(bt_ptr + b * max_blocks + gpage, mask=valid_page, other=0)
         token = gpage * P + within
         valid = valid_page & (token < L)
 
         base = page_id * page_stride + within * (Hkv * kv2d) + kvh * kv2d
-        k_off = base[:, None] + dcol[None, :]
-        v_off = base[:, None] + (D + dcol[None, :])
-        k = tl.load(kv_ptr + k_off, mask=valid[:, None], other=0.0).to(tl.float32)
-        v = tl.load(kv_ptr + v_off, mask=valid[:, None], other=0.0).to(tl.float32)
+        k = tl.load(kv_ptr + base[:, None] + dcol[None, :], mask=valid[:, None], other=0.0)
+        v = tl.load(kv_ptr + base[:, None] + (D + dcol[None, :]), mask=valid[:, None], other=0.0)
 
-        # scores: (GP, BLOCK_N)
         s = tl.dot(q, tl.trans(k), input_precision="ieee") * scale
         s = tl.where(valid[None, :], s, -float("inf"))
 
@@ -82,52 +73,56 @@
         alpha = tl.exp(m_i - m_new)
         p = tl.exp(s - m_new[:, None])
         l_i = l_i * alpha + tl.sum(p, axis=1)
-        acc = acc * alpha[:, None] + tl.dot(p.to(v.dtype), v, input_precision="ieee")
+        acc = acc * alpha[:, None] + tl.dot(p.to(k.dtype), v, input_precision="ieee")
         m_i = m_new
 
-    # Store partials: (B, H, S, D)
     out_head = kvh * G + grow
     valid_g = grow < G
-    o_base = b * (H * S * D) + out_head[:, None] * (S * D) + split * D + dcol[None, :]
-    tl.store(o_ptr + o_base, acc, mask=valid_g[:, None])
-    ml_off = b * (H * S) + out_head * S + split
-    tl.store(m_ptr + ml_off, m_i, mask=valid_g)
-    tl.store(l_ptr + ml_off, l_i, mask=valid_g)
+    if NORMALIZE:
+        o = acc / l_i[:, None]
+        o_base = b * (H * D) + out_head[:, None] * D + dcol[None, :]
+        tl.store(o_ptr + o_base, o.to(tl.bfloat16), mask=valid_g[:, None])
+    else:
+        o_base = b * (H * S * D) + out_head[:, None] * (S * D) + split * D + dcol[None, :]
+        tl.store(o_ptr + o_base, acc, mask=valid_g[:, None])
+        ml_off = b * (H * S) + out_head * S + split
+        tl.store(m_ptr + ml_off, m_i, mask=valid_g)
+        tl.store(l_ptr + ml_off, l_i, mask=valid_g)
 
 
 @triton.jit
 def _paged_decode_combine(
-    o_ptr,            # (B, H, S, D) fp32
-    m_ptr,            # (B, H, S) fp32
-    l_ptr,            # (B, H, S) fp32
-    out_ptr,          # (B, H, D) bf16
+    o_ptr, m_ptr, l_ptr, out_ptr,
     H: tl.constexpr, D: tl.constexpr, S: tl.constexpr,
 ):
-    pid = tl.program_id(0)          # over B*H
+    pid = tl.program_id(0)
     b = pid // H
     h = pid % H
-
     sidx = tl.arange(0, S)
     dcol = tl.arange(0, D)
 
-    m = tl.load(m_ptr + (b * H + h) * S + sidx)        # (S,)
+    m = tl.load(m_ptr + (b * H + h) * S + sidx)
     l = tl.load(l_ptr + (b * H + h) * S + sidx)
     m_g = tl.max(m, axis=0)
-    scale = tl.exp(m - m_g)
-    l_g = tl.sum(l * scale, axis=0)
-
-    o = tl.load(o_ptr + (b * H + h) * (S * D) + sidx[:, None] * D + dcol[None, :])  # (S, D)
-    o = o * scale[:, None]
-    out = tl.sum(o, axis=0) / l_g
+    sc = tl.exp(m - m_g)
+    l_g = tl.sum(l * sc, axis=0)
+    o = tl.load(o_ptr + (b * H + h) * (S * D) + sidx[:, None] * D + dcol[None, :])
+    out = tl.sum(o * sc[:, None], axis=0) / l_g
     tl.store(out_ptr + (b * H + h

... (2468 more chars)

--- /dev/null
+++ b//workspace/problems/03_paged_attention/tune.py
@@ -0,0 +1,42 @@
+"""Per-shape config sweep using the official timing methodology."""
+import sys, itertools
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+import torch
+import reference, shapes, solution
+from src.eval.timing import time_fn
+
+dev = torch.device("cuda:0")
+
+def bytes_of(sh):
+    return 2*sh["batch"]*sh["seq_len"]*sh["num_kv_heads"]*sh["head_dim"]*2 + sh["batch"]*sh["num_heads"]*sh["head_dim"]*2*2
+
+TARGETS = [128, 256, 384, 512, 768, 1024, 1536, 2048]
+BLOCKNS = [16, 32, 64, 128]
+WARPS = [2, 4, 8]
+
+for si, sh in enumerate(shapes.SHAPES):
+    for k in ("BATCH","NUM_HEADS","NUM_KV_HEADS","HEAD_DIM","SEQ_LEN","PAGE_SIZE"):
+        pass
+    reference.BATCH=sh["batch"]; reference.NUM_HEADS=sh["num_heads"]
+    reference.NUM_KV_HEADS=sh["num_kv_heads"]; reference.HEAD_DIM=sh["head_dim"]
+    reference.SEQ_LEN=sh["seq_len"]; reference.PAGE_SIZE=sh["page_size"]
+    ia = reference.get_init_inputs()
+    torch.manual_seed(2026)
+    inputs = [t.to(dev) for t in reference.get_inputs()]
+    bmoved = bytes_of(sh)
+    best = None
+    for tgt, bn, w in itertools.product(TARGETS, BLOCKNS, WARPS):
+        if bn < sh["page_size"]: continue
+        solution._TARGET_BLOCKS = tgt
+        solution._BLOCK_N = bn
+        solution._NUM_WARPS = w
+        m = solution.Model(*ia).to(dev).eval()
+        try:
+            ms = time_fn(lambda *a: m(*a), inputs, iters=30, warmup=10)
+        except Exception as e:
+            continue
+        gbps = bmoved/(ms*1e-3)/1e9
+        if best is None or gbps > best[0]:
+            best = (gbps, tgt, bn, w, ms)
+    print(f"shape {si} {sh['batch']}x{sh['seq_len']}xD{sh['head_dim']}: best gbps={best[0]:.1f} frac={best[0]/1800:.3f} tgt={best[1]} bn={best[2]} w={best[3]} ms={best[4]:.4f}", flush=True)

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -111,13 +111,22 @@
     tl.store(out_ptr + (b * H + h) * D + dcol, out.to(tl.bfloat16))
 
 
-# Per-shape tuned (num_splits_target, BLOCK_N, num_warps). Defaults used otherwise.
+# Per-shape tuned configs keyed by (B, H, Hkv, D, seq_len, P) -> (num_splits, BLOCK_N, num_warps).
+# Found by sweep (tune.py) using the official timing methodology.
+_CONFIGS = {
+    (8, 32, 8, 128, 1024, 16): (8, 32, 8),
+    (32, 32, 8, 128, 2048, 16): (1, 128, 4),
+    (4, 64, 8, 128, 4096, 16): (8, 32, 4),
+    (16, 32, 8, 128, 1535, 16): (1, 128, 8),
+    (8, 16, 4, 64, 2000, 16): (8, 32, 2),
+}
+
 _TARGET_BLOCKS = 512
 _BLOCK_N = 64
 _NUM_WARPS = 4
 
 
-def _pick_num_splits(groups, num_pages):
+def _heuristic_num_splits(groups, num_pages):
     s = max(1, _TARGET_BLOCKS // groups)
     s = min(s, num_pages)
     if s <= 1:

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -147,6 +147,15 @@
         self.scale = 1.0 / math.sqrt(head_dim)
         self.register_buffer("_dummy", torch.zeros(1, dtype=torch.bfloat16), persistent=False)
 
+        key = (batch, num_heads, num_kv_heads, head_dim, seq_len, page_size)
+        num_pages = (seq_len + page_size - 1) // page_size
+        if key in _CONFIGS:
+            self._S, self._bn, self._warps = _CONFIGS[key]
+            self._S = min(self._S, num_pages)
+        else:
+            self._S = _heuristic_num_splits(batch * num_kv_heads, num_pages)
+            self._bn, self._warps = _BLOCK_N, _NUM_WARPS
+
     def forward(self, query, kv_cache, block_table, seq_lens):
         B, H, D = query.shape
         Hkv = self.num_kv_heads

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -163,10 +163,10 @@
         P = self.page_size
         max_blocks = block_table.shape[1]
 
-        num_pages = (self.seq_len + P - 1) // P
-        S = _pick_num_splits(B * Hkv, num_pages)
+        S = self._S
         GP = max(16, triton.next_power_of_2(G))
-        BLOCK_N = _BLOCK_N
+        BLOCK_N = self._bn
+        warps = self._warps
         PAGES_PER_BLOCK = BLOCK_N // P
 
         out = torch.empty(B, H, D, dtype=torch.bfloat16, device=query.device)

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -190,7 +190,7 @@
             query, kv_cache, block_table, seq_lens,
             o_partial, m_partial, l_partial, self.scale,
             H, Hkv, G, D, P, max_blocks, S, BLOCK_N, GP, PAGES_PER_BLOCK,
-            False, num_warps=_NUM_WARPS, num_stages=1,
+            False, num_warps=warps, num_stages=1,
         )
         _paged_decode_combine[(B * H,)](
             o_partial, m_partial, l_partial, out, H, D, S, num_warps=4,

--- /dev/null
+++ b//workspace/problems/03_paged_attention/tune2.py
@@ -0,0 +1,46 @@
+"""Focused re-tune using the actual _CONFIGS override path."""
+import sys, itertools
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+import torch
+import reference, shapes, solution
+from src.eval.timing import time_fn
+
+dev = torch.device("cuda:0")
+def bytes_of(sh):
+    return 2*sh["batch"]*sh["seq_len"]*sh["num_kv_heads"]*sh["head_dim"]*2 + sh["batch"]*sh["num_heads"]*sh["head_dim"]*2*2
+
+import argparse
+which = [int(x) for x in sys.argv[1:]] or list(range(5))
+
+Ss = [1,2,4,8,16,32]
+BNs = [16,32,64,128]
+Ws = [1,2,4,8]
+
+for si in which:
+    sh = shapes.SHAPES[si]
+    reference.BATCH=sh["batch"]; reference.NUM_HEADS=sh["num_heads"]
+    reference.NUM_KV_HEADS=sh["num_kv_heads"]; reference.HEAD_DIM=sh["head_dim"]
+    reference.SEQ_LEN=sh["seq_len"]; reference.PAGE_SIZE=sh["page_size"]
+    ia = reference.get_init_inputs()
+    torch.manual_seed(2026)
+    inputs = [t.to(dev) for t in reference.get_inputs()]
+    bmoved = bytes_of(sh)
+    npages = (sh["seq_len"]+sh["page_size"]-1)//sh["page_size"]
+    key = (sh["batch"],sh["num_heads"],sh["num_kv_heads"],sh["head_dim"],sh["seq_len"],sh["page_size"])
+    results=[]
+    for S,bn,w in itertools.product(Ss,BNs,Ws):
+        if bn < sh["page_size"]: continue
+        if S > npages: continue
+        solution._CONFIGS[key] = (S,bn,w)
+        m = solution.Model(*ia).to(dev).eval()
+        try:
+            ms = time_fn(lambda *a: m(*a), inputs, iters=50, warmup=15)
+        except Exception:
+            continue
+        gbps = bmoved/(ms*1e-3)/1e9
+        results.append((gbps,S,bn,w,ms))
+    results.sort(reverse=True)
+    print(f"=== shape {si} {key} npages={npages} ===")
+    for r in results[:6]:
+        print(f"  gbps={r[0]:.1f} frac={r[0]/1800:.3f} S={r[1]} bn={r[2]} w={r[3]} ms={r[4]:.4f}")

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -114,11 +114,11 @@
 # Per-shape tuned configs keyed by (B, H, Hkv, D, seq_len, P) -> (num_splits, BLOCK_N, num_warps).
 # Found by sweep (tune.py) using the official timing methodology.
 _CONFIGS = {
-    (8, 32, 8, 128, 1024, 16): (8, 32, 8),
-    (32, 32, 8, 128, 2048, 16): (1, 128, 4),
-    (4, 64, 8, 128, 4096, 16): (8, 32, 4),
-    (16, 32, 8, 128, 1535, 16): (1, 128, 8),
-    (8, 16, 4, 64, 2000, 16): (8, 32, 2),
+    (8, 32, 8, 128, 1024, 16): (8, 32, 4),
+    (32, 32, 8, 128, 2048, 16): (1, 128, 8),
+    (4, 64, 8, 128, 4096, 16): (16, 16, 2),
+    (16, 32, 8, 128, 1535, 16): (2, 32, 4),
+    (8, 16, 4, 64, 2000, 16): (16, 128, 4),
 }
 
 _TARGET_BLOCKS = 512

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -84,7 +84,7 @@
         tl.store(o_ptr + o_base, o.to(tl.bfloat16), mask=valid_g[:, None])
     else:
         o_base = b * (H * S * D) + out_head[:, None] * (S * D) + split * D + dcol[None, :]
-        tl.store(o_ptr + o_base, acc, mask=valid_g[:, None])
+        tl.store(o_ptr + o_base, acc.to(tl.bfloat16), mask=valid_g[:, None])
         ml_off = b * (H * S) + out_head * S + split
         tl.store(m_ptr + ml_off, m_i, mask=valid_g)
         tl.store(l_ptr + ml_off, l_i, mask=valid_g)

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -106,7 +106,7 @@
     m_g = tl.max(m, axis=0)
     sc = tl.exp(m - m_g)
     l_g = tl.sum(l * sc, axis=0)
-    o = tl.load(o_ptr + (b * H + h) * (S * D) + sidx[:, None] * D + dcol[None, :])
+    o = tl.load(o_ptr + (b * H + h) * (S * D) + sidx[:, None] * D + dcol[None, :]).to(tl.float32)
     out = tl.sum(o * sc[:, None], axis=0) / l_g
     tl.store(out_ptr + (b * H + h) * D + dcol, out.to(tl.bfloat16))
 

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -181,7 +181,7 @@
             )
             return out
 
-        o_partial = torch.empty(B, H, S, D, dtype=torch.float32, device=query.device)
+        o_partial = torch.empty(B, H, S, D, dtype=torch.bfloat16, device=query.device)
         m_partial = torch.empty(B, H, S, dtype=torch.float32, device=query.device)
         l_partial = torch.empty(B, H, S, dtype=torch.float32, device=query.device)
 

--- /dev/null
+++ b//workspace/problems/03_paged_attention/exp_graph.py
@@ -0,0 +1,42 @@
+"""Measure eager vs CUDA-graph replay for the two worst shapes."""
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+import torch
+import reference, shapes, solution
+from src.eval.timing import time_fn
+
+dev = torch.device("cuda:0")
+def bytes_of(sh):
+    return 2*sh["batch"]*sh["seq_len"]*sh["num_kv_heads"]*sh["head_dim"]*2 + sh["batch"]*sh["num_heads"]*sh["head_dim"]*2*2
+
+for si in [0,2,4,1,3]:
+    sh = shapes.SHAPES[si]
+    reference.BATCH=sh["batch"]; reference.NUM_HEADS=sh["num_heads"]
+    reference.NUM_KV_HEADS=sh["num_kv_heads"]; reference.HEAD_DIM=sh["head_dim"]
+    reference.SEQ_LEN=sh["seq_len"]; reference.PAGE_SIZE=sh["page_size"]
+    ia = reference.get_init_inputs()
+    torch.manual_seed(2026)
+    inputs = [t.to(dev) for t in reference.get_inputs()]
+    bmoved = bytes_of(sh)
+    m = solution.Model(*ia).to(dev).eval()
+
+    # eager
+    ms_e = time_fn(lambda *a: m(*a), inputs, iters=50, warmup=15)
+
+    # capture graph
+    for _ in range(5):
+        out = m(*inputs)
+    torch.cuda.synchronize()
+    s = torch.cuda.Stream()
+    s.wait_stream(torch.cuda.current_stream())
+    with torch.cuda.stream(s):
+        for _ in range(3):
+            out = m(*inputs)
+    torch.cuda.current_stream().wait_stream(s)
+    g = torch.cuda.CUDAGraph()
+    with torch.cuda.graph(g):
+        out = m(*inputs)
+    torch.cuda.synchronize()
+    ms_g = time_fn(lambda *a: g.replay(), [], iters=50, warmup=15)
+    print(f"shape {si}: eager {ms_e*1000:.1f}us ({bmoved/(ms_e*1e-3)/1e9:.0f} GB/s)  graph {ms_g*1000:.1f}us ({bmoved/(ms_g*1e-3)/1e9:.0f} GB/s, {bmoved/(ms_g*1e-3)/1e9/1800:.3f})", flush=True)

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -7,43 +7,78 @@
             self._S = _heuristic_num_splits(batch * num_kv_heads, num_pages)
             self._bn, self._warps = _BLOCK_N, _NUM_WARPS
 
-    def forward(self, query, kv_cache, block_table, seq_lens):
-        B, H, D = query.shape
-        Hkv = self.num_kv_heads
-        G = self.group_size
-        P = self.page_size
+        self._GP = max(16, triton.next_power_of_2(self.group_size))
+        self._bufs = None          # persistent (out, o_partial, m, l)
+        self._graphs = {}          # sig -> CUDAGraph
+
+    def _alloc(self, device):
+        B, H, D = self.batch, self.num_heads, self.head_dim
+        S = self._S
+        out = torch.empty(B, H, D, dtype=torch.bfloat16, device=device)
+        if S == 1:
+            self._bufs = (out, None, None, None)
+        else:
+            o_p = torch.empty(B, H, S, D, dtype=torch.bfloat16, device=device)
+            m_p = torch.empty(B, H, S, dtype=torch.float32, device=device)
+            l_p = torch.empty(B, H, S, dtype=torch.float32, device=device)
+            self._bufs = (out, o_p, m_p, l_p)
+
+    def _launch(self, query, kv_cache, block_table, seq_lens):
+        B, H, D = self.batch, self.num_heads, self.head_dim
+        Hkv, G, P = self.num_kv_heads, self.group_size, self.page_size
         max_blocks = block_table.shape[1]
-
-        S = self._S
-        GP = max(16, triton.next_power_of_2(G))
-        BLOCK_N = self._bn
-        warps = self._warps
+        S, GP, BLOCK_N, warps = self._S, self._GP, self._bn, self._warps
         PAGES_PER_BLOCK = BLOCK_N // P
-
-        out = torch.empty(B, H, D, dtype=torch.bfloat16, device=query.device)
+        out, o_p, m_p, l_p = self._bufs
 
         if S == 1:
-            grid1 = (B * Hkv,)
-            _paged_decode_phase1[grid1](
+            _paged_decode_phase1[(B * Hkv,)](
                 query, kv_cache, block_table, seq_lens,
                 out, out, out, self.scale,
                 H, Hkv, G, D, P, max_blocks, 1, BLOCK_N, GP, PAGES_PER_BLOCK,
                 True, num_warps=warps, num_stages=1,
             )
-            return out
+        else:
+            _paged_decode_phase1[(B * Hkv * S,)](
+                query, kv_cache, block_table, seq_lens,
+                o_p, m_p, l_p, self.scale,
+                H, Hkv, G, D, P, max_blocks, S, BLOCK_N, GP, PAGES_PER_BLOCK,
+                False, num_warps=warps, num_stages=1,
+            )
+            _paged_decode_combine[(B * H,)](
+                o_p, m_p, l_p, out, H, D, S, num_warps=4,
+            )
+        return out
 
-        o_partial = torch.empty(B, H, S, D, dtype=torch.bfloat16, device=query.device)
-        m_partial = torch.empty(B, H, S, dtype=torch.float32, device=query.device)
-        l_partial = torch.empty(B, H, S, dtype=torch.float32, device=query.device)
+    def forward(self, query, kv_cache, block_table, seq_lens):
+        if self._bufs is None:
+            self._alloc(query.device)
 
-        grid1 = (B * Hkv * S,)
-        _paged_decode_phase1[grid1](
-            query, kv_cache, block_table, seq_lens,
-            o_partial, m_partial, l_partial, self.scale,
-            H, Hkv, G, D, P, max_blocks, S, BLOCK_N, GP, PAGES_PER_BLOCK,
-            False, num_warps=warps, num_stages=1,
-        )
-        _paged_decode_combine[(B * H,)](
-            o_partial, m_partial, l_partial, out, H, D, S, num_warps=4,
-        )
-        return out+        sig = (query.data_ptr(), kv_cache.data_ptr(),
+               block_table.data_ptr(), seq_lens.data_ptr())
+        g = self._graphs.get(sig)
+        if g is not None:
+            g.replay()
+            return self._bufs[0]
+
+        # Eager run (also serves as compile/warmup), then try to capture a graph
+        # bound to these input addresses for fast replay on repeated calls.
+        out = self._launch(query, kv_cache, block_table, seq_lens)
+        if len(self._graphs) < 8:
+            try:
+                self._graphs[sig] = self._capture(query, kv_cache, block_table, seq_lens)
+            except Exception:
+                pass
+        return out
+
+    def _capture(self, query, kv_cache, block_table, seq_lens):
+        s = torch.cuda.Stream()
+        s.wait_stream(torch.cuda.current_stream())
+        with torch.cuda.stream(s):
+            for _ in range(3):
+                self._launch(query, kv_cache, block_table, seq_lens)
+        torch.cuda.current_stream().wait_stream(s)
+        g = torch.cuda.CUDAGraph()
+        with torch.cuda.graph(g):
+            self._launch(query, kv_cache, block_table, seq_lens)
+        return g

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -114,11 +114,11 @@
 # Per-shape tuned configs keyed by (B, H, Hkv, D, seq_len, P) -> (num_splits, BLOCK_N, num_warps).
 # Found by sweep (tune.py) using the official timing methodology.
 _CONFIGS = {
-    (8, 32, 8, 128, 1024, 16): (8, 32, 4),
-    (32, 32, 8, 128, 2048, 16): (1, 128, 8),
-    (4, 64, 8, 128, 4096, 16): (16, 16, 2),
+    (8, 32, 8, 128, 1024, 16): (4, 32, 4),
+    (32, 32, 8, 128, 2048, 16): (2, 64, 4),
+    (4, 64, 8, 128, 4096, 16): (16, 16, 8),
     (16, 32, 8, 128, 1535, 16): (2, 32, 4),
-    (8, 16, 4, 64, 2000, 16): (16, 128, 4),
+    (8, 16, 4, 64, 2000, 16): (32, 64, 4),
 }
 
 _TARGET_BLOCKS = 512

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -114,11 +114,11 @@
 # Per-shape tuned configs keyed by (B, H, Hkv, D, seq_len, P) -> (num_splits, BLOCK_N, num_warps).
 # Found by sweep (tune.py) using the official timing methodology.
 _CONFIGS = {
-    (8, 32, 8, 128, 1024, 16): (4, 32, 4),
-    (32, 32, 8, 128, 2048, 16): (2, 64, 4),
-    (4, 64, 8, 128, 4096, 16): (16, 16, 8),
+    (8, 32, 8, 128, 1024, 16): (8, 32, 4),
+    (32, 32, 8, 128, 2048, 16): (1, 128, 8),
+    (4, 64, 8, 128, 4096, 16): (16, 16, 2),
     (16, 32, 8, 128, 1535, 16): (2, 32, 4),
-    (8, 16, 4, 64, 2000, 16): (32, 64, 4),
+    (8, 16, 4, 64, 2000, 16): (16, 128, 4),
 }
 
 _TARGET_BLOCKS = 512

--- /dev/null
+++ b//home/agent/.claude/projects/-workspace-problems-03-paged-attention/memory/paged-attention-approach.md
@@ -0,0 +1,21 @@
+---
+name: paged-attention-approach
+description: Working approach + key wins for the 03_paged_attention decode kernel
+metadata:
+  type: project
+---
+
+Problem: paged-attention single-query decode, RTX PRO 6000 (SM120, 1.8 TB/s). Memory-bound; score = achieved GB/s / 1800, gmean over 5 shapes. Final answer in solution.py (Triton). `python check.py` must print PASS; `python benchmark.py` reports peak_fraction.
+
+Approach: Triton flash-decoding. Phase1 = one block per (batch, kv_head, split); GQA group handled together (load KV once, reuse across group_size query heads) via tl.dot with group padded to GP=16. Online softmax. Split-K (S splits) parallelizes small-batch shapes across 188 SMs; phase2 combine reduces partials. S==1 fuses normalize into phase1 (skip combine).
+
+Key wins (in order of impact):
+1. **CUDA graphs** — biggest win. Two tiny kernel launches dominate ~30us runtime on small shapes. Capturing a graph (per input-ptr signature, eager fallback for new ptrs) lifted gmean ~0.53 -> ~0.70. Safe because ptr-signature match guarantees graph reads current data; check.py's changing inputs fall to eager.
+2. Per-shape tuned (num_splits, BLOCK_N, num_warps) in _CONFIGS dict.
+3. bf16 partials (marginal).
+
+Bugs fixed: K/V load mask must be `valid_page & (token<L)`, NOT just `token<L` — else tokens from the next split (still <L) get loaded from page_id=0 (masked-out page) and wrongly counted. The tl.dot tf32 was a red herring; bf16 dot w/ fp32 accumulate passes 0.02 tol.
+
+Gotcha: tiny shapes (shape0=33MB, shape4=16MB) are NOISY (~15% run-to-run); single-shot tune2.py bests don't transfer to benchmark.py. Proven benchmark config set (gmean 0.6993): shape0 (8,32,4), shape1 (1,128,8), shape2 (16,16,2), shape3 (2,32,4), shape4 (16,128,4). Need multi-run denoised comparison to beat noise floor.
+
+See [[paged-attention-status]] for current best score.

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -1,5 +1,6 @@
         base = page_id * page_stride + within * (Hkv * kv2d) + kvh * kv2d
-        k = tl.load(kv_ptr + base[:, None] + dcol[None, :], mask=valid[:, None], other=0.0)
-        v = tl.load(kv_ptr + base[:, None] + (D + dcol[None, :]), mask=valid[:, None], other=0.0)
+        kv = tl.load(kv_ptr + base[:, None] + dcol2[None, :], mask=valid[:, None], other=0.0)
+        k = kv[:, :D]
+        v = kv[:, D:]
 
         s = tl.dot(q, tl.trans(k)) * scale

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -52,6 +52,7 @@
     row = tl.arange(0, BLOCK_N)
     local_page = row // P
     within = row % P
+    dcol2 = tl.arange(0, 2 * D)
     kv2d = 2 * D
     page_stride = P * Hkv * kv2d
 

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -112,19 +112,20 @@
     tl.store(out_ptr + (b * H + h) * D + dcol, out.to(tl.bfloat16))
 
 
-# Per-shape tuned configs keyed by (B, H, Hkv, D, seq_len, P) -> (num_splits, BLOCK_N, num_warps).
-# Found by sweep (tune.py) using the official timing methodology.
+# Per-shape tuned configs keyed by (B, H, Hkv, D, seq_len, P)
+#   -> (num_splits, BLOCK_N, num_warps, num_stages).
 _CONFIGS = {
-    (8, 32, 8, 128, 1024, 16): (8, 32, 4),
-    (32, 32, 8, 128, 2048, 16): (1, 128, 8),
-    (4, 64, 8, 128, 4096, 16): (16, 16, 2),
-    (16, 32, 8, 128, 1535, 16): (2, 32, 4),
-    (8, 16, 4, 64, 2000, 16): (16, 128, 4),
+    (8, 32, 8, 128, 1024, 16): (8, 32, 4, 1),
+    (32, 32, 8, 128, 2048, 16): (1, 128, 8, 1),
+    (4, 64, 8, 128, 4096, 16): (16, 16, 2, 1),
+    (16, 32, 8, 128, 1535, 16): (2, 32, 4, 1),
+    (8, 16, 4, 64, 2000, 16): (16, 128, 4, 1),
 }
 
 _TARGET_BLOCKS = 512
 _BLOCK_N = 64
 _NUM_WARPS = 4
+_NUM_STAGES = 2
 
 
 def _heuristic_num_splits(groups, num_pages):

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -152,11 +152,11 @@
         key = (batch, num_heads, num_kv_heads, head_dim, seq_len, page_size)
         num_pages = (seq_len + page_size - 1) // page_size
         if key in _CONFIGS:
-            self._S, self._bn, self._warps = _CONFIGS[key]
+            self._S, self._bn, self._warps, self._stages = _CONFIGS[key]
             self._S = min(self._S, num_pages)
         else:
             self._S = _heuristic_num_splits(batch * num_kv_heads, num_pages)
-            self._bn, self._warps = _BLOCK_N, _NUM_WARPS
+            self._bn, self._warps, self._stages = _BLOCK_N, _NUM_WARPS, _NUM_STAGES
 
     def forward(self, query, kv_cache, block_table, seq_lens):
         B, H, D = query.shape

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -1,4 +1,4 @@
-        S, GP, BLOCK_N, warps = self._S, self._GP, self._bn, self._warps
+        S, GP, BLOCK_N, warps, stages = self._S, self._GP, self._bn, self._warps, self._stages
         PAGES_PER_BLOCK = BLOCK_N // P
         out, o_p, m_p, l_p = self._bufs
 
@@ -7,12 +7,12 @@
                 query, kv_cache, block_table, seq_lens,
                 out, out, out, self.scale,
                 H, Hkv, G, D, P, max_blocks, 1, BLOCK_N, GP, PAGES_PER_BLOCK,
-                True, num_warps=warps, num_stages=1,
+                True, num_warps=warps, num_stages=stages,
             )
         else:
             _paged_decode_phase1[(B * Hkv * S,)](
                 query, kv_cache, block_table, seq_lens,
                 o_p, m_p, l_p, self.scale,
                 H, Hkv, G, D, P, max_blocks, S, BLOCK_N, GP, PAGES_PER_BLOCK,
-                False, num_warps=warps, num_stages=1,
+                False, num_warps=warps, num_stages=stages,
             )

--- a//workspace/problems/03_paged_attention/tune2.py
+++ b//workspace/problems/03_paged_attention/tune2.py
@@ -1,5 +1,5 @@
-"""Focused re-tune using the actual _CONFIGS override path."""
-import sys, itertools
+"""Denoised per-shape config sweep (graph path). 3 repeats per config, median gbps."""
+import sys, itertools, statistics
 from pathlib import Path
 sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
 import torch
@@ -10,12 +10,12 @@
 def bytes_of(sh):
     return 2*sh["batch"]*sh["seq_len"]*sh["num_kv_heads"]*sh["head_dim"]*2 + sh["batch"]*sh["num_heads"]*sh["head_dim"]*2*2
 
-import argparse
 which = [int(x) for x in sys.argv[1:]] or list(range(5))
 
 Ss = [1,2,4,8,16,32]
 BNs = [16,32,64,128]
-Ws = [1,2,4,8]
+Ws = [2,4,8]
+STs = [1,2,3]
 
 for si in which:
     sh = shapes.SHAPES[si]
@@ -29,18 +29,22 @@
     npages = (sh["seq_len"]+sh["page_size"]-1)//sh["page_size"]
     key = (sh["batch"],sh["num_heads"],sh["num_kv_heads"],sh["head_dim"],sh["seq_len"],sh["page_size"])
     results=[]
-    for S,bn,w in itertools.product(Ss,BNs,Ws):
+    for S,bn,w,st in itertools.product(Ss,BNs,Ws,STs):
         if bn < sh["page_size"]: continue
         if S > npages: continue
-        solution._CONFIGS[key] = (S,bn,w)
-        m = solution.Model(*ia).to(dev).eval()
+        solution._CONFIGS[key] = (S,bn,w,st)
         try:
-            ms = time_fn(lambda *a: m(*a), inputs, iters=50, warmup=15)
+            samples=[]
+            for _ in range(3):
+                m = solution.Model(*ia).to(dev).eval()
+                ms = time_fn(lambda *a: m(*a), inputs, iters=40, warmup=12)
+                samples.append(ms)
+            ms = statistics.median(samples)
         except Exception:
             continue
         gbps = bmoved/(ms*1e-3)/1e9
-        results.append((gbps,S,bn,w,ms))
+        results.append((gbps,S,bn,w,st,ms))
     results.sort(reverse=True)
     print(f"=== shape {si} {key} npages={npages} ===")
-    for r in results[:6]:
-        print(f"  gbps={r[0]:.1f} frac={r[0]/1800:.3f} S={r[1]} bn={r[2]} w={r[3]} ms={r[4]:.4f}")
+    for r in results[:8]:
+        print(f"  gbps={r[0]:.1f} frac={r[0]/1800:.3f} S={r[1]} bn={r[2]} w={r[3]} st={r[4]} ms={r[5]:.4f}")

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -115,11 +115,11 @@
 # Per-shape tuned configs keyed by (B, H, Hkv, D, seq_len, P)
 #   -> (num_splits, BLOCK_N, num_warps, num_stages).
 _CONFIGS = {
-    (8, 32, 8, 128, 1024, 16): (8, 32, 4, 1),
-    (32, 32, 8, 128, 2048, 16): (1, 128, 8, 1),
-    (4, 64, 8, 128, 4096, 16): (16, 16, 2, 1),
-    (16, 32, 8, 128, 1535, 16): (2, 32, 4, 1),
-    (8, 16, 4, 64, 2000, 16): (16, 128, 4, 1),
+    (8, 32, 8, 128, 1024, 16): (4, 64, 2, 2),
+    (32, 32, 8, 128, 2048, 16): (1, 64, 4, 2),
+    (4, 64, 8, 128, 4096, 16): (16, 32, 4, 2),
+    (16, 32, 8, 128, 1535, 16): (1, 128, 4, 2),
+    (8, 16, 4, 64, 2000, 16): (16, 64, 4, 1),
 }
 
 _TARGET_BLOCKS = 512

--- /dev/null
+++ b//workspace/problems/03_paged_attention/prof.py
@@ -0,0 +1,25 @@
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+import torch
+import reference, shapes, solution
+
+si = int(sys.argv[1]) if len(sys.argv) > 1 else 4
+dev = torch.device("cuda:0")
+sh = shapes.SHAPES[si]
+reference.BATCH=sh["batch"]; reference.NUM_HEADS=sh["num_heads"]
+reference.NUM_KV_HEADS=sh["num_kv_heads"]; reference.HEAD_DIM=sh["head_dim"]
+reference.SEQ_LEN=sh["seq_len"]; reference.PAGE_SIZE=sh["page_size"]
+ia = reference.get_init_inputs()
+torch.manual_seed(2026)
+inputs = [t.to(dev) for t in reference.get_inputs()]
+m = solution.Model(*ia).to(dev).eval()
+# eager only: disable graph capture by monkeypatching
+m._graphs = {}
+def noflush(*a, **k): pass
+for _ in range(5):
+    m._launch(*inputs)
+torch.cuda.synchronize()
+for _ in range(3):
+    m._launch(*inputs)
+torch.cuda.synchronize()

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -1 +1 @@
-        self._GP = max(16, triton.next_power_of_2(self.group_size))+        self._GP = max(4, triton.next_power_of_2(self.group_size))

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -115,11 +115,11 @@
 # Per-shape tuned configs keyed by (B, H, Hkv, D, seq_len, P)
 #   -> (num_splits, BLOCK_N, num_warps, num_stages).
 _CONFIGS = {
-    (8, 32, 8, 128, 1024, 16): (4, 64, 2, 2),
+    (8, 32, 8, 128, 1024, 16): (4, 64, 4, 2),
     (32, 32, 8, 128, 2048, 16): (1, 64, 4, 2),
     (4, 64, 8, 128, 4096, 16): (16, 32, 4, 2),
     (16, 32, 8, 128, 1535, 16): (1, 128, 4, 2),
-    (8, 16, 4, 64, 2000, 16): (16, 64, 4, 1),
+    (8, 16, 4, 64, 2000, 16): (16, 64, 2, 2),
 }
 
 _TARGET_BLOCKS = 512

--- /dev/null
+++ b//workspace/problems/03_paged_attention/exp_combine.py
@@ -0,0 +1,22 @@
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+import torch, triton, triton.language as tl
+from src.eval.timing import time_fn
+
+# shape0: B=8,H=32,S=4,D=128 ; shape4: B=8,H=16,S=16,D=64
+import solution
+
+def bench_combine(B,H,S,D, warps):
+    o=torch.randn(B,H,S,D,device='cuda',dtype=torch.bfloat16)
+    m=torch.randn(B,H,S,device='cuda')
+    l=torch.rand(B,H,S,device='cuda')+0.5
+    out=torch.empty(B,H,D,device='cuda',dtype=torch.bfloat16)
+    fn=lambda: solution._paged_decode_combine[(B*H,)](o,m,l,out,H,D,S,num_warps=warps)
+    fn(); torch.cuda.synchronize()
+    ms=time_fn(lambda *a: fn(), [], iters=200, warmup=30)
+    print(f"  B{B}H{H}S{S}D{D} w{warps}: {ms*1000:.2f}us")
+
+for cfg in [(8,32,4,128),(8,16,16,64),(4,64,16,128)]:
+    for w in [1,2,4,8]:
+        bench_combine(*cfg, w)

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -112,6 +112,92 @@
     tl.store(out_ptr + (b * H + h) * D + dcol, out.to(tl.bfloat16))
 
 
+@triton.jit
+def _paged_decode_fused(
+    q_ptr, kv_ptr, bt_ptr, sl_ptr,
+    o_ptr,            # (B, Hkv, S, GP, D) bf16 partials
+    m_ptr, l_ptr,     # (B, Hkv, S, GP) fp32 partials
+    lock_ptr,         # (B*Hkv,) int32 counters (start at 0; last block resets)
+    out_ptr,          # (B, H, D) bf16
+    scale,
+    H: tl.constexpr, Hkv: tl.constexpr, G: tl.constexpr, D: tl.constexpr,
+    P: tl.constexpr, max_blocks: tl.constexpr,
+    S: tl.constexpr, BLOCK_N: tl.constexpr, GP: tl.constexpr,
+    PAGES_PER_BLOCK: tl.constexpr,
+):
+    pid = tl.program_id(0)
+    split = pid % S
+    bkv = pid // S
+    b = bkv // Hkv
+    kvh = bkv % Hkv
+
+    L = tl.load(sl_ptr + b)
+    num_pages = (L + P - 1) // P
+    pages_per_split = (num_pages + S - 1) // S
+    page_start = split * pages_per_split
+    page_end = tl.minimum(page_start + pages_per_split, num_pages)
+
+    grow = tl.arange(0, GP)
+    dcol = tl.arange(0, D)
+    q_head = kvh * G + grow
+    q_off = b * (H * D) + q_head[:, None] * D + dcol[None, :]
+    q = tl.load(q_ptr + q_off, mask=grow[:, None] < G, other=0.0)
+
+    m_i = tl.full((GP,), -float("inf"), dtype=tl.float32)
+    l_i = tl.zeros((GP,), dtype=tl.float32)
+    acc = tl.zeros((GP, D), dtype=tl.float32)
+
+    row = tl.arange(0, BLOCK_N)
+    local_page = row // P
+    within = row % P
+    kv2d = 2 * D
+    page_stride = P * Hkv * kv2d
+
+    for pblk in range(page_start, page_end, PAGES_PER_BLOCK):
+        gpage = pblk + local_page
+        valid_page = gpage < page_end
+        page_id = tl.load(bt_ptr + b * max_blocks + gpage, mask=valid_page, other=0)
+        token = gpage * P + within
+        valid = valid_page & (token < L)
+        base = page_id * page_stride + within * (Hkv * kv2d) + kvh * kv2d
+        k = tl.load(kv_ptr + base[:, None] + dcol[None, :], mask=valid[:, None], other=0.0)
+        v = tl.load(kv_ptr + base[:, None] + (D + dcol[None, :]), mask=valid[:, None], other=0.0)
+        s = tl.dot(q, tl.trans(k)) * scale
+        s = tl.where(valid[None, :], s, -float("inf"))
+        m_new = tl.maximum(m_i, tl.max(s, axis=1))
+        alpha = tl.exp(m_i - m_new)
+        p = tl.exp(s - m_new[:, None])
+        l_i = l_i * alpha + tl.sum(p, axis=1)
+        acc = acc * alpha[:, None] + tl.dot(p.to(k.dtype), v)
+        m_i = m_new
+
+    # Store this split's partials.
+    po = (bkv * S + split) * GP
+    tl.store(o_ptr + (po + grow[:, None]) * D + dcol[None, :], acc.to(tl.bfloat16))
+    tl.store(m_ptr + po + grow, m_i)
+    tl.store(l_ptr + po + grow, l_i)
+
+    # Signal completion. Release publishes the partial stores above; the last
+    # arriver acquires, so it sees every other split's partials.
+    old = tl.atomic_add(lock_ptr + bkv, 1, sem="acq_rel")
+    if old == S - 1:
+        tl.atomic_xchg(lock_ptr + bkv, 0, sem="release")  # reset for next replay
+        sidx = tl.arange(0, S)
+        m_all = tl.load(m_ptr + (bkv * S + sidx[:, None]) * GP + grow[None, :])  # (S, GP)
+        l_all = tl.load(l_ptr + (bkv * S + sidx[:, None]) * GP + grow[None, :])
+        m_g = tl.max(m_all, axis=0)                                              # (GP,)
+        sc = tl.exp(m_all - m_g[None, :])                                        # (S, GP)
+        l_g = tl.sum(l_all * sc, axis=0)                                         # (GP,)
+        acc_o = tl.zeros((GP, D), dtype=tl.float32)
+        for si in tl.static_range(S):
+            o_si = tl.load(o_ptr + ((bkv * S + si) * GP + grow[:, None]) * D + dcol[None, :]).to(tl.float32)
+            acc_o += o_si * sc[si, :][:, None]
+        out = acc_o / l_g[:, None]
+        out_head = kvh * G + grow
+        tl.store(out_ptr + (b * H + out_head[:, None]) * D + dcol[None, :],
+                 out.to(tl.bfloat16), mask=(grow < G)[:, None])
+
+
 # Per-shape tuned configs keyed by (B, H, Hkv, D, seq_len, P)
 #   -> (num_splits, BLOCK_N, num_warps, num_stages).
 _CONFIGS = {

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -184,14 +184,17 @@
         tl.atomic_xchg(lock_ptr + bkv, 0, sem="release")  # reset for next replay
         sidx = tl.arange(0, S)
         m_all = tl.load(m_ptr + (bkv * S + sidx[:, None]) * GP + grow[None, :])  # (S, GP)
-        l_all = tl.load(l_ptr + (bkv * S + sidx[:, None]) * GP + grow[None, :])
         m_g = tl.max(m_all, axis=0)                                              # (GP,)
-        sc = tl.exp(m_all - m_g[None, :])                                        # (S, GP)
-        l_g = tl.sum(l_all * sc, axis=0)                                         # (GP,)
+        l_g = tl.zeros((GP,), dtype=tl.float32)
         acc_o = tl.zeros((GP, D), dtype=tl.float32)
         for si in tl.static_range(S):
-            o_si = tl.load(o_ptr + ((bkv * S + si) * GP + grow[:, None]) * D + dcol[None, :]).to(tl.float32)
-            acc_o += o_si * sc[si, :][:, None]
+            base_si = (bkv * S + si) * GP
+            m_si = tl.load(m_ptr + base_si + grow)
+            l_si = tl.load(l_ptr + base_si + grow)
+            o_si = tl.load(o_ptr + (base_si + grow[:, None]) * D + dcol[None, :]).to(tl.float32)
+            sc_si = tl.exp(m_si - m_g)
+            l_g += l_si * sc_si
+            acc_o += o_si * sc_si[:, None]
         out = acc_o / l_g[:, None]
         out_head = kvh * G + grow
         tl.store(out_ptr + (b * H + out_head[:, None]) * D + dcol[None, :],

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -215,6 +215,7 @@
 _BLOCK_N = 64
 _NUM_WARPS = 4
 _NUM_STAGES = 2
+_USE_FUSED = True   # single-kernel split-K reduction (last block combines)
 
 
 def _heuristic_num_splits(groups, num_pages):

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -1,14 +1,23 @@
     def _alloc(self, device):
         B, H, D = self.batch, self.num_heads, self.head_dim
-        S = self._S
+        Hkv, GP, S = self.num_kv_heads, self._GP, self._S
         out = torch.empty(B, H, D, dtype=torch.bfloat16, device=device)
+        self._fused = _USE_FUSED and S > 1
         if S == 1:
             self._bufs = (out, None, None, None)
+            self._lock = None
+        elif self._fused:
+            o_p = torch.empty(B, Hkv, S, GP, D, dtype=torch.bfloat16, device=device)
+            m_p = torch.empty(B, Hkv, S, GP, dtype=torch.float32, device=device)
+            l_p = torch.empty(B, Hkv, S, GP, dtype=torch.float32, device=device)
+            self._bufs = (out, o_p, m_p, l_p)
+            self._lock = torch.zeros(B * Hkv, dtype=torch.int32, device=device)
         else:
             o_p = torch.empty(B, H, S, D, dtype=torch.bfloat16, device=device)
             m_p = torch.empty(B, H, S, dtype=torch.float32, device=device)
             l_p = torch.empty(B, H, S, dtype=torch.float32, device=device)
             self._bufs = (out, o_p, m_p, l_p)
+            self._lock = None
 
     def _launch(self, query, kv_cache, block_table, seq_lens):
         B, H, D = self.batch, self.num_heads, self.head_dim
@@ -25,6 +34,13 @@
                 H, Hkv, G, D, P, max_blocks, 1, BLOCK_N, GP, PAGES_PER_BLOCK,
                 True, num_warps=warps, num_stages=stages,
             )
+        elif self._fused:
+            _paged_decode_fused[(B * Hkv * S,)](
+                query, kv_cache, block_table, seq_lens,
+                o_p, m_p, l_p, self._lock, out, self.scale,
+                H, Hkv, G, D, P, max_blocks, S, BLOCK_N, GP, PAGES_PER_BLOCK,
+                num_warps=warps, num_stages=stages,
+            )
         else:
             _paged_decode_phase1[(B * Hkv * S,)](
                 query, kv_cache, block_table, seq_lens,

--- /dev/null
+++ b//workspace/problems/03_paged_attention/stress_fused.py
@@ -0,0 +1,38 @@
+"""Hammer the fused split-K kernel to expose any cross-block ordering race."""
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+import torch
+import reference, shapes, solution
+
+dev = torch.device("cuda:0")
+split_shapes = [0, 2, 4]   # these use the fused path (S>1)
+worst = 0.0
+for si in split_shapes:
+    sh = shapes.SHAPES[si]
+    reference.BATCH=sh["batch"]; reference.NUM_HEADS=sh["num_heads"]
+    reference.NUM_KV_HEADS=sh["num_kv_heads"]; reference.HEAD_DIM=sh["head_dim"]
+    reference.SEQ_LEN=sh["seq_len"]; reference.PAGE_SIZE=sh["page_size"]
+    ia = reference.get_init_inputs()
+    ref = reference.Model(*ia).to(dev).eval()
+    m = solution.Model(*ia).to(dev).eval()
+    m._alloc(dev)
+    assert m._fused, f"shape {si} not using fused path"
+    smax = 0.0
+    for it in range(150):
+        torch.manual_seed(1000 + it * 7 + si)
+        ins = [t.to(dev) for t in reference.get_inputs()]
+        # vary scale to stress softmax ranges
+        scale = [0.01, 1.0, 8.0][it % 3]
+        ins[0] = (ins[0].float() * scale).to(torch.bfloat16)
+        ins[1] = (ins[1].float() * scale).to(torch.bfloat16)
+        with torch.no_grad():
+            ro = ref(*ins)
+            so = m._launch(*ins)   # eager fused, no graph -> maximize race exposure
+            torch.cuda.synchronize()
+            so = so.clone()
+        d = (ro.float() - so.float()).abs().max().item()
+        smax = max(smax, d)
+    print(f"shape {si}: worst max_abs_diff over 150 iters = {smax:.5f}", flush=True)
+    worst = max(worst, smax)
+print(f"OVERALL worst = {worst:.5f}  ({'OK' if worst < 0.02 else 'RACE/BUG'})")

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -215,7 +215,9 @@
 _BLOCK_N = 64
 _NUM_WARPS = 4
 _NUM_STAGES = 2
-_USE_FUSED = True   # single-kernel split-K reduction (last block combines)
+_USE_FUSED = False  # single-kernel split-K reduction (last block combines);
+                    # measured slightly slower than the 2-kernel path (the
+                    # in-kernel combine is tail-latency bound), so disabled.
 
 
 def _heuristic_num_splits(groups, num_pages):

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -112,95 +112,6 @@
     tl.store(out_ptr + (b * H + h) * D + dcol, out.to(tl.bfloat16))
 
 
-@triton.jit
-def _paged_decode_fused(
-    q_ptr, kv_ptr, bt_ptr, sl_ptr,
-    o_ptr,            # (B, Hkv, S, GP, D) bf16 partials
-    m_ptr, l_ptr,     # (B, Hkv, S, GP) fp32 partials
-    lock_ptr,         # (B*Hkv,) int32 counters (start at 0; last block resets)
-    out_ptr,          # (B, H, D) bf16
-    scale,
-    H: tl.constexpr, Hkv: tl.constexpr, G: tl.constexpr, D: tl.constexpr,
-    P: tl.constexpr, max_blocks: tl.constexpr,
-    S: tl.constexpr, BLOCK_N: tl.constexpr, GP: tl.constexpr,
-    PAGES_PER_BLOCK: tl.constexpr,
-):
-    pid = tl.program_id(0)
-    split = pid % S
-    bkv = pid // S
-    b = bkv // Hkv
-    kvh = bkv % Hkv
-
-    L = tl.load(sl_ptr + b)
-    num_pages = (L + P - 1) // P
-    pages_per_split = (num_pages + S - 1) // S
-    page_start = split * pages_per_split
-    page_end = tl.minimum(page_start + pages_per_split, num_pages)
-
-    grow = tl.arange(0, GP)
-    dcol = tl.arange(0, D)
-    q_head = kvh * G + grow
-    q_off = b * (H * D) + q_head[:, None] * D + dcol[None, :]
-    q = tl.load(q_ptr + q_off, mask=grow[:, None] < G, other=0.0)
-
-    m_i = tl.full((GP,), -float("inf"), dtype=tl.float32)
-    l_i = tl.zeros((GP,), dtype=tl.float32)
-    acc = tl.zeros((GP, D), dtype=tl.float32)
-
-    row = tl.arange(0, BLOCK_N)
-    local_page = row // P
-    within = row % P
-    kv2d = 2 * D
-    page_stride = P * Hkv * kv2d
-
-    for pblk in range(page_start, page_end, PAGES_PER_BLOCK):
-        gpage = pblk + local_page
-        valid_page = gpage < page_end
-        page_id = tl.load(bt_ptr + b * max_blocks + gpage, mask=valid_page, other=0)
-        token = gpage * P + within
-        valid = valid_page & (token < L)
-        base = page_id * page_stride + within * (Hkv * kv2d) + kvh * kv2d
-        k = tl.load(kv_ptr + base[:, None] + dcol[None, :], mask=valid[:, None], other=0.0)
-        v = tl.load(kv_ptr + base[:, None] + (D + dcol[None, :]), mask=valid[:, None], other=0.0)
-        s = tl.dot(q, tl.trans(k)) * scale
-        s = tl.where(valid[None, :], s, -float("inf"))
-        m_new = tl.maximum(m_i, tl.max(s, axis=1))
-        alpha = tl.exp(m_i - m_new)
-        p = tl.exp(s - m_new[:, None])
-        l_i = l_i * alpha + tl.sum(p, axis=1)
-        acc = acc * alpha[:, None] + tl.dot(p.to(k.dtype), v)
-        m_i = m_new
-
-    # Store this split's partials.
-    po = (bkv * S + split) * GP
-    tl.store(o_ptr + (po + grow[:, None]) * D + dcol[None, :], acc.to(tl.bfloat16))
-    tl.store(m_ptr + po + grow, m_i)
-    tl.store(l_ptr + po + grow, l_i)
-
-    # Signal completion. Release publishes the partial stores above; the last
-    # arriver acquires, so it sees every other split's partials.
-    old = tl.atomic_add(lock_ptr + bkv, 1, sem="acq_rel")
-    if old == S - 1:
-        tl.atomic_xchg(lock_ptr + bkv, 0, sem="release")  # reset for next replay
-        sidx = tl.arange(0, S)
-        m_all = tl.load(m_ptr + (bkv * S + sidx[:, None]) * GP + grow[None, :])  # (S, GP)
-        m_g = tl.max(m_all, axis=0)                                              # (GP,)
-        l_g = tl.zeros((GP,), dtype=tl.float32)
-        acc_o = tl.zeros((GP, D), dtype=tl.float32)
-        for si in tl.static_range(S):
-            base_si = (bkv * S + si) * GP
-            m_si = tl.load(m_ptr + base_si + grow)
-            l_si = tl.load(l_ptr + base_si + grow)
-            o_si = tl.load(o_ptr + (base_si + grow[:, None]) * D + dcol[None, :]).to(tl.float32)
-            sc_si = tl.exp(m_si - m_g)
-            l_g += l_si * sc_si
-            acc_o += o_si * sc_si[:, None]
-        out = acc_o / l_g[:, None]
-        out_head = kvh * G + grow
-        tl.store(out_ptr + (b * H + out_head[:, None]) * D + dcol[None, :],
-                 out.to(tl.bfloat16), mask=(grow < G)[:, None])
-
-
 # Per-shape tuned configs keyed by (B, H, Hkv, D, seq_len, P)
 #   -> (num_splits, BLOCK_N, num_warps, num_stages).
 _CONFIGS = {

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -126,9 +126,6 @@
 _BLOCK_N = 64
 _NUM_WARPS = 4
 _NUM_STAGES = 2
-_USE_FUSED = False  # single-kernel split-K reduction (last block combines);
-                    # measured slightly slower than the 2-kernel path (the
-                    # in-kernel combine is tail-latency bound), so disabled.
 
 
 def _heuristic_num_splits(groups, num_pages):

--- a//workspace/problems/03_paged_attention/solution.py
+++ b//workspace/problems/03_paged_attention/solution.py
@@ -1,23 +1,14 @@
     def _alloc(self, device):
         B, H, D = self.batch, self.num_heads, self.head_dim
-        Hkv, GP, S = self.num_kv_heads, self._GP, self._S
+        S = self._S
         out = torch.empty(B, H, D, dtype=torch.bfloat16, device=device)
-        self._fused = _USE_FUSED and S > 1
         if S == 1:
             self._bufs = (out, None, None, None)
-            self._lock = None
-        elif self._fused:
-            o_p = torch.empty(B, Hkv, S, GP, D, dtype=torch.bfloat16, device=device)
-            m_p = torch.empty(B, Hkv, S, GP, dtype=torch.float32, device=device)
-            l_p = torch.empty(B, Hkv, S, GP, dtype=torch.float32, device=device)
-            self._bufs = (out, o_p, m_p, l_p)
-            self._lock = torch.zeros(B * Hkv, dtype=torch.int32, device=device)
         else:
             o_p = torch.empty(B, H, S, D, dtype=torch.bfloat16, device=device)
             m_p = torch.empty(B, H, S, dtype=torch.float32, device=device)
             l_p = torch.empty(B, H, S, dtype=torch.float32, device=device)
             self._bufs = (out, o_p, m_p, l_p)
-            self._lock = None
 
     def _launch(self, query, kv_cache, block_table, seq_lens):
         B, H, D = self.batch, self.num_heads, self.head_dim
@@ -34,13 +25,6 @@
                 H, Hkv, G, D, P, max_blocks, 1, BLOCK_N, GP, PAGES_PER_BLOCK,
                 True, num_warps=warps, num_stages=stages,
             )
-        elif self._fused:
-            _paged_decode_fused[(B * Hkv * S,)](
-                query, kv_cache, block_table, seq_lens,
-                o_p, m_p, l_p, self._lock, out, self.scale,
-                H, Hkv, G, D, P, max_blocks, S, BLOCK_N, GP, PAGES_PER_BLOCK,
-                num_warps=warps, num_stages=stages,
-            )
         else:
             _paged_decode_phase1[(B * Hkv * S,)](
                 query, kv_cache, block_table, seq_lens,

--- a//home/agent/.claude/projects/-workspace-problems-03-paged-attention/memory/paged-attention-approach.md
+++ b//home/agent/.claude/projects/-workspace-problems-03-paged-attention/memory/paged-attention-approach.md
@@ -16,6 +16,13 @@
 
 Bugs fixed: K/V load mask must be `valid_page & (token<L)`, NOT just `token<L` — else tokens from the next split (still <L) get loaded from page_id=0 (masked-out page) and wrongly counted. The tl.dot tf32 was a red herring; bf16 dot w/ fp32 accumulate passes 0.02 tol.
 
-Gotcha: tiny shapes (shape0=33MB, shape4=16MB) are NOISY (~15% run-to-run); single-shot tune2.py bests don't transfer to benchmark.py. Proven benchmark config set (gmean 0.6993): shape0 (8,32,4), shape1 (1,128,8), shape2 (16,16,2), shape3 (2,32,4), shape4 (16,128,4). Need multi-run denoised comparison to beat noise floor.
+Gotcha: tiny shapes (shape0=33MB, shape4=16MB) are NOISY (~6-15% run-to-run); single-shot tune2.py bests don't transfer — must use 3-repeat median tuning.
 
-See [[paged-attention-status]] for current best score.
+Final config (num_splits, BLOCK_N, num_warps, num_stages); gmean ~0.665-0.71 (median ~0.67):
+shape0 (4,64,4,2), shape1 (1,64,4,2), shape2 (16,32,4,2), shape3 (1,128,4,2), shape4 (16,64,2,2). num_stages=2 helps the longer shapes. GP (group pad) = next_pow2(G) floored at 4 (tl.dot accepts M=4/8).
+
+Ceiling analysis (we are near it): shape1 (268MB) hits 0.84 — proving the strided paged gather is efficient at scale. The small shapes (0=0.63, 4=0.48) are RAMP-limited (too few bytes to reach peak DRAM) + the combine kernel's flat ~3.4us in-graph overhead, NOT access-pattern limited. So a CUDA-C++ contiguous-read rewrite wouldn't help much.
+
+Dead ends tried: (1) single-kernel fused split-K (last-block-does-combine via acq_rel atomic counter + lock reset) — CORRECT (validated 450 eager launches, max err 0.001) but SLOWER than 2-kernel: the in-kernel combine is tail-latency bound (waits for stragglers then serial reduce) vs the cleanly-parallel separate combine kernel. (2) larger BLOCK_N for MLP — neutral. (3) reducing GP 16->4 — neutral (not register-bound). (4) combined K|V tl.load — Triton can't slice kv[:,:D].
+
+ncu (eager): shape0 phase1 26us @74% DRAM, 5.7% occupancy (low occ but high DRAM = MLP-bound not occ-bound); combine ~3.4us @5% DRAM (pure fixed overhead). shape4 phase1 14.6us @66% DRAM + combine 3.5us.

--- /dev/null
+++ b//home/agent/.claude/projects/-workspace-problems-03-paged-attention/memory/paged-attention-status.md
@@ -0,0 +1,14 @@
+---
+name: paged-attention-status
+description: Final status/score for 03_paged_attention decode kernel
+metadata:
+  type: project
+---
+
+Status as of 2026-06-13: solution.py is COMPLETE and `python check.py` prints PASS (all 5 shapes × 3 seeds × nominal+2 stress cases). `python benchmark.py` peak_fraction ≈ 0.66-0.71 (median ~0.67), RESULT OK. Started from eager baseline gmean 0.25.
+
+Per-shape (achieved GB/s / 1800): shape0 ~0.63, shape1 ~0.84, shape2 ~0.72, shape3 ~0.78, shape4 ~0.48. Worst shapes (0,4) are the smallest KV (33MB, 16MB) and are DRAM-ramp-limited, not fixable by tuning.
+
+Implementation: Triton flash-decoding, 2 kernels (phase1 split-K + combine), CUDA-graph captured per input-ptr signature. See [[paged-attention-approach]] for the full design, key wins, bugs, and dead-ends.
+
+Tools left in dir: tune2.py (3-repeat denoised config sweep), stress_fused.py (race validator for the abandoned fused kernel).