add add-flashinfer-solution skill (end-to-end Solution authoring)

skills/add-flashinfer-solution/PR_DESCRIPTION.md

@@ -0,0 +1,252 @@
+# PR: add-flashinfer-solution skill
+
+> Copy-paste artifacts for opening the PR upstream against
+> https://github.com/flashinfer-ai/flashinfer-bench
+
+---
+
+## Suggested branch name
+
+```
+yyang/add-solution-skill
+```
+
+(or `<your-handle>/add-solution-skill` matching your contributor pattern)
+
+---
+
+## Suggested PR title
+
+```
+feat: add add-flashinfer-solution skill (end-to-end Solution authoring + benchmarking + visualization)
+```
+
+Per `CONTRIBUTING.md` `<type>: <brief description>`:
+- `feat:` — adds a new agent capability (parallel to existing `onboard-model`, `extract-kernel-definitions`, `collect-workloads`)
+- alternative: `docs:` — if reviewers prefer skills be classified as docs
+
+---
+
+## Suggested commit message (single squashed commit)
+
+```
+feat: add add-flashinfer-solution skill (end-to-end Solution authoring)
+
+Adds a new agent skill under .claude/skills/add-flashinfer-solution/ that
+covers the Solution-side workflow: pick a Definition → wrap a kernel →
+write Solution JSON → run flashinfer-bench → inspect traces → visualize.
+
+This complements the existing skill suite, which covers Definition extraction
+(extract-kernel-definitions), workload capture (collect-workloads), and
+end-to-end model onboarding (onboard-model). Solution authoring previously
+had no skill-level documentation; this fills that gap.
+
+Skill contents:
+  SKILL.md              7-step end-to-end workflow + gotchas + quick-run script
+  reference/
+    definition_schema.md  Full Definition JSON schema reference
+    solution_schema.md    Full Solution JSON schema reference
+    wrapper_gotchas.md    17+ catalogued failure modes with diagnostics
+    visualization.md      Local web UI + public site + SSH forwarding
+  templates/
+    dense_baseline_*      PyTorch SDPA-style reference baseline
+    linear_attention_*    External Python lib wrapper (FLA / fla-core)
+    vendored_kernel_*     Vendored Triton / CUDA kernel (SGLang-style)
+
+Verified end-to-end on H100 PCIe and B200 with three reference Solutions:
+  - sdpa_paged_decode_v1   (gqa_paged_decode_h32_kv8_d128_ps1)
+  - fla_gdn_decode_v1      (gdn_decode_qk4_v8_d128_k_last)
+  - sglang_mla_decode_v1   (mla_paged_decode_h16_ckv512_kpe64_ps1)
+
+All three were verified using the workflow documented in SKILL.md
+Section 3.3 + Step 5.1a: `crun -img nvcr.io/nvidia/pytorch:24.10-py3 -r /tmp
+<script>.sh` with per-run pip-install into /tmp/pip-pkgs (no NGC API key
+required; no custom container image; ~5 min pip install per invocation).
+Pre-built `.sqsh` images were considered as an optimization but rejected
+because the build path is blocked by computelab front-end constraints
+(no user docker daemon; cgroup namespace mismatch under VS Code SSH session;
+NGC private blob auth). SKILL.md documents this trade-off explicitly.
+
+Note on layout: existing skills are single SKILL.md files. This skill
+introduces sub-directories (reference/, templates/) because the content
+includes schema references and runnable Python / JSON templates that are
+more discoverable as separate artifacts than embedded in a long monolith.
+Open to flattening if upstream prefers strict one-file convention.
+```
+
+---
+
+## PR description (paste into GitHub)
+
+```markdown
+## Summary
+
+Adds a new agent skill `add-flashinfer-solution` under `.claude/skills/`
+covering the **Solution authoring side** of the flashinfer-bench workflow:
+
+> pick a Definition → wrap a kernel → write Solution JSON → run benchmark
+> → inspect traces → visualize
+
+The existing skill suite covers the **Definition / Workload / model side**
+(`extract-kernel-definitions`, `collect-workloads`, `onboard-model`,
+`add-reference-tests`, `track-models`, `clone-repos`,
+`collect-workloads-bench`). Solution authoring had no skill-level
+documentation; this PR fills that gap.
+
+## Motivation
+
+Three real Solutions were authored end-to-end during this work:
+
+| Solution | Definition | Verified on |
+|---|---|---|
+| `sdpa_paged_decode_v1` | `gqa_paged_decode_h32_kv8_d128_ps1` | H100 PCIe |
+| `fla_gdn_decode_v1` | `gdn_decode_qk4_v8_d128_k_last` | H100 PCIe |
+| `sglang_mla_decode_v1` | `mla_paged_decode_h16_ckv512_kpe64_ps1` | H100 PCIe + B200 |
+
+Recurring patterns surfaced — KV-cache layout conversion, LSE base-2 vs
+base-e, GQA `H_kv → H_q` expansion, FLA's `transpose_state_layout` flag,
+vendored-Triton sys.path, NGC PyTorch + CuTe DSL ABI mismatch — were
+costly to re-derive each time. This skill captures them as a reusable
+playbook so subsequent Solution contributors don't relive the debug loops.
+
+## What's added
+
+```
+.claude/skills/add-flashinfer-solution/
+├── SKILL.md                              7-step workflow + gotchas
+├── reference/
+│   ├── definition_schema.md              Definition JSON full schema
+│   ├── solution_schema.md                Solution JSON full schema
+│   ├── wrapper_gotchas.md                17+ failure modes with diagnostics
+│   └── visualization.md                  Web UI / public site / SSH forwarding
+└── templates/
+    ├── dense_baseline_main.py + .json      PyTorch SDPA-style baseline
+    ├── linear_attention_main.py + .json    External lib wrapper (FLA)
+    └── vendored_kernel_main.py + .json     Vendored Triton kernel (SGLang-style)
+```
+
+### Verified environment
+
+All three reference Solutions were verified using the workflow in
+**SKILL.md Section 3.3 + Step 5.1a**:
+
+```bash
+crun -q 'gpu.chip=gh100 and cpu.arch=x86_64' --gpus=1 -C \
+     -img nvcr.io/nvidia/pytorch:24.10-py3 \
+     -r /tmp <user_script>.sh
+```
+
+Inside `<user_script>.sh`, the pinned dependency stack:
+
+```bash
+pip install --target /tmp/pip-pkgs --no-cache-dir \
+    flashinfer-python==0.6.9 \
+    "flashinfer-bench>=0.6.0,<0.7" \
+    "flash-linear-attention>=0.5.0" \
+    "nvidia-cutlass-dsl[cu13]" \
+    cuda-python safetensors huggingface-hub
+```
+
+No NGC API key required (crun authenticates against NGC via the compute
+node's docker daemon credentials), no custom container image needed.
+Per-invocation cost: ~5 min pip install. SKILL.md explains why a pre-built
+`.sqsh` was considered as an optimization and why it is not included
+(computelab front-end build constraints).
+
+## Layout note for reviewers
+
+Existing skills are single-file `SKILL.md`. This one uses subdirectories
+(`reference/`, `templates/`) because:
+
+1. Schema reference docs (~200 lines each) are more useful as standalone
+   linkable artifacts than as inline sections of a longer SKILL.md
+2. Wrapper templates need to be **runnable** as `.py` / `.json` for the
+   "copy → modify" use case, not as inline code blocks
+
+Total content is ~1500 lines distributed across 11 purposeful files. Happy
+to flatten into a single SKILL.md if maintainers prefer strict one-file
+convention; in that case the wrapper templates would still need to live as
+separate executable artifacts somewhere.
+
+## How to test
+
+### 1. Skill metadata sanity
+```bash
+head -4 .claude/skills/add-flashinfer-solution/SKILL.md
+# Expect valid YAML frontmatter with name + description
+```
+
+### 2. End-to-end Solution run on a computelab GPU node
+Follow SKILL.md Section 3.3 + Step 5.1a to author a trivial Solution
+against any existing Definition (e.g. `gqa_paged_decode_h32_kv8_d128_ps1`)
+and confirm `flashinfer-bench run --solutions <yours>` produces PASSED
+traces.
+
+### 3. Lint / format
+No code changes; only markdown + Python + JSON templates.
+
+## Checklist
+
+- [x] PR title follows `<type>: <description>` convention
+- [x] Skill metadata (`name`, `description`) follows existing skill pattern
+- [x] No changes to `flashinfer_bench/` Python package
+- [x] No changes to existing skills (additive only)
+- [x] No CI / build system changes required
+- [x] CONTRIBUTING.md workflow followed (fork → branch → PR)
+- [ ] Reviewers comfortable with subdir layout (else willing to flatten)
+
+## Related
+
+- Existing skills suite: see `.claude/skills/` and CLAUDE.md
+- Last skill-related PR: #384 (docs: add skill summaries and
+  cross-references)
+- Prior skill-restructure PR: #224 (referenced in #384)
+```
+
+---
+
+## How to actually open the PR
+
+```bash
+# 0. set git identity if not yet (replace with yours)
+cd /home/scratch.yuny_wwfo/kernel_arena/flashinfer-bench
+git config user.name "Your Name"
+git config user.email "your@email"
+
+# 1. fork on GitHub, then add as an additional remote
+git remote add fork https://github.com/<your-gh-handle>/flashinfer-bench.git
+
+# 2. create a clean branch from current main
+git fetch origin
+git checkout -b yyang/add-solution-skill origin/main
+
+# 3. copy the skill in place
+mkdir -p .claude/skills/add-flashinfer-solution
+cp -r /home/yuny/kernel_arena/skills/add-flashinfer-solution/* \
+      .claude/skills/add-flashinfer-solution/
+# NB: PR_DESCRIPTION.md is the source for the PR body itself — don't ship
+# it as part of the skill. Remove it from the staged copy:
+rm .claude/skills/add-flashinfer-solution/PR_DESCRIPTION.md
+
+# 4. confirm only the skill files are staged (the working tree currently has
+#    unrelated 'deleted' entries from the flashinfer_trace symlink — DO NOT
+#    stage those)
+git add .claude/skills/add-flashinfer-solution
+git status
+
+# 5. commit (paste the suggested commit message above)
+git commit  # then paste the commit message body in the editor
+
+# 6. push to your fork
+git push -u fork yyang/add-solution-skill
+
+# 7. open PR via gh CLI (or GitHub web)
+gh pr create \
+    --repo flashinfer-ai/flashinfer-bench \
+    --base main \
+    --head <your-gh-handle>:yyang/add-solution-skill \
+    --title "feat: add add-flashinfer-solution skill (end-to-end Solution authoring + benchmarking + visualization)" \
+    --body-file <(sed -n '/^## PR description/,/^---$/p' /home/yuny/kernel_arena/skills/add-flashinfer-solution/PR_DESCRIPTION.md | sed -n '/```markdown/,/^```$/p' | grep -v '^```')
+```
+
+---

skills/add-flashinfer-solution/SKILL.md

@@ -0,0 +1,702 @@
+---
+name: add-flashinfer-solution
+description: End-to-end workflow for adding a new Solution to the flashinfer-trace dataset, running its benchmark with flashinfer-bench, and visualizing traces in the web UI / public leaderboard. Use when implementing a new attention / GEMM / MoE / RMSNorm / sampling kernel as a Solution against an existing Definition, integrating a third-party kernel library (Flash Attention, FLA, SGLang, TRT-LLM, vLLM, cuDNN, etc.), or onboarding new contributors to the benchmark workflow.
+---
+
+# Add a New Solution → Run Benchmark → Visualize Traces
+
+End-to-end guide. Read sections in order on first use; jump to specific sections via the index after that.
+
+## Index
+
+1. [When to use this skill](#1-when-to-use-this-skill)
+2. [Background: flashinfer-bench vs flashinfer-trace](#2-background-flashinfer-bench-vs-flashinfer-trace)
+3. [Prerequisites](#3-prerequisites)
+4. [Workflow overview (7 steps)](#4-workflow-overview)
+5. [Step 1 — Pick a Definition + audit existing solutions](#step-1--pick-a-definition--audit-existing-solutions)
+6. [Step 2 — Pull workload LFS data](#step-2--pull-workload-lfs-data)
+7. [Step 3 — Write the wrapper (`main.py`)](#step-3--write-the-wrapper-mainpy)
+8. [Step 4 — Write the Solution JSON](#step-4--write-the-solution-json)
+9. [Step 5 — Run benchmark with `flashinfer-bench run`](#step-5--run-benchmark-with-flashinfer-bench-run)
+10. [Step 6 — Inspect generated traces](#step-6--inspect-generated-traces)
+11. [Step 7 — Visualize](#step-7--visualize)
+12. [Common gotchas](#common-gotchas)
+13. [Reference & templates](#reference--templates)
+
+---
+
+## 1. When to use this skill
+
+Trigger this skill when:
+- You are implementing a **new kernel** as a Solution for an existing Definition in `flashinfer-trace`
+- You are wrapping a **third-party library** (Flash Attention, Flash Linear Attention, SGLang vendored kernel, TRT-LLM, vLLM, cuDNN, xFormers, …) so it can run inside `flashinfer-bench`
+- You need to **run the benchmark** and produce traces (latency / speedup / correctness) for a Solution
+- You want to **visualize results** in the local Next.js web UI or upload to https://bench.flashinfer.ai
+
+Do NOT use this skill for:
+- Adding a new Definition (use the official `extract-kernel-definitions` skill)
+- Collecting Workload tensor data from a SGLang inference run (use `collect-workloads`)
+- Onboarding a brand-new model (use `onboard-model`)
+
+## 2. Background: flashinfer-bench vs flashinfer-trace
+
+Two repos, two roles:
+
+| Repo | Role | Contains |
+|---|---|---|
+| **flashinfer-bench** (https://github.com/flashinfer-ai/flashinfer-bench) | benchmark **codebase / framework** | Python package `flashinfer_bench/` + CLI (`flashinfer-bench run`, `flashinfer-bench report …`) + Next.js web UI under `web/` |
+| **flashinfer-trace** (https://huggingface.co/datasets/flashinfer-ai/flashinfer-trace) | benchmark **dataset** | `definitions/`, `solutions/`, `workloads/`, `blob/workloads/` (LFS), `traces/` |
+
+Data model:
+
+```
+Definition  ──── what kernel + parameter space (axes, inputs, outputs, reference impl)
+Workload    ──── concrete tensor inputs for one Definition instance (UUID-keyed)
+Solution    ──── one implementation of a Definition (Python / Triton / CUDA / …)
+Trace       ──── result of running a Solution on a Workload (latency, speedup, status)
+```
+
+Adding a new Solution = create the JSON + `main.py` under `solutions/<author>/<op_type>/<def_name>/`, then run `flashinfer-bench run` to evaluate it against existing Workloads, which writes Traces under `traces/<author>/<op_type>/<def_name>.jsonl`.
+
+## 3. Prerequisites
+
+### 3.1 Hardware
+- Linux x86_64 + NVIDIA GPU (H100 PCIe / SXM, B200, L40, A100 ... see Definition `target_hardware` to check compatibility)
+
+### 3.2 Disk space
+- **Important**: home quota is typically tight (~5 GB). Place all heavy dirs on a scratch path:
+  ```
+  HOME (small):
+    /home/<user>/kernel_arena/
+        flashinfer-bench → symlink → SCRATCH
+        flashinfer-trace → symlink → SCRATCH
+        scripts/         → symlink → SCRATCH
+        results/         → symlink → SCRATCH
+
+  SCRATCH (~700 GB):
+    /home/scratch.<user>/kernel_arena/
+        flashinfer-bench/    # Codebase clone
+        flashinfer-trace/    # Dataset clone (LFS data lives here)
+        scripts/             # Your wrapper scripts, run scripts
+        results/             # Run logs
+  ```
+- LFS data per Workload: ~500 KB–2 MB; pulling 50–100 Workloads is typically <100 MB
+
+### 3.3 Environment — verified workflow on NVIDIA computelab / SLURM clusters
+
+This is the path actually used to verify the three reference Solutions
+end-to-end. Zero NGC API key setup, zero docker daemon, zero custom
+container image. Each `crun` invocation pulls the NGC base on the compute
+node (which has cluster-configured NGC credentials), and the user script
+installs pip dependencies into `/tmp/pip-pkgs` inside that container.
+
+Per-run cost: ~5 min pip install at start of every `crun` invocation. The
+torch 2.5 → 2.11 upgrade triggered by `fla-core` is the dominant time.
+
+```bash
+crun -q 'gpu.chip=gh100 and cpu.arch=x86_64' --gpus=1 -C \
+     -img nvcr.io/nvidia/pytorch:24.10-py3 \
+     -r /tmp <your_script>.sh
+```
+
+Inside `<your_script>.sh`, install the exact stack used to verify the
+reference Solutions:
+
+```bash
+PIP_TARGET=/tmp/pip-pkgs
+mkdir -p "$PIP_TARGET"
+export PYTHONPATH="$PIP_TARGET:$PYTHONPATH"
+export PATH="$PIP_TARGET/bin:$PATH"
+
+pip install --target "$PIP_TARGET" --no-cache-dir \
+    flashinfer-python==0.6.9 \
+    "flashinfer-bench>=0.6.0,<0.7" \
+    "flash-linear-attention>=0.5.0" \
+    "nvidia-cutlass-dsl[cu13]" \
+    cuda-python \
+    safetensors huggingface-hub
+```
+
+**Version pin rationale**:
+- `flashinfer-python==0.6.9` — pinned for CuTe DSL GDN kernel ABI compatibility; do not drop the pin
+- `flashinfer-bench<0.7` — paired with flashinfer-python 0.6.9
+- `flash-linear-attention>=0.5.0` — only required if your wrapper uses FLA; safe to keep in the install list either way
+- `nvidia-cutlass-dsl[cu13] + cuda-python` — CuTe DSL backend deps; required even if you only run FLA (FlashInfer GDN baseline pulls them in)
+
+For wrappers that need additional libraries:
+- **FA3**: add a source-build step inside the script (`cd /tmp && git clone https://github.com/Dao-AILab/flash-attention.git && cd flash-attention/hopper && python setup.py install`)
+- **SGLang vendored kernel**: vendor the kernel file into your Solution's `sources/` — no pip install required
+
+> **Why not a pre-built `.sqsh` / docker image to skip the 5-minute pip install?**
+> Building a custom container in the computelab front-end environment is
+> blocked by multiple constraints: no user-accessible docker daemon, no
+> permission to `unshare --cgroup`, `enroot start` fails inside the
+> front-end's VS Code SSH session cgroup namespace, and NGC private blob
+> layers require an API key. The "pip install on every run" pattern adds
+> ~5 min per invocation but needs zero setup and is what the three
+> reference Solutions actually used.
+>
+> If your team will run benchmarks dozens of times against the same stack
+> and the ~5 min adds up, the recommended path is to build a custom image
+> on an **external** build host (a personal docker workstation, or a
+> dedicated cluster build farm with sudo) and drop the resulting `.sqsh`
+> at a shared scratch path. That work is out of scope for this skill.
+
+### 3.4 Clone the dataset
+```bash
+cd /home/scratch.<user>/kernel_arena
+git clone https://huggingface.co/datasets/flashinfer-ai/flashinfer-trace
+cd flashinfer-trace
+git-lfs install --local
+# Don't pull all LFS yet — pull only the Workloads you need (Step 2)
+```
+
+### 3.5 (Optional) Clone the framework codebase for the local web UI
+```bash
+git clone https://github.com/flashinfer-ai/flashinfer-bench.git
+```
+
+## 4. Workflow overview
+
+```
+Step 1 ── Pick a Definition + audit existing solutions
+Step 2 ── Pull workload LFS data (just for that Definition)
+Step 3 ── Write wrapper (main.py)
+Step 4 ── Write Solution JSON
+Step 5 ── Run benchmark with `flashinfer-bench run`
+Step 6 ── Inspect generated traces
+Step 7 ── Visualize (web UI / public site)
+```
+
+Estimated time for an experienced contributor:
+- First time end-to-end: **half a day to a full day** (env setup dominates)
+- Subsequent solutions on same env: **1–2 hours per Solution**
+
+---
+
+## Step 1 — Pick a Definition + audit existing solutions
+
+### 1.1 Find candidate Definition
+
+Browse `flashinfer-trace/definitions/<op_type>/` and pick a JSON file. The filename matches the Definition `name`.
+
+```bash
+ls /home/scratch.<user>/kernel_arena/flashinfer-trace/definitions/
+# dsa_paged  gdn  gemm  gqa_paged  gqa_ragged  mamba_ssu
+# mla_paged  mla_ragged  moe  rmsnorm  rope  sampling
+ls /home/scratch.<user>/kernel_arena/flashinfer-trace/definitions/gqa_paged/
+# gqa_paged_decode_h32_kv8_d128_ps1.json
+# gqa_paged_decode_h32_kv8_d128_ps64.json
+# ...
+```
+
+### 1.2 Read the Definition JSON
+
+Field semantics → see [`reference/definition_schema.md`](reference/definition_schema.md). Key fields to confirm before writing the wrapper:
+
+| Field | What to confirm |
+|---|---|
+| `axes` | Which dims are `const` (compile-time) vs `var` (runtime). Wrapper signature must accept all `var` axes |
+| `inputs` | Tensor names + dtypes + shapes. Wrapper signature must match exactly |
+| `outputs` | Whether output is allocated by wrapper (return) or pre-allocated (`destination_passing_style: true`) |
+| `tags` | `fi_api:` tells you which FlashInfer API the Definition was modeled after — your Solution may want to follow the same contract |
+| `reference.code` | The PyTorch reference implementation. Read it to understand semantics (sm_scale, masking, LSE base, etc.) |
+
+### 1.3 Audit existing solutions for that Definition
+
+```bash
+DEF=mla_paged_decode_h16_ckv512_kpe64_ps1
+OP=mla_paged
+TRACE=/home/scratch.<user>/kernel_arena/flashinfer-trace
+for author in baseline claude-opus-4-1-20250805 gemini-2.5-pro gpt-5-2025-08-07 gpt-o3; do
+    p="$TRACE/solutions/$author/$OP/$DEF"
+    if [ -d "$p" ]; then
+        echo "$author:"
+        ls "$p"
+    fi
+done
+```
+
+Why: read existing Solutions' `main.py` to understand:
+- How they map `axes` / `inputs` to function arguments
+- How they handle paged KV layout (flat indices vs 2D page table)
+- How they convert LSE base, sm_scale, dtype
+- Whether they pre-allocate output (`destination_passing_style`)
+
+The `baseline/` solution (FlashInfer wrapper) is the ground-truth reference — match its function signature.
+
+---
+
+## Step 2 — Pull workload LFS data
+
+Workload tensors live in `blob/workloads/<op_type>/<def_name>/<def_name>_<uuid>.safetensors`, stored as Git-LFS. Pull selectively to save disk:
+
+### 2.1 Pull all workloads for one Definition
+```bash
+cd /home/scratch.<user>/kernel_arena/flashinfer-trace
+DEF=mla_paged_decode_h16_ckv512_kpe64_ps1
+OP=mla_paged
+git-lfs pull --include="blob/workloads/$OP/$DEF/*"
+```
+
+### 2.2 Pull only N workloads (for quick iteration on a tight quota)
+
+Each Workload UUID is one entry in `workloads/<op>/<def>.jsonl`. Use head to take the first N:
+
+```bash
+WL_FILE=workloads/$OP/$DEF.jsonl
+UUIDS=$(head -5 "$WL_FILE" | python3 -c "import json,sys; [print(json.loads(l)['uuid']) for l in sys.stdin]")
+INCLUDES=""
+for u in $UUIDS; do
+    INCLUDES="${INCLUDES}${INCLUDES:+,}blob/workloads/$OP/$DEF/${DEF}_${u}.safetensors"
+done
+git-lfs pull --include="$INCLUDES"
+```
+
+### 2.3 Temp-trim the workloads jsonl to N entries (so the runner only sees those N)
+```bash
+WL_FILE=workloads/$OP/$DEF.jsonl
+cp "$WL_FILE" "$WL_FILE.bak"
+head -5 "$WL_FILE.bak" > "$WL_FILE"
+# After your run, restore:
+# mv "$WL_FILE.bak" "$WL_FILE"
+```
+
+Tip: a `bash trap` cleanup line is the safest way to ensure the original jsonl is restored even on script failure.
+
+### 2.4 Verify workloads exist
+```bash
+find blob/workloads/$OP/$DEF -name "*.safetensors" -size +1k | head -5
+```
+
+---
+
+## Step 3 — Write the wrapper (`main.py`)
+
+The wrapper is a single Python file at:
+```
+solutions/<author>/<op_type>/<def_name>/main.py
+```
+
+### 3.1 Wrapper signature contract
+
+Function signature must match the Definition's `inputs` exactly:
+- Each `inputs[].name` becomes a positional or keyword argument
+- Each `axes[].name` (the `var` ones) is also passed
+- Tensor dtypes / shapes match `inputs[].dtype` / `inputs[].shape`
+
+Default entry point is `main.py::run`. Function returns the output tensor(s) in the order declared by `outputs[]`.
+
+If `spec.destination_passing_style: true`, output tensors are pre-allocated and passed in — modify them in place, then return None or a status flag.
+
+### 3.2 Three wrapper patterns (templates)
+
+Pick the template closest to your situation:
+
+| Pattern | When to use | Template |
+|---|---|---|
+| **Dense baseline** | Wrapping a generic dense impl (PyTorch SDPA / cuDNN frontend) for reference | [`templates/dense_baseline_main.py`](templates/dense_baseline_main.py) |
+| **External Python lib** | Wrapping a pip-installable third-party lib (`fla-core`, `flash-attn`, `xformers`, `triton.ops` …) | [`templates/linear_attention_main.py`](templates/linear_attention_main.py) |
+| **Vendored kernel** | Bringing in a Triton / CUDA kernel file from another project (SGLang / vLLM / private) without depending on the upstream package | [`templates/vendored_kernel_main.py`](templates/vendored_kernel_main.py) |
+
+### 3.3 Writing checklist
+
+- [ ] Function signature matches Definition `inputs` + `var` axes
+- [ ] Output shape / dtype matches Definition `outputs`
+- [ ] LSE (if produced) uses **base-2** convention (FlashInfer convention; convert from natural-log via `* (1.0 / math.log(2.0))`)
+- [ ] `sm_scale` is taken from the input parameter, NOT recomputed as `1/sqrt(d)`
+- [ ] Paged KV cache is read using the supplied `kv_indices` / `kv_indptr` flat layout (not assumed dense)
+- [ ] GQA: kv heads broadcasted to query heads if the underlying lib expects MHA (`repeat_interleave(H_q // H_kv, dim=-2)`)
+- [ ] Persistent state (e.g. recurrent kernels) returns the new state in the order Definition declares
+- [ ] No global state mutation across batches (avoid using cached buffers keyed only on shape — also key on device + dtype)
+
+See [`reference/wrapper_gotchas.md`](reference/wrapper_gotchas.md) for a full list of common pitfalls.
+
+---
+
+## Step 4 — Write the Solution JSON
+
+Create `solutions/<author>/<op_type>/<def_name>/<solution_name>.json`:
+
+```json
+{
+  "name": "my_solution_v1",
+  "definition": "mla_paged_decode_h16_ckv512_kpe64_ps1",
+  "author": "<your-author-tag>",
+  "spec": {
+    "language": "python",
+    "target_hardware": ["NVIDIA H100", "NVIDIA B200"],
+    "entry_point": "main.py::run",
+    "dependencies": [],
+    "destination_passing_style": false
+  },
+  "sources": [
+    {"path": "main.py", "content": "<full content of main.py>"}
+  ]
+}
+```
+
+### 4.1 Field semantics
+
+Full schema → [`reference/solution_schema.md`](reference/solution_schema.md). Quick reference:
+
+| Field | Notes |
+|---|---|
+| `name` | Solution identifier. Convention: `<lib_or_method>_<op_type>_<variant_or_hash>`, e.g. `fa3_gqa_paged_decode_v1`, `sglang_mla_decode_v1` |
+| `definition` | MUST exactly match the Definition `name` |
+| `author` | Subdir name under `solutions/`. Pick a stable identifier for your team / lab (e.g. `acme-research`) |
+| `spec.language` | `python` (most common) / `triton` / `cuda` / `tilelang` / `tvm_ffi` |
+| `spec.target_hardware` | List of strings; framework checks current GPU is in this list before running |
+| `spec.entry_point` | `<file>::<function>`; default is `main.py::run` |
+| `spec.dependencies` | pip-installable packages required at runtime (e.g. `["flash-attn>=3.0.0", "fla-core"]`); leave `[]` if everything is vendored |
+| `spec.destination_passing_style` | `true` if outputs are pre-allocated and passed in; `false` (default) if the entry function returns the outputs |
+| `sources` | List of `{path, content}` dicts; include `main.py` plus any vendored `.py` / `.cu` / `.triton` files |
+
+### 4.2 Multi-file Solution
+
+For vendored kernels or multi-module wrappers, list every file in `sources`:
+
+```json
+"sources": [
+  {"path": "main.py",          "content": "..."},
+  {"path": "vendored_kernel.py", "content": "..."},
+  {"path": "kernel.cu",        "content": "..."}
+]
+```
+
+Files are extracted to a temp dir at run time; relative imports work as expected.
+
+### 4.3 Tooling
+
+`flashinfer-bench solution build .` (in the solution dir) helps generate the JSON `sources` blob from on-disk files, but writing manually with `json.dumps` from a quick Python script also works.
+
+---
+
+## Step 5 — Run benchmark with `flashinfer-bench run`
+
+### 5.1 Bare `flashinfer-bench run` command (inside the container)
+
+```bash
+cd /home/scratch.<user>/kernel_arena/flashinfer-trace
+
+flashinfer-bench run \
+    --local . \
+    --definitions <def_name> \
+    --solutions <solution_name_1> [<solution_name_2> ...] \
+    --warmup-runs 5 \
+    --iterations 20 \
+    --num-trials 1 \
+    --timeout 600 \
+    --log-level INFO
+```
+
+### 5.1a Full `crun` invocation (computelab / SLURM cluster) — what to actually type
+
+On computelab and similar clusters, wrap the command in a shell script and
+launch via `crun`. The script reproduces the exact path used to verify the
+three reference Solutions:
+
+```bash
+#!/bin/bash
+# my_run.sh
+set -e
+LOGFILE=/home/yuny/kernel_arena/results/my_run_$(date +%Y%m%d_%H%M%S).log
+mkdir -p $(dirname $LOGFILE)
+exec > >(tee -a "$LOGFILE") 2>&1
+
+echo "=== HOST: $(hostname)  TIME: $(date) ==="
+
+# 1. Install dependency stack into ephemeral /tmp/pip-pkgs
+PIP_TARGET=/tmp/pip-pkgs
+mkdir -p $PIP_TARGET
+pip install --target $PIP_TARGET --no-cache-dir \
+    flashinfer-python==0.6.9 \
+    "flashinfer-bench>=0.6.0,<0.7" \
+    "flash-linear-attention>=0.5.0" \
+    "nvidia-cutlass-dsl[cu13]" \
+    cuda-python \
+    safetensors huggingface-hub 2>&1 | tail -3
+export PYTHONPATH=$PIP_TARGET:$PYTHONPATH
+export PATH=$PIP_TARGET/bin:$PATH
+
+# 2. (Optional) Deploy your solution into the dataset before running
+DATASET=/home/scratch.yuny_wwfo/kernel_arena/flashinfer-trace
+DST=$DATASET/solutions/<your-author>/<op_type>/<def_name>
+mkdir -p $DST
+cp /home/yuny/kernel_arena/solutions/<your-solution>/*.json $DST/
+cp /home/yuny/kernel_arena/solutions/<your-solution>/main.py $DST/
+
+# 3. Run the benchmark
+cd $DATASET
+flashinfer-bench run \
+    --local . \
+    --definitions <def_name> \
+    --solutions <your-solution-name> \
+    --warmup-runs 5 \
+    --iterations 20 \
+    --num-trials 1 \
+    --timeout 600 \
+    --log-level INFO
+```
+
+Then submit:
+
+```bash
+crun -q 'gpu.chip=gh100 and cpu.arch=x86_64' --gpus=1 -C \
+     -img nvcr.io/nvidia/pytorch:24.10-py3 \
+     -r /tmp /home/yuny/kernel_arena/scripts/my_run.sh
+```
+
+GPU chip query examples:
+- `gpu.chip=gh100` → H100 (PCIe / SXM)
+- `gpu.chip=gb200` → B200
+- `gpu.chip=ga100` → A100
+
+### 5.2 Key flags
+
+| Flag | Meaning |
+|---|---|
+| `--local <path>` | Point to a local trace dataset clone (not HF) |
+| `--definitions` | Whitelist Definitions to run (space-separated; can also pass `--definitions all`) |
+| `--solutions` | Whitelist Solutions to run; `baseline` (FlashInfer wrapper) typically runs as the comparison reference automatically |
+| `--warmup-runs` | Forward passes before timing (default 10) |
+| `--iterations` | Forward passes for timing each trial |
+| `--num-trials` | Repeat trials, take median (default 3) |
+| `--timeout` | Per-(solution × workload) wall time, seconds |
+| `--log-level` | `DEBUG` / `INFO` / `WARNING` / `ERROR` |
+| `--no-save-results` | Don't write traces (only print summary). Omit to write traces |
+
+### 5.3 What happens
+
+For each (Solution × Workload) pair the runner:
+1. Loads input tensors from the workload `safetensors`
+2. Builds a baseline output via Definition `reference.code` (PyTorch)
+3. Calls the Solution's `entry_point`
+4. Compares Solution output vs baseline (rtol=1e-2, atol=1e-2 by default → status PASSED / INCORRECT_NUMERICAL)
+5. Times `iterations` warmup + measured passes → reports latency, ref_latency, speedup
+
+Result is a row in `traces/<author>/<op_type>/<def_name>.jsonl`.
+
+### 5.4 Status enum
+
+| Status | Meaning |
+|---|---|
+| `PASSED` | Output within tolerance, latency measured |
+| `INCORRECT_NUMERICAL` | rtol / atol exceeded |
+| `RUNTIME_ERROR` | Exception during execution (true exception is hidden by worker isolation — see Common gotchas) |
+| `TIMEOUT` | Exceeded `--timeout` |
+| `SETUP_FAILED` | Failed to set up baseline / solution before measurement |
+
+---
+
+## Step 6 — Inspect generated traces
+
+After `flashinfer-bench run`, check:
+
+```bash
+TRACE=/home/scratch.<user>/kernel_arena/flashinfer-trace
+find $TRACE/traces -name "*.jsonl" -newer $TRACE/run.log 2>/dev/null
+# Or just list everything:
+find $TRACE/traces -name "*<def_name>*.jsonl" -size +100c
+```
+
+### 6.1 Per-trace inspection
+```bash
+head -1 $TRACE/traces/<author>/<op>/<def>.jsonl | python3 -m json.tool | head -40
+```
+
+Key fields per trace row:
+- `definition`, `solution`, `workload.uuid`
+- `evaluation.status` (PASSED / RUNTIME_ERROR / …)
+- `evaluation.environment.hardware` (e.g. `NVIDIA H100 PCIe`)
+- `evaluation.performance.speedup_factor`, `latency_ms`, `reference_latency_ms`
+- `evaluation.correctness.max_absolute_error`, `max_relative_error`
+
+### 6.2 Quick stats from CLI
+```bash
+flashinfer-bench report best --local . 2>&1 | head -40
+flashinfer-bench report summary --local . 2>&1 | head -40
+```
+
+> Note: The `flashinfer-bench report visualize` CLI subcommand has a known issue in the current 0.6.x release where it treats Pydantic objects as dicts (`.get(...)`) and raises AttributeError. Use `report best` / `report summary` for CLI-level inspection, and the web UI (Step 7) for full visualization.
+
+---
+
+## Step 7 — Visualize
+
+Two paths:
+
+### 7.1 Public site (read-only, official traces only)
+
+https://bench.flashinfer.ai
+
+This site is the production build of `flashinfer-bench/web/`. It shows the official `baseline` + `claude-…` / `gemini-…` / `gpt-…` author traces but NOT your local traces. It also has a `/viewer` page that accepts a single trace JSON as paste-in for inspection.
+
+### 7.2 Local web UI (sees your traces)
+
+The local Next.js dev server reads traces from the local `flashinfer-trace` clone:
+
+```bash
+# Install pnpm (if not already; standalone binary is the simplest path)
+curl -fsSL -o ~/bin/pnpm \
+    https://github.com/pnpm/pnpm/releases/download/v9.15.0/pnpm-linuxstatic-x64
+chmod +x ~/bin/pnpm
+export PATH=~/bin:$PATH
+
+# Configure pnpm to store packages on scratch (avoids home-quota issues)
+mkdir -p /home/scratch.<user>/.pnpm-store
+pnpm config set store-dir /home/scratch.<user>/.pnpm-store
+
+# Install web app dependencies
+cd /home/scratch.<user>/kernel_arena/flashinfer-bench/web
+pnpm install      # ~2-3 minutes; produces ~1.9 GB node_modules
+
+# Point the data loader at your local dataset
+export FIB_DATASET_PATH=/home/scratch.<user>/kernel_arena/flashinfer-trace
+# Belt-and-suspenders: the data loader also looks at three fallback paths;
+# the surest cover is to symlink one of the fallback locations:
+ln -sfn $FIB_DATASET_PATH /tmp/flashinfer-trace
+ln -sfn $FIB_DATASET_PATH /home/scratch.<user>/kernel_arena/flashinfer-bench/flashinfer_trace
+
+# Start the dev server (apps/web only; skip apps/docs to save resources)
+cd apps/web
+nohup pnpm dev > /tmp/dev.log 2>&1 &
+
+# Wait until ready (typically 60–90 s on a frontend-only machine)
+until grep -q "Ready in" /tmp/dev.log; do sleep 2; done
+echo "Open http://localhost:3000"
+```
+
+Notes on the web UI:
+- Default port 3000 (web app), 3030 (docs)
+- VS Code Remote-SSH auto-forwards port 3000 to local; otherwise set up an SSH tunnel
+- **First page-load is slow** in dev mode — Next.js compiles each route on demand; `/` typically takes 200–400 s the first time, then is cached. Subsequent loads are seconds
+- For a faster experience: `pnpm build && pnpm start` produces a production bundle (~10 min build, then sub-second navigation forever)
+
+### 7.3 Pages worth opening
+
+| Path | Contents |
+|---|---|
+| `http://localhost:3000` | Leaderboard / kernel list / model list (homepage) |
+| `http://localhost:3000/kernels/<def_name>` | Per-Definition page: Solutions table, fast_p curve over workloads, top-5 by speedup |
+| `http://localhost:3000/models/<model_id>` | Per-model coverage page (which Definitions belong to this model, status) |
+| `http://localhost:3000/viewer` | Paste a single Trace JSON to inspect raw structure |
+
+### 7.4 Sharing traces with collaborators
+
+Traces are jsonl files in `traces/<author>/<op_type>/<def_name>.jsonl`. To share:
+- Copy the jsonl directly (one file per (author, op_type, def))
+- Open the public Viewer (https://bench.flashinfer.ai/viewer) and paste a single line of jsonl as a Trace JSON
+- Or commit + push to a branch of `flashinfer-trace` and open a PR (then the public site updates after merge)
+
+---
+
+## Common gotchas
+
+Curated from real run failures. Full list with diagnostics → [`reference/wrapper_gotchas.md`](reference/wrapper_gotchas.md).
+
+### Numerical / contract mismatches
+
+| Symptom | Likely cause | Fix |
+|---|---|---|
+| `INCORRECT_NUMERICAL` with `max_rel_error` ~ 1e0 | LSE base mismatch (natural log vs base-2) | Multiply natural-log LSE by `1 / math.log(2)` |
+| `INCORRECT_NUMERICAL`, max_abs_error proportional to `1 / sqrt(d)` | sm_scale dropped, lib defaulted to `1 / sqrt(d)` instead of the supplied value | Pass `scale=sm_scale` (or `softmax_scale=`) explicitly |
+| `INCORRECT_NUMERICAL` only on long-KV workloads | GQA expansion (`repeat_interleave`) mis-axis | Expand `H_kv → H_q` along the *head* axis only |
+| Output values look like garbage | `transpose_state_layout=True` not set on FLA / k-first vs k-last layout | Match the Definition's KV layout flag |
+| MLA wrapper passes correctness but speedup is < 1× | Kernel is fall-back path (e.g. FA3 ps=1 hits cp.async slow path) | Try ps=64 variant or different backend |
+
+### Runtime / framework
+
+| Symptom | Likely cause | Fix |
+|---|---|---|
+| `RUNTIME_ERROR` with no traceback shown | Worker subprocess swallowed the exception | Reproduce by `import` + calling the function directly outside `flashinfer-bench run` (skip the runner) |
+| First Solution fails 3 times → all subsequent runs `SKIPPED` | `flashinfer-bench` skips Solutions with 3 consecutive failures | Fix the underlying issue or rerun targeting a different Solution; see PersistentRunner state caveats below |
+| Second `flashinfer-bench run` re-uses stale baseline | PersistentRunner caches reference output keyed on (definition, workload); kill the persistent worker between runs | Pass `--runner=isolated` or restart the bench session |
+| `ImportError` for vendored module despite being in `sources` | Path issue: framework extracts sources to a temp dir but `sys.path` excludes that dir | At top of `main.py`, do `sys.path.insert(0, os.path.dirname(__file__))` before importing vendored modules |
+
+### Environment / disk
+
+| Symptom | Likely cause | Fix |
+|---|---|---|
+| `git-lfs pull` fails or outputs only pointers | git-lfs not installed locally | `git-lfs install --local`, then re-pull |
+| Disk-full mid-run | Home quota too small | Move repo + scripts + results to scratch (Section 3.3) |
+| `ImportError: flashinfer_bench has no attribute apply` | Old pip cache with stale flashinfer-bench | `pip install --target /tmp/pip-pkgs --no-cache-dir flashinfer-bench` |
+
+### Hardware-specific
+
+| Symptom | Likely cause | Fix |
+|---|---|---|
+| `flashinfer.gdn` raises `'NoneType' object is not callable` (`run_pretranspose_decode is None`) on NGC PyTorch 24.10 | FlashInfer 0.6.x GDN uses CuTe DSL whose ABI doesn't match torch 2.11 in NGC 24.10 | Use FLA wrapper (Linear-Attention pattern) as the Solution; file an upstream issue if needed |
+| FA3 wheel won't import (`undefined symbol`) | C++11 ABI mismatch between prebuilt wheel and PyTorch in container | Source-build FA3: `git clone Dao-AILab/flash-attention && cd hopper && python setup.py install` |
+| Solution fails on B200 but works on H100 | `target_hardware` includes only H100 / wrapper hard-codes SM90 | Add `"NVIDIA B200"` to `spec.target_hardware`; verify cubin / kernel template covers SM100 |
+
+---
+
+## Reference & templates
+
+### Reference docs (deep dives)
+
+- [`reference/definition_schema.md`](reference/definition_schema.md) — full Definition JSON schema with field semantics
+- [`reference/solution_schema.md`](reference/solution_schema.md) — full Solution JSON schema
+- [`reference/wrapper_gotchas.md`](reference/wrapper_gotchas.md) — extended troubleshooting list
+- [`reference/visualization.md`](reference/visualization.md) — full web-UI / viewer setup notes including production build path
+
+### Wrapper templates (copy-paste starting points)
+
+- [`templates/dense_baseline_main.py`](templates/dense_baseline_main.py) — PyTorch SDPA-style dense baseline (paged GQA decode example)
+- [`templates/dense_baseline_solution.json`](templates/dense_baseline_solution.json) — matching Solution JSON
+- [`templates/linear_attention_main.py`](templates/linear_attention_main.py) — third-party Python lib wrapper (FLA-style; recurrent state, gated delta rule)
+- [`templates/linear_attention_solution.json`](templates/linear_attention_solution.json) — matching Solution JSON
+- [`templates/vendored_kernel_main.py`](templates/vendored_kernel_main.py) — vendored Triton kernel (SGLang-style; MLA decode with split-K + LSE reduction)
+- [`templates/vendored_kernel_solution.json`](templates/vendored_kernel_solution.json) — matching Solution JSON
+
+Each template is heavily commented; the comments mark the lines you typically need to change for a new Definition.
+
+---
+
+## Quick reference: end-to-end run script
+
+A complete script for running a single (Definition, Solution) pair from scratch:
+
+```bash
+#!/bin/bash
+set -e
+USER_NAME=$(whoami)
+SCRATCH=/home/scratch.${USER_NAME}_*
+TRACE_ROOT=$SCRATCH/kernel_arena/flashinfer-trace
+DEF=mla_paged_decode_h16_ckv512_kpe64_ps1   # ← Edit
+OP=mla_paged                                  # �� Edit
+SOL=my_solution_v1                            # ← Edit
+AUTHOR=acme-research                          # ← Edit
+
+export PIP_TARGET=/tmp/pip-pkgs
+mkdir -p "$PIP_TARGET"
+export PYTHONPATH="$PIP_TARGET:$PYTHONPATH"
+export PATH="$PIP_TARGET/bin:$PATH"
+pip install --target "$PIP_TARGET" --no-cache-dir flashinfer-bench 2>&1 | tail -2
+
+cd "$TRACE_ROOT"
+git-lfs install --local
+git-lfs pull --include="blob/workloads/$OP/$DEF/*"
+
+# (Solution files at solutions/$AUTHOR/$OP/$DEF/ are assumed already created)
+
+flashinfer-bench run \
+    --local . \
+    --definitions "$DEF" \
+    --solutions "$SOL" \
+    --warmup-runs 5 \
+    --iterations 20 \
+    --num-trials 1 \
+    --timeout 600 \
+    --log-level INFO
+
+# Inspect
+find traces -name "*${DEF}*.jsonl" -size +100c | xargs wc -l
+```
+
+Save as `run_single_solution.sh`, set the four `← Edit` variables, and run.
+
+---
+
+**END OF SKILL**

skills/add-flashinfer-solution/reference/definition_schema.md

@@ -0,0 +1,198 @@
+# Definition JSON Schema (full reference)
+
+Each Definition JSON file lives at `definitions/<op_type>/<def_name>.json` in the `flashinfer-trace` repo. It declares a kernel's parameter space and the reference (PyTorch) implementation used for correctness checking.
+
+## Top-level schema
+
+```json
+{
+  "name":         "<string>",
+  "description":  "<string>",
+  "axes":         { ... },
+  "inputs":       [ ... ],
+  "outputs":      [ ... ],
+  "constraints":  [ ... ],
+  "tags":         [ ... ],
+  "reference":    { ... }
+}
+```
+
+| Field | Type | Required | Notes |
+|---|---|---|---|
+| `name` | string | yes | MUST equal filename stem (no `.json`) |
+| `description` | string | yes | One-line natural language description: what the op does, source model, deployment context |
+| `axes` | object | yes | Map of axis_name → axis spec |
+| `inputs` | list of objects | yes | Input tensor declarations |
+| `outputs` | list of objects | yes | Output tensor declarations |
+| `constraints` | list of strings | optional | Inter-axis constraints (natural language or symbolic) |
+| `tags` | list of strings | yes | Metadata; see Tag taxonomy below |
+| `reference` | object | yes | PyTorch reference impl; sees `code` field |
+
+## `axes` field
+
+```json
+"axes": {
+  "batch_size":      {"type": "var",   "description": "Number of sequences"},
+  "num_qo_heads":    {"type": "const", "value": 16, "description": "Query/output heads"},
+  "num_kv_heads":    {"type": "const", "value": 1,  "description": "Grouped KV heads"},
+  "head_dim":        {"type": "const", "value": 128},
+  "page_size":       {"type": "const", "value": 64},
+  "num_pages":       {"type": "var"},
+  "kv_seqlen":       {"type": "var",   "description": "KV cache length per sequence"},
+  ...
+}
+```
+
+Per-axis sub-schema:
+
+| Sub-field | Type | When | Notes |
+|---|---|---|---|
+| `type` | `"const"` or `"var"` | always | `const` = compile-time fixed (e.g. head_dim, sm_arch), captured in the def name; `var` = workload-time variable (batch, seq_len) |
+| `value` | int / float / string | when `type=="const"` | The fixed value |
+| `description` | string | optional | Human-readable purpose |
+
+## `inputs` and `outputs` fields
+
+Both are lists of tensor specs:
+
+```json
+"inputs": [
+  {
+    "name":       "q",
+    "dtype":      "bfloat16",
+    "shape":      ["batch_size", "num_qo_heads", "head_dim"]
+  },
+  {
+    "name":       "k_cache",
+    "dtype":      "bfloat16",
+    "shape":      ["num_pages", "page_size", "num_kv_heads", "head_dim"]
+  },
+  {
+    "name":       "kv_indptr",
+    "dtype":      "int32",
+    "shape":      ["len_indptr"]
+  },
+  {
+    "name":       "sm_scale",
+    "dtype":      "float32",
+    "shape":      []          // scalar
+  }
+]
+```
+
+Per-tensor sub-schema:
+
+| Sub-field | Notes |
+|---|---|
+| `name` | Variable name in the reference code AND wrapper signature |
+| `dtype` | Strings: `bfloat16`, `float16`, `float32`, `int32`, `int64`, `fp8_e4m3fn`, `fp8_e5m2`, … |
+| `shape` | List of strings; each entry is either an axis name (resolved at runtime) or a literal integer; empty `[]` for scalars |
+
+Special note: the input order is the function-signature order. Some tensor inputs may be passed via the workload `safetensors` `tensor_key` field; consult `reference.code` for the actual call.
+
+## `constraints` field
+
+List of natural-language strings checked at runtime by the runner before launching:
+
+```json
+"constraints": [
+  "len_indptr == batch_size + 1",
+  "num_kv_indices == kv_indptr[-1].item()"
+]
+```
+
+These are not parsed; they are advisory comments. The runner doesn't enforce them — it's the workload generator's responsibility to satisfy them.
+
+## `tags` field — taxonomy
+
+Tags are strings of the form `<prefix>:<value>`:
+
+| Prefix | Allowed values | Purpose |
+|---|---|---|
+| `stage:` | `decode`, `prefill`, `mtp`, `sparse_attention`, `topk_indexer` | Inference stage |
+| `status:` | `verified`, `unverified`, `reference` | Curation status (verified = was actually produced by an inference run with confirmed correctness) |
+| `model:` | `deepseek-v3`, `deepseek-r1`, `qwen3-235b`, `llama-3.1-70b`, `llama-3.2-3b`, `gemma-3-27b`, `kimi-k2`, `qwen3-next`, `nemotron-h-8b`, ... | Source model(s); a Definition may serve multiple models |
+| `fi_api:` | e.g. `flashinfer.mla.BatchMLAPagedAttentionWrapper`, `flashinfer.decode.BatchDecodeWithPagedKVCacheWrapper` | The FlashInfer Python API the def is modeled after |
+| `tp:` | `1`, `2`, `4`, `8`, `16` | Assumed tensor-parallel slicing |
+
+Additional tags occasionally seen but not formally part of the taxonomy: `quant:`, `fi_module:`, etc. These are advisory.
+
+## `reference` field
+
+Embeds the PyTorch reference implementation as a string of source code:
+
+```json
+"reference": {
+  "code": "import torch\n\ndef run(q, k_cache, v_cache, kv_indptr, kv_indices, sm_scale):\n    ...\n    return out, lse\n",
+  "language": "python"
+}
+```
+
+| Sub-field | Notes |
+|---|---|
+| `code` | Full Python source defining `run(...)` (or whatever the entry point is). Must be self-contained — runner will exec it in an isolated context |
+| `language` | Currently only `python` is used |
+
+Convention: the reference function is named `run`. Its signature is the canonical contract for any wrapper Solution.
+
+## Worked example: `mla_paged_decode_h16_ckv512_kpe64_ps1`
+
+```json
+{
+  "name": "mla_paged_decode_h16_ckv512_kpe64_ps1",
+  "description": "Batched Multi-head Latent Attention decode with a paged KV cache. Captured from DeepSeek V3 at TP=8.",
+  "axes": {
+    "batch_size":   {"type": "var"},
+    "num_qo_heads": {"type": "const", "value": 16},
+    "ckv_dim":      {"type": "const", "value": 512},
+    "kpe_dim":      {"type": "const", "value": 64},
+    "page_size":    {"type": "const", "value": 1},
+    "num_pages":    {"type": "var"},
+    "kv_seqlen":    {"type": "var"}
+  },
+  "inputs": [
+    {"name": "q_nope", "dtype": "bfloat16", "shape": ["batch_size", "num_qo_heads", "ckv_dim"]},
+    {"name": "q_pe",   "dtype": "bfloat16", "shape": ["batch_size", "num_qo_heads", "kpe_dim"]},
+    {"name": "ckv_cache", "dtype": "bfloat16", "shape": ["num_pages", "page_size", "ckv_dim"]},
+    {"name": "kpe_cache", "dtype": "bfloat16", "shape": ["num_pages", "page_size", "kpe_dim"]},
+    {"name": "kv_indptr",  "dtype": "int32", "shape": ["len_indptr"]},
+    {"name": "kv_indices", "dtype": "int32", "shape": ["num_kv_indices"]},
+    {"name": "sm_scale",   "dtype": "float32", "shape": []}
+  ],
+  "outputs": [
+    {"name": "output", "dtype": "bfloat16", "shape": ["batch_size", "num_qo_heads", "ckv_dim"]},
+    {"name": "lse",    "dtype": "float32",  "shape": ["batch_size", "num_qo_heads"]}
+  ],
+  "constraints": [
+    "len_indptr == batch_size + 1",
+    "num_kv_indices == kv_indptr[-1].item()"
+  ],
+  "tags": [
+    "stage:decode",
+    "status:verified",
+    "model:deepseek-v3",
+    "model:deepseek-r1",
+    "fi_api:flashinfer.mla.BatchMLAPagedAttentionWrapper",
+    "tp:8"
+  ],
+  "reference": {
+    "language": "python",
+    "code": "import torch\n\ndef run(q_nope, q_pe, ckv_cache, kpe_cache, kv_indptr, kv_indices, sm_scale):\n    ..."
+  }
+}
+```
+
+---
+
+## Quick lookup: where to find what when writing a Solution
+
+| Question while writing wrapper | Look in Definition JSON at |
+|---|---|
+| What are the function args? | `inputs[].name` (in order) |
+| What dtype must I produce as output? | `outputs[].dtype` |
+| What's the LSE shape? | `outputs[]` where `name == "lse"` |
+| Is sm_scale a scalar I receive, or do I compute it? | `inputs[]` — if `sm_scale` is in inputs, USE it; do NOT recompute |
+| What's the KV layout? | `inputs[].shape` for the cache tensors (paged: `[P, ps, H_kv, D]`; ragged: `[total, H_kv, D]`; MLA paged: `[P, ps, ckv_dim]` + `[P, ps, kpe_dim]`) |
+| Does causal mask apply? | Definition `name` contains `causal` or `description` mentions it |
+| Should I expand GQA `H_kv → H_q`? | Yes if your underlying lib only supports MHA; check `num_qo_heads` vs `num_kv_heads` axes |
+| What does the reference impl look like? | `reference.code` — read it to understand exact semantics |

skills/add-flashinfer-solution/reference/solution_schema.md

@@ -0,0 +1,195 @@
+# Solution JSON Schema (full reference)
+
+Each Solution JSON file lives at `solutions/<author>/<op_type>/<def_name>/<solution_name>.json`. It declares one implementation of a Definition, including its source code (embedded in the JSON) and runtime spec.
+
+## Top-level schema
+
+```json
+{
+  "name":       "<string>",
+  "definition": "<string>",
+  "author":     "<string>",
+  "spec":       { ... },
+  "sources":    [ ... ]
+}
+```
+
+| Field | Type | Required | Notes |
+|---|---|---|---|
+| `name` | string | yes | Solution identifier (unique within `<author>/<op_type>/<def_name>/`) |
+| `definition` | string | yes | MUST equal a Definition `name` exactly |
+| `author` | string | yes | Subdir name under `solutions/`; pick one stable identifier per team / lab |
+| `spec` | object | yes | Runtime metadata |
+| `sources` | list of objects | yes | Embedded source code files |
+
+## `name` conventions
+
+Common patterns observed in the public dataset:
+
+| Pattern | Used when |
+|---|---|
+| `flashinfer_wrapper_<6hex>` | Reserved for the official `baseline` author — calls FlashInfer Python API directly |
+| `<lib>_<op_type>_v<N>` | Hand-written wrapper around a third-party lib, e.g. `fa3_gqa_paged_decode_v1`, `sglang_mla_decode_v1`, `fla_gdn_decode_v1` |
+| `<author_short>_<lang>_<6hex>` | LLM-generated implementations, e.g. `gpt-5_cuda_5eb89c`, `claude-opus-4-1_triton_a98005` |
+
+Pick a name pattern that conveys lib + op + variant; bump version (`v2`) when changing the underlying impl meaningfully.
+
+## `spec` field
+
+```json
+"spec": {
+  "language":                  "python",
+  "target_hardware":           ["NVIDIA H100", "NVIDIA B200"],
+  "entry_point":               "main.py::run",
+  "dependencies":              ["flash-attn>=3.0.0"],
+  "destination_passing_style": false
+}
+```
+
+| Sub-field | Type | Notes |
+|---|---|---|
+| `language` | string | `python` (most common, even when wrapping CUDA/Triton) / `triton` / `cuda` / `tilelang` / `tvm_ffi` |
+| `target_hardware` | list of strings | Allowed GPU arches; runner refuses to run on unlisted hardware. Common values: `"NVIDIA H100"`, `"NVIDIA H200"`, `"NVIDIA B200"`, `"NVIDIA L40"`, `"NVIDIA A100"` |
+| `entry_point` | string | `<file>::<function>`; default convention is `main.py::run` |
+| `dependencies` | list of strings | Pip-installable packages required at runtime. Empty list `[]` if all needed code is vendored in `sources` |
+| `destination_passing_style` | bool | `false` (default): entry function returns a tuple of output tensors. `true`: outputs are pre-allocated and passed in as additional args; entry function modifies in place and returns nothing |
+
+### Notes on each sub-field
+
+#### `language`
+The runner uses this only for documentation; the actual entry point loading uses `entry_point` and Python's import mechanism. Even Triton / CUDA solutions usually have `language: python` because their `main.py` is a Python wrapper that imports / launches the underlying kernel.
+
+#### `target_hardware`
+The runner introspects current GPU via `torch.cuda.get_device_name(0)`. Examples of returned strings:
+- `"NVIDIA H100 PCIe"` — note: PCIe vs SXM both report `H100`-prefixed strings; matching is by prefix
+- `"NVIDIA H100 80GB HBM3"`
+- `"NVIDIA B200"`
+
+Use `["NVIDIA H100", "NVIDIA B200"]` to allow both Hopper and Blackwell.
+
+#### `entry_point`
+Format: `<filename_relative_to_sources>::<function_name>`. The function is loaded via `importlib`. Default: `main.py::run`.
+
+#### `dependencies`
+Listed packages are NOT auto-installed by the runner; they must be present in the Python environment beforehand. Use `pip install --target /tmp/pip-pkgs <pkg>` and `export PYTHONPATH=/tmp/pip-pkgs:$PYTHONPATH` for ephemeral envs.
+
+For a fully self-contained Solution, leave `dependencies: []` and embed all required source files into `sources` (vendor the kernel).
+
+#### `destination_passing_style`
+- `false` (default):
+  ```python
+  def run(q, k_cache, v_cache, ..., sm_scale):
+      out = ...
+      lse = ...
+      return out, lse
+  ```
+- `true`:
+  ```python
+  def run(q, k_cache, v_cache, ..., sm_scale, output, lse):
+      output.copy_(...)
+      lse.copy_(...)
+  ```
+
+Use `true` when working with kernels that strictly require pre-allocated output (e.g. some Triton kernels). Most wrappers prefer `false` for simplicity.
+
+## `sources` field
+
+Embeds the entire source tree of the Solution as a JSON array:
+
+```json
+"sources": [
+  {"path": "main.py",       "content": "<full content as Python string>"},
+  {"path": "kernel.triton", "content": "..."},
+  {"path": "vendored.py",   "content": "..."}
+]
+```
+
+| Sub-field | Notes |
+|---|---|
+| `path` | Relative to the Solution's directory; use forward slashes for nested files |
+| `content` | Raw file content as a UTF-8 string (escape backslashes and newlines per JSON spec) |
+
+The runner extracts `sources` to a temp dir at run time; the entry function is loaded from there. Relative imports between files in `sources` work as expected if `main.py` includes:
+
+```python
+import os, sys
+_HERE = os.path.dirname(os.path.abspath(__file__))
+if _HERE not in sys.path:
+    sys.path.insert(0, _HERE)
+```
+
+## Worked example: minimal Solution
+
+For a Solution at `solutions/acme-research/gqa_paged/gqa_paged_decode_h32_kv8_d128_ps1/my_fa3_v1.json`:
+
+```json
+{
+  "name": "my_fa3_v1",
+  "definition": "gqa_paged_decode_h32_kv8_d128_ps1",
+  "author": "acme-research",
+  "spec": {
+    "language": "python",
+    "target_hardware": ["NVIDIA H100", "NVIDIA B200"],
+    "entry_point": "main.py::run",
+    "dependencies": ["flash-attn>=3.0.0"],
+    "destination_passing_style": false
+  },
+  "sources": [
+    {
+      "path": "main.py",
+      "content": "import math\nimport torch\nfrom flash_attn_3 import flash_attn_with_kvcache\n\n\ndef run(q, k_cache, v_cache, kv_indptr, kv_indices, sm_scale):\n    # ... wrapper body ...\n    return out, lse\n"
+    }
+  ]
+}
+```
+
+## Building a Solution JSON from on-disk files
+
+There's no standalone CLI to do this in the public 0.6.x flashinfer-bench, so a tiny Python script is fine:
+
+```python
+import json, os
+from pathlib import Path
+
+solution_dir = Path("solutions/acme-research/gqa_paged/gqa_paged_decode_h32_kv8_d128_ps1")
+out_json     = solution_dir / "my_fa3_v1.json"
+
+sources = []
+for p in sorted(solution_dir.glob("**/*")):
+    if p.is_file() and p.name != out_json.name and p.suffix in (".py", ".cu", ".triton", ".cpp", ".h"):
+        sources.append({
+            "path": str(p.relative_to(solution_dir)),
+            "content": p.read_text(),
+        })
+
+doc = {
+    "name": "my_fa3_v1",
+    "definition": "gqa_paged_decode_h32_kv8_d128_ps1",
+    "author": "acme-research",
+    "spec": {
+        "language": "python",
+        "target_hardware": ["NVIDIA H100", "NVIDIA B200"],
+        "entry_point": "main.py::run",
+        "dependencies": ["flash-attn>=3.0.0"],
+        "destination_passing_style": False,
+    },
+    "sources": sources,
+}
+
+out_json.write_text(json.dumps(doc, indent=2))
+```
+
+Run from the directory containing the Solution sources; produces a JSON ready for the runner.
+
+## Field-level checklist before committing a Solution JSON
+
+- [ ] `name` is unique within the target def directory
+- [ ] `definition` matches the actual Definition name exactly (no typos, no prefix/suffix drift)
+- [ ] `author` matches an existing author dir (else create one)
+- [ ] `spec.target_hardware` includes the hardware you actually tested on
+- [ ] `spec.entry_point` resolves correctly (function exists in the named file)
+- [ ] `spec.dependencies` list is honest — every `import` in `main.py` is either in `dependencies` or in `sources`
+- [ ] `spec.destination_passing_style` matches the actual entry signature
+- [ ] `sources` contains every file the entry function imports (use AST or `grep -E "^(import|from)"` to audit)
+- [ ] `sources[].content` is valid UTF-8 and parses as the right language (`python -c "exec(open(p).read())"` for Python; CUDA / Triton parsing requires the relevant compiler)
+- [ ] No absolute paths in source content — use `os.path.dirname(__file__)` for relative loads

skills/add-flashinfer-solution/reference/visualization.md

@@ -0,0 +1,207 @@
+# Visualization Reference
+
+Two paths: public site (read-only, official traces only) and local web UI (sees your local traces, full functionality).
+
+---
+
+## 1. Public site
+
+URL: **https://bench.flashinfer.ai**
+
+Reads the published `flashinfer-trace` HF dataset directly. Shows traces from authors that have been merged upstream:
+- `baseline` (FlashInfer official)
+- `claude-opus-4-1-20250805`, `gemini-2.5-pro`, `gpt-5-2025-08-07`, `gpt-o3` (LLM-generated)
+- ... plus any author whose contributions land on the dataset's `main` branch
+
+### Pages
+- `/` — homepage with three sections: Leaderboard / Models / Kernels
+- `/kernels/<def_name>` — per-Definition page: Solutions table, fast_p curve over all workloads, top-5 by speedup
+- `/models/<model_id>` — per-model coverage: which Definitions belong, status
+- `/viewer` — paste a single Trace JSON to inspect the raw structure
+
+### `/viewer` page details
+Accepts a **single** Trace JSON object. Most jsonl files have many lines (one Trace each); take just one line:
+
+```bash
+sed -n '1p' traces/<author>/<op_type>/<def_name>.jsonl > /tmp/single.json
+# Then copy /tmp/single.json contents into the textarea on /viewer
+```
+
+Pasting the whole jsonl raises `Unexpected non-whitespace character after JSON at position …`.
+
+---
+
+## 2. Local web UI (recommended for local development)
+
+The web UI is the production source of bench.flashinfer.ai, vendored under `flashinfer-bench/web/`. Running it locally lets you visualize traces from a local `flashinfer-trace` clone, including authors that haven't been merged upstream.
+
+### 2.1 Setup
+
+```bash
+# 1. Get pnpm (the project uses pnpm workspaces)
+mkdir -p ~/bin
+curl -fsSL -o ~/bin/pnpm \
+    https://github.com/pnpm/pnpm/releases/download/v9.15.0/pnpm-linuxstatic-x64
+chmod +x ~/bin/pnpm
+export PATH=~/bin:$PATH
+
+# 2. Configure pnpm to keep its store on scratch (~ 1 GB cache, plus 1.9 GB node_modules)
+SCRATCH=/home/scratch.<user>
+mkdir -p $SCRATCH/.pnpm-store
+pnpm config set store-dir $SCRATCH/.pnpm-store
+
+# 3. Clone flashinfer-bench codebase (if not already)
+cd $SCRATCH/kernel_arena
+git clone https://github.com/flashinfer-ai/flashinfer-bench.git
+
+# 4. Install web app dependencies (~2-3 min)
+cd $SCRATCH/kernel_arena/flashinfer-bench/web
+pnpm install
+```
+
+### 2.2 Point data loader at your local dataset
+
+The web app's data loader resolves the trace dataset path in this priority order (`apps/web/lib/data-loader.ts`):
+1. `FLASHINFER_TRACE_PATH` env var (explicit override)
+2. `FIB_DATASET_PATH` env var (set by the prebuild script)
+3. Local repo's `flashinfer_trace/` dir (`web/apps/web` → `../../../flashinfer_trace`)
+4. `/tmp/flashinfer-trace` (fallback)
+
+Belt-and-suspenders: set the env var AND symlink at the fallback paths:
+
+```bash
+export FIB_DATASET_PATH=$SCRATCH/kernel_arena/flashinfer-trace
+ln -sfn $FIB_DATASET_PATH /tmp/flashinfer-trace
+ln -sfn $FIB_DATASET_PATH $SCRATCH/kernel_arena/flashinfer-bench/flashinfer_trace
+```
+
+### 2.3 Start the dev server
+
+```bash
+cd $SCRATCH/kernel_arena/flashinfer-bench/web/apps/web
+nohup pnpm dev > /tmp/dev.log 2>&1 &
+
+# Wait until ready (~60-90 s on a frontend-only host)
+until grep -q "Ready in" /tmp/dev.log; do sleep 2; done
+echo "Open http://localhost:3000"
+```
+
+The dev server runs only `apps/web` (skip `apps/docs` to save resources).
+
+### 2.4 Caveats of dev mode
+
+- **First page load is slow** — Next.js compiles each route on demand. The first `GET /` typically takes 200–400 s; the home page SSR fetches all 137+ Definitions × N solutions per Definition for the leaderboard. Subsequent loads are 5–20 s
+- **Build process competing for CPU**: avoid running `pnpm build` in parallel with `pnpm dev`; it will stretch compile time to many minutes
+- **Browser shows endless spinner**: usually first-load compilation. Check `tail -f /tmp/dev.log`; once you see `GET /<path> 200 in <ms>` the page is ready
+
+### 2.5 Production build (recommended for sustained use)
+
+For more than ~30 minutes of use, build once and run a production server:
+
+```bash
+cd $SCRATCH/kernel_arena/flashinfer-bench/web/apps/web
+
+# Build (takes 8–15 min on a typical frontend host; produces .next/ ~1 GB)
+pnpm build
+
+# Start production server (instant; pages are SSG / ISR cached)
+nohup pnpm start > /tmp/prod.log 2>&1 &
+```
+
+Production mode:
+- Pages render in <500 ms (vs 200+ s in dev)
+- Hot-reload on file changes is OFF; rebuild required after data changes (re-run `pnpm build`)
+
+### 2.6 Page reference
+
+| Path | Use |
+|---|---|
+| `http://localhost:3000` | Leaderboard table + fast_p curve + Models grid + Kernels list |
+| `http://localhost:3000/kernels/<def_name>` | Per-Definition Solutions table + fast_p curve over workloads + top-5 by speedup |
+| `http://localhost:3000/models/<model_id>` | Per-model coverage page |
+| `http://localhost:3000/viewer` | Paste single Trace JSON for raw inspection |
+| `http://localhost:3000/docs/api/python/` | Embedded Sphinx docs of `flashinfer_bench` Python API |
+
+---
+
+## 3. SSH port forwarding
+
+If the dev server runs on a remote machine and you browse from your laptop:
+
+### 3.1 VS Code Remote-SSH (easiest)
+- VS Code auto-detects port 3000 and forwards it to localhost on your laptop
+- Look at the **PORTS** tab at the bottom; if not auto-forwarded, click `Forward a Port` and enter `3000`
+
+### 3.2 Manual SSH tunnel
+```bash
+# From your laptop:
+ssh -L 3000:localhost:3000 <user>@<remote-host>
+# Then open http://localhost:3000 in your browser
+```
+
+For HTTP keep-alive across the tunnel:
+```bash
+ssh -L 3000:localhost:3000 -o ServerAliveInterval=60 -o ServerAliveCountMax=3 <user>@<remote-host>
+```
+
+---
+
+## 4. Sharing a trace with collaborators (no full UI required)
+
+Three options:
+
+### 4.1 Send the jsonl file
+```bash
+# One file per (author × op_type × def_name); typically 50-200 KB
+scp $TRACE_ROOT/traces/<author>/<op_type>/<def_name>.jsonl reviewer@host:/tmp/
+# Reviewer runs the local web UI or pastes individual rows into /viewer
+```
+
+### 4.2 Use the public Viewer
+Take a single Trace JSON line and paste into https://bench.flashinfer.ai/viewer. Reviewer gets the same structured inspection without setup.
+
+```bash
+sed -n '<row_number>p' $TRACE_ROOT/traces/<author>/<op_type>/<def_name>.jsonl > /tmp/single_trace.json
+# Open the file, copy contents, paste at https://bench.flashinfer.ai/viewer
+```
+
+### 4.3 Open a PR to flashinfer-trace
+Once the Solution is merged on `main`, the public site picks it up automatically (next dataset rebuild). Workflow:
+- Fork `huggingface.co/datasets/flashinfer-ai/flashinfer-trace`
+- Add the Solution JSON, run benchmark, commit produced traces
+- Open a PR; maintainers review
+
+---
+
+## 5. Programmatic access to traces
+
+If you want to build custom dashboards, just read the jsonl directly:
+
+```python
+import json
+from pathlib import Path
+
+trace_root = Path("/home/scratch.<user>/kernel_arena/flashinfer-trace")
+trace_file = trace_root / "traces/<author>/<op_type>/<def_name>.jsonl"
+
+traces = [json.loads(l) for l in trace_file.read_text().splitlines()]
+for t in traces:
+    print(
+        t["definition"], t["solution"],
+        t["evaluation"]["status"],
+        t["evaluation"].get("performance", {}).get("speedup_factor"),
+    )
+```
+
+Or use the framework's helper:
+
+```python
+from flashinfer_bench.data import TraceSet
+ts = TraceSet.from_path(trace_root)
+for def_name in ts.definitions:
+    best = ts.get_best_trace(def_name)
+    if best:
+        print(def_name, "→", best.solution, best.evaluation.performance.speedup_factor)
+```
+
+`TraceSet` provides filter / best / score queries; see `flashinfer_bench/data/trace_set.py` for the full API.

skills/add-flashinfer-solution/reference/wrapper_gotchas.md

@@ -0,0 +1,243 @@
+# Wrapper Gotchas (extended troubleshooting)
+
+Catalogued issues that have surfaced when wrapping kernels for `flashinfer-bench`. Each entry has: symptom → root cause → fix → diagnostic command.
+
+---
+
+## 1. Numerical / contract mismatches
+
+### 1.1 LSE base mismatch (natural log vs base-2)
+
+- **Symptom**: `INCORRECT_NUMERICAL`, `max_relative_error` ≈ `0.301` (i.e. `log10(2)`) on the LSE output specifically; output tensor itself is correct
+- **Root cause**: FlashInfer uses **base-2** LSE by convention (`lse = log2(sum_exp(logits * log2(e)))`). Many third-party libs (Flash Attention, naive Triton) emit **natural-log** LSE
+- **Fix**: in the wrapper, convert before returning:
+  ```python
+  import math
+  lse_b2 = lse_natural * (1.0 / math.log(2.0))
+  ```
+- **Diagnostic**: print both LSEs side-by-side; ratio should be exactly `log_2(e)` ≈ `1.4427`
+
+### 1.2 Lost / overridden `sm_scale`
+
+- **Symptom**: `INCORRECT_NUMERICAL` proportional to `1/sqrt(d)`; output is "almost right" but uniformly off
+- **Root cause**: third-party API was called without explicitly passing the supplied `sm_scale`, so the lib defaulted to `1/sqrt(head_dim)`. FlashInfer Definitions sometimes use a different scale (e.g. for absorbed MLA prefill the scale includes the rope-dim mixing factor)
+- **Fix**: always pass `sm_scale` (or whatever the lib calls it: `softmax_scale`, `scale`, `sm_scale_for_q`, …) explicitly:
+  ```python
+  out = F.scaled_dot_product_attention(q, k, v, scale=sm_scale)
+  out = flash_attn_with_kvcache(..., softmax_scale=sm_scale, ...)
+  ```
+- **Diagnostic**: temporarily set `sm_scale = 1.0` in the workload; if the wrapper still produces non-trivially scaled output, scale is being silently overridden somewhere
+
+### 1.3 GQA expansion along wrong axis
+
+- **Symptom**: `INCORRECT_NUMERICAL` only on long-KV workloads; short-KV passes
+- **Root cause**: `repeat_interleave` to expand `H_kv → H_q` was applied along the wrong axis. Common confusion: `[B, S, H_kv, D]` vs `[B, H_kv, S, D]`
+- **Fix**: always check the target lib's expected layout, then expand exactly along the head axis:
+  ```python
+  # If layout is [B, S, H, D]:
+  k = k.repeat_interleave(H_q // H_kv, dim=2)  # not dim=1!
+  # If layout is [B, H, S, D]:
+  k = k.repeat_interleave(H_q // H_kv, dim=1)
+  ```
+- **Diagnostic**: print `k.shape` vs `q.shape` after expansion — head dims must match
+
+### 1.4 KV layout direction (k-first vs k-last) for recurrent state kernels
+
+- **Symptom**: Output garbage — recurrent state values look uniformly wrong, not just numerically off
+- **Root cause**: FLA-family kernels accept state as `[B, HV, K, V]` (k-first, default) or `[B, HV, V, K]` (k-last). Many Definition specs use k-last layout (Qwen3-Next GDN), but FLA's default is k-first
+- **Fix**: pass `transpose_state_layout=True` to the FLA op explicitly when the Definition uses k-last:
+  ```python
+  o, new_state = fused_recurrent_gated_delta_rule(
+      ..., transpose_state_layout=True
+  )
+  ```
+- **Diagnostic**: check the Definition `inputs[]` shape for the state tensor; the last two dim names will tell you (e.g. `[batch, head, k_dim, v_dim]` = k-first)
+
+### 1.5 Custom gating not pre-applied
+
+- **Symptom**: Output bias tracks closer to zero than expected
+- **Root cause**: Some lib ops require a pre-computed gating value (e.g. `beta = sigmoid(b)` for FLA gated_delta_rule), but Definitions hand you the raw input
+- **Fix**: do the activation in the wrapper:
+  ```python
+  beta = torch.sigmoid(b)
+  out, _ = fused_recurrent_gated_delta_rule(..., beta=beta, ...)
+  ```
+- **Diagnostic**: read both the Definition `reference.code` AND the lib's docstring; differences in gating semantics are a common source of confusion
+
+### 1.6 Double L2-norm
+
+- **Symptom**: Output magnitude consistently ~half of reference
+- **Root cause**: Definition's `reference.code` already includes L2 norm, AND the lib's `use_qk_l2norm_in_kernel=True` flag was passed → applied twice
+- **Fix**: confirm with one source of truth; either:
+  ```python
+  # Lib does the norm — don't pre-norm in wrapper
+  out = lib_op(q_raw, k_raw, ..., use_qk_l2norm_in_kernel=True)
+  # OR pre-norm in wrapper, lib doesn't
+  q_normed = F.normalize(q_raw, dim=-1)
+  k_normed = F.normalize(k_raw, dim=-1)
+  out = lib_op(q_normed, k_normed, ..., use_qk_l2norm_in_kernel=False)
+  ```
+- **Diagnostic**: compare `out.abs().mean()` with reference; ratio of ~0.5 is the smoking gun
+
+### 1.7 Q tensor extra dim (4D vs 3D)
+
+- **Symptom**: shape error `Expected 3-d but got 4-d` or vice versa
+- **Root cause**: FlashInfer's decode wrappers use 3-D Q (`[B, H, D]`); FA3 expects 4-D Q (`[B, S=1, H, D]`). The wrapper needs to add or remove that S dim
+- **Fix**:
+  ```python
+  q_4d = q.unsqueeze(1)              # [B, H, D] -> [B, 1, H, D]
+  out_4d = flash_attn_with_kvcache(q_4d, ...)
+  out = out_4d.squeeze(1)            # [B, 1, H, D] -> [B, H, D]
+  ```
+
+---
+
+## 2. Runtime / framework
+
+### 2.1 Worker subprocess swallowed traceback
+
+- **Symptom**: Trace status `RUNTIME_ERROR` with no useful error message in logs (`--log-level DEBUG` shows the same)
+- **Root cause**: `flashinfer-bench` runs each Solution in an isolated subprocess; uncaught exceptions become a status enum, the actual traceback is lost
+- **Fix (diagnostic only)**: reproduce outside the runner. Write a minimal script that imports the wrapper directly and calls it with manually-loaded workload tensors:
+  ```python
+  # 17_direct_repro.py
+  import torch
+  from safetensors.torch import load_file
+  import sys; sys.path.insert(0, "solutions/acme/op/def_name")
+  from main import run
+
+  inputs = load_file("blob/workloads/op/def_name/def_name_<uuid>.safetensors")
+  q = inputs["q"]; k = inputs["k_cache"]; ...
+  out = run(q, k, ..., sm_scale=0.08838)
+  print(out)
+  ```
+  Run with `python -u 17_direct_repro.py` to see the real traceback.
+
+### 2.2 Three-strikes Solution skip
+
+- **Symptom**: Mid-way through a long run, you see `Skipping solution X due to 3 consecutive failures`
+- **Root cause**: `flashinfer-bench` short-circuits a Solution after 3 consecutive errors, treating it as broken — this affects all subsequent workloads for that Solution
+- **Fix**: address the root error first; then either re-run with a smaller `--num-trials` to confirm, or delete the Solution's traces and re-run
+- **Diagnostic**: count `RUNTIME_ERROR` rows in the trace jsonl per Solution; if the first 3 fail, expect skip thereafter
+
+### 2.3 PersistentRunner stale baseline cache
+
+- **Symptom**: Re-running with a corrected Solution still shows the same speedup numbers
+- **Root cause**: `PersistentRunner` (default for `flashinfer-bench run`) caches the reference baseline output keyed on `(definition, workload.uuid)`. If the worker subprocess crashed mid-run, that cache might be stale
+- **Fix**: explicitly use the isolated runner:
+  ```bash
+  flashinfer-bench run --runner=isolated ...
+  ```
+  Or simply delete the trace file for that solution before re-running (so cached comparisons are regenerated)
+
+### 2.4 Vendored module import error
+
+- **Symptom**: `ModuleNotFoundError: No module named 'sglang_decode'` despite the file being in `sources`
+- **Root cause**: When the runner extracts `sources` to a temp dir, that dir is not on `sys.path`
+- **Fix**: at the top of `main.py`, add:
+  ```python
+  import os, sys
+  _HERE = os.path.dirname(os.path.abspath(__file__))
+  if _HERE not in sys.path:
+      sys.path.insert(0, _HERE)
+  from vendored_module import ...
+  ```
+
+### 2.5 `flashinfer-bench report visualize` AttributeError
+
+- **Symptom**: Calling `flashinfer-bench report visualize --local .` raises `AttributeError: 'Evaluation' object has no attribute 'get'`
+- **Root cause**: A bug in the public 0.6.x release: `cli/main.py:202` calls `trace.evaluation.get("status", ...)` but `trace.evaluation` is a Pydantic object, not a dict
+- **Workaround**: skip the CLI `visualize` subcommand; use `report best` / `report summary` for CLI-level inspection, and use the local web UI (Step 7 in the main SKILL doc) for the full visualization
+
+### 2.6 No `--max-workloads` flag
+
+- **Symptom**: You want to run only the first N workloads of a large Definition for quick iteration; flag does not exist
+- **Workaround**: temp-trim the workloads jsonl:
+  ```bash
+  WL=workloads/op/def.jsonl
+  cp "$WL" "$WL.bak"
+  head -10 "$WL.bak" > "$WL"
+  flashinfer-bench run ...
+  mv "$WL.bak" "$WL"
+  ```
+  Use a `bash trap "mv \"$WL.bak\" \"$WL\"" EXIT` to restore on script exit (including failure).
+
+---
+
+## 3. Environment / disk
+
+### 3.1 git-lfs returns pointer files instead of tensors
+
+- **Symptom**: `safetensors.SafetensorError: invalid header` when loading a workload tensor
+- **Root cause**: `git-lfs install --local` was not run; the file is the LFS pointer, not the actual tensor
+- **Fix**:
+  ```bash
+  cd flashinfer-trace
+  git-lfs install --local
+  git-lfs pull --include="blob/workloads/<op>/<def>/*"
+  ```
+  Verify: the file size should be > 1KB (pointer files are ~130 bytes):
+  ```bash
+  find blob/workloads -name "*.safetensors" -size +1k | wc -l
+  ```
+
+### 3.2 home quota full mid-run
+
+- **Symptom**: `OSError: [Errno 122] Disk quota exceeded` or `pip install` fails with `No space left on device`
+- **Root cause**: Many corporate environments have a 5-GB home quota
+- **Fix**: relocate everything to scratch:
+  ```bash
+  SCRATCH=/home/scratch.<user>/kernel_arena
+  mkdir -p $SCRATCH
+  mv ~/kernel_arena/flashinfer-trace  $SCRATCH/
+  ln -sfn $SCRATCH/flashinfer-trace   ~/kernel_arena/flashinfer-trace
+  # Also pip target:
+  export PIP_TARGET=/tmp/pip-pkgs    # /tmp is usually large
+  ```
+
+### 3.3 Stale flashinfer-bench install
+
+- **Symptom**: `ImportError: cannot import name 'apply' from 'flashinfer_bench'`
+- **Root cause**: pip cache picked up an older version
+- **Fix**:
+  ```bash
+  rm -rf $PIP_TARGET/flashinfer_bench*
+  pip install --target $PIP_TARGET --no-cache-dir flashinfer-bench
+  ```
+
+---
+
+## 4. Hardware-specific
+
+### 4.1 FlashInfer GDN CuTe DSL ABI mismatch (NGC PyTorch 24.10)
+
+- **Symptom**: `flashinfer.gdn` import succeeds but calling `gdn_decode(...)` raises `TypeError: 'NoneType' object is not callable`; introspection shows `flashinfer.gdn.run_pretranspose_decode is None`
+- **Root cause**: FlashInfer 0.6.x GDN uses CuTe DSL kernels that require NVRTC + a specific PyTorch ABI. NGC PyTorch 24.10 ships torch 2.11 with `_GLIBCXX_USE_CXX11_ABI=1`, mismatching the FlashInfer-shipped ABI; the kernel registry silently leaves the entry as `None`
+- **Workaround**: use FLA's `fused_recurrent_gated_delta_rule` instead (see `templates/linear_attention_main.py`); FLA is pure Triton, no ABI dependency
+
+### 4.2 FA3 wheel `undefined symbol`
+
+- **Symptom**: `import flash_attn_3` raises `undefined symbol: _ZNxxxxx` or similar
+- **Root cause**: The prebuilt FA3 wheel was compiled against a different libstdc++ ABI than the PyTorch in your container
+- **Fix**: source-build FA3:
+  ```bash
+  git clone https://github.com/Dao-AILab/flash-attention.git
+  cd flash-attention/hopper
+  python setup.py install
+  ```
+  This compiles against the active PyTorch's ABI. Takes ~15–25 min on H100 with 64 cores; one-time cost.
+
+### 4.3 FA3 page_size=1 slow path
+
+- **Symptom**: FA3 GQA decode passes correctness but is slower than FlashInfer baseline at page_size=1
+- **Root cause**: FA3 supports arbitrary page_size, but the TMA fast path requires `page_size % kBlockN == 0` (kBlockN typically 64 or 128). page_size=1 falls back to a `cp.async`-based slow path
+- **Fix / workaround**: this is a known limitation; benchmark both ps=1 and ps=64 variants of the Definition and report both. For production deployment with FA3, prefer ps=64 if the workload allows.
+
+### 4.4 SM-arch wrapper hardcoded but runtime is different SM
+
+- **Symptom**: Solution `RUNTIME_ERROR` only on B200 / SM100, works on H100
+- **Root cause**: Wrapper hardcodes `arch_capability(9, 0)` or builds a Triton kernel without `tl.constexpr` arch dispatch
+- **Fix**:
+  - In `spec.target_hardware`, include only the GPUs you actually verified
+  - If wrapping a Triton kernel, ensure all `triton.autotune` configs cover the target archs; or use `triton.heuristics`
+  - For CUDA: build with `-gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100`

skills/add-flashinfer-solution/templates/dense_baseline_main.py

@@ -0,0 +1,94 @@
+"""
+Template A: Dense Baseline Wrapper
+==================================
+
+Use this template when wrapping a generic dense attention impl (PyTorch SDPA,
+cuDNN frontend, etc.) as a reference baseline Solution. Demonstrates:
+
+  * paged KV cache → contiguous batch (per-sequence index lookup)
+  * GQA expansion (replicate kv heads to query heads via repeat_interleave)
+  * sm_scale forwarding
+  * 3-D Q tensor (FlashInfer convention) — no S=1 unsqueeze needed
+  * No LSE output (this template is decode-only, no LSE)
+
+Target Definition example: gqa_paged_decode_h32_kv8_d128_ps1
+  inputs:  q [B, H_q, D], k_cache [P, ps, H_kv, D], v_cache [P, ps, H_kv, D],
+           kv_indptr [B+1], kv_indices [num_kv_indices], sm_scale (scalar)
+  outputs: output [B, H_q, D]
+"""
+from __future__ import annotations
+
+import torch
+import torch.nn.functional as F
+
+
+def run(
+    q,                # [B, H_q, D] bfloat16
+    k_cache,          # [num_pages, page_size, H_kv, D] bfloat16
+    v_cache,          # [num_pages, page_size, H_kv, D] bfloat16
+    kv_indptr,        # [B+1] int32 — flat index into kv_indices
+    kv_indices,       # [num_kv_indices] int32 — physical page numbers
+    sm_scale,         # scalar float32
+):
+    B, H_q, D = q.shape
+    _, page_size, H_kv, _ = k_cache.shape
+    assert H_q % H_kv == 0, f"GQA: H_q ({H_q}) must be multiple of H_kv ({H_kv})"
+    G = H_q // H_kv  # group size
+
+    # --- 1. Paged → contiguous: gather pages per batch and concat ---
+    # SDPA wants dense [B, H, S, D]; we build it from the paged store.
+    # No batching of variable-length sequences is supported by SDPA, so we
+    # process each batch row separately and pad to max length, OR we loop.
+    # Looping is simplest for a baseline:
+    outs = []
+    for b in range(B):
+        s_start = kv_indptr[b].item()
+        s_end   = kv_indptr[b + 1].item()
+        seq_pages = kv_indices[s_start:s_end]                 # [n_pages_b]
+
+        # Gather pages → [n_pages_b * page_size, H_kv, D]
+        k_b = k_cache[seq_pages].reshape(-1, H_kv, D)         # [S_b, H_kv, D]
+        v_b = v_cache[seq_pages].reshape(-1, H_kv, D)
+
+        # GQA expand: [S_b, H_kv, D] → [S_b, H_q, D]
+        k_b = k_b.repeat_interleave(G, dim=1)
+        v_b = v_b.repeat_interleave(G, dim=1)
+
+        # Reshape for SDPA: [B=1, H, S, D]
+        q_b = q[b : b + 1].unsqueeze(2)                       # [1, H_q, 1, D]
+        k_b = k_b.permute(1, 0, 2).unsqueeze(0)               # [1, H_q, S_b, D]
+        v_b = v_b.permute(1, 0, 2).unsqueeze(0)               # [1, H_q, S_b, D]
+
+        # --- 2. SDPA call (decode = causal mask is irrelevant since we have S_kv >> S_q=1) ---
+        out_b = F.scaled_dot_product_attention(
+            q_b, k_b, v_b,
+            attn_mask=None,
+            dropout_p=0.0,
+            is_causal=False,
+            scale=float(sm_scale),    # ← MUST pass; SDPA defaults to 1/sqrt(d)
+        )                                                      # [1, H_q, 1, D]
+
+        outs.append(out_b.squeeze(2).squeeze(0))               # [H_q, D]
+
+    output = torch.stack(outs, dim=0)                          # [B, H_q, D]
+    return output
+
+
+# Notes on adapting this template:
+#
+#  * For GQA paged PREFILL (instead of decode):
+#       - Q is [total_q, H_q, D] (ragged), or [B, S_q, H_q, D] (paged); check
+#         the Definition `inputs[0].shape`.
+#       - Apply causal mask: `is_causal=True` in F.scaled_dot_product_attention,
+#         or build a custom mask if the def specifies one.
+#
+#  * For MLA paged decode (no head dim in cache):
+#       - cache layout is [P, ps, ckv_dim] + [P, ps, kpe_dim], not [P, ps, H, D]
+#       - Q has 2 components: q_nope [B, H, ckv_dim] and q_pe [B, H, kpe_dim]
+#       - Reference pseudo-code: out = softmax(q_nope @ k_nope^T / sqrt(d)) @ v
+#                                  + softmax(q_pe @ k_pe^T / sqrt(d)) @ v
+#         (Read Definition.reference.code for exact formula.)
+#
+#  * If the def expects an LSE output:
+#       - SDPA does not return LSE; switch to FA / cuDNN / manual softmax + log
+#       - Remember LSE base-2: lse_b2 = lse_natural / math.log(2)

skills/add-flashinfer-solution/templates/dense_baseline_solution.json

@@ -0,0 +1,18 @@
+{
+  "name": "sdpa_paged_decode_v1",
+  "definition": "gqa_paged_decode_h32_kv8_d128_ps1",
+  "author": "<your-author-tag>",
+  "spec": {
+    "language": "python",
+    "target_hardware": ["NVIDIA H100", "NVIDIA H200", "NVIDIA B200", "NVIDIA L40", "NVIDIA A100"],
+    "entry_point": "main.py::run",
+    "dependencies": [],
+    "destination_passing_style": false
+  },
+  "sources": [
+    {
+      "path": "main.py",
+      "content": "<replace with full text of templates/dense_baseline_main.py, JSON-escaped (use python: json.dumps(open('main.py').read()))>"
+    }
+  ]
+}

skills/add-flashinfer-solution/templates/linear_attention_main.py

@@ -0,0 +1,86 @@
+"""
+Template B: External Python Lib Wrapper (FLA-style linear attention)
+====================================================================
+
+Use this template when wrapping a pip-installable third-party Python lib
+(`flash-linear-attention` aka `fla-core`, `flash-attn`, `xformers`, etc.) as
+a Solution. Demonstrates:
+
+  * Calling a third-party op via Python API
+  * Pre-activations the lib expects (e.g. sigmoid for beta gating)
+  * Fused-mode flags that must be set explicitly (e.g. use_gate_in_kernel)
+  * Layout flags (k-first vs k-last)
+  * Recurrent state input/output handling
+
+Target Definition example: gdn_decode_qk4_v8_d128_k_last
+  inputs:  q [B, T=1, HQ=4, K=128], k [B, T=1, HQ=4, K=128], v [B, T=1, HV=8, V=128],
+           state [B, HV, V, K] (k-last layout!), A_log [HV], a [B, T=1, HV],
+           dt_bias [HV], b [B, T=1, HV], scale (scalar)
+  outputs: output [B, T=1, HV, V], new_state [B, HV, V, K]
+"""
+from __future__ import annotations
+
+import torch
+
+# fla-core comes from: pip install fla-core
+from fla.ops.gated_delta_rule import fused_recurrent_gated_delta_rule
+
+
+def run(
+    q,            # [B, T, H_q, K]
+    k,            # [B, T, H_q, K]
+    v,            # [B, T, H_v, V]
+    state,        # [B, H_v, V, K]  ← k-last layout
+    A_log,        # [H_v]
+    a,            # [B, T, H_v]
+    dt_bias,      # [H_v]
+    b,            # [B, T, H_v]
+    scale,        # scalar float32
+):
+    # --- 1. Pre-compute beta = sigmoid(b)  (FLA's op does NOT do this internally) ---
+    beta = torch.sigmoid(b)
+
+    # --- 2. Call the FLA op with explicit fused-mode flags ---
+    output, new_state = fused_recurrent_gated_delta_rule(
+        q, k, v,
+        state,                        # initial state, in-place updated by op
+        g=a, A_log=A_log,             # gating raw inputs (NOT pre-applied)
+        dt_bias=dt_bias,
+        beta=beta,
+        scale=float(scale),
+
+        # ↓ All four flags below MUST be set explicitly for the standard def:
+        use_gate_in_kernel=True,            # let FLA fuse g_eff = exp(-exp(A_log)*softplus(g+dt_bias))
+        use_qk_l2norm_in_kernel=True,       # FLA does the qk l2norm; do NOT pre-norm in this wrapper
+        transpose_state_layout=True,        # def uses k-last layout; FLA's default is k-first
+    )
+
+    # output: [B, T, H_v, V]
+    # new_state: [B, H_v, V, K] (k-last, in-place modified)
+    return output, new_state
+
+
+# Notes on adapting this template to other linear-attention variants:
+#
+#  * For Mamba2 SSU (selective state update): use `fla.layers.mamba2`, but FLA
+#    delegates Mamba2 to upstream `mamba_ssm`. Install both: `pip install mamba-ssm fla-core`
+#
+#  * For RetNet, GLA, RWKV4/6/7: use the corresponding op under `fla.ops.<name>`,
+#    e.g. `fla.ops.rwkv7.fused_recurrent_rwkv7`. Each variant has its own gating
+#    semantics; consult the FLA docs.
+#
+#  * For DeltaNet (non-gated): use `fla.ops.delta_rule.fused_recurrent_delta_rule`,
+#    drop the `beta` and `g` / `A_log` / `dt_bias` args.
+#
+#  * For PREFILL (T > 1): switch to `fla.ops.gated_delta_rule.chunk_gated_delta_rule`
+#    instead of `fused_recurrent_*`. The chunk variant is faster for long sequences.
+#
+#  * For MTP (multi-token prediction): pass `cu_seqlens` to handle variable-length;
+#    note FLA does not have a dedicated MTP entry, but vLLM's fork adds
+#    `num_accepted_tokens` and `ssm_state_indices` parameters for spec decode.
+#
+# Common mistakes:
+#  * Forgetting `transpose_state_layout=True` → state values silently corrupted
+#  * Forgetting `use_gate_in_kernel=True` → gating not applied, output drifts
+#  * Pre-applying L2 norm in wrapper while also setting `use_qk_l2norm_in_kernel=True`
+#    → output magnitude is half of reference

skills/add-flashinfer-solution/templates/linear_attention_solution.json

@@ -0,0 +1,18 @@
+{
+  "name": "fla_gdn_decode_v1",
+  "definition": "gdn_decode_qk4_v8_d128_k_last",
+  "author": "<your-author-tag>",
+  "spec": {
+    "language": "python",
+    "target_hardware": ["NVIDIA H100", "NVIDIA H200", "NVIDIA B200"],
+    "entry_point": "main.py::run",
+    "dependencies": ["fla-core>=0.5.0"],
+    "destination_passing_style": false
+  },
+  "sources": [
+    {
+      "path": "main.py",
+      "content": "<replace with full text of templates/linear_attention_main.py, JSON-escaped>"
+    }
+  ]
+}

skills/add-flashinfer-solution/templates/vendored_kernel_main.py

@@ -0,0 +1,139 @@
+"""
+Template C: Vendored Kernel Wrapper (SGLang-style MLA decode)
+=============================================================
+
+Use this template when bringing in a Triton (or CUDA) kernel from another
+project (SGLang / vLLM / private) WITHOUT depending on the upstream package.
+The kernel source is co-located in the Solution sources.
+
+Demonstrates:
+
+  * Vendored module import (sys.path manipulation for runner-extracted dirs)
+  * Workspace caching (avoid re-allocating per call)
+  * Split-K + LSE reduction (typical MLA decode pattern)
+  * MLA-specific tensor fusion (ckv + kpe → fused k buffer)
+  * LSE base conversion (natural-log → base-2)
+
+Target Definition example: mla_paged_decode_h16_ckv512_kpe64_ps1
+  inputs:  q_nope [B, H=16, ckv_dim=512], q_pe [B, H=16, kpe_dim=64],
+           ckv_cache [P, ps=1, 512], kpe_cache [P, ps=1, 64],
+           kv_indptr [B+1], kv_indices [num_kv_indices], sm_scale (scalar)
+  outputs: output [B, H=16, ckv_dim=512], lse [B, H=16] (base-2)
+"""
+from __future__ import annotations
+
+import math
+import os
+import sys
+from typing import Tuple
+
+import torch
+
+# --- Vendored module loading ---
+# When the runner extracts this Solution's `sources` to a temp dir, that dir
+# is NOT on sys.path automatically. Insert it so we can import sibling files.
+_HERE = os.path.dirname(os.path.abspath(__file__))
+if _HERE not in sys.path:
+    sys.path.insert(0, _HERE)
+
+from sglang_decode import decode_attention_fwd_grouped_split_k_lse  # noqa: E402
+
+# --- Per-process state (workspace cache + constants) ---
+_MAX_KV_SPLITS = 8
+_MIN_BLOCK_KV = 64
+_LOG2 = math.log(2.0)
+_ws_cache: dict = {}
+
+
+def _get_workspace(B: int, H: int, V: int, device, dtype) -> dict:
+    """Cache pre-allocated work tensors keyed on (B, H, V, device, dtype)."""
+    key = (B, H, V, str(device), dtype)
+    ws = _ws_cache.get(key)
+    if ws is None:
+        ws = {
+            "q_fused":      torch.empty((B, H, V + 64), dtype=dtype, device=device),
+            "attn_logits":  torch.empty((B, H, _MAX_KV_SPLITS, V), dtype=torch.float32, device=device),
+            "attn_lse":     torch.empty((B, H, _MAX_KV_SPLITS), dtype=torch.float32, device=device),
+            "num_kv_splits": torch.empty((B,), dtype=torch.int32, device=device),
+        }
+        _ws_cache[key] = ws
+    return ws
+
+
+def run(
+    q_nope,        # [B, H, ckv_dim]
+    q_pe,          # [B, H, kpe_dim]
+    ckv_cache,     # [num_pages, page_size, ckv_dim]
+    kpe_cache,     # [num_pages, page_size, kpe_dim]
+    kv_indptr,     # [B+1]
+    kv_indices,    # [num_kv_indices]
+    sm_scale,      # scalar
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    B, H, ckv_dim = q_nope.shape
+    kpe_dim = q_pe.shape[-1]
+    assert ckv_dim == 512 and kpe_dim == 64, "MLA decode template assumes ckv=512, kpe=64"
+
+    device = q_nope.device
+    dtype  = q_nope.dtype
+    ws     = _get_workspace(B, H, ckv_dim, device, dtype)
+
+    # --- Fuse Q ---
+    # MLA needs Q to be a single [B, H, ckv+kpe] tensor; we concat once.
+    ws["q_fused"][:, :, :ckv_dim].copy_(q_nope)
+    ws["q_fused"][:, :, ckv_dim:].copy_(q_pe)
+
+    # --- Determine kv_splits per batch ---
+    # SGLang uses a heuristic: split count grows with KV length; capped at MAX.
+    seq_lens = kv_indptr[1:] - kv_indptr[:-1]                      # [B]
+    ws["num_kv_splits"].copy_((seq_lens.float() / _MIN_BLOCK_KV).clamp(min=1, max=_MAX_KV_SPLITS).int())
+
+    # --- Output buffer ---
+    output = torch.empty((B, H, ckv_dim), dtype=dtype, device=device)
+
+    # --- Launch the vendored kernel ---
+    # Note: kernel uses ckv_cache as the V buffer (zero-copy, MLA's compressed-V property).
+    decode_attention_fwd_grouped_split_k_lse(
+        ws["q_fused"],            # [B, H, ckv+kpe]
+        ckv_cache,                 # K (ckv) cache
+        ckv_cache,                 # V buffer = ckv (MLA compressed)
+        kpe_cache,                 # KPE component
+        output,
+        kv_indices, kv_indptr,
+        ws["num_kv_splits"], _MAX_KV_SPLITS,
+        ws["attn_logits"], ws["attn_lse"],
+        page_size=1,
+        sm_scale=float(sm_scale),
+    )
+
+    # --- Reduce per-split LSE to final LSE, in base-2 (FlashInfer convention) ---
+    # `attn_lse` stores natural-log LSE per split; reduce + convert.
+    lse_natural_per_split = ws["attn_lse"]                        # [B, H, splits], natural log
+    # logsumexp across split dim:
+    lse_natural = torch.logsumexp(lse_natural_per_split, dim=2)   # [B, H], natural log
+    # Convert to base-2:
+    lse_b2 = lse_natural / _LOG2                                   # [B, H], base-2
+
+    return output, lse_b2
+
+
+# Notes on adapting this template:
+#
+#  * For NON-MLA vendored kernels: drop the q_nope / q_pe fusion, keep the
+#    workspace caching pattern and split-K LSE reduction (most modern decode
+#    kernels use split-K).
+#
+#  * If the vendored kernel returns base-2 LSE already, skip the `/ _LOG2` step.
+#
+#  * If the kernel does not produce LSE, change the function signature to
+#    return only output. (Check Definition.outputs to confirm.)
+#
+#  * For multi-file vendored sources: list every file in solution.json
+#    "sources"; the runner unpacks all of them to the same temp dir.
+#
+#  * For CUDA kernels (vs Triton): vendor a pre-built .so file or compile at
+#    import time via cppimport / torch.utils.cpp_extension. Avoid blocking
+#    in run(); compile in module load time.
+#
+#  * The `_ws_cache` global persists across run() calls within one process,
+#    speeding up repeated benchmarks. Be careful: in multi-process testing
+#    each worker has its own cache (which is what you want).

skills/add-flashinfer-solution/templates/vendored_kernel_solution.json

@@ -0,0 +1,22 @@
+{
+  "name": "sglang_mla_decode_v1",
+  "definition": "mla_paged_decode_h16_ckv512_kpe64_ps1",
+  "author": "<your-author-tag>",
+  "spec": {
+    "language": "python",
+    "target_hardware": ["NVIDIA H100", "NVIDIA H200", "NVIDIA B200"],
+    "entry_point": "main.py::run",
+    "dependencies": [],
+    "destination_passing_style": false
+  },
+  "sources": [
+    {
+      "path": "main.py",
+      "content": "<full content of templates/vendored_kernel_main.py>"
+    },
+    {
+      "path": "sglang_decode.py",
+      "content": "<full content of the vendored Triton kernel — copy from upstream sglang/python/sglang/srt/layers/attention/triton_ops/decode_attention.py and trim to just the function you need>"
+    }
+  ]
+}