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

tasks/video-sparse-attention/sparse-attn-mask-build-3d/tests/verify_env.py

@@ -0,0 +1,213 @@
+"""sparse-attn-mask-build-3d verifier — correctness gate + achieved-GB/s SPEED LEADERBOARD (uncapped).
+
+    reward = 0                                     if the submission is incorrect
+    reward = geomean over graded shapes of GB/s otherwise
+
+GENERATED by _factory/build.py — do not edit here; edit the spec and regenerate.
+
+There is no gold solution and no oracle: the score is an absolute hardware metric, so it is hardware-portable
+by construction and nothing has to be vendored, sealed, or re-benchmarked.
+
+CORRECTNESS is a hard gate, checked against an INDEPENDENT (embedded) copy of the reference at every graded
+shape including the timed ones, so editing /app/reference.py cannot affect grading and a fast wrong kernel
+scores 0.
+
+ANTI-CHEAT on the timing path: every timed rep runs on FRESHLY generated inputs, and the output of the last
+timed rep is itself validated against the reference for those exact inputs. A submission that memoizes a
+result and replays it fails the gate instead of posting an inflated number. Warm-up runs on a separate
+throwaway input set, so ordinary shape-keyed JIT/autotune caching is not penalised.
+
+WORK is attributed by a CANONICAL formula that depends only on the shape, never on the implementation, so all
+submissions are credited identically and the ranking is a pure speed ranking.
+"""
+import importlib.util
+import json
+import math
+import os
+import sys
+import traceback
+
+import torch
+
+REWARD_DIR = "/logs/verifier"
+MODULE_PATH = "/app/mask_build.py"
+TOL = 0.015
+
+GRADER_SHAPES = [(1, 32, 48, 80, 24, 128, 2, 4, 4), (1, 20, 48, 80, 40, 128, 2, 4, 8), (1, 32, 48, 80, 16, 128, 2, 2, 8), (1, 24, 48, 80, 24, 64, 2, 4, 4), (2, 16, 48, 80, 24, 128, 2, 4, 4)]
+CORRECT_SHAPES = [(1, 8, 16, 32, 4, 64, 2, 4, 8), (2, 6, 12, 24, 4, 64, 2, 4, 8), (1, 12, 16, 32, 8, 128, 3, 4, 8), (1, 10, 10, 20, 4, 64, 2, 2, 4), (1, 9, 12, 20, 4, 128, 3, 4, 5)]
+
+sys.path.insert(0, "/app")
+
+def canonical_work(B, F, Hh, Ww, NH, D, TF, TH, TW):
+    """BYTES attributed to one call, from the SHAPE ALONE.
+
+    Read q and k once (bf16) to pool them, write the (B, NH, NT, NT) fp32 score map once. The pooled
+    tensors, the (NT, NT) bias and the softmax state are tiny by comparison and stay on chip. The output
+    dominates: this is a bandwidth kernel, so the score is achieved bandwidth against this fixed byte count.
+    """
+    ntf, nth, ntw = F // TF, Hh // TH, Ww // TW
+    NT = ntf * nth * ntw
+    T = F * Hh * Ww
+    return 2 * (B * T * NH * D * 2) + B * NH * NT * NT * 4
+
+def _ref(q, k, latent, tile, decay, scale=None):
+    """3D tile pooling + block-score GEMM + distance decay + row softmax, in fp32.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target. It permutes the whole
+    sequence into tile-major order, materialises the pooled tensors and the full (B, NH, NT, NT) bias, and
+    then softmaxes.
+    """
+    B, T, NH, D = q.shape
+    F, Hh, Ww = latent
+    tf, th, tw = tile
+    lf, lh, lw = decay
+    ntf, nth, ntw = F // tf, Hh // th, Ww // tw
+    NT = ntf * nth * ntw
+    TS = tf * th * tw
+    if scale is None:
+        scale = D ** -0.5
+    dev = q.device
+
+    def pool(x):
+        return (x.view(B, ntf, tf, nth, th, ntw, tw, NH, D)
+                 .permute(0, 1, 3, 5, 7, 2, 4, 6, 8)
+                 .reshape(B, NT, NH, TS, D).float().mean(dim=3))       # (B, NT, NH, D)
+
+    qp, kp = pool(q), pool(k)
+    s = torch.einsum("bihd,bjhd->bhij", qp * scale, kp)                # (B, NH, NT, NT)
+
+    a = torch.arange(NT, device=dev)
+    ta, tb, tc = a // (nth * ntw), (a // ntw) % nth, a % ntw
+    bias = (lf * (ta[:, None] - ta[None, :]).abs()
+            + lh * (tb[:, None] - tb[None, :]).abs()
+            + lw * (tc[:, None] - tc[None, :]).abs()).float()          # (NT, NT)
+    return torch.softmax(s - bias, dim=-1)
+
+def _mk(B, F, Hh, Ww, NH, D, TF, TH, TW, seed):
+    import math
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    T = F * Hh * Ww
+    dev = "cuda"
+    R = 12
+    AMP = 2.6
+    # Realistic activations: a smooth low-frequency 3D field plus white noise. Real latent activations vary
+    # slowly across the volume, which is exactly why tile-mean pooling is an informative summary at all --
+    # pooling white noise would leave the block scores at zero and the map would be pure distance decay.
+    ax = [torch.arange(n, device=dev, dtype=torch.float32) / n for n in (F, Hh, Ww)]
+    kk = torch.randint(0, 3, (3, R), device=dev, generator=gen).float()
+    ph = torch.rand(R, device=dev, generator=gen) * (2 * math.pi)
+    ang = (kk[0].view(R, 1, 1, 1) * ax[0].view(1, F, 1, 1)
+           + kk[1].view(R, 1, 1, 1) * ax[1].view(1, 1, Hh, 1)
+           + kk[2].view(R, 1, 1, 1) * ax[2].view(1, 1, 1, Ww)) * (2 * math.pi) + ph.view(R, 1, 1, 1)
+    basis = torch.cos(ang).reshape(R, T).t().contiguous()               # (T, R)
+    def field():
+        w = torch.randn(NH, R, D, device=dev, generator=gen) * (AMP / R ** 0.5)
+        out = torch.empty(B, T, NH, D, device=dev, dtype=torch.bfloat16)
+        step = max(1, 8_000_000 // max(1, NH * D))
+        for s0 in range(0, T, step):
+            e0 = min(T, s0 + step)
+            x = torch.einsum("tr,hrd->thd", basis[s0:e0], w).unsqueeze(0)
+            x = x + torch.randn(B, e0 - s0, NH, D, device=dev, generator=gen)
+            out[:, s0:e0] = x.bfloat16()
+        return out
+    return field(), field(), (F, Hh, Ww), (TF, TH, TW), (0.20, 0.05, 0.05)
+
+
+def _is_exact(t):
+    """Integer/bool tensors are compared EXACTLY: .float() is lossy above 2**24, so two distinct large
+    ids (page ids, token ids, indices) can compare equal and let a wrong kernel pass."""
+    return t.dtype in (torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8, torch.bool)
+
+
+def _check(out, ref):
+    """-> (ok, value, msg). Exact for integer/bool; relative Frobenius error otherwise."""
+    if out is None or tuple(out.shape) != tuple(ref.shape):
+        return False, 1.0, "bad/None shape"
+    if _is_exact(ref):
+        bad = int((out != ref).sum())
+        return bad == 0, float(bad), ("exact match" if bad == 0 else f"{bad} elements differ")
+    e = float((out.float() - ref.float()).norm() / (ref.float().norm() + 1e-12))
+    return e <= TOL, e, f"relerr {e:.2e}"
+
+
+def _bench_fresh(fn, mkargs, reps=5, warm=3):
+    """Time `fn` on FRESH inputs every rep -> (min_seconds, timed_ok). See the module docstring."""
+    wargs = mkargs(0)
+    for _ in range(warm):
+        fn(*wargs)
+    torch.cuda.synchronize()
+    del wargs
+    torch.cuda.empty_cache()
+
+    best, timed_ok = float("inf"), True
+    for i in range(reps):
+        args = mkargs(10_000 + i)
+        s, e = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True)
+        s.record()
+        out = fn(*args)
+        e.record()
+        torch.cuda.synchronize()
+        best = min(best, s.elapsed_time(e))
+        if i == reps - 1:
+            timed_ok = _check(out, _ref(*args))[0]
+        del args, out
+        torch.cuda.empty_cache()
+    return best / 1e3, timed_ok
+
+
+def _geomean(xs):
+    return math.exp(sum(math.log(max(v, 1e-9)) for v in xs) / len(xs)) if xs else 0.0
+
+
+def main():
+    details, correct_gate, geo = {}, False, 0.0
+    try:
+        spec = importlib.util.spec_from_file_location("submission", MODULE_PATH)
+        m = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(m)
+        fn = m.build_block_scores_3d
+
+        corr_ok, msg = True, ""
+        for i, shp in enumerate(CORRECT_SHAPES):
+            args = _mk(*shp, seed=10 + i)
+            ok, val, m_ = _check(fn(*args), _ref(*args))
+            if not ok:
+                corr_ok, msg = False, f"cfg{i} {shp} {m_}"
+                break
+            del args
+            torch.cuda.empty_cache()
+        details["correct_msg"] = msg or "all correctness shapes pass"
+
+        vals, per_shape, perf_ok = [], [], corr_ok
+        for i, shp in enumerate(GRADER_SHAPES):
+            args = _mk(*shp, seed=100 + i)
+            ok, val, m_ = _check(fn(*args), _ref(*args))
+            if not ok:
+                perf_ok = False
+            del args
+            torch.cuda.empty_cache()
+            t, timed_ok = _bench_fresh(fn, lambda s, _p=shp: _mk(*_p, seed=s))
+            if not timed_ok:
+                perf_ok = False
+            v = canonical_work(*shp) / t / 2**30 if t > 0 else 0.0
+            vals.append(v)
+            per_shape.append({"shape": list(shp), "gbps": round(v, 3), "ms": round(t * 1e3, 3),
+                              "check": m_, "timed_ok": timed_ok})
+        geo = _geomean(vals)
+        details.update(per_shape=per_shape, geomean=round(geo, 4), perf_size_ok=perf_ok)
+        correct_gate = corr_ok and perf_ok
+    except Exception as e:
+        details["error"] = f"{e.__class__.__name__}: {e}"[:220]
+        details["trace"] = traceback.format_exc()[-800:]
+
+    reward = round(geo, 4) if correct_gate else 0.0
+    os.makedirs(REWARD_DIR, exist_ok=True)
+    json.dump({"reward": reward, "correct": 1.0 if correct_gate else 0.0,
+               "geomean": round(geo, 4), "metric": "GB/s (geomean over graded shapes)"},
+              open(f"{REWARD_DIR}/reward.json", "w"), indent=2)
+    open(f"{REWARD_DIR}/reward.txt", "w").write(str(reward))
+    json.dump(details, open(f"{REWARD_DIR}/details.json", "w"), indent=2, default=str)
+    print("reward:", reward, "GB/s | correct:", 1.0 if correct_gate else 0.0)
+
+
+main()

tasks/video-sparse-attention/sparse-block-worklist-build/RUN.md

@@ -0,0 +1,42 @@
+# Running `sparse-block-worklist-build`
+
+Between the mask builder and the attention kernel sits the piece nobody writes about and everybody needs: turning a per-head tile BITMAP into the flat work list a block-sparse attention kernel actually consumes. Popcount every row, prefix-sum 300k rows into CSR offsets, compact the live (query tile, key tile) pairs in row-major order, and cut the result into equal-work slices for a persistent grid. It is a scan and a stream compaction over a gigabyte of pairs, and it runs before every attention call.
+
+|  |  |
+|---|---|
+| **Task id** | `mle-bench/sparse-block-worklist-build` |
+| **Group** | `kernel-generation` |
+| **GPUs** | 1 |
+| **Agent edits** | `/app/worklist.py` |
+| **Score** | achieved **GB/s** (uncapped speed leaderboard), `0` if incorrect |
+| **Grade output** | `tests/test.sh` -> `/logs/verifier/reward.json` |
+
+## Run through harbor
+
+```bash
+harbor run --dataset-path kernel-generation/kernels/sparse-block-worklist-build --task-name sparse-block-worklist-build \
+  --agent claude-code --model anthropic/claude-opus-4-1 -e docker
+```
+
+## Run manually
+
+```bash
+cd kernel-generation/kernels/sparse-block-worklist-build
+docker build -t sparse-block-worklist-build environment/
+docker run -d --name v --gpus '"device=0"' --shm-size=8g --entrypoint sleep sparse-block-worklist-build infinity
+docker cp tests v:/tests && docker exec v bash /tests/test.sh   # untouched start -> reward 0.0
+docker rm -f v
+```
+
+Use an **idle** GPU: the score is a timing measurement.
+
+## Design
+
+Correctness is a hard gate; the score is an absolute hardware metric (GB/s), so the task is
+hardware-portable and needs no gold solution, no oracle, and nothing vendored or sealed.
+
+Anti-cheat is structural: the image holds only the permitted toolchain and has no internet; the grader is
+copied in at grade time with its own private copy of the reference; and every timed rep runs on fresh inputs
+with the timed output itself validated, so memoize-and-replay fails the gate.
+
+Generated by `_factory/build.py` — edit the spec and regenerate rather than editing this task by hand.

tasks/video-sparse-attention/sparse-block-worklist-build/environment/CLAUDE.md

@@ -0,0 +1,25 @@
+# Working in this environment
+
+## ⚠️ Stop background processes without killing yourself
+
+You are launched as `claude --print -- '<the task instruction>'`, so the task text — including the
+file names and commands it mentions — is on **your own** process's command line. Any command that
+finds processes by **matching that text** (`pkill -f …`, `pgrep -f … | xargs kill`, a `/proc`
+cmdline scan, `fuser -k`, `killall`) can match and **kill the agent itself**, ending your run
+(`NonZeroAgentExitCodeError`) and grading you on unfinished work.
+
+This bites whenever you background something and later stop/restart it — a **server**, a long
+**build** or **training run**, or an **ncu / nsys profiling** session.
+
+**Always** manage a background process by its **exact recorded PID**, never by a name pattern:
+
+```bash
+nohup <your command> > /tmp/job.log 2>&1 & echo $! > /tmp/job.pid   # start + record the PID
+kill "$(cat /tmp/job.pid)"; sleep 3                                 # stop (SIGTERM); -9 only if needed
+```
+
+Use `setsid` and kill the process **group** (`kill -- -"$(cat /tmp/job.pid)"`) if it spawns children.
+If you must enumerate processes, match a **unique token that is NOT anywhere in this prompt** and
+**exclude any cmdline containing `claude` or `--print`** — `pgrep -af`, and look before you kill.
+
+Full details + safe recipes: **`/app/PROCESS_MANAGEMENT.md`**.

tasks/video-sparse-attention/sparse-block-worklist-build/environment/Dockerfile

@@ -0,0 +1,41 @@
+# Kernel-generation task: Write a fast block-sparse work-list builder (bitmap -> CSR + balanced partition)
+#
+# Between the mask builder and the attention kernel sits the piece nobody writes about and everybody needs: turning a per-head tile BITMAP into the flat work list a block-sparse attention kernel actually consumes. Popcount every row, prefix-sum 300k rows into CSR offsets, compact the live (query tile, key tile) pairs in row-major order, and cut the result into equal-work slices for a persistent grid. It is a scan and a stream compaction over a gigabyte of pairs, and it runs before every attention call.
+#
+# SCORING: correctness is a hard gate; the score is achieved GB/s (uncapped leaderboard, 0 if wrong).
+# There is no gold solution and no oracle, so nothing has to be vendored or sealed.
+#
+# TOOLCHAIN POLICY: the agent writes the kernel with Triton (+Gluon), CUDA C++ via nvcc, CUTLASS headers, or
+# the CuTe DSL. Enforcement is by ABSENCE, not by scanning: only the permitted toolchain is installed and
+# there is no internet, so nothing else can be obtained.
+#
+# GENERATED by _factory/build.py.
+FROM pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
+
+# NOTE: every heavy layer comes FIRST and depends only on {base_image, pip_extra}, so all tasks in this
+# lane share the same cached layers. The task-specific COPYs are LAST. Do not reorder.
+RUN pip install --break-system-packages --no-cache-dir einops nvidia-cutlass-dsl && \
+    apt-get update && apt-get install -y --no-install-recommends iptables iproute2 curl ca-certificates build-essential git && \
+    curl -LsSf https://astral.sh/uv/install.sh | sh && \
+    /root/.local/bin/uv tool install mini-swe-agent
+# header-only CUTLASS for the agent's CUDA/CuTe route
+RUN git clone --depth 1 https://github.com/NVIDIA/cutlass /opt/cutlass && rm -rf /opt/cutlass/.git
+# pre-bake Claude Code; harbor's claude_code.install() skips when present
+RUN curl -fsSL https://deb.nodesource.com/setup_22.x | bash - && \
+    apt-get install -y nodejs procps && \
+    npm install -g @anthropic-ai/claude-code && claude --version
+ENV PATH=/root/.local/bin:$PATH
+ENV DISABLE_TELEMETRY=1 DISABLE_AUTOUPDATER=1 DISABLE_ERROR_REPORTING=1 CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1
+
+COPY restrict-network.sh /app/restrict-network.sh
+RUN chmod +x /app/restrict-network.sh
+# strip apt sources LAST so harbor's post-firewall apt step is a no-op that succeeds
+RUN rm -rf /var/lib/apt/lists/* /etc/apt/sources.list /etc/apt/sources.list.d
+
+WORKDIR /app
+COPY CLAUDE.md PROCESS_MANAGEMENT.md /app/
+
+# task-specific files LAST so the layers above stay shared across every task
+COPY reference.py /app/reference.py
+COPY measure.py /app/measure.py
+COPY worklist.py /app/worklist.py

tasks/video-sparse-attention/sparse-block-worklist-build/environment/PROCESS_MANAGEMENT.md

@@ -0,0 +1,96 @@
+# Managing background processes — READ THIS before you `kill` anything
+
+You may start and stop background processes while iterating — a **server**, a long **build** or
+**training run**, or an **ncu / nsys profiling** session. **The way you stop one can silently kill
+*your own agent process* and end the whole run.** This has happened repeatedly, including via a
+hand-rolled `/proc` scan — not just `pkill`. Read this once and follow the safe recipe.
+
+## The trap: matching task text against process command lines
+
+You were launched as roughly:
+
+```
+claude --print -- '<the entire task instruction text>'
+```
+
+The full task instruction is on **your own** process's command line, and it contains the file names
+and commands the task mentions (e.g. `server.py`, `build.sh`, `train.py`, `solution.cu`, `/app/...`).
+So **any** command that finds processes by matching those strings will match — and can kill — **the
+agent itself**:
+
+```
+pkill -9 -f "train.py"                              # matches the claude agent -> kills YOU
+pgrep -f "server.py" | xargs kill                   # same: the pid list includes claude
+for p in $(pgrep -f build.sh); do kill -9 $p; done  # same
+for pid in /proc/*; do case "$(cmdline)" in *solution*) kill -9 $pid;; esac; done   # same
+```
+
+It is **not about `pkill`** — it is about **matching a string that appears in your prompt**. `pgrep`,
+a `/proc` scan, `fuser`, or `nvidia-smi`-pid loops all have the same failure if the match pattern (or
+the surviving pid list) includes the `claude` process. When you `kill -9` yourself the run dies
+immediately (`NonZeroAgentExitCodeError`) and you are graded on whatever was already in place — usually
+worse than what you were about to finish.
+
+## The one safe rule: kill only the exact PID you recorded
+
+**Start** a background job and record its PID in a file:
+
+```bash
+nohup <your command> > /tmp/job.log 2>&1 &
+echo $! > /tmp/job.pid
+```
+
+**Stop / restart** by that exact PID — never by a name pattern:
+
+```bash
+kill "$(cat /tmp/job.pid)" 2>/dev/null      # SIGTERM: lets it release the GPU / flush cleanly
+sleep 3
+kill -9 "$(cat /tmp/job.pid)" 2>/dev/null   # force only if it did not exit
+```
+
+If the job spawns workers, run it in its own process group and signal the group by its (negative)
+PGID — still an exact id, never a pattern:
+
+```bash
+setsid <your command> > /tmp/job.log 2>&1 < /dev/null & echo $! > /tmp/job.pid
+kill -TERM -- "-$(cat /tmp/job.pid)" 2>/dev/null
+```
+
+## If you ever enumerate processes, EXCLUDE the agent
+
+Prefer not to. But if you must scan (e.g. hunting a leaked worker), **exclude the `claude` agent and
+your own shell**, and match on a **unique token that is NOT anywhere in this prompt** — give your job
+a unique name and match only that:
+
+```bash
+# job named e.g. job_7x3q9 — a token that appears NOWHERE in the task text
+pgrep -af job_7x3q9 | grep -v -E 'claude|--print|pgrep|grep|bash'   # LOOK FIRST
+# only kill pids from THIS filtered list, and never a pid whose cmdline contains 'claude' or '--print'
+```
+
+Do **not** add a prompt word (a file name, `/app`, `python3`, …) to the pattern "just in case" — that
+single addition re-introduces the self-kill. Match the unique token **only**.
+
+## Freeing the GPU without going nuclear
+
+If VRAM stays high after you stop a GPU job, the usual cause is a **child process** or a not-yet-
+collected CUDA context — not a stray process you need to hunt across `/proc`. Do this instead of a
+`/proc` sweep:
+
+- Kill the job **by its recorded PID / PGID** (above) and `sleep 5–10`; the CUDA context frees after
+  the process fully exits.
+- Make the job release cleanly on `SIGTERM` (drop the model / `torch.cuda.empty_cache()` / exit) so a
+  single `kill $PID` is enough.
+- Start it in its own group (`setsid`) so `kill -- -$PGID` takes the workers with it.
+- Check with `nvidia-smi` — if a PID still holds memory, `kill` **that exact numeric PID**, after
+  confirming its cmdline is **not** `claude` / `--print`.
+
+## Rules of thumb
+
+- **Never** match a task-prompt string (`server.py`, `train.py`, `build.sh`, `/app`, `python3`, …)
+  with `pkill -f`, `pgrep -f`, `killall`, `fuser`, or a `/proc` cmdline scan — they all can hit the
+  agent (its argv holds the prompt).
+- **Always** kill a background job by the exact PID from its pidfile (or its PGID).
+- If you must enumerate, match a **unique token not in the prompt** and **exclude `claude` / `--print`
+  and your own shell**; `pgrep -af` and look before you kill.
+- `SIGTERM` first for a clean release; `-9` only as a last resort on a specific numeric PID.

tasks/video-sparse-attention/sparse-block-worklist-build/environment/docker-compose.yaml

@@ -0,0 +1,18 @@
+# Anti-cheat firewall overlay, merged on top of Harbor's base compose. Gives the main container
+# NET_ADMIN and runs restrict-network.sh as the entrypoint, so only DNS + the LLM API endpoints are
+# reachable (pypi/github/HF blocked). network_mode stays "public" (see task.toml) — the firewall, not
+# Docker, enforces the allowlist. mini-swe-agent is pre-installed and harbor's patched installer skips
+# the (now-blocked) network install when it is already present.
+services:
+  main:
+    cap_add:
+      - NET_ADMIN
+    entrypoint: ["/bin/bash", "/app/restrict-network.sh"]
+    environment:
+      - ALLOWED_HOSTS=${ALLOWED_HOSTS:-}
+      - FIREWORKS_BASE_URL=${FIREWORKS_BASE_URL:-}
+      - OPENROUTER_BASE_URL=${OPENROUTER_BASE_URL:-}
+      - OPENAI_BASE_URL=${OPENAI_BASE_URL:-}
+      - ANTHROPIC_BASE_URL=${ANTHROPIC_BASE_URL:-}
+      - LLM_BASE_URL=${LLM_BASE_URL:-}
+      - LITELLM_BASE_URL=${LITELLM_BASE_URL:-}

tasks/video-sparse-attention/sparse-block-worklist-build/environment/measure.py

@@ -0,0 +1,141 @@
+"""Self-assessment tool — your correctness + achieved GB/s across a RANGE of shapes.
+
+    python /app/measure.py            # the graded regime
+    python /app/measure.py --quick    # smaller sizes for fast iteration
+
+You are scored on the **geomean achieved GB/s** — NOT one fixed size, and the leaderboard is UNCAPPED
+(higher is always better). The shapes below are a DIFFERENT sample from the same regime the grader uses, so
+optimize for GENERALITY. Work is counted with the same shape-only formula the grader uses, so the number
+printed here is computed exactly as your score is.
+
+GENERATED by _factory/build.py.
+"""
+import argparse
+import math
+import sys
+
+import torch
+
+sys.path.insert(0, "/app")
+from reference import build_block_worklist as _ref
+from worklist import build_block_worklist as _agent
+
+TOL = 0.0
+NAMES = ('counts', 'offsets', 'pairs', 'bucket_row')
+
+FULL = [(2, 32, 4096, 4096, 12, 2048), (2, 24, 4096, 4096, 11, 1024), (4, 20, 3200, 3200, 14, 4096), (1, 40, 4608, 4608, 12, 2048), (2, 24, 3840, 3840, 13, 1536)]
+QUICK = [(1, 8, 1024, 1024, 12, 256), (2, 4, 768, 768, 15, 128), (1, 12, 512, 512, 20, 64)]
+
+def _live_counts(B, NH, NQ, NK, DEN):
+    """Live key tiles per (batch, head, query tile), from the SHAPE ALONE.
+
+    About DEN percent of the NK tiles survive, jittered by +-1 per row so the rows are genuinely ragged, and
+    always at least 1.
+    """
+    out = []
+    base = (NK * DEN) // 100
+    for b in range(B):
+        for h in range(NH):
+            for i in range(NQ):
+                c = base + ((b * 31 + h * 17 + i * 7) % 3) - 1
+                out.append(min(max(c, 1), NK))
+    return out
+
+
+def canonical_work(B, NH, NQ, NK, DEN, P):
+    """BYTES moved by one call, from the SHAPE ALONE.
+
+    Read the packed bitmap once (NK/8 bytes per row), write the counts and the CSR offsets (4 bytes per
+    row each), and write the compacted pair list (8 bytes per live pair). The live count is fixed by the
+    shape, so the pair list has the same length for every submission.
+    """
+    R = B * NH * NQ
+    L = sum(_live_counts(B, NH, NQ, NK, DEN))
+    return R * (NK // 8) + 8 * L + 8 * R + 4 * (P + 1)
+
+def _mk(B, NH, NQ, NK, DEN, P, seed):
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    cnt = torch.tensor(_live_counts(B, NH, NQ, NK, DEN), device="cuda").view(B, NH, NQ)
+    kmax = int(cnt.max().item())
+    sh = torch.arange(8, device="cuda", dtype=torch.int32)
+    bits = torch.empty(B, NH, NQ, NK // 8, device="cuda", dtype=torch.uint8)
+    for b in range(B):
+        for h in range(NH):
+            r = torch.rand(NQ, NK, device="cuda", generator=gen)
+            idx = r.topk(kmax, dim=-1).indices                       # (NQ, kmax) random distinct columns
+            live = torch.arange(kmax, device="cuda").view(1, -1) < cnt[b, h].view(-1, 1)
+            m = torch.zeros(NQ, NK, dtype=torch.bool, device="cuda")
+            m.scatter_(1, torch.where(live, idx, idx[:, :1]), True)   # rank 0 is always live
+            bits[b, h] = ((m.view(NQ, NK // 8, 8).to(torch.int32) << sh).sum(-1)).to(torch.uint8)
+    return bits, NK, P
+
+
+def _check(out, ref):
+    """-> (ok, value, msg). value = MAX relative error across the returned tuple."""
+    if out is None or len(out) != len(NAMES):
+        return False, 1.0, f"expected a {len(NAMES)}-tuple {NAMES}"
+    per = []
+    for n, a, b in zip(NAMES, out, ref):
+        if a is None or tuple(a.shape) != tuple(b.shape):
+            return False, 1.0, f"{n} bad shape"
+        if b.dtype in (torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8, torch.bool):
+            # exact: .float() is lossy above 2**24 and would let distinct large ids compare equal
+            bad = int((a != b).sum())
+            if bad:
+                return False, 1.0, f"{n}: {bad} elements differ"
+            continue
+        per.append((n, float((a.float() - b.float()).norm() / (b.float().norm() + 1e-12))))
+    if not per:
+        return True, 0.0, "all integer outputs exact"
+    wn, wv = max(per, key=lambda x: x[1])
+    return wv <= TOL, wv, f"worst {wn} {wv:.2e}"
+
+
+def _bench(fn, reps=8, warm=3):
+    for _ in range(warm):
+        fn()
+    torch.cuda.synchronize()
+    best = float("inf")
+    for _ in range(reps):
+        s, e = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True)
+        s.record()
+        fn()
+        e.record()
+        torch.cuda.synchronize()
+        best = min(best, s.elapsed_time(e))
+    return best / 1e3
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--quick", action="store_true")
+    a = ap.parse_args()
+    shapes = QUICK if a.quick else FULL
+    print(f"geomean over {len(shapes)} shapes ({'quick' if a.quick else 'full'}); the grader uses "
+          f"DIFFERENT sizes in the same regime — optimize for generality\n")
+    vals, allok = [], True
+    for shp in shapes:
+        args = _mk(*shp, seed=sum(int(x) for x in shp) % 9973)
+        ref = _ref(*args)
+        try:
+            out = _agent(*args)
+        except Exception as ex:
+            print(f"  {shp}: RAISED {type(ex).__name__}: {str(ex)[:70]}")
+            allok = False
+            continue
+        ok, val, msg = _check(out, ref)
+        allok = allok and ok
+        t = _bench(lambda: _agent(*args))
+        v = canonical_work(*shp) / t / 2**30 if t > 0 else 0.0
+        vals.append(v)
+        print(f"  {str(shp):28s} {t*1e3:9.2f} ms | {v:9.2f} GB/s | {msg} {'ok' if ok else 'FAIL'}")
+        del args, ref, out
+        torch.cuda.empty_cache()
+    geo = math.exp(sum(math.log(max(v, 1e-9)) for v in vals) / len(vals)) if vals else 0.0
+    print(f"\n  => GEOMEAN {geo:.2f} GB/s   "
+          f"({'all correct' if allok else 'SOME WRONG — a wrong kernel scores 0, fix correctness first'})")
+    print("     This IS your score, and it is uncapped — higher is always better. Keep pushing.")
+
+
+if __name__ == "__main__":
+    main()

tasks/video-sparse-attention/sparse-block-worklist-build/environment/reference.py

@@ -0,0 +1,39 @@
+"""Reference implementation — the CORRECTNESS SPEC for `build_block_worklist`.
+
+This is correct but slow. It defines exactly what your kernel must reproduce; its speed has no
+bearing on your score, which is an absolute GB/s number. GENERATED by _factory/build.py.
+"""
+import torch
+
+
+def build_block_worklist(bits, n_key_blocks, n_buckets):
+    """Unpack, popcount, prefix-sum, compact and partition — written as dense boolean tensor algebra.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target. It materialises the
+    whole boolean mask one (batch, head) at a time and calls nonzero() on it.
+    """
+    B, NH, NQ, NW = bits.shape
+    NK = n_key_blocks
+    dev = bits.device
+    sh = torch.arange(8, device=dev, dtype=torch.uint8)
+
+    counts = torch.empty(B, NH, NQ, device=dev, dtype=torch.int32)
+    chunks = []
+    for b in range(B):
+        for h in range(NH):
+            m = (((bits[b, h].unsqueeze(-1) >> sh) & 1) != 0).reshape(NQ, NW * 8)[:, :NK]
+            counts[b, h] = m.sum(-1, dtype=torch.int32)
+            nz = m.nonzero()                                        # row-major: row asc, then col asc
+            base = (b * NH + h) * NQ
+            chunks.append(torch.stack([nz[:, 0].to(torch.int32) + base,
+                                       nz[:, 1].to(torch.int32)], dim=1))
+    pairs = torch.cat(chunks, dim=0)
+
+    flat = counts.reshape(-1)
+    offsets = torch.zeros(flat.numel() + 1, device=dev, dtype=torch.int32)
+    offsets[1:] = torch.cumsum(flat, 0, dtype=torch.int64).to(torch.int32)
+    L = int(offsets[-1].item())
+
+    split = (torch.arange(n_buckets + 1, device=dev, dtype=torch.int64) * L) // n_buckets
+    bucket_row = torch.searchsorted(offsets.to(torch.int64), split, right=False).to(torch.int32)
+    return counts, offsets, pairs, bucket_row

tasks/video-sparse-attention/sparse-block-worklist-build/environment/restrict-network.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+# Outbound firewall (anti-cheat): allow ONLY DNS, loopback, docker-internal networks, and the LLM API
+# endpoints the agent needs. Everything else is dropped — in particular pypi, github, and huggingface,
+# so the agent cannot `pip install vllm` / `pip install sglang` / clone the reference moe_align kernel and
+# copy it. torch + triton are already in the image, and mini-swe-agent is pre-installed (harbor's patched
+# installer skips the network install when it is already present), so no package index is needed at run time.
+#
+# Runs as the container ENTRYPOINT before the CMD. iptables rules are network-namespace-wide, so they also
+# apply to the agent's `docker exec` commands. Requires cap_add: NET_ADMIN.
+set -uo pipefail
+
+# LLM API endpoints the agent may reach. Extend at launch via ALLOWED_HOSTS=host1,host2 (no scheme).
+API_HOSTS=(
+    api.fireworks.ai
+    openrouter.ai openrouter.io
+    api.openai.com api.anthropic.com generativelanguage.googleapis.com
+    api.together.xyz integrate.api.nvidia.com api.moonshot.cn api.kimi.com
+)
+# Auto-allow hosts from any *_BASE_URL / *_ENDPOINT env var (ANTHROPIC_BASE_URL, OPENAI_BASE_URL, …).
+CUSTOM=()
+while IFS='=' read -r n v; do
+    case "$n" in
+        *_BASE_URL|*_URL|*_ENDPOINT)
+            [ -n "$v" ] && CUSTOM+=("$(echo "$v" | sed 's|.*://||; s|[:/].*||')") ;;
+    esac
+done < <(env)
+if [ -n "${ALLOWED_HOSTS:-}" ]; then IFS=',' read -ra E <<< "$ALLOWED_HOSTS"; CUSTOM+=("${E[@]}"); fi
+ALL_HOSTS=("${API_HOSTS[@]}" ${CUSTOM[@]+"${CUSTOM[@]}"})
+
+if iptables -L OUTPUT -n >/dev/null 2>&1; then
+    echo "restrict-network: applying outbound allowlist firewall..."
+    iptables -F OUTPUT 2>/dev/null || true
+    iptables -A OUTPUT -o lo -j ACCEPT
+    iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
+    iptables -A OUTPUT -p udp --dport 53 -j ACCEPT
+    iptables -A OUTPUT -p tcp --dport 53 -j ACCEPT
+    iptables -A OUTPUT -d 10.0.0.0/8 -j ACCEPT
+    iptables -A OUTPUT -d 172.16.0.0/12 -j ACCEPT
+    iptables -A OUTPUT -d 192.168.0.0/16 -j ACCEPT
+    iptables -A OUTPUT -d 127.0.0.11 -j ACCEPT
+    for h in "${ALL_HOSTS[@]}"; do
+        for ip in $(getent ahosts "$h" 2>/dev/null | awk '{print $1}' | sort -u); do
+            iptables -A OUTPUT -d "$ip" -j ACCEPT
+        done
+    done
+    iptables -A OUTPUT -j REJECT --reject-with icmp-admin-prohibited
+    echo "restrict-network: outbound locked to DNS + LLM endpoints; pypi/github/HF blocked."
+else
+    echo "restrict-network: WARNING — iptables unavailable (need cap_add NET_ADMIN); NOT firewalled." >&2
+fi
+
+exec "$@"

tasks/video-sparse-attention/sparse-block-worklist-build/environment/worklist.py

@@ -0,0 +1,29 @@
+"""Your implementation goes here.
+
+Replace the body of `build_block_worklist` with a FAST implementation that reproduces the output of /app/reference.py
+(same signature, same numerics within tolerance) but is much faster — see /app/instruction.md.
+Run `python /app/measure.py` to check your correctness and achieved GB/s.
+
+You may add helper modules, Triton kernels, CUDA extensions, caches, etc. — only this function's name,
+signature and returned value are fixed by the contract.
+"""
+
+
+def build_block_worklist(bits, n_key_blocks, n_buckets):
+    """Bitmap -> CSR work list + a row-aligned equal-work partition.
+
+    Args:
+        bits:         (B, NH, NQ, NK//8) uint8 — packed tile bitmap, LSB-first: bit (1 << t) of byte w of row
+                      (b,h,i) means key tile 8*w + t is live for query tile i.
+        n_key_blocks: int — NK, the number of key tiles (a multiple of 8).
+        n_buckets:    int — P, the number of equal-work buckets to cut the work list into.
+
+    Returns:
+        (counts, offsets, pairs, bucket_row):
+          counts:     (B, NH, NQ) int32     — live key tiles per row (popcount).
+          offsets:    (R+1,) int32          — exclusive prefix sum over the R = B*NH*NQ rows, offsets[R] = L.
+          pairs:      (L, 2) int32          — [flat row id, key tile id] for every live pair, ROW-MAJOR order.
+          bucket_row: (P+1,) int32          — bucket p owns rows [bucket_row[p], bucket_row[p+1]).
+        All four are integer tensors and are compared EXACTLY.
+    """
+    raise NotImplementedError("Implement a fast build_block_worklist in /app/worklist.py")

tasks/video-sparse-attention/sparse-block-worklist-build/instruction.md

@@ -0,0 +1,207 @@
+# Write a fast block-sparse work-list builder (bitmap -> CSR + balanced partition)
+
+You are given a **correct but slow** reference at **`/app/reference.py`** — `build_block_worklist(bits, n_key_blocks, n_buckets)`. **Read it, run it, profile it.**
+
+Write **`/app/worklist.py`** with the **same signature** and the **same numerical output**, but **as fast as you can make it**.
+
+```python
+def build_block_worklist(bits, n_key_blocks, n_buckets):
+    ...
+```
+
+## The computation (this is the exact spec)
+
+`bits` is the packed output of an upstream mask builder: for the row `(b, h, i)`, key tile
+`8*w + t` is live iff bit `1 << t` of byte `w` is set (**LSB first**). There are `NK` key tiles, `NK` a
+multiple of 8, so a row is exactly `NK/8` bytes.
+
+Rows are numbered **flat and row-major**: `row(b,h,i) = (b*NH + h)*NQ + i`, `R = B*NH*NQ` rows in total.
+
+**1. Counts.** `counts[b,h,i]` = popcount of the row = number of live key tiles. Every row has at least one.
+
+**2. Offsets.** The exclusive prefix sum of `counts` over the flat row order:
+
+```
+offsets[0] = 0
+offsets[r+1] = offsets[r] + counts_flat[r]
+offsets[R] = L        # total live pairs
+```
+
+**3. Pairs.** The compacted work list, `L` entries of `[flat row id, key tile id]`, in **row-major order** —
+rows in increasing flat order, and within a row the key tiles in increasing order. Row `r` therefore owns
+exactly `pairs[offsets[r] : offsets[r+1]]`, and `pairs[j,0] == r` for every one of those `j`.
+
+**4. Buckets.** A persistent grid of `P` CTAs wants equal work, but a CTA must not be handed half a row (it
+would have to re-read that row's query tile). So the split points are snapped to row boundaries:
+
+```
+split[p]      = (p * L) // P                     # integer division, p = 0 .. P
+bucket_row[p] = the smallest r in [0, R] with offsets[r] >= split[p]
+```
+
+i.e. `bucket_row = searchsorted(offsets, split, side='left')`. Bucket `p` then owns rows
+`[bucket_row[p], bucket_row[p+1])`, some of which are empty when `P` is large — that is expected and must be
+reproduced exactly. `bucket_row[0]` is `0` and `bucket_row[P]` is `R`.
+
+`/app/reference.py` unpacks the whole boolean mask per `(b, h)` and calls `nonzero()`. That is the exact
+specification; it is deliberately simple rather than fast.
+
+## The contract (fixed — do not change these)
+
+| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `bits` | `(B, NH, NQ, NK//8)` | `uint8` | packed tile bitmap, LSB-first |
+| `n_key_blocks` | int | `NK`, a multiple of 8 (**not** always a multiple of 32) |
+| `n_buckets` | int | `P`, the number of equal-work buckets |
+
+**Return** a 4-tuple `(counts, offsets, pairs, bucket_row)` **in that order**:
+
+| out | shape | dtype |
+|-----|-------|-------|
+| `counts` | `(B, NH, NQ)` | `int32` |
+| `offsets` | `(R+1,)` where `R = B*NH*NQ` | `int32` |
+| `pairs` | `(L, 2)` | `int32` |
+| `bucket_row` | `(P+1,)` | `int32` |
+
+**Every output is compared element-exactly** — this is index metadata, not arithmetic. `L` fits in `int32`
+at every graded shape. `NQ` and `NK` need not be equal and need not be powers of two; `P` may be larger or
+smaller than `R`. `bits` is read-only, CUDA and contiguous.
+
+The shape of `pairs` is itself part of the answer: producing the right pairs in the wrong order, or the right
+count in the wrong place, fails.
+
+**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `NQ`, `NK`
+3200-5120 tile ids (a 118k-token latent cut into ~30-token tiles), `NH` 24-40 heads, `B` 1-4, density 12-16%,
+`P` 1024-4096 buckets. That is **150-300k rows and 100-200 million live pairs**, i.e. a 1.2-1.6 GiB pair list
+written from a 150-250 MiB bitmap.
+
+The output is 8x the input, so this is a **write-bound** kernel: the pair list is the whole cost, and the scan
+that tells you where to put it is the whole difficulty.
+
+## How success is decided (runs on GPU)
+
+**1. Correctness — a required gate.** All four outputs are compared **element-exactly** at every graded shape, including the
+timed ones. There is no tolerance: a single misplaced pair, a shifted offset or an off-by-one bucket boundary
+scores **0**. Every output is an `int32` tensor, so the grader takes its exact-comparison path and the
+numeric `tol` is never consulted at all — it is set to `0` to say so.
+
+That was checked from both sides. **Achievable:** an independent implementation that shares no mechanism with
+the reference — fully vectorised with no `(b, h)` python loop, the pair list built from a sorted flat index
+instead of `nonzero()` per head, an `int64` `cumsum` for the scan — reproduces all four outputs
+**element-for-element** at every `correct_shape`. **Discriminating:** partitioning the buckets by equal
+*rows* instead of equal *work* leaves `counts`, `offsets` and `pairs` perfect and still mismatches **43
+`bucket_row` entries**; MSB-first bit order inside each byte mismatches **47288 `pairs` entries**; and
+emitting each row's columns in descending order mismatches **56000**. There is no numerical window here at
+all — the gate is a pure equality check, which is the correct design for an all-integer output. A wrong kernel scores **0**, no matter how fast.
+
+**2. Performance — this is your score, and it is an UNCAPPED leaderboard.**
+
+```
+reward = geomean over graded shapes of ( canonical_work(shape) / your_runtime )   [GB/s]
+reward = 0   if the submission is wrong at any graded shape
+```
+
+`canonical_work` depends **only on the shape**, never on how you implemented it, so every submission is
+credited the same work and this is a pure speed ranking in useful units:
+
+```
+R = B*NH*NQ;  L = total live pairs (fixed by the shape)
+BYTES = R*(NK/8)  +  8*L  +  8*R  +  4*(P+1)     # bitmap in, pair list + counts + offsets out
+```
+
+**There is no cap and no target.** Higher GB/s is always a strictly better score, so **push the
+performance as hard as you can**. Getting a correct implementation is the *start* of the task, not the end of
+it. Once correct, spend the entire remainder of your budget profiling and optimising, re-checking correctness
+after every change. **Use your full time budget.**
+
+Run **`python /app/measure.py`** at any point to see your per-shape and geomean GB/s plus correctness.
+
+## Where the performance comes from
+
+**Two passes, not three.** Pass 1: read the bitmap, `__popc` each row's words, write `counts`
+and run a device-wide exclusive scan into `offsets`. Pass 2: re-read the bitmap and write each row's live
+column ids straight to `pairs[offsets[r] ...]`. The bitmap is small (150-250 MiB) so reading it twice is
+cheap; what you must not do is stage the pairs anywhere before their final position.
+
+**The scan is over 150-300k elements** — a single-pass decoupled-lookback scan, or two small kernels
+(block sums, then scan-of-scans, then add). Do not call a generic sort or `nonzero`.
+
+**Compaction inside a row is a ballot.** With one warp per row, each lane holds one 32-bit word of the
+bitmap; `__popc` of the lanes below it (a warp prefix sum) gives its base offset, and `__ffs` in a loop
+emits the set bits in ascending order. No atomics, no shared-memory staging, and the writes are contiguous
+per row.
+
+**Write `pairs` as 64-bit stores.** Each entry is two `int32`; storing them as one `int2`/`uint64` per pair
+halves the instruction count and keeps the stores perfectly coalesced within a row.
+
+**`bucket_row` is `P+1` binary searches** over a monotone `int32` array — a single tiny kernel with one
+thread per bucket, or a merge-path-style co-rank. It is nothing next to the pair writes, but it does depend
+on `L`, so it has to come after the scan.
+
+**Rows are ragged by +-1 around `DEN%` of `NK`,** so a row-per-warp mapping is naturally balanced; the reason
+`bucket_row` exists at all is the *consumer* kernel, not this one.
+
+## Precision and faithfulness (read this)
+
+There is no floating-point arithmetic in this kernel at all: every input and output is an
+integer, and every output is compared **exactly**. `tol` is `0` and the grader never reaches its
+floating-point branch — this is the genuinely bit-exact case, confirmed by measuring an independent
+vectorised implementation at element-for-element equality on every correctness shape.
+
+Two things still count as precision:
+
+**The prefix sum must not overflow.** `L` is up to ~2x10^8, which fits in `int32`, but an intermediate that
+sums `counts` in 16-bit or that accumulates per-block sums in a narrower type will silently wrap. Accumulate
+the scan in 32-bit (or 64-bit) and store `int32`.
+
+**Bit order is LSB-first.** Bit `1 << t` of byte `w` is key tile `8*w + t`; reading the bytes as little-endian
+32-bit words keeps that order (tile `32*W + 31` is the top bit of word `W`), which is why the warp ballot
+trick works unchanged. Reversing it produces a valid-looking list with every row's columns permuted, which
+fails immediately.
+
+`n_key_blocks` is a multiple of 8 but not always of 32, so the last word of a row may be partial: mask the
+bits above `NK` before the popcount, or you will emit tiles that do not exist.
+
+### What the tolerance does NOT permit
+
+The tolerance exists **only** to absorb low-precision arithmetic noise. You are responsible for a **faithful
+implementation of the specified computation**. It is not a budget to spend on approximation. The following
+are wrong answers even if they happen to land inside the tolerance at some shape:
+
+- changing the algorithm to something that merely *approximates* the spec (dropping terms, truncating a
+  series, low-rank or sketched substitutes, skipping a correction term);
+- shortening the computation (fewer iterations/steps than specified, early exit on a heuristic, subsampling
+  or striding over the sequence, ignoring positions whose contribution "looks small");
+- computing at a coarser granularity than the spec (sharing a decay, scale, or normaliser across positions
+  that the spec gives their own);
+- anything whose error **grows** with sequence length, batch, or head count.
+
+A faithful bf16/fp8 kernel's error is *noise*: it stays flat as the problem grows and sits an order of
+magnitude below the gate. An approximation's error is *bias*: it scales with the problem. The graded shapes
+are deliberately large, so the difference shows up.
+
+## What's available
+
+- **Triton 3.6** (with Gluon), **CUDA C++ via `nvcc`** (`torch.utils.cpp_extension.load` for an inline
+  extension), header-only **CUTLASS** at `/opt/cutlass/include`, and the **CuTe DSL**
+  (`nvidia-cutlass-dsl`). C++ / CuTe DSL is the encouraged route; Triton is fully supported.
+- `torch` 2.11 (CUDA 12.8) and `einops` for bookkeeping.
+- A GPU with compute capability sm≥90 (Hopper or newer).
+- **No internet access.** `pip install` and cloning repos are blocked. Everything you are permitted to use is
+  already installed, and no library implementation of this kernel exists on the machine.
+- Manage any long-running background job (a build, an `ncu`/`nsys` profile) by its **recorded PID** — see
+  `/app/CLAUDE.md` and `/app/PROCESS_MANAGEMENT.md`.
+
+## How the grading actually runs (so there are no surprises)
+
+- **`/app/worklist.py` is the only file that is graded.** The grader imports `build_block_worklist` from it and reads nothing
+  else from `/app`.
+- **The grader is not on this machine while you work.** It is copied in only after your session ends and it
+  carries its **own private copy of the reference** and its own input generator. Editing `/app/reference.py`
+  or `/app/measure.py` is allowed — they are yours to experiment with — but it has **no effect whatsoever on
+  your score**. Do not spend budget on them.
+- **Every timed repetition uses freshly generated inputs**, and the output of a timed call is itself checked
+  against the reference. Caching or memoizing a result and replaying it fails the correctness gate rather
+  than producing a fast measurement. Ordinary shape-keyed JIT/autotune caching is fine and is not penalised.
+- **The timed shapes are correctness-checked too.** Being correct only at the small shapes scores **0**.
+- Inputs are random each grade and the graded shapes are not the ones in `measure.py`.

tasks/video-sparse-attention/sparse-block-worklist-build/task.toml

@@ -0,0 +1,38 @@
+schema_version = "1.1"
+
+[task]
+name = "mle-bench/sparse-block-worklist-build"
+description = "Between the mask builder and the attention kernel sits the piece nobody writes about and everybody needs: turning a per-head tile BITMAP into the flat work list a block-sparse attention kernel actually consumes. Popcount every row, prefix-sum 300k rows into CSR offsets, compact the live (query tile, key tile) pairs in row-major order, and cut the result into equal-work slices for a persistent grid. It is a scan and a stream compaction over a gigabyte of pairs, and it runs before every attention call."
+authors = []
+keywords = ["mle", "kernel-generation", "sparse-attention", "video-diffusion", "block-mask", "prefix-sum", "stream-compaction", "scheduling", "csr", "load-balancing"]
+
+[metadata]
+suite = "mle-bench"
+group = "kernel-generation"
+level = "1.0"
+difficulty = "hard"
+category = "mle"
+tags = [ "mle", "kernel-generation", "kernels", "gpu", "real-world",]
+
+[verifier]
+timeout_sec = 1800.0
+
+[agent]
+timeout_sec = 14400.0
+
+# GPU request: honored by Modal/GKE/Daytona. On the local docker backend set environment.override_gpus: 0
+# in the job config and attach a GPU via configs/gpu_overlay_nvidia.yaml (see RUNNING.md §5).
+[environment]
+build_timeout_sec = 3600.0
+cpus = 8
+memory_mb = 65536
+storage_mb = 40960
+gpus = 1
+network_mode = "public"
+mcp_servers = []
+
+[verifier.env]
+
+[environment.env]
+
+[solution.env]

tasks/video-sparse-attention/sparse-block-worklist-build/tests/test.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# GENERATED by _factory/build.py. python3 (not python): some CUDA bases lack the symlink.
+set -u
+mkdir -p /logs/verifier
+python3 /tests/verify_env.py

tasks/video-sparse-attention/sparse-block-worklist-build/tests/verify_env.py

@@ -0,0 +1,219 @@
+"""sparse-block-worklist-build verifier — correctness gate + achieved-GB/s SPEED LEADERBOARD (uncapped).
+
+    reward = 0                                     if the submission is incorrect
+    reward = geomean over graded shapes of GB/s otherwise
+
+GENERATED by _factory/build.py — do not edit here; edit the spec and regenerate.
+
+There is no gold solution and no oracle: the score is an absolute hardware metric, so it is hardware-portable
+by construction and nothing has to be vendored, sealed, or re-benchmarked.
+
+CORRECTNESS is a hard gate, checked against an INDEPENDENT (embedded) copy of the reference at every graded
+shape including the timed ones, so editing /app/reference.py cannot affect grading and a fast wrong kernel
+scores 0.
+
+ANTI-CHEAT on the timing path: every timed rep runs on FRESHLY generated inputs, and the output of the last
+timed rep is itself validated against the reference for those exact inputs. A submission that memoizes a
+result and replays it fails the gate instead of posting an inflated number. Warm-up runs on a separate
+throwaway input set, so ordinary shape-keyed JIT/autotune caching is not penalised.
+
+WORK is attributed by a CANONICAL formula that depends only on the shape, never on the implementation, so all
+submissions are credited identically and the ranking is a pure speed ranking.
+"""
+import importlib.util
+import json
+import math
+import os
+import sys
+import traceback
+
+import torch
+
+REWARD_DIR = "/logs/verifier"
+MODULE_PATH = "/app/worklist.py"
+TOL = 0.0
+NAMES = ('counts', 'offsets', 'pairs', 'bucket_row')
+
+GRADER_SHAPES = [(2, 40, 4096, 4096, 12, 2048), (2, 24, 4608, 4608, 14, 1024), (4, 24, 3200, 3200, 16, 4096), (1, 40, 5120, 5120, 14, 2048), (2, 32, 3840, 3840, 16, 1536)]
+CORRECT_SHAPES = [(1, 4, 128, 128, 12, 32), (2, 3, 96, 256, 15, 17), (1, 6, 200, 64, 25, 8), (1, 2, 64, 512, 9, 64), (2, 5, 150, 128, 30, 100), (1, 3, 77, 88, 18, 13)]
+
+sys.path.insert(0, "/app")
+
+def _live_counts(B, NH, NQ, NK, DEN):
+    """Live key tiles per (batch, head, query tile), from the SHAPE ALONE.
+
+    About DEN percent of the NK tiles survive, jittered by +-1 per row so the rows are genuinely ragged, and
+    always at least 1.
+    """
+    out = []
+    base = (NK * DEN) // 100
+    for b in range(B):
+        for h in range(NH):
+            for i in range(NQ):
+                c = base + ((b * 31 + h * 17 + i * 7) % 3) - 1
+                out.append(min(max(c, 1), NK))
+    return out
+
+
+def canonical_work(B, NH, NQ, NK, DEN, P):
+    """BYTES moved by one call, from the SHAPE ALONE.
+
+    Read the packed bitmap once (NK/8 bytes per row), write the counts and the CSR offsets (4 bytes per
+    row each), and write the compacted pair list (8 bytes per live pair). The live count is fixed by the
+    shape, so the pair list has the same length for every submission.
+    """
+    R = B * NH * NQ
+    L = sum(_live_counts(B, NH, NQ, NK, DEN))
+    return R * (NK // 8) + 8 * L + 8 * R + 4 * (P + 1)
+
+def _ref(bits, n_key_blocks, n_buckets):
+    """Unpack, popcount, prefix-sum, compact and partition — written as dense boolean tensor algebra.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target. It materialises the
+    whole boolean mask one (batch, head) at a time and calls nonzero() on it.
+    """
+    B, NH, NQ, NW = bits.shape
+    NK = n_key_blocks
+    dev = bits.device
+    sh = torch.arange(8, device=dev, dtype=torch.uint8)
+
+    counts = torch.empty(B, NH, NQ, device=dev, dtype=torch.int32)
+    chunks = []
+    for b in range(B):
+        for h in range(NH):
+            m = (((bits[b, h].unsqueeze(-1) >> sh) & 1) != 0).reshape(NQ, NW * 8)[:, :NK]
+            counts[b, h] = m.sum(-1, dtype=torch.int32)
+            nz = m.nonzero()                                        # row-major: row asc, then col asc
+            base = (b * NH + h) * NQ
+            chunks.append(torch.stack([nz[:, 0].to(torch.int32) + base,
+                                       nz[:, 1].to(torch.int32)], dim=1))
+    pairs = torch.cat(chunks, dim=0)
+
+    flat = counts.reshape(-1)
+    offsets = torch.zeros(flat.numel() + 1, device=dev, dtype=torch.int32)
+    offsets[1:] = torch.cumsum(flat, 0, dtype=torch.int64).to(torch.int32)
+    L = int(offsets[-1].item())
+
+    split = (torch.arange(n_buckets + 1, device=dev, dtype=torch.int64) * L) // n_buckets
+    bucket_row = torch.searchsorted(offsets.to(torch.int64), split, right=False).to(torch.int32)
+    return counts, offsets, pairs, bucket_row
+
+def _mk(B, NH, NQ, NK, DEN, P, seed):
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    cnt = torch.tensor(_live_counts(B, NH, NQ, NK, DEN), device="cuda").view(B, NH, NQ)
+    kmax = int(cnt.max().item())
+    sh = torch.arange(8, device="cuda", dtype=torch.int32)
+    bits = torch.empty(B, NH, NQ, NK // 8, device="cuda", dtype=torch.uint8)
+    for b in range(B):
+        for h in range(NH):
+            r = torch.rand(NQ, NK, device="cuda", generator=gen)
+            idx = r.topk(kmax, dim=-1).indices                       # (NQ, kmax) random distinct columns
+            live = torch.arange(kmax, device="cuda").view(1, -1) < cnt[b, h].view(-1, 1)
+            m = torch.zeros(NQ, NK, dtype=torch.bool, device="cuda")
+            m.scatter_(1, torch.where(live, idx, idx[:, :1]), True)   # rank 0 is always live
+            bits[b, h] = ((m.view(NQ, NK // 8, 8).to(torch.int32) << sh).sum(-1)).to(torch.uint8)
+    return bits, NK, P
+
+
+def _check(out, ref):
+    """-> (ok, value, msg). value = MAX relative error across the returned tuple."""
+    if out is None or len(out) != len(NAMES):
+        return False, 1.0, f"expected a {len(NAMES)}-tuple {NAMES}"
+    per = []
+    for n, a, b in zip(NAMES, out, ref):
+        if a is None or tuple(a.shape) != tuple(b.shape):
+            return False, 1.0, f"{n} bad shape"
+        if b.dtype in (torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8, torch.bool):
+            # exact: .float() is lossy above 2**24 and would let distinct large ids compare equal
+            bad = int((a != b).sum())
+            if bad:
+                return False, 1.0, f"{n}: {bad} elements differ"
+            continue
+        per.append((n, float((a.float() - b.float()).norm() / (b.float().norm() + 1e-12))))
+    if not per:
+        return True, 0.0, "all integer outputs exact"
+    wn, wv = max(per, key=lambda x: x[1])
+    return wv <= TOL, wv, f"worst {wn} {wv:.2e}"
+
+
+def _bench_fresh(fn, mkargs, reps=5, warm=3):
+    """Time `fn` on FRESH inputs every rep -> (min_seconds, timed_ok). See the module docstring."""
+    wargs = mkargs(0)
+    for _ in range(warm):
+        fn(*wargs)
+    torch.cuda.synchronize()
+    del wargs
+    torch.cuda.empty_cache()
+
+    best, timed_ok = float("inf"), True
+    for i in range(reps):
+        args = mkargs(10_000 + i)
+        s, e = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True)
+        s.record()
+        out = fn(*args)
+        e.record()
+        torch.cuda.synchronize()
+        best = min(best, s.elapsed_time(e))
+        if i == reps - 1:
+            timed_ok = _check(out, _ref(*args))[0]
+        del args, out
+        torch.cuda.empty_cache()
+    return best / 1e3, timed_ok
+
+
+def _geomean(xs):
+    return math.exp(sum(math.log(max(v, 1e-9)) for v in xs) / len(xs)) if xs else 0.0
+
+
+def main():
+    details, correct_gate, geo = {}, False, 0.0
+    try:
+        spec = importlib.util.spec_from_file_location("submission", MODULE_PATH)
+        m = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(m)
+        fn = m.build_block_worklist
+
+        corr_ok, msg = True, ""
+        for i, shp in enumerate(CORRECT_SHAPES):
+            args = _mk(*shp, seed=10 + i)
+            ok, val, m_ = _check(fn(*args), _ref(*args))
+            if not ok:
+                corr_ok, msg = False, f"cfg{i} {shp} {m_}"
+                break
+            del args
+            torch.cuda.empty_cache()
+        details["correct_msg"] = msg or "all correctness shapes pass"
+
+        vals, per_shape, perf_ok = [], [], corr_ok
+        for i, shp in enumerate(GRADER_SHAPES):
+            args = _mk(*shp, seed=100 + i)
+            ok, val, m_ = _check(fn(*args), _ref(*args))
+            if not ok:
+                perf_ok = False
+            del args
+            torch.cuda.empty_cache()
+            t, timed_ok = _bench_fresh(fn, lambda s, _p=shp: _mk(*_p, seed=s))
+            if not timed_ok:
+                perf_ok = False
+            v = canonical_work(*shp) / t / 2**30 if t > 0 else 0.0
+            vals.append(v)
+            per_shape.append({"shape": list(shp), "gbps": round(v, 3), "ms": round(t * 1e3, 3),
+                              "check": m_, "timed_ok": timed_ok})
+        geo = _geomean(vals)
+        details.update(per_shape=per_shape, geomean=round(geo, 4), perf_size_ok=perf_ok)
+        correct_gate = corr_ok and perf_ok
+    except Exception as e:
+        details["error"] = f"{e.__class__.__name__}: {e}"[:220]
+        details["trace"] = traceback.format_exc()[-800:]
+
+    reward = round(geo, 4) if correct_gate else 0.0
+    os.makedirs(REWARD_DIR, exist_ok=True)
+    json.dump({"reward": reward, "correct": 1.0 if correct_gate else 0.0,
+               "geomean": round(geo, 4), "metric": "GB/s (geomean over graded shapes)"},
+              open(f"{REWARD_DIR}/reward.json", "w"), indent=2)
+    open(f"{REWARD_DIR}/reward.txt", "w").write(str(reward))
+    json.dump(details, open(f"{REWARD_DIR}/details.json", "w"), indent=2, default=str)
+    print("reward:", reward, "GB/s | correct:", 1.0 if correct_gate else 0.0)
+
+
+main()

tasks/video-sparse-attention/spatial-window-temporal-global/RUN.md

@@ -0,0 +1,42 @@
+# Running `spatial-window-temporal-global`
+
+Local in space, global in time: every token attends densely inside a small window of its own frame, and additionally to a uniform stride-`s` sample of every OTHER frame, so the whole clip stays visible for a few percent of the keys. Two gathers with opposite characters — a short 2D box with row stride Ww, and a long stride-`s` comb spanning the entire sequence — sharing one softmax, plus a boundary rule that keeps the two sets disjoint.
+
+|  |  |
+|---|---|
+| **Task id** | `mle-bench/spatial-window-temporal-global` |
+| **Group** | `kernel-generation` |
+| **GPUs** | 1 |
+| **Agent edits** | `/app/win_global.py` |
+| **Score** | achieved **TFLOP/s** (uncapped speed leaderboard), `0` if incorrect |
+| **Grade output** | `tests/test.sh` -> `/logs/verifier/reward.json` |
+
+## Run through harbor
+
+```bash
+harbor run --dataset-path kernel-generation/kernels/spatial-window-temporal-global --task-name spatial-window-temporal-global \
+  --agent claude-code --model anthropic/claude-opus-4-1 -e docker
+```
+
+## Run manually
+
+```bash
+cd kernel-generation/kernels/spatial-window-temporal-global
+docker build -t spatial-window-temporal-global environment/
+docker run -d --name v --gpus '"device=0"' --shm-size=8g --entrypoint sleep spatial-window-temporal-global infinity
+docker cp tests v:/tests && docker exec v bash /tests/test.sh   # untouched start -> reward 0.0
+docker rm -f v
+```
+
+Use an **idle** GPU: the score is a timing measurement.
+
+## Design
+
+Correctness is a hard gate; the score is an absolute hardware metric (TFLOP/s), so the task is
+hardware-portable and needs no gold solution, no oracle, and nothing vendored or sealed.
+
+Anti-cheat is structural: the image holds only the permitted toolchain and has no internet; the grader is
+copied in at grade time with its own private copy of the reference; and every timed rep runs on fresh inputs
+with the timed output itself validated, so memoize-and-replay fails the gate.
+
+Generated by `_factory/build.py` — edit the spec and regenerate rather than editing this task by hand.

tasks/video-sparse-attention/spatial-window-temporal-global/environment/CLAUDE.md

@@ -0,0 +1,25 @@
+# Working in this environment
+
+## ⚠️ Stop background processes without killing yourself
+
+You are launched as `claude --print -- '<the task instruction>'`, so the task text — including the
+file names and commands it mentions — is on **your own** process's command line. Any command that
+finds processes by **matching that text** (`pkill -f …`, `pgrep -f … | xargs kill`, a `/proc`
+cmdline scan, `fuser -k`, `killall`) can match and **kill the agent itself**, ending your run
+(`NonZeroAgentExitCodeError`) and grading you on unfinished work.
+
+This bites whenever you background something and later stop/restart it — a **server**, a long
+**build** or **training run**, or an **ncu / nsys profiling** session.
+
+**Always** manage a background process by its **exact recorded PID**, never by a name pattern:
+
+```bash
+nohup <your command> > /tmp/job.log 2>&1 & echo $! > /tmp/job.pid   # start + record the PID
+kill "$(cat /tmp/job.pid)"; sleep 3                                 # stop (SIGTERM); -9 only if needed
+```
+
+Use `setsid` and kill the process **group** (`kill -- -"$(cat /tmp/job.pid)"`) if it spawns children.
+If you must enumerate processes, match a **unique token that is NOT anywhere in this prompt** and
+**exclude any cmdline containing `claude` or `--print`** — `pgrep -af`, and look before you kill.
+
+Full details + safe recipes: **`/app/PROCESS_MANAGEMENT.md`**.

tasks/video-sparse-attention/spatial-window-temporal-global/environment/Dockerfile

@@ -0,0 +1,41 @@
+# Kernel-generation task: Write a fast spatial-window + strided-global video attention kernel
+#
+# Local in space, global in time: every token attends densely inside a small window of its own frame, and additionally to a uniform stride-`s` sample of every OTHER frame, so the whole clip stays visible for a few percent of the keys. Two gathers with opposite characters — a short 2D box with row stride Ww, and a long stride-`s` comb spanning the entire sequence — sharing one softmax, plus a boundary rule that keeps the two sets disjoint.
+#
+# SCORING: correctness is a hard gate; the score is achieved TFLOP/s (uncapped leaderboard, 0 if wrong).
+# There is no gold solution and no oracle, so nothing has to be vendored or sealed.
+#
+# TOOLCHAIN POLICY: the agent writes the kernel with Triton (+Gluon), CUDA C++ via nvcc, CUTLASS headers, or
+# the CuTe DSL. Enforcement is by ABSENCE, not by scanning: only the permitted toolchain is installed and
+# there is no internet, so nothing else can be obtained.
+#
+# GENERATED by _factory/build.py.
+FROM pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
+
+# NOTE: every heavy layer comes FIRST and depends only on {base_image, pip_extra}, so all tasks in this
+# lane share the same cached layers. The task-specific COPYs are LAST. Do not reorder.
+RUN pip install --break-system-packages --no-cache-dir einops nvidia-cutlass-dsl && \
+    apt-get update && apt-get install -y --no-install-recommends iptables iproute2 curl ca-certificates build-essential git && \
+    curl -LsSf https://astral.sh/uv/install.sh | sh && \
+    /root/.local/bin/uv tool install mini-swe-agent
+# header-only CUTLASS for the agent's CUDA/CuTe route
+RUN git clone --depth 1 https://github.com/NVIDIA/cutlass /opt/cutlass && rm -rf /opt/cutlass/.git
+# pre-bake Claude Code; harbor's claude_code.install() skips when present
+RUN curl -fsSL https://deb.nodesource.com/setup_22.x | bash - && \
+    apt-get install -y nodejs procps && \
+    npm install -g @anthropic-ai/claude-code && claude --version
+ENV PATH=/root/.local/bin:$PATH
+ENV DISABLE_TELEMETRY=1 DISABLE_AUTOUPDATER=1 DISABLE_ERROR_REPORTING=1 CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1
+
+COPY restrict-network.sh /app/restrict-network.sh
+RUN chmod +x /app/restrict-network.sh
+# strip apt sources LAST so harbor's post-firewall apt step is a no-op that succeeds
+RUN rm -rf /var/lib/apt/lists/* /etc/apt/sources.list /etc/apt/sources.list.d
+
+WORKDIR /app
+COPY CLAUDE.md PROCESS_MANAGEMENT.md /app/
+
+# task-specific files LAST so the layers above stay shared across every task
+COPY reference.py /app/reference.py
+COPY measure.py /app/measure.py
+COPY win_global.py /app/win_global.py

tasks/video-sparse-attention/spatial-window-temporal-global/environment/PROCESS_MANAGEMENT.md

@@ -0,0 +1,96 @@
+# Managing background processes — READ THIS before you `kill` anything
+
+You may start and stop background processes while iterating — a **server**, a long **build** or
+**training run**, or an **ncu / nsys profiling** session. **The way you stop one can silently kill
+*your own agent process* and end the whole run.** This has happened repeatedly, including via a
+hand-rolled `/proc` scan — not just `pkill`. Read this once and follow the safe recipe.
+
+## The trap: matching task text against process command lines
+
+You were launched as roughly:
+
+```
+claude --print -- '<the entire task instruction text>'
+```
+
+The full task instruction is on **your own** process's command line, and it contains the file names
+and commands the task mentions (e.g. `server.py`, `build.sh`, `train.py`, `solution.cu`, `/app/...`).
+So **any** command that finds processes by matching those strings will match — and can kill — **the
+agent itself**:
+
+```
+pkill -9 -f "train.py"                              # matches the claude agent -> kills YOU
+pgrep -f "server.py" | xargs kill                   # same: the pid list includes claude
+for p in $(pgrep -f build.sh); do kill -9 $p; done  # same
+for pid in /proc/*; do case "$(cmdline)" in *solution*) kill -9 $pid;; esac; done   # same
+```
+
+It is **not about `pkill`** — it is about **matching a string that appears in your prompt**. `pgrep`,
+a `/proc` scan, `fuser`, or `nvidia-smi`-pid loops all have the same failure if the match pattern (or
+the surviving pid list) includes the `claude` process. When you `kill -9` yourself the run dies
+immediately (`NonZeroAgentExitCodeError`) and you are graded on whatever was already in place — usually
+worse than what you were about to finish.
+
+## The one safe rule: kill only the exact PID you recorded
+
+**Start** a background job and record its PID in a file:
+
+```bash
+nohup <your command> > /tmp/job.log 2>&1 &
+echo $! > /tmp/job.pid
+```
+
+**Stop / restart** by that exact PID — never by a name pattern:
+
+```bash
+kill "$(cat /tmp/job.pid)" 2>/dev/null      # SIGTERM: lets it release the GPU / flush cleanly
+sleep 3
+kill -9 "$(cat /tmp/job.pid)" 2>/dev/null   # force only if it did not exit
+```
+
+If the job spawns workers, run it in its own process group and signal the group by its (negative)
+PGID — still an exact id, never a pattern:
+
+```bash
+setsid <your command> > /tmp/job.log 2>&1 < /dev/null & echo $! > /tmp/job.pid
+kill -TERM -- "-$(cat /tmp/job.pid)" 2>/dev/null
+```
+
+## If you ever enumerate processes, EXCLUDE the agent
+
+Prefer not to. But if you must scan (e.g. hunting a leaked worker), **exclude the `claude` agent and
+your own shell**, and match on a **unique token that is NOT anywhere in this prompt** — give your job
+a unique name and match only that:
+
+```bash
+# job named e.g. job_7x3q9 — a token that appears NOWHERE in the task text
+pgrep -af job_7x3q9 | grep -v -E 'claude|--print|pgrep|grep|bash'   # LOOK FIRST
+# only kill pids from THIS filtered list, and never a pid whose cmdline contains 'claude' or '--print'
+```
+
+Do **not** add a prompt word (a file name, `/app`, `python3`, …) to the pattern "just in case" — that
+single addition re-introduces the self-kill. Match the unique token **only**.
+
+## Freeing the GPU without going nuclear
+
+If VRAM stays high after you stop a GPU job, the usual cause is a **child process** or a not-yet-
+collected CUDA context — not a stray process you need to hunt across `/proc`. Do this instead of a
+`/proc` sweep:
+
+- Kill the job **by its recorded PID / PGID** (above) and `sleep 5–10`; the CUDA context frees after
+  the process fully exits.
+- Make the job release cleanly on `SIGTERM` (drop the model / `torch.cuda.empty_cache()` / exit) so a
+  single `kill $PID` is enough.
+- Start it in its own group (`setsid`) so `kill -- -$PGID` takes the workers with it.
+- Check with `nvidia-smi` — if a PID still holds memory, `kill` **that exact numeric PID**, after
+  confirming its cmdline is **not** `claude` / `--print`.
+
+## Rules of thumb
+
+- **Never** match a task-prompt string (`server.py`, `train.py`, `build.sh`, `/app`, `python3`, …)
+  with `pkill -f`, `pgrep -f`, `killall`, `fuser`, or a `/proc` cmdline scan — they all can hit the
+  agent (its argv holds the prompt).
+- **Always** kill a background job by the exact PID from its pidfile (or its PGID).
+- If you must enumerate, match a **unique token not in the prompt** and **exclude `claude` / `--print`
+  and your own shell**; `pgrep -af` and look before you kill.
+- `SIGTERM` first for a clean release; `-9` only as a last resort on a specific numeric PID.

tasks/video-sparse-attention/spatial-window-temporal-global/environment/docker-compose.yaml

@@ -0,0 +1,18 @@
+# Anti-cheat firewall overlay, merged on top of Harbor's base compose. Gives the main container
+# NET_ADMIN and runs restrict-network.sh as the entrypoint, so only DNS + the LLM API endpoints are
+# reachable (pypi/github/HF blocked). network_mode stays "public" (see task.toml) — the firewall, not
+# Docker, enforces the allowlist. mini-swe-agent is pre-installed and harbor's patched installer skips
+# the (now-blocked) network install when it is already present.
+services:
+  main:
+    cap_add:
+      - NET_ADMIN
+    entrypoint: ["/bin/bash", "/app/restrict-network.sh"]
+    environment:
+      - ALLOWED_HOSTS=${ALLOWED_HOSTS:-}
+      - FIREWORKS_BASE_URL=${FIREWORKS_BASE_URL:-}
+      - OPENROUTER_BASE_URL=${OPENROUTER_BASE_URL:-}
+      - OPENAI_BASE_URL=${OPENAI_BASE_URL:-}
+      - ANTHROPIC_BASE_URL=${ANTHROPIC_BASE_URL:-}
+      - LLM_BASE_URL=${LLM_BASE_URL:-}
+      - LITELLM_BASE_URL=${LITELLM_BASE_URL:-}

tasks/video-sparse-attention/spatial-window-temporal-global/environment/measure.py

@@ -0,0 +1,112 @@
+"""Self-assessment tool — your correctness + achieved TFLOP/s across a RANGE of shapes.
+
+    python /app/measure.py            # the graded regime
+    python /app/measure.py --quick    # smaller sizes for fast iteration
+
+You are scored on the **geomean achieved TFLOP/s** — NOT one fixed size, and the leaderboard is UNCAPPED
+(higher is always better). The shapes below are a DIFFERENT sample from the same regime the grader uses, so
+optimize for GENERALITY. Work is counted with the same shape-only formula the grader uses, so the number
+printed here is computed exactly as your score is.
+
+GENERATED by _factory/build.py.
+"""
+import argparse
+import math
+import sys
+
+import torch
+
+sys.path.insert(0, "/app")
+from reference import window_global_stride_attention as _ref
+from win_global import window_global_stride_attention as _agent
+
+TOL = 0.005
+
+FULL = [(1, 24, 48, 80, 16, 128, 4, 8, 3, 3, 128), (1, 16, 48, 80, 24, 128, 4, 8, 3, 3, 96), (1, 24, 48, 80, 12, 128, 2, 8, 5, 3, 128), (1, 20, 48, 64, 24, 64, 4, 8, 3, 5, 96), (2, 12, 32, 64, 24, 128, 4, 8, 3, 3, 64)]
+QUICK = [(1, 8, 24, 40, 8, 128, 4, 8, 3, 3, 48), (1, 12, 16, 40, 8, 64, 4, 8, 3, 3, 32), (1, 8, 24, 32, 8, 128, 4, 8, 3, 3, 48)]
+
+def canonical_work(B, F, Hh, Ww, NH, D, TH, TW, WH, WW, STR):
+    """FLOPs attributed to one forward, from the SHAPE ALONE.
+
+    Every query sees WH*WW spatial tiles of TS = TH*TW tokens inside its own frame (the window is clamped
+    inward, never truncated) plus (F-1)*S/STR strided keys drawn from the OTHER frames -- the two sets are
+    disjoint by construction. Each pair costs 4*D FLOPs.
+    """
+    TS = TH * TW
+    S = Hh * Ww
+    keys = WH * WW * TS + (F - 1) * (S // STR)
+    return 4 * D * B * NH * (F * S) * keys
+
+def _mk(B, F, Hh, Ww, NH, D, TH, TW, WH, WW, STR, seed):
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    T = F * Hh * Ww
+    def r():
+        return torch.randn(B, T, NH, D, device="cuda", dtype=torch.bfloat16, generator=gen)
+    return r(), r(), r(), (F, Hh, Ww), (TH, TW), (WH, WW), STR
+
+
+def _is_exact(t):
+    """Integer/bool tensors are compared EXACTLY: .float() is lossy above 2**24, so two distinct large
+    ids (page ids, token ids, indices) can compare equal and let a wrong kernel pass."""
+    return t.dtype in (torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8, torch.bool)
+
+
+def _check(out, ref):
+    """-> (ok, value, msg). Exact for integer/bool; relative Frobenius error otherwise."""
+    if out is None or tuple(out.shape) != tuple(ref.shape):
+        return False, 1.0, "bad/None shape"
+    if _is_exact(ref):
+        bad = int((out != ref).sum())
+        return bad == 0, float(bad), ("exact match" if bad == 0 else f"{bad} elements differ")
+    e = float((out.float() - ref.float()).norm() / (ref.float().norm() + 1e-12))
+    return e <= TOL, e, f"relerr {e:.2e}"
+
+
+def _bench(fn, reps=8, warm=3):
+    for _ in range(warm):
+        fn()
+    torch.cuda.synchronize()
+    best = float("inf")
+    for _ in range(reps):
+        s, e = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True)
+        s.record()
+        fn()
+        e.record()
+        torch.cuda.synchronize()
+        best = min(best, s.elapsed_time(e))
+    return best / 1e3
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--quick", action="store_true")
+    a = ap.parse_args()
+    shapes = QUICK if a.quick else FULL
+    print(f"geomean over {len(shapes)} shapes ({'quick' if a.quick else 'full'}); the grader uses "
+          f"DIFFERENT sizes in the same regime — optimize for generality\n")
+    vals, allok = [], True
+    for shp in shapes:
+        args = _mk(*shp, seed=sum(int(x) for x in shp) % 9973)
+        ref = _ref(*args)
+        try:
+            out = _agent(*args)
+        except Exception as ex:
+            print(f"  {shp}: RAISED {type(ex).__name__}: {str(ex)[:70]}")
+            allok = False
+            continue
+        ok, val, msg = _check(out, ref)
+        allok = allok and ok
+        t = _bench(lambda: _agent(*args))
+        v = canonical_work(*shp) / t / 1e12 if t > 0 else 0.0
+        vals.append(v)
+        print(f"  {str(shp):28s} {t*1e3:9.2f} ms | {v:9.2f} TFLOP/s | {msg} {'ok' if ok else 'FAIL'}")
+        del args, ref, out
+        torch.cuda.empty_cache()
+    geo = math.exp(sum(math.log(max(v, 1e-9)) for v in vals) / len(vals)) if vals else 0.0
+    print(f"\n  => GEOMEAN {geo:.2f} TFLOP/s   "
+          f"({'all correct' if allok else 'SOME WRONG — a wrong kernel scores 0, fix correctness first'})")
+    print("     This IS your score, and it is uncapped — higher is always better. Keep pushing.")
+
+
+if __name__ == "__main__":
+    main()

tasks/video-sparse-attention/spatial-window-temporal-global/environment/reference.py

@@ -0,0 +1,62 @@
+"""Reference implementation — the CORRECTNESS SPEC for `window_global_stride_attention`.
+
+This is correct but slow. It defines exactly what your kernel must reproduce; its speed has no
+bearing on your score, which is an absolute TFLOP/s number. GENERATED by _factory/build.py.
+"""
+import torch
+
+
+def window_global_stride_attention(q, k, v, latent, tile, window, stride, scale=None):
+    """In-frame tile window + strided sample of the other frames, as an explicit gather in fp32.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target. It gathers the whole
+    window of every query tile and the whole global set of every query frame and softmaxes them densely.
+    """
+    B, T, NH, D = q.shape
+    F, Hh, Ww = latent
+    th, tw = tile
+    wh, ww = window
+    nsh, nsw = Hh // th, Ww // tw
+    nsp = nsh * nsw
+    TS = th * tw
+    NW = wh * ww
+    S = Hh * Ww
+    if scale is None:
+        scale = D ** -0.5
+    dev = q.device
+
+    def to_tiles(x):
+        return (x.view(B, F, nsh, th, nsw, tw, NH, D)
+                 .permute(0, 1, 2, 4, 3, 5, 6, 7)
+                 .reshape(B, F, nsp, TS, NH, D))
+
+    qt, kt, vt = to_tiles(q.float()), to_tiles(k.float()), to_tiles(v.float())
+    kf, vf = k.float(), v.float()
+    ot = torch.empty(B, F, nsp, TS, NH, D, device=dev, dtype=torch.float32)
+
+    sp = torch.arange(nsp, device=dev)
+    sh = (sp // nsw - wh // 2).clamp(0, nsh - wh)
+    sw = (sp % nsw - ww // 2).clamp(0, nsw - ww)
+    ih = sh[:, None] + torch.arange(wh, device=dev)
+    iw = sw[:, None] + torch.arange(ww, device=dev)
+    wt = (ih[:, :, None] * nsw + iw[:, None, :]).reshape(nsp, NW)      # (nsp, wh*ww) tile ids
+
+    off = torch.arange(0, S, stride, device=dev)                       # sampled offsets inside a frame
+    step = max(1, int(4e8) // max(1, (NW * TS + (F - 1) * off.numel()) * NH * D * 4))
+    for f in range(F):
+        other = torch.tensor([x for x in range(F) if x != f], device=dev, dtype=torch.long)
+        gidx = (other[:, None] * S + off[None, :]).reshape(-1)          # global keys of this query frame
+        kg, vg = kf[:, gidx], vf[:, gidx]                               # (B, NG, NH, D)
+        for s0 in range(0, nsp, step):
+            e0 = min(nsp, s0 + step)
+            g = wt[s0:e0]
+            kc = torch.cat([kt[:, f][:, g].reshape(B, e0 - s0, NW * TS, NH, D),
+                            kg.unsqueeze(1).expand(B, e0 - s0, gidx.numel(), NH, D)], dim=2)
+            vc = torch.cat([vt[:, f][:, g].reshape(B, e0 - s0, NW * TS, NH, D),
+                            vg.unsqueeze(1).expand(B, e0 - s0, gidx.numel(), NH, D)], dim=2)
+            qc = qt[:, f, s0:e0] * scale
+            s = torch.einsum("bcqhd,bckhd->bchqk", qc, kc)
+            ot[:, f, s0:e0] = torch.einsum("bchqk,bckhd->bcqhd", torch.softmax(s, dim=-1), vc)
+
+    return (ot.reshape(B, F, nsh, nsw, th, tw, NH, D)
+              .permute(0, 1, 2, 4, 3, 5, 6, 7).reshape(B, T, NH, D))

tasks/video-sparse-attention/spatial-window-temporal-global/environment/restrict-network.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+# Outbound firewall (anti-cheat): allow ONLY DNS, loopback, docker-internal networks, and the LLM API
+# endpoints the agent needs. Everything else is dropped — in particular pypi, github, and huggingface,
+# so the agent cannot `pip install vllm` / `pip install sglang` / clone the reference moe_align kernel and
+# copy it. torch + triton are already in the image, and mini-swe-agent is pre-installed (harbor's patched
+# installer skips the network install when it is already present), so no package index is needed at run time.
+#
+# Runs as the container ENTRYPOINT before the CMD. iptables rules are network-namespace-wide, so they also
+# apply to the agent's `docker exec` commands. Requires cap_add: NET_ADMIN.
+set -uo pipefail
+
+# LLM API endpoints the agent may reach. Extend at launch via ALLOWED_HOSTS=host1,host2 (no scheme).
+API_HOSTS=(
+    api.fireworks.ai
+    openrouter.ai openrouter.io
+    api.openai.com api.anthropic.com generativelanguage.googleapis.com
+    api.together.xyz integrate.api.nvidia.com api.moonshot.cn api.kimi.com
+)
+# Auto-allow hosts from any *_BASE_URL / *_ENDPOINT env var (ANTHROPIC_BASE_URL, OPENAI_BASE_URL, …).
+CUSTOM=()
+while IFS='=' read -r n v; do
+    case "$n" in
+        *_BASE_URL|*_URL|*_ENDPOINT)
+            [ -n "$v" ] && CUSTOM+=("$(echo "$v" | sed 's|.*://||; s|[:/].*||')") ;;
+    esac
+done < <(env)
+if [ -n "${ALLOWED_HOSTS:-}" ]; then IFS=',' read -ra E <<< "$ALLOWED_HOSTS"; CUSTOM+=("${E[@]}"); fi
+ALL_HOSTS=("${API_HOSTS[@]}" ${CUSTOM[@]+"${CUSTOM[@]}"})
+
+if iptables -L OUTPUT -n >/dev/null 2>&1; then
+    echo "restrict-network: applying outbound allowlist firewall..."
+    iptables -F OUTPUT 2>/dev/null || true
+    iptables -A OUTPUT -o lo -j ACCEPT
+    iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
+    iptables -A OUTPUT -p udp --dport 53 -j ACCEPT
+    iptables -A OUTPUT -p tcp --dport 53 -j ACCEPT
+    iptables -A OUTPUT -d 10.0.0.0/8 -j ACCEPT
+    iptables -A OUTPUT -d 172.16.0.0/12 -j ACCEPT
+    iptables -A OUTPUT -d 192.168.0.0/16 -j ACCEPT
+    iptables -A OUTPUT -d 127.0.0.11 -j ACCEPT
+    for h in "${ALL_HOSTS[@]}"; do
+        for ip in $(getent ahosts "$h" 2>/dev/null | awk '{print $1}' | sort -u); do
+            iptables -A OUTPUT -d "$ip" -j ACCEPT
+        done
+    done
+    iptables -A OUTPUT -j REJECT --reject-with icmp-admin-prohibited
+    echo "restrict-network: outbound locked to DNS + LLM endpoints; pypi/github/HF blocked."
+else
+    echo "restrict-network: WARNING — iptables unavailable (need cap_add NET_ADMIN); NOT firewalled." >&2
+fi
+
+exec "$@"

tasks/video-sparse-attention/spatial-window-temporal-global/environment/win_global.py

@@ -0,0 +1,26 @@
+"""Your implementation goes here.
+
+Replace the body of `window_global_stride_attention` with a FAST implementation that reproduces the output of /app/reference.py
+(same signature, same numerics within tolerance) but is much faster — see /app/instruction.md.
+Run `python /app/measure.py` to check your correctness and achieved TFLOP/s.
+
+You may add helper modules, Triton kernels, CUDA extensions, caches, etc. — only this function's name,
+signature and returned value are fixed by the contract.
+"""
+
+
+def window_global_stride_attention(q, k, v, latent, tile, window, stride, scale=None):
+    """In-frame spatial window + strided global attention.
+
+    Args:
+        q, k, v: (B, T, NH, D) bfloat16 — T = F*Hh*Ww tokens in RASTER order.
+        latent:  (F, Hh, Ww)  tuple of int — latent frames / height / width.
+        tile:    (th, tw)     tuple of int — 2D SPATIAL tile; divides (Hh, Ww) exactly.
+        window:  (wh, ww)     tuple of int — in-frame window measured in spatial TILES, both odd.
+        stride:  int          — global sampling stride within a frame; divides S = Hh*Ww exactly.
+        scale:   float or None — logit scale; None means D ** -0.5.
+
+    Returns:
+        o: (B, T, NH, D), bfloat16 or float32 — must match /app/reference.py numerically.
+    """
+    raise NotImplementedError("Implement a fast window_global_stride_attention in /app/win_global.py")

tasks/video-sparse-attention/spatial-window-temporal-global/instruction.md

@@ -0,0 +1,218 @@
+# Write a fast spatial-window + strided-global video attention kernel
+
+You are given a **correct but slow** reference at **`/app/reference.py`** — `window_global_stride_attention(q, k, v, latent, tile, window, stride, scale=None)`. **Read it, run it, profile it.**
+
+Write **`/app/win_global.py`** with the **same signature** and the **same numerical output**, but **as fast as you can make it**.
+
+```python
+def window_global_stride_attention(q, k, v, latent, tile, window, stride, scale=None):
+    ...
+```
+
+## The computation (this is the exact spec)
+
+The sequence is a 3D latent in **raster order** (`i = (f*Hh + h)*Ww + w`, `T = F*S`,
+`S = Hh*Ww`), and each frame's spatial plane is cut into 2D tiles of size `(th, tw)`:
+`nsh*nsw = (Hh/th)*(Ww/tw)` tiles of `TS = th*tw` tokens, with flat spatial-tile index
+`sp = (h//th)*nsw + (w//tw)`.
+
+A query in frame `f`, spatial tile `sp = bh*nsw + bw`, attends to the union of two **disjoint** sets:
+
+```
+A) the IN-FRAME WINDOW: the (wh x ww) block of spatial tiles of frame f starting at
+      sh = clamp(bh - wh//2, 0, nsh - wh),   sw = clamp(bw - ww//2, 0, nsw - ww)
+   -> wh*ww tiles = wh*ww*TS tokens, all inside frame f     (clamped inward, never truncated)
+
+B) the STRIDED GLOBAL SET: every stride-th token of every OTHER frame,
+      { fk*S + m*stride  :  fk in [0, F), fk != f,  m in [0, S/stride) }
+   -> (F-1) * (S/stride) tokens
+```
+
+`stride` divides `S` exactly, and the sample always starts at offset `0` inside each frame. The two sets are
+disjoint because A lives entirely in frame `f` and B excludes frame `f`, so there is nothing to
+de-duplicate — but the exclusion of the query's own frame from B **is part of the specification**: including
+it would add `S/stride` extra keys, most of which are already inside the window.
+
+Then one softmax over the union:
+
+```
+logit(i, j) = scale * (q_i . k_j)      for j in A(i) UNION B(i)
+o_i         = softmax_j( logit(i, j) ) @ v
+```
+
+with `scale` defaulting to `D ** -0.5`. Bidirectional, no causal mask, no bias, no reweighting: the global
+keys are ordinary keys and get no boost for "representing" the tokens they were sampled from.
+
+Two things worth internalising:
+
+* **B depends only on the query's frame**, not on its spatial position, so all `S` queries of a frame share
+  the same `(F-1)*S/stride` global keys — thousands of queries against one key block.
+* **A depends only on the query's spatial tile**, not on its frame, up to the frame offset — so the *shape*
+  of the window gather is the same in every frame.
+
+`/app/reference.py` gathers the whole window of every query tile and the whole global set of every query
+frame and softmaxes them densely. That is the exact specification; it is deliberately simple rather than
+fast.
+
+## The contract (fixed — do not change these)
+
+| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `q`, `k`, `v` | `(B, T, NH, D)` | `bfloat16` | raster-ordered over the latent |
+| `latent` | 3-tuple | `int` | `(F, Hh, Ww)`; `T == F*Hh*Ww` |
+| `tile` | 2-tuple | `int` | `(th, tw)`; divides `(Hh, Ww)` exactly; `TS = th*tw` is 16-64 |
+| `window` | 2-tuple | `int` | `(wh, ww)` in spatial **tiles**, both odd, `wh <= Hh/th`, `ww <= Ww/tw` |
+| `stride` | scalar | `int` | global sampling stride; **divides `S = Hh*Ww` exactly**, 16-128 |
+| `scale` | scalar | `float` or `None` | logit scale; `None` means `D ** -0.5` |
+
+**Return** `o` of shape `(B, T, NH, D)` in the same raster order as `q`, dtype `bfloat16` or `float32`.
+
+All of `latent`, `tile`, `window`, `stride` are **host-side Python values**, so the whole mask is known
+before launch — there is no device-side indirection anywhere in this task.
+
+`window` may be `(1, 3)` (one correctness shape is). All tensors are CUDA, contiguous, **read-only**. No GQA,
+no causality, no RoPE, no dropout, no bias.
+
+**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): the real
+video latents — `F x Hh x Ww` from `16 x 32 x 64` to `32 x 48 x 80` (33k-123k tokens), `NH` in 12-24, `D` in
+{64, 128}, `tile` `(4,8)` or `(2,8)`, `window` `(3,3)`, `(5,3)` or `(3,5)` tiles, `stride` in {64, 96, 128},
+`B` in 1-2.
+
+That is a few hundred window keys plus one to two thousand global keys — around 1-3% of dense. The two
+branches are of comparable size, so **both** of them matter to the answer and to the score: the work formula
+credits `wh*ww*TS + (F-1)*S/stride` keys per query and nothing else.
+
+## How success is decided (runs on GPU)
+
+**1. Correctness — a required gate.** Your output must match the reference (evaluated in fp32 as a stable ground truth)
+within **relative Frobenius error `5e-3`** at every graded shape, including the timed ones.
+
+The gate is measured. **Noise floor:** two independent implementations agree with the reference to
+**`4.3e-7`** and **`4.9e-7`** — a single dense masked softmax over the raster sequence with the whole key set
+expressed as a per-token boolean predicate (no tile permute, no per-frame gather, no chunking), and a
+flash-style streaming online softmax over 256-key raster tiles, which visits the in-frame and cross-frame
+keys *interleaved* instead of concatenated as the reference does. So neither the geometry nor the
+concatenation order costs anything. The floor is the dtypes: rounding `P` and `V` to bf16 for the `P@V` GEMM
+and returning `o` in bf16 measures **`2.36e-3`**, and the gate is **2.1x** that.
+
+**Discrimination:** dropping the temporal-global branch and attending only inside the query's own frame
+scores **`1.05`**; dropping the spatial window and attending to the whole query frame scores **`0.74`**;
+keeping both branches but ignoring `stride` and taking every token of the other frames scores **`0.97`**.
+All three are 150-200x above the gate. A wrong kernel scores **0**, no matter how fast.
+
+**2. Performance — this is your score, and it is an UNCAPPED leaderboard.**
+
+```
+reward = geomean over graded shapes of ( canonical_work(shape) / your_runtime )   [TFLOP/s]
+reward = 0   if the submission is wrong at any graded shape
+```
+
+`canonical_work` depends **only on the shape**, never on how you implemented it, so every submission is
+credited the same work and this is a pure speed ranking in useful units:
+
+```
+TS    = th*tw ;  S = Hh*Ww ;  T = F*S
+keys  = wh*ww*TS + (F-1) * (S // stride)      # in-frame window + strided sample of the OTHER frames
+FLOPs = 4 * D * B * NH * T * keys             # 2*D for q.k + 2*D for p*v
+```
+
+**There is no cap and no target.** Higher TFLOP/s is always a strictly better score, so **push the
+performance as hard as you can**. Getting a correct implementation is the *start* of the task, not the end of
+it. Once correct, spend the entire remainder of your budget profiling and optimising, re-checking correctness
+after every change. **Use your full time budget.**
+
+Run **`python /app/measure.py`** at any point to see your per-shape and geomean TFLOP/s plus correctness.
+
+## Where the performance comes from
+
+**The global set is shared by a whole frame** — `S` queries (1500-4000 of them) against the
+same `(F-1)*S/stride` keys. That is the dominant structure: make the threadblock own a `(frame, head)` pair
+(or a range of query tiles within one frame) and stream the global block once, keeping it in shared memory a
+tile at a time while all of that frame's query tiles pass over it. A kernel that re-reads the global block
+per query tile does `nsp` times the traffic it needs to.
+
+**The global gather is a stride-`s` comb over the whole sequence**, one element every `stride` tokens, i.e.
+one `D`-wide contiguous row every `stride*NH*D` elements. Vectorise along `D` (a full 128- or 256-byte row per
+key) so each key is one or two coalesced transactions; do *not* let a warp span multiple sampled keys with a
+strided thread mapping. Since the sampled offsets are identical in every frame, the whole comb is
+`(F-1)` copies of one address pattern shifted by `S` — cheap to generate and perfectly prefetchable.
+
+**Skipping the query's own frame** turns the comb into two contiguous ranges of frames (`[0, f)` and
+`(f, F)`), not a predicated walk. Emit it as two loops.
+
+**The window is the cheap branch** but it is where the reuse is: adjacent query tiles along `w` share
+`(ww-1)/ww` of their window tiles, and at a frame edge the clamp makes several query tiles share the *same*
+window. One threadblock per row of query tiles amortises it.
+
+**One softmax.** Run branch A then branch B (or the reverse) inside a single online-softmax loop. Two
+separate attentions followed by an average is simply wrong; two separate attentions followed by a correct
+log-sum-exp merge is right but costs an extra pass over `o` for no reason.
+
+Do not materialise a mask: `T` reaches 123k.
+
+## Precision and faithfulness (read this)
+
+Inputs are **bfloat16**; the output may be bf16 or fp32. Matmuls on bf16 tensor cores with
+**fp32 accumulation**; online-softmax state (running max, running sum, output accumulator) in **fp32**. The
+reduction is 1000-3000 keys long — enough that a bf16 running sum is visible in the norm, and it is *longer*
+for queries in clips with more frames, so the error would grow with `F`.
+
+The tolerance is **`5e-3`**, measured rather than inherited. In fp32 the computation is reproducible to
+**`~5e-7`** by two independent implementations (see the correctness section), so nothing about the two-branch
+key set costs accuracy. What sets the floor is rounding `P` and `V` to bf16 for the second GEMM and returning
+`o` in bf16: **`2.36e-3`**, and the gate is 2.1x that.
+
+**fp8** is acceptable only if you can hold `5e-3`; on a structurally identical task, per-tensor e4m3
+quantisation of `Q` and `K` measured `4.0e-2`, so it does not hold by default.
+
+The global sample is **exactly** every `stride`-th token starting at offset `0` of each frame other than the
+query's own. Do not re-phase the sample per frame, do not round `S/stride` to a convenient tile count, and do
+not include the query's own frame "for symmetry" — each of those changes the set of terms in the denominator,
+a systematic error that grows with `F`, not a rounding difference.
+
+Do **not** infer from the reference that fp32 compute is wanted; it runs in fp32 purely to be a stable
+numerical *specification*.
+
+### What the tolerance does NOT permit
+
+The tolerance exists **only** to absorb low-precision arithmetic noise. You are responsible for a **faithful
+implementation of the specified computation**. It is not a budget to spend on approximation. The following
+are wrong answers even if they happen to land inside the tolerance at some shape:
+
+- changing the algorithm to something that merely *approximates* the spec (dropping terms, truncating a
+  series, low-rank or sketched substitutes, skipping a correction term);
+- shortening the computation (fewer iterations/steps than specified, early exit on a heuristic, subsampling
+  or striding over the sequence, ignoring positions whose contribution "looks small");
+- computing at a coarser granularity than the spec (sharing a decay, scale, or normaliser across positions
+  that the spec gives their own);
+- anything whose error **grows** with sequence length, batch, or head count.
+
+A faithful bf16/fp8 kernel's error is *noise*: it stays flat as the problem grows and sits an order of
+magnitude below the gate. An approximation's error is *bias*: it scales with the problem. The graded shapes
+are deliberately large, so the difference shows up.
+
+## What's available
+
+- **Triton 3.6** (with Gluon), **CUDA C++ via `nvcc`** (`torch.utils.cpp_extension.load` for an inline
+  extension), header-only **CUTLASS** at `/opt/cutlass/include`, and the **CuTe DSL**
+  (`nvidia-cutlass-dsl`). C++ / CuTe DSL is the encouraged route; Triton is fully supported.
+- `torch` 2.11 (CUDA 12.8) and `einops` for bookkeeping.
+- A GPU with compute capability sm≥90 (Hopper or newer).
+- **No internet access.** `pip install` and cloning repos are blocked. Everything you are permitted to use is
+  already installed, and no library implementation of this kernel exists on the machine.
+- Manage any long-running background job (a build, an `ncu`/`nsys` profile) by its **recorded PID** — see
+  `/app/CLAUDE.md` and `/app/PROCESS_MANAGEMENT.md`.
+
+## How the grading actually runs (so there are no surprises)
+
+- **`/app/win_global.py` is the only file that is graded.** The grader imports `window_global_stride_attention` from it and reads nothing
+  else from `/app`.
+- **The grader is not on this machine while you work.** It is copied in only after your session ends and it
+  carries its **own private copy of the reference** and its own input generator. Editing `/app/reference.py`
+  or `/app/measure.py` is allowed — they are yours to experiment with — but it has **no effect whatsoever on
+  your score**. Do not spend budget on them.
+- **Every timed repetition uses freshly generated inputs**, and the output of a timed call is itself checked
+  against the reference. Caching or memoizing a result and replaying it fails the correctness gate rather
+  than producing a fast measurement. Ordinary shape-keyed JIT/autotune caching is fine and is not penalised.
+- **The timed shapes are correctness-checked too.** Being correct only at the small shapes scores **0**.
+- Inputs are random each grade and the graded shapes are not the ones in `measure.py`.

tasks/video-sparse-attention/spatial-window-temporal-global/task.toml

@@ -0,0 +1,38 @@
+schema_version = "1.1"
+
+[task]
+name = "mle-bench/spatial-window-temporal-global"
+description = "Local in space, global in time: every token attends densely inside a small window of its own frame, and additionally to a uniform stride-`s` sample of every OTHER frame, so the whole clip stays visible for a few percent of the keys. Two gathers with opposite characters — a short 2D box with row stride Ww, and a long stride-`s` comb spanning the entire sequence — sharing one softmax, plus a boundary rule that keeps the two sets disjoint."
+authors = []
+keywords = ["mle", "kernel-generation", "attention", "sparse-attention", "video-diffusion", "global-tokens", "strided-gather", "hunyuanvideo", "wan"]
+
+[metadata]
+suite = "mle-bench"
+group = "kernel-generation"
+level = "1.0"
+difficulty = "hard"
+category = "mle"
+tags = [ "mle", "kernel-generation", "kernels", "gpu", "real-world",]
+
+[verifier]
+timeout_sec = 1800.0
+
+[agent]
+timeout_sec = 14400.0
+
+# GPU request: honored by Modal/GKE/Daytona. On the local docker backend set environment.override_gpus: 0
+# in the job config and attach a GPU via configs/gpu_overlay_nvidia.yaml (see RUNNING.md §5).
+[environment]
+build_timeout_sec = 3600.0
+cpus = 8
+memory_mb = 65536
+storage_mb = 40960
+gpus = 1
+network_mode = "public"
+mcp_servers = []
+
+[verifier.env]
+
+[environment.env]
+
+[solution.env]

tasks/video-sparse-attention/spatial-window-temporal-global/tests/test.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# GENERATED by _factory/build.py. python3 (not python): some CUDA bases lack the symlink.
+set -u
+mkdir -p /logs/verifier
+python3 /tests/verify_env.py

tasks/video-sparse-attention/spatial-window-temporal-global/tests/verify_env.py

@@ -0,0 +1,213 @@
+"""spatial-window-temporal-global verifier — correctness gate + achieved-TFLOP/s SPEED LEADERBOARD (uncapped).
+
+    reward = 0                                     if the submission is incorrect
+    reward = geomean over graded shapes of TFLOP/s otherwise
+
+GENERATED by _factory/build.py — do not edit here; edit the spec and regenerate.
+
+There is no gold solution and no oracle: the score is an absolute hardware metric, so it is hardware-portable
+by construction and nothing has to be vendored, sealed, or re-benchmarked.
+
+CORRECTNESS is a hard gate, checked against an INDEPENDENT (embedded) copy of the reference at every graded
+shape including the timed ones, so editing /app/reference.py cannot affect grading and a fast wrong kernel
+scores 0.
+
+ANTI-CHEAT on the timing path: every timed rep runs on FRESHLY generated inputs, and the output of the last
+timed rep is itself validated against the reference for those exact inputs. A submission that memoizes a
+result and replays it fails the gate instead of posting an inflated number. Warm-up runs on a separate
+throwaway input set, so ordinary shape-keyed JIT/autotune caching is not penalised.
+
+WORK is attributed by a CANONICAL formula that depends only on the shape, never on the implementation, so all
+submissions are credited identically and the ranking is a pure speed ranking.
+"""
+import importlib.util
+import json
+import math
+import os
+import sys
+import traceback
+
+import torch
+
+REWARD_DIR = "/logs/verifier"
+MODULE_PATH = "/app/win_global.py"
+TOL = 0.005
+
+GRADER_SHAPES = [(1, 32, 48, 80, 16, 128, 4, 8, 3, 3, 128), (1, 20, 48, 80, 24, 128, 4, 8, 3, 3, 96), (1, 32, 48, 80, 12, 128, 2, 8, 5, 3, 128), (1, 24, 48, 64, 24, 64, 4, 8, 3, 5, 96), (2, 16, 32, 64, 24, 128, 4, 8, 3, 3, 64)]
+CORRECT_SHAPES = [(1, 8, 16, 32, 4, 64, 4, 8, 3, 3, 32), (2, 6, 16, 32, 4, 64, 2, 8, 3, 3, 16), (1, 12, 16, 32, 8, 128, 4, 8, 3, 3, 64), (1, 9, 12, 20, 4, 64, 3, 4, 3, 5, 20), (1, 7, 20, 40, 4, 128, 4, 8, 5, 3, 50), (1, 10, 12, 24, 4, 64, 4, 8, 1, 3, 36)]
+
+sys.path.insert(0, "/app")
+
+def canonical_work(B, F, Hh, Ww, NH, D, TH, TW, WH, WW, STR):
+    """FLOPs attributed to one forward, from the SHAPE ALONE.
+
+    Every query sees WH*WW spatial tiles of TS = TH*TW tokens inside its own frame (the window is clamped
+    inward, never truncated) plus (F-1)*S/STR strided keys drawn from the OTHER frames -- the two sets are
+    disjoint by construction. Each pair costs 4*D FLOPs.
+    """
+    TS = TH * TW
+    S = Hh * Ww
+    keys = WH * WW * TS + (F - 1) * (S // STR)
+    return 4 * D * B * NH * (F * S) * keys
+
+def _ref(q, k, v, latent, tile, window, stride, scale=None):
+    """In-frame tile window + strided sample of the other frames, as an explicit gather in fp32.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target. It gathers the whole
+    window of every query tile and the whole global set of every query frame and softmaxes them densely.
+    """
+    B, T, NH, D = q.shape
+    F, Hh, Ww = latent
+    th, tw = tile
+    wh, ww = window
+    nsh, nsw = Hh // th, Ww // tw
+    nsp = nsh * nsw
+    TS = th * tw
+    NW = wh * ww
+    S = Hh * Ww
+    if scale is None:
+        scale = D ** -0.5
+    dev = q.device
+
+    def to_tiles(x):
+        return (x.view(B, F, nsh, th, nsw, tw, NH, D)
+                 .permute(0, 1, 2, 4, 3, 5, 6, 7)
+                 .reshape(B, F, nsp, TS, NH, D))
+
+    qt, kt, vt = to_tiles(q.float()), to_tiles(k.float()), to_tiles(v.float())
+    kf, vf = k.float(), v.float()
+    ot = torch.empty(B, F, nsp, TS, NH, D, device=dev, dtype=torch.float32)
+
+    sp = torch.arange(nsp, device=dev)
+    sh = (sp // nsw - wh // 2).clamp(0, nsh - wh)
+    sw = (sp % nsw - ww // 2).clamp(0, nsw - ww)
+    ih = sh[:, None] + torch.arange(wh, device=dev)
+    iw = sw[:, None] + torch.arange(ww, device=dev)
+    wt = (ih[:, :, None] * nsw + iw[:, None, :]).reshape(nsp, NW)      # (nsp, wh*ww) tile ids
+
+    off = torch.arange(0, S, stride, device=dev)                       # sampled offsets inside a frame
+    step = max(1, int(4e8) // max(1, (NW * TS + (F - 1) * off.numel()) * NH * D * 4))
+    for f in range(F):
+        other = torch.tensor([x for x in range(F) if x != f], device=dev, dtype=torch.long)
+        gidx = (other[:, None] * S + off[None, :]).reshape(-1)          # global keys of this query frame
+        kg, vg = kf[:, gidx], vf[:, gidx]                               # (B, NG, NH, D)
+        for s0 in range(0, nsp, step):
+            e0 = min(nsp, s0 + step)
+            g = wt[s0:e0]
+            kc = torch.cat([kt[:, f][:, g].reshape(B, e0 - s0, NW * TS, NH, D),
+                            kg.unsqueeze(1).expand(B, e0 - s0, gidx.numel(), NH, D)], dim=2)
+            vc = torch.cat([vt[:, f][:, g].reshape(B, e0 - s0, NW * TS, NH, D),
+                            vg.unsqueeze(1).expand(B, e0 - s0, gidx.numel(), NH, D)], dim=2)
+            qc = qt[:, f, s0:e0] * scale
+            s = torch.einsum("bcqhd,bckhd->bchqk", qc, kc)
+            ot[:, f, s0:e0] = torch.einsum("bchqk,bckhd->bcqhd", torch.softmax(s, dim=-1), vc)
+
+    return (ot.reshape(B, F, nsh, nsw, th, tw, NH, D)
+              .permute(0, 1, 2, 4, 3, 5, 6, 7).reshape(B, T, NH, D))
+
+def _mk(B, F, Hh, Ww, NH, D, TH, TW, WH, WW, STR, seed):
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    T = F * Hh * Ww
+    def r():
+        return torch.randn(B, T, NH, D, device="cuda", dtype=torch.bfloat16, generator=gen)
+    return r(), r(), r(), (F, Hh, Ww), (TH, TW), (WH, WW), STR
+
+
+def _is_exact(t):
+    """Integer/bool tensors are compared EXACTLY: .float() is lossy above 2**24, so two distinct large
+    ids (page ids, token ids, indices) can compare equal and let a wrong kernel pass."""
+    return t.dtype in (torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8, torch.bool)
+
+
+def _check(out, ref):
+    """-> (ok, value, msg). Exact for integer/bool; relative Frobenius error otherwise."""
+    if out is None or tuple(out.shape) != tuple(ref.shape):
+        return False, 1.0, "bad/None shape"
+    if _is_exact(ref):
+        bad = int((out != ref).sum())
+        return bad == 0, float(bad), ("exact match" if bad == 0 else f"{bad} elements differ")
+    e = float((out.float() - ref.float()).norm() / (ref.float().norm() + 1e-12))
+    return e <= TOL, e, f"relerr {e:.2e}"
+
+
+def _bench_fresh(fn, mkargs, reps=5, warm=3):
+    """Time `fn` on FRESH inputs every rep -> (min_seconds, timed_ok). See the module docstring."""
+    wargs = mkargs(0)
+    for _ in range(warm):
+        fn(*wargs)
+    torch.cuda.synchronize()
+    del wargs
+    torch.cuda.empty_cache()
+
+    best, timed_ok = float("inf"), True
+    for i in range(reps):
+        args = mkargs(10_000 + i)
+        s, e = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True)
+        s.record()
+        out = fn(*args)
+        e.record()
+        torch.cuda.synchronize()
+        best = min(best, s.elapsed_time(e))
+        if i == reps - 1:
+            timed_ok = _check(out, _ref(*args))[0]
+        del args, out
+        torch.cuda.empty_cache()
+    return best / 1e3, timed_ok
+
+
+def _geomean(xs):
+    return math.exp(sum(math.log(max(v, 1e-9)) for v in xs) / len(xs)) if xs else 0.0
+
+
+def main():
+    details, correct_gate, geo = {}, False, 0.0
+    try:
+        spec = importlib.util.spec_from_file_location("submission", MODULE_PATH)
+        m = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(m)
+        fn = m.window_global_stride_attention
+
+        corr_ok, msg = True, ""
+        for i, shp in enumerate(CORRECT_SHAPES):
+            args = _mk(*shp, seed=10 + i)
+            ok, val, m_ = _check(fn(*args), _ref(*args))
+            if not ok:
+                corr_ok, msg = False, f"cfg{i} {shp} {m_}"
+                break
+            del args
+            torch.cuda.empty_cache()
+        details["correct_msg"] = msg or "all correctness shapes pass"
+
+        vals, per_shape, perf_ok = [], [], corr_ok
+        for i, shp in enumerate(GRADER_SHAPES):
+            args = _mk(*shp, seed=100 + i)
+            ok, val, m_ = _check(fn(*args), _ref(*args))
+            if not ok:
+                perf_ok = False
+            del args
+            torch.cuda.empty_cache()
+            t, timed_ok = _bench_fresh(fn, lambda s, _p=shp: _mk(*_p, seed=s))
+            if not timed_ok:
+                perf_ok = False
+            v = canonical_work(*shp) / t / 1e12 if t > 0 else 0.0
+            vals.append(v)
+            per_shape.append({"shape": list(shp), "tflops": round(v, 3), "ms": round(t * 1e3, 3),
+                              "check": m_, "timed_ok": timed_ok})
+        geo = _geomean(vals)
+        details.update(per_shape=per_shape, geomean=round(geo, 4), perf_size_ok=perf_ok)
+        correct_gate = corr_ok and perf_ok
+    except Exception as e:
+        details["error"] = f"{e.__class__.__name__}: {e}"[:220]
+        details["trace"] = traceback.format_exc()[-800:]
+
+    reward = round(geo, 4) if correct_gate else 0.0
+    os.makedirs(REWARD_DIR, exist_ok=True)
+    json.dump({"reward": reward, "correct": 1.0 if correct_gate else 0.0,
+               "geomean": round(geo, 4), "metric": "TFLOP/s (geomean over graded shapes)"},
+              open(f"{REWARD_DIR}/reward.json", "w"), indent=2)
+    open(f"{REWARD_DIR}/reward.txt", "w").write(str(reward))
+    json.dump(details, open(f"{REWARD_DIR}/details.json", "w"), indent=2, default=str)
+    print("reward:", reward, "TFLOP/s | correct:", 1.0 if correct_gate else 0.0)
+
+
+main()

tasks/video-sparse-attention/sta-backward/RUN.md

@@ -0,0 +1,42 @@
+# Running `sta-backward`
+
+Fine-tuning a video diffusion transformer on a sparse attention pattern needs the pattern's BACKWARD pass, and that is where the 3D tile window stops being convenient: dQ follows the window, but dK and dV have to accumulate from every query tile whose window covers them, and at the boundary the window is shifted inward so the two directions are NOT mirror images. Recompute the scores, never store the (T, T) probabilities, and get the scatter side right.
+
+|  |  |
+|---|---|
+| **Task id** | `mle-bench/sta-backward` |
+| **Group** | `kernel-generation` |
+| **GPUs** | 1 |
+| **Agent edits** | `/app/sta_bwd.py` |
+| **Score** | achieved **TFLOP/s** (uncapped speed leaderboard), `0` if incorrect |
+| **Grade output** | `tests/test.sh` -> `/logs/verifier/reward.json` |
+
+## Run through harbor
+
+```bash
+harbor run --dataset-path kernel-generation/kernels/sta-backward --task-name sta-backward \
+  --agent claude-code --model anthropic/claude-opus-4-1 -e docker
+```
+
+## Run manually
+
+```bash
+cd kernel-generation/kernels/sta-backward
+docker build -t sta-backward environment/
+docker run -d --name v --gpus '"device=0"' --shm-size=8g --entrypoint sleep sta-backward infinity
+docker cp tests v:/tests && docker exec v bash /tests/test.sh   # untouched start -> reward 0.0
+docker rm -f v
+```
+
+Use an **idle** GPU: the score is a timing measurement.
+
+## Design
+
+Correctness is a hard gate; the score is an absolute hardware metric (TFLOP/s), so the task is
+hardware-portable and needs no gold solution, no oracle, and nothing vendored or sealed.
+
+Anti-cheat is structural: the image holds only the permitted toolchain and has no internet; the grader is
+copied in at grade time with its own private copy of the reference; and every timed rep runs on fresh inputs
+with the timed output itself validated, so memoize-and-replay fails the gate.
+
+Generated by `_factory/build.py` — edit the spec and regenerate rather than editing this task by hand.

tasks/video-sparse-attention/sta-backward/environment/CLAUDE.md

@@ -0,0 +1,25 @@
+# Working in this environment
+
+## ⚠️ Stop background processes without killing yourself
+
+You are launched as `claude --print -- '<the task instruction>'`, so the task text — including the
+file names and commands it mentions — is on **your own** process's command line. Any command that
+finds processes by **matching that text** (`pkill -f …`, `pgrep -f … | xargs kill`, a `/proc`
+cmdline scan, `fuser -k`, `killall`) can match and **kill the agent itself**, ending your run
+(`NonZeroAgentExitCodeError`) and grading you on unfinished work.
+
+This bites whenever you background something and later stop/restart it — a **server**, a long
+**build** or **training run**, or an **ncu / nsys profiling** session.
+
+**Always** manage a background process by its **exact recorded PID**, never by a name pattern:
+
+```bash
+nohup <your command> > /tmp/job.log 2>&1 & echo $! > /tmp/job.pid   # start + record the PID
+kill "$(cat /tmp/job.pid)"; sleep 3                                 # stop (SIGTERM); -9 only if needed
+```
+
+Use `setsid` and kill the process **group** (`kill -- -"$(cat /tmp/job.pid)"`) if it spawns children.
+If you must enumerate processes, match a **unique token that is NOT anywhere in this prompt** and
+**exclude any cmdline containing `claude` or `--print`** — `pgrep -af`, and look before you kill.
+
+Full details + safe recipes: **`/app/PROCESS_MANAGEMENT.md`**.

tasks/video-sparse-attention/sta-backward/environment/Dockerfile

@@ -0,0 +1,41 @@
+# Kernel-generation task: Write a fast Sliding Tile Attention backward kernel
+#
+# Fine-tuning a video diffusion transformer on a sparse attention pattern needs the pattern's BACKWARD pass, and that is where the 3D tile window stops being convenient: dQ follows the window, but dK and dV have to accumulate from every query tile whose window covers them, and at the boundary the window is shifted inward so the two directions are NOT mirror images. Recompute the scores, never store the (T, T) probabilities, and get the scatter side right.
+#
+# SCORING: correctness is a hard gate; the score is achieved TFLOP/s (uncapped leaderboard, 0 if wrong).
+# There is no gold solution and no oracle, so nothing has to be vendored or sealed.
+#
+# TOOLCHAIN POLICY: the agent writes the kernel with Triton (+Gluon), CUDA C++ via nvcc, CUTLASS headers, or
+# the CuTe DSL. Enforcement is by ABSENCE, not by scanning: only the permitted toolchain is installed and
+# there is no internet, so nothing else can be obtained.
+#
+# GENERATED by _factory/build.py.
+FROM pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
+
+# NOTE: every heavy layer comes FIRST and depends only on {base_image, pip_extra}, so all tasks in this
+# lane share the same cached layers. The task-specific COPYs are LAST. Do not reorder.
+RUN pip install --break-system-packages --no-cache-dir einops nvidia-cutlass-dsl && \
+    apt-get update && apt-get install -y --no-install-recommends iptables iproute2 curl ca-certificates build-essential git && \
+    curl -LsSf https://astral.sh/uv/install.sh | sh && \
+    /root/.local/bin/uv tool install mini-swe-agent
+# header-only CUTLASS for the agent's CUDA/CuTe route
+RUN git clone --depth 1 https://github.com/NVIDIA/cutlass /opt/cutlass && rm -rf /opt/cutlass/.git
+# pre-bake Claude Code; harbor's claude_code.install() skips when present
+RUN curl -fsSL https://deb.nodesource.com/setup_22.x | bash - && \
+    apt-get install -y nodejs procps && \
+    npm install -g @anthropic-ai/claude-code && claude --version
+ENV PATH=/root/.local/bin:$PATH
+ENV DISABLE_TELEMETRY=1 DISABLE_AUTOUPDATER=1 DISABLE_ERROR_REPORTING=1 CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1
+
+COPY restrict-network.sh /app/restrict-network.sh
+RUN chmod +x /app/restrict-network.sh
+# strip apt sources LAST so harbor's post-firewall apt step is a no-op that succeeds
+RUN rm -rf /var/lib/apt/lists/* /etc/apt/sources.list /etc/apt/sources.list.d
+
+WORKDIR /app
+COPY CLAUDE.md PROCESS_MANAGEMENT.md /app/
+
+# task-specific files LAST so the layers above stay shared across every task
+COPY reference.py /app/reference.py
+COPY measure.py /app/measure.py
+COPY sta_bwd.py /app/sta_bwd.py

tasks/video-sparse-attention/sta-backward/environment/PROCESS_MANAGEMENT.md

@@ -0,0 +1,96 @@
+# Managing background processes — READ THIS before you `kill` anything
+
+You may start and stop background processes while iterating — a **server**, a long **build** or
+**training run**, or an **ncu / nsys profiling** session. **The way you stop one can silently kill
+*your own agent process* and end the whole run.** This has happened repeatedly, including via a
+hand-rolled `/proc` scan — not just `pkill`. Read this once and follow the safe recipe.
+
+## The trap: matching task text against process command lines
+
+You were launched as roughly:
+
+```
+claude --print -- '<the entire task instruction text>'
+```
+
+The full task instruction is on **your own** process's command line, and it contains the file names
+and commands the task mentions (e.g. `server.py`, `build.sh`, `train.py`, `solution.cu`, `/app/...`).
+So **any** command that finds processes by matching those strings will match — and can kill — **the
+agent itself**:
+
+```
+pkill -9 -f "train.py"                              # matches the claude agent -> kills YOU
+pgrep -f "server.py" | xargs kill                   # same: the pid list includes claude
+for p in $(pgrep -f build.sh); do kill -9 $p; done  # same
+for pid in /proc/*; do case "$(cmdline)" in *solution*) kill -9 $pid;; esac; done   # same
+```
+
+It is **not about `pkill`** — it is about **matching a string that appears in your prompt**. `pgrep`,
+a `/proc` scan, `fuser`, or `nvidia-smi`-pid loops all have the same failure if the match pattern (or
+the surviving pid list) includes the `claude` process. When you `kill -9` yourself the run dies
+immediately (`NonZeroAgentExitCodeError`) and you are graded on whatever was already in place — usually
+worse than what you were about to finish.
+
+## The one safe rule: kill only the exact PID you recorded
+
+**Start** a background job and record its PID in a file:
+
+```bash
+nohup <your command> > /tmp/job.log 2>&1 &
+echo $! > /tmp/job.pid
+```
+
+**Stop / restart** by that exact PID — never by a name pattern:
+
+```bash
+kill "$(cat /tmp/job.pid)" 2>/dev/null      # SIGTERM: lets it release the GPU / flush cleanly
+sleep 3
+kill -9 "$(cat /tmp/job.pid)" 2>/dev/null   # force only if it did not exit
+```
+
+If the job spawns workers, run it in its own process group and signal the group by its (negative)
+PGID — still an exact id, never a pattern:
+
+```bash
+setsid <your command> > /tmp/job.log 2>&1 < /dev/null & echo $! > /tmp/job.pid
+kill -TERM -- "-$(cat /tmp/job.pid)" 2>/dev/null
+```
+
+## If you ever enumerate processes, EXCLUDE the agent
+
+Prefer not to. But if you must scan (e.g. hunting a leaked worker), **exclude the `claude` agent and
+your own shell**, and match on a **unique token that is NOT anywhere in this prompt** — give your job
+a unique name and match only that:
+
+```bash
+# job named e.g. job_7x3q9 — a token that appears NOWHERE in the task text
+pgrep -af job_7x3q9 | grep -v -E 'claude|--print|pgrep|grep|bash'   # LOOK FIRST
+# only kill pids from THIS filtered list, and never a pid whose cmdline contains 'claude' or '--print'
+```
+
+Do **not** add a prompt word (a file name, `/app`, `python3`, …) to the pattern "just in case" — that
+single addition re-introduces the self-kill. Match the unique token **only**.
+
+## Freeing the GPU without going nuclear
+
+If VRAM stays high after you stop a GPU job, the usual cause is a **child process** or a not-yet-
+collected CUDA context — not a stray process you need to hunt across `/proc`. Do this instead of a
+`/proc` sweep:
+
+- Kill the job **by its recorded PID / PGID** (above) and `sleep 5–10`; the CUDA context frees after
+  the process fully exits.
+- Make the job release cleanly on `SIGTERM` (drop the model / `torch.cuda.empty_cache()` / exit) so a
+  single `kill $PID` is enough.
+- Start it in its own group (`setsid`) so `kill -- -$PGID` takes the workers with it.
+- Check with `nvidia-smi` — if a PID still holds memory, `kill` **that exact numeric PID**, after
+  confirming its cmdline is **not** `claude` / `--print`.
+
+## Rules of thumb
+
+- **Never** match a task-prompt string (`server.py`, `train.py`, `build.sh`, `/app`, `python3`, …)
+  with `pkill -f`, `pgrep -f`, `killall`, `fuser`, or a `/proc` cmdline scan — they all can hit the
+  agent (its argv holds the prompt).
+- **Always** kill a background job by the exact PID from its pidfile (or its PGID).
+- If you must enumerate, match a **unique token not in the prompt** and **exclude `claude` / `--print`
+  and your own shell**; `pgrep -af` and look before you kill.
+- `SIGTERM` first for a clean release; `-9` only as a last resort on a specific numeric PID.

tasks/video-sparse-attention/sta-backward/environment/docker-compose.yaml

@@ -0,0 +1,18 @@
+# Anti-cheat firewall overlay, merged on top of Harbor's base compose. Gives the main container
+# NET_ADMIN and runs restrict-network.sh as the entrypoint, so only DNS + the LLM API endpoints are
+# reachable (pypi/github/HF blocked). network_mode stays "public" (see task.toml) — the firewall, not
+# Docker, enforces the allowlist. mini-swe-agent is pre-installed and harbor's patched installer skips
+# the (now-blocked) network install when it is already present.
+services:
+  main:
+    cap_add:
+      - NET_ADMIN
+    entrypoint: ["/bin/bash", "/app/restrict-network.sh"]
+    environment:
+      - ALLOWED_HOSTS=${ALLOWED_HOSTS:-}
+      - FIREWORKS_BASE_URL=${FIREWORKS_BASE_URL:-}
+      - OPENROUTER_BASE_URL=${OPENROUTER_BASE_URL:-}
+      - OPENAI_BASE_URL=${OPENAI_BASE_URL:-}
+      - ANTHROPIC_BASE_URL=${ANTHROPIC_BASE_URL:-}
+      - LLM_BASE_URL=${LLM_BASE_URL:-}
+      - LITELLM_BASE_URL=${LITELLM_BASE_URL:-}

tasks/video-sparse-attention/sta-backward/environment/measure.py

@@ -0,0 +1,151 @@
+"""Self-assessment tool — your correctness + achieved TFLOP/s across a RANGE of shapes.
+
+    python /app/measure.py            # the graded regime
+    python /app/measure.py --quick    # smaller sizes for fast iteration
+
+You are scored on the **geomean achieved TFLOP/s** — NOT one fixed size, and the leaderboard is UNCAPPED
+(higher is always better). The shapes below are a DIFFERENT sample from the same regime the grader uses, so
+optimize for GENERALITY. Work is counted with the same shape-only formula the grader uses, so the number
+printed here is computed exactly as your score is.
+
+GENERATED by _factory/build.py.
+"""
+import argparse
+import math
+import sys
+
+import torch
+
+sys.path.insert(0, "/app")
+from reference import sta_backward as _ref
+from sta_bwd import sta_backward as _agent
+
+TOL = 0.005
+NAMES = ('dq', 'dk', 'dv')
+
+FULL = [(1, 12, 48, 80, 16, 128, 2, 4, 8, 3, 3, 3), (1, 12, 32, 80, 24, 128, 2, 4, 8, 3, 3, 3), (1, 16, 32, 80, 16, 128, 4, 4, 8, 3, 3, 3), (1, 12, 32, 64, 16, 128, 2, 4, 8, 3, 5, 5), (2, 12, 32, 32, 16, 64, 2, 4, 8, 5, 3, 3)]
+QUICK = [(1, 8, 24, 40, 8, 128, 2, 4, 8, 3, 3, 3), (1, 8, 16, 40, 8, 64, 2, 4, 8, 3, 3, 3), (1, 8, 24, 24, 8, 128, 2, 4, 8, 3, 3, 3)]
+
+def canonical_work(B, F, Hh, Ww, NH, D, TF, TH, TW, WF, WH, WW):
+    """FLOPs attributed to one backward, from the SHAPE ALONE.
+
+    Every one of the T = F*Hh*Ww queries has exactly KW = WF*WH*WW*TF*TH*TW visible keys (the window is
+    clamped, never truncated). Each (query, key) pair costs 10*D FLOPs: 2*D to recompute the score, 2*D for
+    dP = dO.V^T, 2*D for dV += P^T.dO, 2*D for dQ += dS.K and 2*D for dK += dS^T.Q. Nothing depends on the
+    data or on how the scatter is realised.
+    """
+    return 10 * D * B * NH * (F * Hh * Ww) * (WF * WH * WW * TF * TH * TW)
+
+def _mk(B, F, Hh, Ww, NH, D, TF, TH, TW, WF, WH, WW, seed):
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    T = F * Hh * Ww
+    ntf, nth, ntw = F // TF, Hh // TH, Ww // TW
+    NT, TS = ntf * nth * ntw, TF * TH * TW
+    def r():
+        return torch.randn(B, T, NH, D, device="cuda", dtype=torch.bfloat16, generator=gen)
+    q, k, v, do = r(), r(), r(), r()
+    scale = D ** -0.5
+
+    # forward pass, chunked over query tiles, to produce a CONSISTENT (lse, delta) pair
+    def to_tiles(x):
+        return (x.view(B, ntf, TF, nth, TH, ntw, TW, NH, D)
+                 .permute(0, 1, 3, 5, 2, 4, 6, 7, 8).reshape(B, NT, TS, NH, D))
+    qt, kt, vt, dot = (to_tiles(x.float()) for x in (q, k, v, do))
+    dev = q.device
+    sa = (torch.arange(ntf, device=dev) - WF // 2).clamp(0, ntf - WF)
+    sb = (torch.arange(nth, device=dev) - WH // 2).clamp(0, nth - WH)
+    sc = (torch.arange(ntw, device=dev) - WW // 2).clamp(0, ntw - WW)
+    ia = sa[:, None] + torch.arange(WF, device=dev)
+    ib = sb[:, None] + torch.arange(WH, device=dev)
+    ic = sc[:, None] + torch.arange(WW, device=dev)
+    tid = (((ia[:, None, None, :, None, None] * nth + ib[None, :, None, None, :, None]) * ntw
+            + ic[None, None, :, None, None, :]).reshape(NT, WF * WH * WW))
+    KW = WF * WH * WW * TS
+    lset = torch.empty(B, NT, TS, NH, device=dev)
+    delt = torch.empty(B, NT, TS, NH, device=dev)
+    step = max(1, int(2.5e8) // max(1, KW * NH * D * 4))
+    for s in range(0, NT, step):
+        e = min(NT, s + step)
+        g = tid[s:e]
+        kc = kt[:, g].reshape(B, e - s, KW, NH, D)
+        vc = vt[:, g].reshape(B, e - s, KW, NH, D)
+        sc_ = torch.einsum("bcqhd,bckhd->bchqk", qt[:, s:e] * scale, kc)
+        l = torch.logsumexp(sc_, dim=-1)                                   # (B, ch, NH, TS)
+        o = torch.einsum("bchqk,bckhd->bcqhd", torch.exp(sc_ - l.unsqueeze(-1)), vc)
+        lset[:, s:e] = l.permute(0, 1, 3, 2)
+        delt[:, s:e] = (o * dot[:, s:e]).sum(-1)
+    def un_s(x):
+        return (x.reshape(B, ntf, nth, ntw, TF, TH, TW, NH)
+                 .permute(0, 1, 4, 2, 5, 3, 6, 7).reshape(B, T, NH).permute(0, 2, 1).contiguous())
+    return q, k, v, do, un_s(lset), un_s(delt), (F, Hh, Ww), (TF, TH, TW), (WF, WH, WW)
+
+
+def _check(out, ref):
+    """-> (ok, value, msg). value = MAX relative error across the returned tuple."""
+    if out is None or len(out) != len(NAMES):
+        return False, 1.0, f"expected a {len(NAMES)}-tuple {NAMES}"
+    per = []
+    for n, a, b in zip(NAMES, out, ref):
+        if a is None or tuple(a.shape) != tuple(b.shape):
+            return False, 1.0, f"{n} bad shape"
+        if b.dtype in (torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8, torch.bool):
+            # exact: .float() is lossy above 2**24 and would let distinct large ids compare equal
+            bad = int((a != b).sum())
+            if bad:
+                return False, 1.0, f"{n}: {bad} elements differ"
+            continue
+        per.append((n, float((a.float() - b.float()).norm() / (b.float().norm() + 1e-12))))
+    if not per:
+        return True, 0.0, "all integer outputs exact"
+    wn, wv = max(per, key=lambda x: x[1])
+    return wv <= TOL, wv, f"worst {wn} {wv:.2e}"
+
+
+def _bench(fn, reps=8, warm=3):
+    for _ in range(warm):
+        fn()
+    torch.cuda.synchronize()
+    best = float("inf")
+    for _ in range(reps):
+        s, e = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True)
+        s.record()
+        fn()
+        e.record()
+        torch.cuda.synchronize()
+        best = min(best, s.elapsed_time(e))
+    return best / 1e3
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--quick", action="store_true")
+    a = ap.parse_args()
+    shapes = QUICK if a.quick else FULL
+    print(f"geomean over {len(shapes)} shapes ({'quick' if a.quick else 'full'}); the grader uses "
+          f"DIFFERENT sizes in the same regime — optimize for generality\n")
+    vals, allok = [], True
+    for shp in shapes:
+        args = _mk(*shp, seed=sum(int(x) for x in shp) % 9973)
+        ref = _ref(*args)
+        try:
+            out = _agent(*args)
+        except Exception as ex:
+            print(f"  {shp}: RAISED {type(ex).__name__}: {str(ex)[:70]}")
+            allok = False
+            continue
+        ok, val, msg = _check(out, ref)
+        allok = allok and ok
+        t = _bench(lambda: _agent(*args))
+        v = canonical_work(*shp) / t / 1e12 if t > 0 else 0.0
+        vals.append(v)
+        print(f"  {str(shp):28s} {t*1e3:9.2f} ms | {v:9.2f} TFLOP/s | {msg} {'ok' if ok else 'FAIL'}")
+        del args, ref, out
+        torch.cuda.empty_cache()
+    geo = math.exp(sum(math.log(max(v, 1e-9)) for v in vals) / len(vals)) if vals else 0.0
+    print(f"\n  => GEOMEAN {geo:.2f} TFLOP/s   "
+          f"({'all correct' if allok else 'SOME WRONG — a wrong kernel scores 0, fix correctness first'})")
+    print("     This IS your score, and it is uncapped — higher is always better. Keep pushing.")
+
+
+if __name__ == "__main__":
+    main()

tasks/video-sparse-attention/sta-backward/environment/reference.py

@@ -0,0 +1,76 @@
+"""Reference implementation — the CORRECTNESS SPEC for `sta_backward`.
+
+This is correct but slow. It defines exactly what your kernel must reproduce; its speed has no
+bearing on your score, which is an absolute TFLOP/s number. GENERATED by _factory/build.py.
+"""
+import torch
+
+
+def sta_backward(q, k, v, do, lse, delta, latent, tile, window, scale=None):
+    """STA backward, written as an explicit tile-gather + scatter-add in fp32.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target. It gathers each query
+    tile's whole (wf*wh*ww) neighbourhood of key/value tiles, materialises the probabilities for that
+    neighbourhood, and scatter-adds dk/dv back with index_add_. That gather is many times the size of K.
+    """
+    B, T, NH, D = q.shape
+    F, Hh, Ww = latent
+    tf, th, tw = tile
+    wf, wh, ww = window
+    ntf, nth, ntw = F // tf, Hh // th, Ww // tw
+    NT = ntf * nth * ntw
+    TS = tf * th * tw
+    NW = wf * wh * ww
+    KW = NW * TS
+    if scale is None:
+        scale = D ** -0.5
+    dev = q.device
+
+    def to_tiles(x):
+        return (x.view(B, ntf, tf, nth, th, ntw, tw, NH, D)
+                 .permute(0, 1, 3, 5, 2, 4, 6, 7, 8)
+                 .reshape(B, NT, TS, NH, D))
+
+    def to_tiles_s(x):                                        # (B, NH, T) -> (B, NT, TS, NH)
+        return (x.permute(0, 2, 1).view(B, ntf, tf, nth, th, ntw, tw, NH)
+                 .permute(0, 1, 3, 5, 2, 4, 6, 7).reshape(B, NT, TS, NH))
+
+    qt, kt, vt, dot = (to_tiles(x.float()) for x in (q, k, v, do))
+    lt, dt = to_tiles_s(lse), to_tiles_s(delta)
+
+    sa = (torch.arange(ntf, device=dev) - wf // 2).clamp(0, ntf - wf)
+    sb = (torch.arange(nth, device=dev) - wh // 2).clamp(0, nth - wh)
+    sc = (torch.arange(ntw, device=dev) - ww // 2).clamp(0, ntw - ww)
+    ia = sa[:, None] + torch.arange(wf, device=dev)
+    ib = sb[:, None] + torch.arange(wh, device=dev)
+    ic = sc[:, None] + torch.arange(ww, device=dev)
+    tid = (((ia[:, None, None, :, None, None] * nth + ib[None, :, None, None, :, None]) * ntw
+            + ic[None, None, :, None, None, :]).reshape(NT, NW))
+
+    dqt = torch.zeros(B, NT, TS, NH, D, device=dev, dtype=torch.float32)
+    dkt = torch.zeros(B, NT, TS, NH, D, device=dev, dtype=torch.float32)
+    dvt = torch.zeros(B, NT, TS, NH, D, device=dev, dtype=torch.float32)
+
+    step = max(1, int(2.5e8) // max(1, KW * NH * D * 4))
+    for s in range(0, NT, step):
+        e = min(NT, s + step)
+        ch = e - s
+        g = tid[s:e]                                           # (ch, NW)
+        kc = kt[:, g].reshape(B, ch, KW, NH, D)
+        vc = vt[:, g].reshape(B, ch, KW, NH, D)
+        sc_ = torch.einsum("bcqhd,bckhd->bchqk", qt[:, s:e] * scale, kc)
+        p = torch.exp(sc_ - lt[:, s:e].permute(0, 1, 3, 2).unsqueeze(-1))
+        dp = torch.einsum("bcqhd,bckhd->bchqk", dot[:, s:e], vc)
+        ds = p * (dp - dt[:, s:e].permute(0, 1, 3, 2).unsqueeze(-1))
+        dqt[:, s:e] = torch.einsum("bchqk,bckhd->bcqhd", ds, kc) * scale
+        dkc = torch.einsum("bchqk,bcqhd->bckhd", ds, qt[:, s:e]) * scale
+        dvc = torch.einsum("bchqk,bcqhd->bckhd", p, dot[:, s:e])
+        flat = g.reshape(-1)
+        dkt.index_add_(1, flat, dkc.reshape(B, ch * NW, TS, NH, D))
+        dvt.index_add_(1, flat, dvc.reshape(B, ch * NW, TS, NH, D))
+
+    def un_tile(x):
+        return (x.reshape(B, ntf, nth, ntw, tf, th, tw, NH, D)
+                 .permute(0, 1, 4, 2, 5, 3, 6, 7, 8).reshape(B, T, NH, D))
+
+    return un_tile(dqt), un_tile(dkt), un_tile(dvt)

tasks/video-sparse-attention/sta-backward/environment/restrict-network.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+# Outbound firewall (anti-cheat): allow ONLY DNS, loopback, docker-internal networks, and the LLM API
+# endpoints the agent needs. Everything else is dropped — in particular pypi, github, and huggingface,
+# so the agent cannot `pip install vllm` / `pip install sglang` / clone the reference moe_align kernel and
+# copy it. torch + triton are already in the image, and mini-swe-agent is pre-installed (harbor's patched
+# installer skips the network install when it is already present), so no package index is needed at run time.
+#
+# Runs as the container ENTRYPOINT before the CMD. iptables rules are network-namespace-wide, so they also
+# apply to the agent's `docker exec` commands. Requires cap_add: NET_ADMIN.
+set -uo pipefail
+
+# LLM API endpoints the agent may reach. Extend at launch via ALLOWED_HOSTS=host1,host2 (no scheme).
+API_HOSTS=(
+    api.fireworks.ai
+    openrouter.ai openrouter.io
+    api.openai.com api.anthropic.com generativelanguage.googleapis.com
+    api.together.xyz integrate.api.nvidia.com api.moonshot.cn api.kimi.com
+)
+# Auto-allow hosts from any *_BASE_URL / *_ENDPOINT env var (ANTHROPIC_BASE_URL, OPENAI_BASE_URL, …).
+CUSTOM=()
+while IFS='=' read -r n v; do
+    case "$n" in
+        *_BASE_URL|*_URL|*_ENDPOINT)
+            [ -n "$v" ] && CUSTOM+=("$(echo "$v" | sed 's|.*://||; s|[:/].*||')") ;;
+    esac
+done < <(env)
+if [ -n "${ALLOWED_HOSTS:-}" ]; then IFS=',' read -ra E <<< "$ALLOWED_HOSTS"; CUSTOM+=("${E[@]}"); fi
+ALL_HOSTS=("${API_HOSTS[@]}" ${CUSTOM[@]+"${CUSTOM[@]}"})
+
+if iptables -L OUTPUT -n >/dev/null 2>&1; then
+    echo "restrict-network: applying outbound allowlist firewall..."
+    iptables -F OUTPUT 2>/dev/null || true
+    iptables -A OUTPUT -o lo -j ACCEPT
+    iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
+    iptables -A OUTPUT -p udp --dport 53 -j ACCEPT
+    iptables -A OUTPUT -p tcp --dport 53 -j ACCEPT
+    iptables -A OUTPUT -d 10.0.0.0/8 -j ACCEPT
+    iptables -A OUTPUT -d 172.16.0.0/12 -j ACCEPT
+    iptables -A OUTPUT -d 192.168.0.0/16 -j ACCEPT
+    iptables -A OUTPUT -d 127.0.0.11 -j ACCEPT
+    for h in "${ALL_HOSTS[@]}"; do
+        for ip in $(getent ahosts "$h" 2>/dev/null | awk '{print $1}' | sort -u); do
+            iptables -A OUTPUT -d "$ip" -j ACCEPT
+        done
+    done
+    iptables -A OUTPUT -j REJECT --reject-with icmp-admin-prohibited
+    echo "restrict-network: outbound locked to DNS + LLM endpoints; pypi/github/HF blocked."
+else
+    echo "restrict-network: WARNING — iptables unavailable (need cap_add NET_ADMIN); NOT firewalled." >&2
+fi
+
+exec "$@"

tasks/video-sparse-attention/sta-backward/environment/sta_bwd.py

@@ -0,0 +1,28 @@
+"""Your implementation goes here.
+
+Replace the body of `sta_backward` with a FAST implementation that reproduces the output of /app/reference.py
+(same signature, same numerics within tolerance) but is much faster — see /app/instruction.md.
+Run `python /app/measure.py` to check your correctness and achieved TFLOP/s.
+
+You may add helper modules, Triton kernels, CUDA extensions, caches, etc. — only this function's name,
+signature and returned value are fixed by the contract.
+"""
+
+
+def sta_backward(q, k, v, do, lse, delta, latent, tile, window, scale=None):
+    """Backward pass of Sliding Tile Attention.
+
+    Args:
+        q, k, v: (B, T, NH, D) bfloat16 — the forward pass's inputs, T = F*Hh*Ww tokens in RASTER order.
+        do:      (B, T, NH, D) bfloat16 — gradient of the loss w.r.t. the forward output o.
+        lse:     (B, NH, T)    float32  — the forward pass's log-sum-exp per query, natural log.
+        delta:   (B, NH, T)    float32  — rowsum(do * o) per query, the usual flash-attention D term.
+        latent:  (F, Hh, Ww)   tuple of int — latent frames / height / width.
+        tile:    (tf, th, tw)  tuple of int — 3D tile size; divides (F, Hh, Ww) exactly.
+        window:  (wf, wh, ww)  tuple of int — window size measured in TILES, all odd.
+        scale:   float or None — logit scale used in the forward; None means D ** -0.5.
+
+    Returns:
+        (dq, dk, dv), each (B, T, NH, D) bfloat16 or float32 — must match /app/reference.py numerically.
+    """
+    raise NotImplementedError("Implement a fast sta_backward in /app/sta_bwd.py")

tasks/video-sparse-attention/sta-backward/instruction.md

@@ -0,0 +1,228 @@
+# Write a fast Sliding Tile Attention backward kernel
+
+You are given a **correct but slow** reference at **`/app/reference.py`** — `sta_backward(q, k, v, do, lse, delta, latent, tile, window, scale=None)`. **Read it, run it, profile it.**
+
+Write **`/app/sta_bwd.py`** with the **same signature** and the **same numerical output**, but **as fast as you can make it**.
+
+```python
+def sta_backward(q, k, v, do, lse, delta, latent, tile, window, scale=None):
+    ...
+```
+
+## The computation (this is the exact spec)
+
+This is the backward pass of **Sliding Tile Attention**. The forward pass it differentiates is:
+the sequence is a 3D latent, token `i` is voxel `(f, h, w)` at `i = (f*Hh + h)*Ww + w` (raster order); the
+latent is cut into `(tf, th, tw)` tiles; and the query tile at tile-coordinate `(a, b, c)` attends to the
+`wf x wh x ww` block of key tiles starting at
+
+```
+sa = clamp(a - wf//2, 0, ntf - wf),   sb = clamp(b - wh//2, 0, nth - wh),   sc = clamp(c - ww//2, 0, ntw - ww)
+```
+
+with `ntf, nth, ntw = F/tf, Hh/th, Ww/tw`. The window is **shifted inward at the boundary, never truncated**,
+so every query sees exactly `KW = wf*wh*ww*tf*th*tw` keys. Attention is bidirectional; there is no causal
+mask.
+
+You are given `lse` and `delta` from that forward pass, so the probabilities are recovered without a second
+softmax. Writing `M(i)` for the set of keys visible to query `i` and `scale` for the logit scale:
+
+```
+p_ij     = exp( scale * (q_i . k_j) - lse_i )          for j in M(i),   and 0 otherwise
+dp_ij    = do_i . v_j
+ds_ij    = p_ij * ( dp_ij - delta_i )                  delta_i = sum_d do[i,d] * o[i,d]
+dq_i     = scale * sum_{j in M(i)}  ds_ij * k_j
+dk_j     = scale * sum_{i : j in M(i)}  ds_ij * q_i
+dv_j     =         sum_{i : j in M(i)}  p_ij * do_i
+```
+
+The asymmetry is the whole difficulty. `dq` iterates over the window of the query's own tile — the same
+gather the forward does. `dk` and `dv` iterate over the **inverse** relation `{i : j in M(i)}`, and because
+of the inward shift that set is **not** the mirror window: a key tile at the boundary of the volume is
+covered by *more* query tiles than an interior one (up to `wf//2` extra along each shifted axis), while a
+tile just inside the boundary is covered by fewer. Assuming the relation is symmetric gives a `dk`/`dv` that
+is wrong exactly on the faces of the volume — a small fraction of the tensor with a large error, which is
+easy to miss at a small shape and fatal at a real one.
+
+`lse` and `delta` are supplied **consistent with `q, k, v`** under exactly this mask, i.e. `lse[b,h,i] =
+log sum_{j in M(i)} exp(scale * q_i . k_j)`. `p` therefore already sums to one over `M(i)` and needs no
+renormalisation.
+
+`/app/reference.py` gathers each query tile's whole neighbourhood and `index_add_`s the key-side gradients
+back. That is the exact specification; it is deliberately simple rather than fast.
+
+## The contract (fixed — do not change these)
+
+| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `q`, `k`, `v` | `(B, T, NH, D)` | `bfloat16` | forward inputs, raster-ordered over the latent |
+| `do` | `(B, T, NH, D)` | `bfloat16` | gradient w.r.t. the forward output |
+| `lse` | `(B, NH, T)` | `float32` | forward log-sum-exp (natural log), **head-major** layout |
+| `delta` | `(B, NH, T)` | `float32` | `rowsum(do * o)`, same layout as `lse` |
+| `latent` | 3-tuple | `int` | `(F, Hh, Ww)`; `T == F*Hh*Ww` |
+| `tile` | 3-tuple | `int` | `(tf, th, tw)`; divides `(F, Hh, Ww)` exactly |
+| `window` | 3-tuple | `int` | `(wf, wh, ww)` in **tiles**, all odd, each at most the tile count on that axis |
+| `scale` | scalar | `float` or `None` | logit scale; `None` means `D ** -0.5` |
+
+**Return** a 3-tuple `(dq, dk, dv)` **in that order**, each `(B, T, NH, D)` in the same raster order as `q`,
+dtype `bfloat16` or `float32`.
+
+`latent`, `tile` and `window` are host-side Python `int` tuples, so the geometry is known before launch. All
+tensors are CUDA, contiguous and **read-only**; nothing is updated in place.
+
+No GQA, no causality, no dropout, no bias — and note `lse`/`delta` are `(B, NH, T)`, transposed relative to
+the `(B, T, NH, D)` tensors.
+
+**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): video
+latents at fine-tuning resolution — `F x Hh x Ww` from `12 x 32 x 48` up to `20 x 48 x 80` (46k-77k tokens),
+`NH` in 16-24, `D` in {64, 128}, `tile` `(2,4,8)` or `(4,4,8)`, `window` `(3,3,3)`, `(3,5,5)` or `(5,3,3)`.
+`B` is 1-2.
+
+The work formula credits only the **windowed** pairs at `10*D` FLOPs each, so a kernel that runs a dense
+backward and masks afterwards is credited nothing for the ~98% of pairs it threw away.
+
+## How success is decided (runs on GPU)
+
+**1. Correctness — a required gate.** **All three** of `dq`, `dk`, `dv` must match the reference (evaluated in fp32) within
+**relative Frobenius error `5e-3`** at every graded shape, including the timed ones. `dk` and `dv` are graded
+just as hard as `dq`, and the boundary tiles are where a wrong inverse-window shows up.
+
+The gate is measured. **Noise floor:** the reference's closed-form gather/scatter backward was checked
+against **`torch.autograd` differentiating a dense masked fp32 forward** — an implementation that shares no
+code path with it and does not use `lse` or `delta` at all — and they agree to **`1.2e-6`**. A second
+independent closed-form version that is whole-sequence dense (no tiling, no gather, no `index_add_`, so `dk`
+and `dv` accumulate in a completely different order) agrees to **`1.1e-6`**. So the tiling, the inverse
+window and the scatter contribute nothing measurable. The floor is set by the dtypes a real kernel uses:
+bf16 operands into all four GEMMs and bf16 gradient outputs measures **`2.38e-3`**, and the gate is **2.1x**
+that.
+
+**Discrimination:** a dense backward that ignores the window scores **`3.4`**; truncating the window at the
+volume boundary instead of shifting it inward scores **`1.03`**; and omitting the `delta` subtraction —
+`ds = p * dp` — scores **`0.16`**, still 31x above the gate. That last one is the tightest and it is the
+mistake most worth guarding against, which is why the tolerance is not left at a comfortable `2e-2`. A wrong kernel scores **0**, no matter how fast.
+
+**2. Performance — this is your score, and it is an UNCAPPED leaderboard.**
+
+```
+reward = geomean over graded shapes of ( canonical_work(shape) / your_runtime )   [TFLOP/s]
+reward = 0   if the submission is wrong at any graded shape
+```
+
+`canonical_work` depends **only on the shape**, never on how you implemented it, so every submission is
+credited the same work and this is a pure speed ranking in useful units:
+
+```
+T      = F * Hh * Ww
+KW     = WF*WH*WW * TF*TH*TW            # keys visible to EVERY query
+FLOPs  = 10 * D * B * NH * T * KW       # 2*D recompute S, then dP, dV, dQ, dK at 2*D each
+```
+
+**There is no cap and no target.** Higher TFLOP/s is always a strictly better score, so **push the
+performance as hard as you can**. Getting a correct implementation is the *start* of the task, not the end of
+it. Once correct, spend the entire remainder of your budget profiling and optimising, re-checking correctness
+after every change. **Use your full time budget.**
+
+Run **`python /app/measure.py`** at any point to see your per-shape and geomean TFLOP/s plus correctness.
+
+## Where the performance comes from
+
+The reference gathers `wf*wh*ww` key/value tiles per query tile, materialises the whole
+probability block, and `index_add_`s the result back — tens of gigabytes of traffic and an atomics storm.
+
+**Split the pass in two, as flash-attention does.** One kernel parallel over query tiles produces `dq` by
+walking that tile's window (a pure gather, no atomics). A second kernel parallel over **key** tiles produces
+`dk` and `dv` by walking the *inverse* window — the set of query tiles whose window contains this key tile.
+Both loops are over the same total number of pairs, and neither needs an atomic if you enumerate the inverse
+set correctly.
+
+**Enumerate the inverse window in closed form.** Query tile `a` covers key tiles `[sa(a), sa(a)+wf)` with
+`sa(a) = clamp(a - wf//2, 0, ntf - wf)`. Inverting: key tile `a'` is covered by exactly those `a` with
+`sa(a) <= a' < sa(a)+wf`, which is a contiguous range of `a` — of length `wf` in the interior, but *longer*
+at the two ends of the axis because `sa` saturates there. The three axes are independent, so the inverse set
+is again a box of query tiles, just a differently-sized one. Computing that box with two `clamp`s beats
+building an explicit inverse table, and it means the key-side kernel is a clean nested loop with no gather
+list at all.
+
+**Do not store P.** Recompute `s = scale * q.k^T` inside both passes and rebuild `p = exp(s - lse)` from the
+supplied `lse`. Storing the probabilities would be `KW` floats per query — larger than every other tensor in
+the problem combined.
+
+**Layout.** The tokens of a 3D tile are a strided box in the raster sequence. Either permute `q, k, v, do`
+into tile-major order once (three streaming passes, then every tile load is contiguous) or issue the strided
+loads directly into shared memory. `lse` and `delta` are `(B, NH, T)` — head-major — so their tile gather has
+a different stride pattern from the `(B, T, NH, D)` tensors; loading them once per tile into shared memory
+avoids re-reading them per key tile.
+
+**Balance.** Boundary key tiles have a larger inverse set than interior ones (by up to `(wf//2)` query tiles
+per axis), so a static one-threadblock-per-key-tile grid has a genuine tail. With `ntf*nth*ntw` in the
+thousands and `NH` in the tens there is enough parallelism to hide it, but a persistent grid over a flattened
+work list does better.
+
+## Precision and faithfulness (read this)
+
+`q, k, v, do` are **bfloat16**; `lse` and `delta` are **float32**. Do the matmuls on bf16
+tensor cores with **fp32 accumulation**, and keep `p`, `ds` and all three gradient accumulators in fp32.
+
+The tolerance is **`5e-3`**, measured rather than inherited: `torch.autograd` through a dense masked fp32
+forward reproduces the reference to **`1.2e-6`**, and the floor comes from bf16 GEMM operands and bf16
+gradient outputs, which measure **`2.38e-3`**. The gate is 2.1x that.
+
+`ds = p * (dp - delta)` is a *difference* of two quantities of similar magnitude, so subtract in **fp32**.
+Measured honestly, this one is less punishing than it sounds at these shapes — rounding `dp` and `delta` to
+bf16 *before* the subtraction costs `1.7e-3`, inside the gate — but it buys nothing (the subtraction is a
+CUDA-core op either way) and the cancellation gets worse as `do` becomes correlated with `o`, which it is in
+real training and is not in this fixture. Keep it in fp32.
+
+`dk` and `dv` are **reductions over a large number of query tiles** — up to `wf*wh*ww` plus the boundary
+excess. Accumulate them in fp32 registers or fp32 shared memory. If you do use atomics, use fp32 atomics; a
+bf16 atomic accumulation over that many contributions drifts far past the gate.
+
+The window geometry is exact integer bookkeeping. Do not approximate the inverse window by the mirror window
+— that is a systematic error concentrated on the faces of the volume, not a rounding difference.
+
+Do **not** infer from the reference that fp32 storage is wanted; it computes in fp32 purely to be a stable
+numerical *specification*.
+
+### What the tolerance does NOT permit
+
+The tolerance exists **only** to absorb low-precision arithmetic noise. You are responsible for a **faithful
+implementation of the specified computation**. It is not a budget to spend on approximation. The following
+are wrong answers even if they happen to land inside the tolerance at some shape:
+
+- changing the algorithm to something that merely *approximates* the spec (dropping terms, truncating a
+  series, low-rank or sketched substitutes, skipping a correction term);
+- shortening the computation (fewer iterations/steps than specified, early exit on a heuristic, subsampling
+  or striding over the sequence, ignoring positions whose contribution "looks small");
+- computing at a coarser granularity than the spec (sharing a decay, scale, or normaliser across positions
+  that the spec gives their own);
+- anything whose error **grows** with sequence length, batch, or head count.
+
+A faithful bf16/fp8 kernel's error is *noise*: it stays flat as the problem grows and sits an order of
+magnitude below the gate. An approximation's error is *bias*: it scales with the problem. The graded shapes
+are deliberately large, so the difference shows up.
+
+## What's available
+
+- **Triton 3.6** (with Gluon), **CUDA C++ via `nvcc`** (`torch.utils.cpp_extension.load` for an inline
+  extension), header-only **CUTLASS** at `/opt/cutlass/include`, and the **CuTe DSL**
+  (`nvidia-cutlass-dsl`). C++ / CuTe DSL is the encouraged route; Triton is fully supported.
+- `torch` 2.11 (CUDA 12.8) and `einops` for bookkeeping.
+- A GPU with compute capability sm≥90 (Hopper or newer).
+- **No internet access.** `pip install` and cloning repos are blocked. Everything you are permitted to use is
+  already installed, and no library implementation of this kernel exists on the machine.
+- Manage any long-running background job (a build, an `ncu`/`nsys` profile) by its **recorded PID** — see
+  `/app/CLAUDE.md` and `/app/PROCESS_MANAGEMENT.md`.
+
+## How the grading actually runs (so there are no surprises)
+
+- **`/app/sta_bwd.py` is the only file that is graded.** The grader imports `sta_backward` from it and reads nothing
+  else from `/app`.
+- **The grader is not on this machine while you work.** It is copied in only after your session ends and it
+  carries its **own private copy of the reference** and its own input generator. Editing `/app/reference.py`
+  or `/app/measure.py` is allowed — they are yours to experiment with — but it has **no effect whatsoever on
+  your score**. Do not spend budget on them.
+- **Every timed repetition uses freshly generated inputs**, and the output of a timed call is itself checked
+  against the reference. Caching or memoizing a result and replaying it fails the correctness gate rather
+  than producing a fast measurement. Ordinary shape-keyed JIT/autotune caching is fine and is not penalised.
+- **The timed shapes are correctness-checked too.** Being correct only at the small shapes scores **0**.
+- Inputs are random each grade and the graded shapes are not the ones in `measure.py`.

tasks/video-sparse-attention/sta-backward/task.toml

@@ -0,0 +1,38 @@
+schema_version = "1.1"
+
+[task]
+name = "mle-bench/sta-backward"
+description = "Fine-tuning a video diffusion transformer on a sparse attention pattern needs the pattern's BACKWARD pass, and that is where the 3D tile window stops being convenient: dQ follows the window, but dK and dV have to accumulate from every query tile whose window covers them, and at the boundary the window is shifted inward so the two directions are NOT mirror images. Recompute the scores, never store the (T, T) probabilities, and get the scatter side right."
+authors = []
+keywords = ["mle", "kernel-generation", "attention", "backward", "sparse-attention", "video-diffusion", "sliding-tile-attention", "hunyuanvideo", "training"]
+
+[metadata]
+suite = "mle-bench"
+group = "kernel-generation"
+level = "1.0"
+difficulty = "hard"
+category = "mle"
+tags = [ "mle", "kernel-generation", "kernels", "gpu", "real-world",]
+
+[verifier]
+timeout_sec = 1800.0
+
+[agent]
+timeout_sec = 14400.0
+
+# GPU request: honored by Modal/GKE/Daytona. On the local docker backend set environment.override_gpus: 0
+# in the job config and attach a GPU via configs/gpu_overlay_nvidia.yaml (see RUNNING.md §5).
+[environment]
+build_timeout_sec = 3600.0
+cpus = 8
+memory_mb = 65536
+storage_mb = 40960
+gpus = 1
+network_mode = "public"
+mcp_servers = []
+
+[verifier.env]
+
+[environment.env]
+
+[solution.env]

tasks/video-sparse-attention/sta-backward/tests/test.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# GENERATED by _factory/build.py. python3 (not python): some CUDA bases lack the symlink.
+set -u
+mkdir -p /logs/verifier
+python3 /tests/verify_env.py

tasks/video-sparse-attention/sta-backward/tests/verify_env.py

@@ -0,0 +1,266 @@
+"""sta-backward verifier — correctness gate + achieved-TFLOP/s SPEED LEADERBOARD (uncapped).
+
+    reward = 0                                     if the submission is incorrect
+    reward = geomean over graded shapes of TFLOP/s otherwise
+
+GENERATED by _factory/build.py — do not edit here; edit the spec and regenerate.
+
+There is no gold solution and no oracle: the score is an absolute hardware metric, so it is hardware-portable
+by construction and nothing has to be vendored, sealed, or re-benchmarked.
+
+CORRECTNESS is a hard gate, checked against an INDEPENDENT (embedded) copy of the reference at every graded
+shape including the timed ones, so editing /app/reference.py cannot affect grading and a fast wrong kernel
+scores 0.
+
+ANTI-CHEAT on the timing path: every timed rep runs on FRESHLY generated inputs, and the output of the last
+timed rep is itself validated against the reference for those exact inputs. A submission that memoizes a
+result and replays it fails the gate instead of posting an inflated number. Warm-up runs on a separate
+throwaway input set, so ordinary shape-keyed JIT/autotune caching is not penalised.
+
+WORK is attributed by a CANONICAL formula that depends only on the shape, never on the implementation, so all
+submissions are credited identically and the ranking is a pure speed ranking.
+"""
+import importlib.util
+import json
+import math
+import os
+import sys
+import traceback
+
+import torch
+
+REWARD_DIR = "/logs/verifier"
+MODULE_PATH = "/app/sta_bwd.py"
+TOL = 0.005
+NAMES = ('dq', 'dk', 'dv')
+
+GRADER_SHAPES = [(1, 16, 48, 80, 16, 128, 2, 4, 8, 3, 3, 3), (1, 12, 48, 80, 24, 128, 2, 4, 8, 3, 3, 3), (1, 20, 32, 80, 16, 128, 4, 4, 8, 3, 3, 3), (1, 12, 32, 80, 16, 128, 2, 4, 8, 3, 5, 5), (2, 12, 32, 48, 16, 64, 2, 4, 8, 5, 3, 3)]
+CORRECT_SHAPES = [(1, 8, 16, 32, 4, 64, 2, 4, 8, 3, 3, 3), (2, 10, 16, 32, 4, 64, 2, 4, 8, 3, 3, 3), (1, 12, 16, 32, 8, 128, 3, 4, 8, 3, 3, 3), (1, 10, 10, 20, 4, 64, 2, 2, 4, 3, 3, 3), (1, 12, 16, 32, 4, 64, 2, 4, 8, 5, 3, 3), (1, 8, 20, 40, 4, 128, 2, 4, 8, 1, 3, 3)]
+
+sys.path.insert(0, "/app")
+
+def canonical_work(B, F, Hh, Ww, NH, D, TF, TH, TW, WF, WH, WW):
+    """FLOPs attributed to one backward, from the SHAPE ALONE.
+
+    Every one of the T = F*Hh*Ww queries has exactly KW = WF*WH*WW*TF*TH*TW visible keys (the window is
+    clamped, never truncated). Each (query, key) pair costs 10*D FLOPs: 2*D to recompute the score, 2*D for
+    dP = dO.V^T, 2*D for dV += P^T.dO, 2*D for dQ += dS.K and 2*D for dK += dS^T.Q. Nothing depends on the
+    data or on how the scatter is realised.
+    """
+    return 10 * D * B * NH * (F * Hh * Ww) * (WF * WH * WW * TF * TH * TW)
+
+def _ref(q, k, v, do, lse, delta, latent, tile, window, scale=None):
+    """STA backward, written as an explicit tile-gather + scatter-add in fp32.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target. It gathers each query
+    tile's whole (wf*wh*ww) neighbourhood of key/value tiles, materialises the probabilities for that
+    neighbourhood, and scatter-adds dk/dv back with index_add_. That gather is many times the size of K.
+    """
+    B, T, NH, D = q.shape
+    F, Hh, Ww = latent
+    tf, th, tw = tile
+    wf, wh, ww = window
+    ntf, nth, ntw = F // tf, Hh // th, Ww // tw
+    NT = ntf * nth * ntw
+    TS = tf * th * tw
+    NW = wf * wh * ww
+    KW = NW * TS
+    if scale is None:
+        scale = D ** -0.5
+    dev = q.device
+
+    def to_tiles(x):
+        return (x.view(B, ntf, tf, nth, th, ntw, tw, NH, D)
+                 .permute(0, 1, 3, 5, 2, 4, 6, 7, 8)
+                 .reshape(B, NT, TS, NH, D))
+
+    def to_tiles_s(x):                                        # (B, NH, T) -> (B, NT, TS, NH)
+        return (x.permute(0, 2, 1).view(B, ntf, tf, nth, th, ntw, tw, NH)
+                 .permute(0, 1, 3, 5, 2, 4, 6, 7).reshape(B, NT, TS, NH))
+
+    qt, kt, vt, dot = (to_tiles(x.float()) for x in (q, k, v, do))
+    lt, dt = to_tiles_s(lse), to_tiles_s(delta)
+
+    sa = (torch.arange(ntf, device=dev) - wf // 2).clamp(0, ntf - wf)
+    sb = (torch.arange(nth, device=dev) - wh // 2).clamp(0, nth - wh)
+    sc = (torch.arange(ntw, device=dev) - ww // 2).clamp(0, ntw - ww)
+    ia = sa[:, None] + torch.arange(wf, device=dev)
+    ib = sb[:, None] + torch.arange(wh, device=dev)
+    ic = sc[:, None] + torch.arange(ww, device=dev)
+    tid = (((ia[:, None, None, :, None, None] * nth + ib[None, :, None, None, :, None]) * ntw
+            + ic[None, None, :, None, None, :]).reshape(NT, NW))
+
+    dqt = torch.zeros(B, NT, TS, NH, D, device=dev, dtype=torch.float32)
+    dkt = torch.zeros(B, NT, TS, NH, D, device=dev, dtype=torch.float32)
+    dvt = torch.zeros(B, NT, TS, NH, D, device=dev, dtype=torch.float32)
+
+    step = max(1, int(2.5e8) // max(1, KW * NH * D * 4))
+    for s in range(0, NT, step):
+        e = min(NT, s + step)
+        ch = e - s
+        g = tid[s:e]                                           # (ch, NW)
+        kc = kt[:, g].reshape(B, ch, KW, NH, D)
+        vc = vt[:, g].reshape(B, ch, KW, NH, D)
+        sc_ = torch.einsum("bcqhd,bckhd->bchqk", qt[:, s:e] * scale, kc)
+        p = torch.exp(sc_ - lt[:, s:e].permute(0, 1, 3, 2).unsqueeze(-1))
+        dp = torch.einsum("bcqhd,bckhd->bchqk", dot[:, s:e], vc)
+        ds = p * (dp - dt[:, s:e].permute(0, 1, 3, 2).unsqueeze(-1))
+        dqt[:, s:e] = torch.einsum("bchqk,bckhd->bcqhd", ds, kc) * scale
+        dkc = torch.einsum("bchqk,bcqhd->bckhd", ds, qt[:, s:e]) * scale
+        dvc = torch.einsum("bchqk,bcqhd->bckhd", p, dot[:, s:e])
+        flat = g.reshape(-1)
+        dkt.index_add_(1, flat, dkc.reshape(B, ch * NW, TS, NH, D))
+        dvt.index_add_(1, flat, dvc.reshape(B, ch * NW, TS, NH, D))
+
+    def un_tile(x):
+        return (x.reshape(B, ntf, nth, ntw, tf, th, tw, NH, D)
+                 .permute(0, 1, 4, 2, 5, 3, 6, 7, 8).reshape(B, T, NH, D))
+
+    return un_tile(dqt), un_tile(dkt), un_tile(dvt)
+
+def _mk(B, F, Hh, Ww, NH, D, TF, TH, TW, WF, WH, WW, seed):
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    T = F * Hh * Ww
+    ntf, nth, ntw = F // TF, Hh // TH, Ww // TW
+    NT, TS = ntf * nth * ntw, TF * TH * TW
+    def r():
+        return torch.randn(B, T, NH, D, device="cuda", dtype=torch.bfloat16, generator=gen)
+    q, k, v, do = r(), r(), r(), r()
+    scale = D ** -0.5
+
+    # forward pass, chunked over query tiles, to produce a CONSISTENT (lse, delta) pair
+    def to_tiles(x):
+        return (x.view(B, ntf, TF, nth, TH, ntw, TW, NH, D)
+                 .permute(0, 1, 3, 5, 2, 4, 6, 7, 8).reshape(B, NT, TS, NH, D))
+    qt, kt, vt, dot = (to_tiles(x.float()) for x in (q, k, v, do))
+    dev = q.device
+    sa = (torch.arange(ntf, device=dev) - WF // 2).clamp(0, ntf - WF)
+    sb = (torch.arange(nth, device=dev) - WH // 2).clamp(0, nth - WH)
+    sc = (torch.arange(ntw, device=dev) - WW // 2).clamp(0, ntw - WW)
+    ia = sa[:, None] + torch.arange(WF, device=dev)
+    ib = sb[:, None] + torch.arange(WH, device=dev)
+    ic = sc[:, None] + torch.arange(WW, device=dev)
+    tid = (((ia[:, None, None, :, None, None] * nth + ib[None, :, None, None, :, None]) * ntw
+            + ic[None, None, :, None, None, :]).reshape(NT, WF * WH * WW))
+    KW = WF * WH * WW * TS
+    lset = torch.empty(B, NT, TS, NH, device=dev)
+    delt = torch.empty(B, NT, TS, NH, device=dev)
+    step = max(1, int(2.5e8) // max(1, KW * NH * D * 4))
+    for s in range(0, NT, step):
+        e = min(NT, s + step)
+        g = tid[s:e]
+        kc = kt[:, g].reshape(B, e - s, KW, NH, D)
+        vc = vt[:, g].reshape(B, e - s, KW, NH, D)
+        sc_ = torch.einsum("bcqhd,bckhd->bchqk", qt[:, s:e] * scale, kc)
+        l = torch.logsumexp(sc_, dim=-1)                                   # (B, ch, NH, TS)
+        o = torch.einsum("bchqk,bckhd->bcqhd", torch.exp(sc_ - l.unsqueeze(-1)), vc)
+        lset[:, s:e] = l.permute(0, 1, 3, 2)
+        delt[:, s:e] = (o * dot[:, s:e]).sum(-1)
+    def un_s(x):
+        return (x.reshape(B, ntf, nth, ntw, TF, TH, TW, NH)
+                 .permute(0, 1, 4, 2, 5, 3, 6, 7).reshape(B, T, NH).permute(0, 2, 1).contiguous())
+    return q, k, v, do, un_s(lset), un_s(delt), (F, Hh, Ww), (TF, TH, TW), (WF, WH, WW)
+
+
+def _check(out, ref):
+    """-> (ok, value, msg). value = MAX relative error across the returned tuple."""
+    if out is None or len(out) != len(NAMES):
+        return False, 1.0, f"expected a {len(NAMES)}-tuple {NAMES}"
+    per = []
+    for n, a, b in zip(NAMES, out, ref):
+        if a is None or tuple(a.shape) != tuple(b.shape):
+            return False, 1.0, f"{n} bad shape"
+        if b.dtype in (torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8, torch.bool):
+            # exact: .float() is lossy above 2**24 and would let distinct large ids compare equal
+            bad = int((a != b).sum())
+            if bad:
+                return False, 1.0, f"{n}: {bad} elements differ"
+            continue
+        per.append((n, float((a.float() - b.float()).norm() / (b.float().norm() + 1e-12))))
+    if not per:
+        return True, 0.0, "all integer outputs exact"
+    wn, wv = max(per, key=lambda x: x[1])
+    return wv <= TOL, wv, f"worst {wn} {wv:.2e}"
+
+
+def _bench_fresh(fn, mkargs, reps=5, warm=3):
+    """Time `fn` on FRESH inputs every rep -> (min_seconds, timed_ok). See the module docstring."""
+    wargs = mkargs(0)
+    for _ in range(warm):
+        fn(*wargs)
+    torch.cuda.synchronize()
+    del wargs
+    torch.cuda.empty_cache()
+
+    best, timed_ok = float("inf"), True
+    for i in range(reps):
+        args = mkargs(10_000 + i)
+        s, e = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True)
+        s.record()
+        out = fn(*args)
+        e.record()
+        torch.cuda.synchronize()
+        best = min(best, s.elapsed_time(e))
+        if i == reps - 1:
+            timed_ok = _check(out, _ref(*args))[0]
+        del args, out
+        torch.cuda.empty_cache()
+    return best / 1e3, timed_ok
+
+
+def _geomean(xs):
+    return math.exp(sum(math.log(max(v, 1e-9)) for v in xs) / len(xs)) if xs else 0.0
+
+
+def main():
+    details, correct_gate, geo = {}, False, 0.0
+    try:
+        spec = importlib.util.spec_from_file_location("submission", MODULE_PATH)
+        m = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(m)
+        fn = m.sta_backward
+
+        corr_ok, msg = True, ""
+        for i, shp in enumerate(CORRECT_SHAPES):
+            args = _mk(*shp, seed=10 + i)
+            ok, val, m_ = _check(fn(*args), _ref(*args))
+            if not ok:
+                corr_ok, msg = False, f"cfg{i} {shp} {m_}"
+                break
+            del args
+            torch.cuda.empty_cache()
+        details["correct_msg"] = msg or "all correctness shapes pass"
+
+        vals, per_shape, perf_ok = [], [], corr_ok
+        for i, shp in enumerate(GRADER_SHAPES):
+            args = _mk(*shp, seed=100 + i)
+            ok, val, m_ = _check(fn(*args), _ref(*args))
+            if not ok:
+                perf_ok = False
+            del args
+            torch.cuda.empty_cache()
+            t, timed_ok = _bench_fresh(fn, lambda s, _p=shp: _mk(*_p, seed=s))
+            if not timed_ok:
+                perf_ok = False
+            v = canonical_work(*shp) / t / 1e12 if t > 0 else 0.0
+            vals.append(v)
+            per_shape.append({"shape": list(shp), "tflops": round(v, 3), "ms": round(t * 1e3, 3),
+                              "check": m_, "timed_ok": timed_ok})
+        geo = _geomean(vals)
+        details.update(per_shape=per_shape, geomean=round(geo, 4), perf_size_ok=perf_ok)
+        correct_gate = corr_ok and perf_ok
+    except Exception as e:
+        details["error"] = f"{e.__class__.__name__}: {e}"[:220]
+        details["trace"] = traceback.format_exc()[-800:]
+
+    reward = round(geo, 4) if correct_gate else 0.0
+    os.makedirs(REWARD_DIR, exist_ok=True)
+    json.dump({"reward": reward, "correct": 1.0 if correct_gate else 0.0,
+               "geomean": round(geo, 4), "metric": "TFLOP/s (geomean over graded shapes)"},
+              open(f"{REWARD_DIR}/reward.json", "w"), indent=2)
+    open(f"{REWARD_DIR}/reward.txt", "w").write(str(reward))
+    json.dump(details, open(f"{REWARD_DIR}/details.json", "w"), indent=2, default=str)
+    print("reward:", reward, "TFLOP/s | correct:", 1.0 if correct_gate else 0.0)
+
+
+main()

tasks/video-sparse-attention/sta-ragged-tile-boundary/RUN.md

@@ -0,0 +1,42 @@
+# Running `sta-ragged-tile-boundary`
+
+Real video latents do not divide by the tile: HunyuanVideo at 720p is 33 x 45 x 80 and every tile size anyone actually uses leaves a remainder on all three axes. That single fact removes the two things every tiled attention kernel relies on — the tile-major reshape and the constant key count — because the boundary tiles are SHORT, the window that reaches them is short with them, and no two query tiles need the same amount of work. Ceil-divide the grid, clamp the window inward, and attend over a 3D box whose size changes from tile to tile.
+
+|  |  |
+|---|---|
+| **Task id** | `mle-bench/sta-ragged-tile-boundary` |
+| **Group** | `kernel-generation` |
+| **GPUs** | 1 |
+| **Agent edits** | `/app/sta_ragged.py` |
+| **Score** | achieved **TFLOP/s** (uncapped speed leaderboard), `0` if incorrect |
+| **Grade output** | `tests/test.sh` -> `/logs/verifier/reward.json` |
+
+## Run through harbor
+
+```bash
+harbor run --dataset-path kernel-generation/kernels/sta-ragged-tile-boundary --task-name sta-ragged-tile-boundary \
+  --agent claude-code --model anthropic/claude-opus-4-1 -e docker
+```
+
+## Run manually
+
+```bash
+cd kernel-generation/kernels/sta-ragged-tile-boundary
+docker build -t sta-ragged-tile-boundary environment/
+docker run -d --name v --gpus '"device=0"' --shm-size=8g --entrypoint sleep sta-ragged-tile-boundary infinity
+docker cp tests v:/tests && docker exec v bash /tests/test.sh   # untouched start -> reward 0.0
+docker rm -f v
+```
+
+Use an **idle** GPU: the score is a timing measurement.
+
+## Design
+
+Correctness is a hard gate; the score is an absolute hardware metric (TFLOP/s), so the task is
+hardware-portable and needs no gold solution, no oracle, and nothing vendored or sealed.
+
+Anti-cheat is structural: the image holds only the permitted toolchain and has no internet; the grader is
+copied in at grade time with its own private copy of the reference; and every timed rep runs on fresh inputs
+with the timed output itself validated, so memoize-and-replay fails the gate.
+
+Generated by `_factory/build.py` — edit the spec and regenerate rather than editing this task by hand.

tasks/video-sparse-attention/sta-ragged-tile-boundary/environment/CLAUDE.md

@@ -0,0 +1,25 @@
+# Working in this environment
+
+## ⚠️ Stop background processes without killing yourself
+
+You are launched as `claude --print -- '<the task instruction>'`, so the task text — including the
+file names and commands it mentions — is on **your own** process's command line. Any command that
+finds processes by **matching that text** (`pkill -f …`, `pgrep -f … | xargs kill`, a `/proc`
+cmdline scan, `fuser -k`, `killall`) can match and **kill the agent itself**, ending your run
+(`NonZeroAgentExitCodeError`) and grading you on unfinished work.
+
+This bites whenever you background something and later stop/restart it — a **server**, a long
+**build** or **training run**, or an **ncu / nsys profiling** session.
+
+**Always** manage a background process by its **exact recorded PID**, never by a name pattern:
+
+```bash
+nohup <your command> > /tmp/job.log 2>&1 & echo $! > /tmp/job.pid   # start + record the PID
+kill "$(cat /tmp/job.pid)"; sleep 3                                 # stop (SIGTERM); -9 only if needed
+```
+
+Use `setsid` and kill the process **group** (`kill -- -"$(cat /tmp/job.pid)"`) if it spawns children.
+If you must enumerate processes, match a **unique token that is NOT anywhere in this prompt** and
+**exclude any cmdline containing `claude` or `--print`** — `pgrep -af`, and look before you kill.
+
+Full details + safe recipes: **`/app/PROCESS_MANAGEMENT.md`**.

tasks/video-sparse-attention/sta-ragged-tile-boundary/environment/Dockerfile

@@ -0,0 +1,41 @@
+# Kernel-generation task: Write a fast ragged-tile 3D sliding-window video attention kernel
+#
+# Real video latents do not divide by the tile: HunyuanVideo at 720p is 33 x 45 x 80 and every tile size anyone actually uses leaves a remainder on all three axes. That single fact removes the two things every tiled attention kernel relies on — the tile-major reshape and the constant key count — because the boundary tiles are SHORT, the window that reaches them is short with them, and no two query tiles need the same amount of work. Ceil-divide the grid, clamp the window inward, and attend over a 3D box whose size changes from tile to tile.
+#
+# SCORING: correctness is a hard gate; the score is achieved TFLOP/s (uncapped leaderboard, 0 if wrong).
+# There is no gold solution and no oracle, so nothing has to be vendored or sealed.
+#
+# TOOLCHAIN POLICY: the agent writes the kernel with Triton (+Gluon), CUDA C++ via nvcc, CUTLASS headers, or
+# the CuTe DSL. Enforcement is by ABSENCE, not by scanning: only the permitted toolchain is installed and
+# there is no internet, so nothing else can be obtained.
+#
+# GENERATED by _factory/build.py.
+FROM pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
+
+# NOTE: every heavy layer comes FIRST and depends only on {base_image, pip_extra}, so all tasks in this
+# lane share the same cached layers. The task-specific COPYs are LAST. Do not reorder.
+RUN pip install --break-system-packages --no-cache-dir einops nvidia-cutlass-dsl && \
+    apt-get update && apt-get install -y --no-install-recommends iptables iproute2 curl ca-certificates build-essential git && \
+    curl -LsSf https://astral.sh/uv/install.sh | sh && \
+    /root/.local/bin/uv tool install mini-swe-agent
+# header-only CUTLASS for the agent's CUDA/CuTe route
+RUN git clone --depth 1 https://github.com/NVIDIA/cutlass /opt/cutlass && rm -rf /opt/cutlass/.git
+# pre-bake Claude Code; harbor's claude_code.install() skips when present
+RUN curl -fsSL https://deb.nodesource.com/setup_22.x | bash - && \
+    apt-get install -y nodejs procps && \
+    npm install -g @anthropic-ai/claude-code && claude --version
+ENV PATH=/root/.local/bin:$PATH
+ENV DISABLE_TELEMETRY=1 DISABLE_AUTOUPDATER=1 DISABLE_ERROR_REPORTING=1 CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1
+
+COPY restrict-network.sh /app/restrict-network.sh
+RUN chmod +x /app/restrict-network.sh
+# strip apt sources LAST so harbor's post-firewall apt step is a no-op that succeeds
+RUN rm -rf /var/lib/apt/lists/* /etc/apt/sources.list /etc/apt/sources.list.d
+
+WORKDIR /app
+COPY CLAUDE.md PROCESS_MANAGEMENT.md /app/
+
+# task-specific files LAST so the layers above stay shared across every task
+COPY reference.py /app/reference.py
+COPY measure.py /app/measure.py
+COPY sta_ragged.py /app/sta_ragged.py

tasks/video-sparse-attention/sta-ragged-tile-boundary/environment/PROCESS_MANAGEMENT.md

@@ -0,0 +1,96 @@
+# Managing background processes — READ THIS before you `kill` anything
+
+You may start and stop background processes while iterating — a **server**, a long **build** or
+**training run**, or an **ncu / nsys profiling** session. **The way you stop one can silently kill
+*your own agent process* and end the whole run.** This has happened repeatedly, including via a
+hand-rolled `/proc` scan — not just `pkill`. Read this once and follow the safe recipe.
+
+## The trap: matching task text against process command lines
+
+You were launched as roughly:
+
+```
+claude --print -- '<the entire task instruction text>'
+```
+
+The full task instruction is on **your own** process's command line, and it contains the file names
+and commands the task mentions (e.g. `server.py`, `build.sh`, `train.py`, `solution.cu`, `/app/...`).
+So **any** command that finds processes by matching those strings will match — and can kill — **the
+agent itself**:
+
+```
+pkill -9 -f "train.py"                              # matches the claude agent -> kills YOU
+pgrep -f "server.py" | xargs kill                   # same: the pid list includes claude
+for p in $(pgrep -f build.sh); do kill -9 $p; done  # same
+for pid in /proc/*; do case "$(cmdline)" in *solution*) kill -9 $pid;; esac; done   # same
+```
+
+It is **not about `pkill`** — it is about **matching a string that appears in your prompt**. `pgrep`,
+a `/proc` scan, `fuser`, or `nvidia-smi`-pid loops all have the same failure if the match pattern (or
+the surviving pid list) includes the `claude` process. When you `kill -9` yourself the run dies
+immediately (`NonZeroAgentExitCodeError`) and you are graded on whatever was already in place — usually
+worse than what you were about to finish.
+
+## The one safe rule: kill only the exact PID you recorded
+
+**Start** a background job and record its PID in a file:
+
+```bash
+nohup <your command> > /tmp/job.log 2>&1 &
+echo $! > /tmp/job.pid
+```
+
+**Stop / restart** by that exact PID — never by a name pattern:
+
+```bash
+kill "$(cat /tmp/job.pid)" 2>/dev/null      # SIGTERM: lets it release the GPU / flush cleanly
+sleep 3
+kill -9 "$(cat /tmp/job.pid)" 2>/dev/null   # force only if it did not exit
+```
+
+If the job spawns workers, run it in its own process group and signal the group by its (negative)
+PGID — still an exact id, never a pattern:
+
+```bash
+setsid <your command> > /tmp/job.log 2>&1 < /dev/null & echo $! > /tmp/job.pid
+kill -TERM -- "-$(cat /tmp/job.pid)" 2>/dev/null
+```
+
+## If you ever enumerate processes, EXCLUDE the agent
+
+Prefer not to. But if you must scan (e.g. hunting a leaked worker), **exclude the `claude` agent and
+your own shell**, and match on a **unique token that is NOT anywhere in this prompt** — give your job
+a unique name and match only that:
+
+```bash
+# job named e.g. job_7x3q9 — a token that appears NOWHERE in the task text
+pgrep -af job_7x3q9 | grep -v -E 'claude|--print|pgrep|grep|bash'   # LOOK FIRST
+# only kill pids from THIS filtered list, and never a pid whose cmdline contains 'claude' or '--print'
+```
+
+Do **not** add a prompt word (a file name, `/app`, `python3`, …) to the pattern "just in case" — that
+single addition re-introduces the self-kill. Match the unique token **only**.
+
+## Freeing the GPU without going nuclear
+
+If VRAM stays high after you stop a GPU job, the usual cause is a **child process** or a not-yet-
+collected CUDA context — not a stray process you need to hunt across `/proc`. Do this instead of a
+`/proc` sweep:
+
+- Kill the job **by its recorded PID / PGID** (above) and `sleep 5–10`; the CUDA context frees after
+  the process fully exits.
+- Make the job release cleanly on `SIGTERM` (drop the model / `torch.cuda.empty_cache()` / exit) so a
+  single `kill $PID` is enough.
+- Start it in its own group (`setsid`) so `kill -- -$PGID` takes the workers with it.
+- Check with `nvidia-smi` — if a PID still holds memory, `kill` **that exact numeric PID**, after
+  confirming its cmdline is **not** `claude` / `--print`.
+
+## Rules of thumb
+
+- **Never** match a task-prompt string (`server.py`, `train.py`, `build.sh`, `/app`, `python3`, …)
+  with `pkill -f`, `pgrep -f`, `killall`, `fuser`, or a `/proc` cmdline scan — they all can hit the
+  agent (its argv holds the prompt).
+- **Always** kill a background job by the exact PID from its pidfile (or its PGID).
+- If you must enumerate, match a **unique token not in the prompt** and **exclude `claude` / `--print`
+  and your own shell**; `pgrep -af` and look before you kill.
+- `SIGTERM` first for a clean release; `-9` only as a last resort on a specific numeric PID.

tasks/video-sparse-attention/sta-ragged-tile-boundary/environment/docker-compose.yaml

@@ -0,0 +1,18 @@
+# Anti-cheat firewall overlay, merged on top of Harbor's base compose. Gives the main container
+# NET_ADMIN and runs restrict-network.sh as the entrypoint, so only DNS + the LLM API endpoints are
+# reachable (pypi/github/HF blocked). network_mode stays "public" (see task.toml) — the firewall, not
+# Docker, enforces the allowlist. mini-swe-agent is pre-installed and harbor's patched installer skips
+# the (now-blocked) network install when it is already present.
+services:
+  main:
+    cap_add:
+      - NET_ADMIN
+    entrypoint: ["/bin/bash", "/app/restrict-network.sh"]
+    environment:
+      - ALLOWED_HOSTS=${ALLOWED_HOSTS:-}
+      - FIREWORKS_BASE_URL=${FIREWORKS_BASE_URL:-}
+      - OPENROUTER_BASE_URL=${OPENROUTER_BASE_URL:-}
+      - OPENAI_BASE_URL=${OPENAI_BASE_URL:-}
+      - ANTHROPIC_BASE_URL=${ANTHROPIC_BASE_URL:-}
+      - LLM_BASE_URL=${LLM_BASE_URL:-}
+      - LITELLM_BASE_URL=${LITELLM_BASE_URL:-}

tasks/video-sparse-attention/sta-ragged-tile-boundary/environment/measure.py

@@ -0,0 +1,128 @@
+"""Self-assessment tool — your correctness + achieved TFLOP/s across a RANGE of shapes.
+
+    python /app/measure.py            # the graded regime
+    python /app/measure.py --quick    # smaller sizes for fast iteration
+
+You are scored on the **geomean achieved TFLOP/s** — NOT one fixed size, and the leaderboard is UNCAPPED
+(higher is always better). The shapes below are a DIFFERENT sample from the same regime the grader uses, so
+optimize for GENERALITY. Work is counted with the same shape-only formula the grader uses, so the number
+printed here is computed exactly as your score is.
+
+GENERATED by _factory/build.py.
+"""
+import argparse
+import math
+import sys
+
+import torch
+
+sys.path.insert(0, "/app")
+from reference import sta_ragged_attention as _ref
+from sta_ragged import sta_ragged_attention as _agent
+
+TOL = 0.008
+
+FULL = [(1, 17, 21, 25, 12, 128, 4, 6, 7, 3, 3, 3), (1, 13, 25, 29, 16, 128, 3, 7, 8, 3, 3, 3), (1, 19, 23, 27, 12, 128, 5, 6, 7, 3, 3, 3), (2, 11, 19, 21, 16, 128, 3, 5, 6, 3, 3, 3), (1, 17, 25, 31, 16, 64, 4, 7, 8, 3, 3, 3)]
+QUICK = [(1, 11, 13, 17, 8, 128, 2, 3, 4, 3, 3, 3), (1, 9, 11, 13, 8, 64, 2, 2, 3, 3, 3, 3), (2, 7, 9, 15, 6, 128, 2, 2, 4, 3, 3, 3)]
+
+def _axis_plan(n, t, w):
+    """Per tile on one axis: (query range, key range) as half-open token intervals. SHAPE ONLY."""
+    nt = -(-n // t)
+    out = []
+    for i in range(nt):
+        s = min(max(i - w // 2, 0), nt - w)
+        out.append(((i * t, min(n, (i + 1) * t)), (s * t, min(n, (s + w) * t))))
+    return out
+
+
+def canonical_work(B, F, Hh, Ww, NH, D, TF, TH, TW, WF, WH, WW):
+    """FLOPs attributed to one call, from the SHAPE ALONE.
+
+    A query tile is the product of its three axis ranges, and its key box is the product of the three
+    (clamped, clipped) window ranges -- so both the query count and the key count vary from tile to tile,
+    and both follow from the shape. Every (query, key) pair costs 4*D FLOPs.
+    """
+    A = _axis_plan(F, TF, WF)
+    Bx = _axis_plan(Hh, TH, WH)
+    C = _axis_plan(Ww, TW, WW)
+    pairs = 0
+    for (qa0, qa1), (ka0, ka1) in A:
+        for (qb0, qb1), (kb0, kb1) in Bx:
+            for (qc0, qc1), (kc0, kc1) in C:
+                pairs += ((qa1 - qa0) * (qb1 - qb0) * (qc1 - qc0)) * \
+                         ((ka1 - ka0) * (kb1 - kb0) * (kc1 - kc0))
+    return 4 * D * B * NH * pairs
+
+def _mk(B, F, Hh, Ww, NH, D, TF, TH, TW, WF, WH, WW, seed):
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    T = F * Hh * Ww
+    def r():
+        return torch.randn(B, T, NH, D, device="cuda", dtype=torch.bfloat16, generator=gen)
+    return r(), r(), r(), (F, Hh, Ww), (TF, TH, TW), (WF, WH, WW)
+
+
+def _is_exact(t):
+    """Integer/bool tensors are compared EXACTLY: .float() is lossy above 2**24, so two distinct large
+    ids (page ids, token ids, indices) can compare equal and let a wrong kernel pass."""
+    return t.dtype in (torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8, torch.bool)
+
+
+def _check(out, ref):
+    """-> (ok, value, msg). Exact for integer/bool; relative Frobenius error otherwise."""
+    if out is None or tuple(out.shape) != tuple(ref.shape):
+        return False, 1.0, "bad/None shape"
+    if _is_exact(ref):
+        bad = int((out != ref).sum())
+        return bad == 0, float(bad), ("exact match" if bad == 0 else f"{bad} elements differ")
+    e = float((out.float() - ref.float()).norm() / (ref.float().norm() + 1e-12))
+    return e <= TOL, e, f"relerr {e:.2e}"
+
+
+def _bench(fn, reps=8, warm=3):
+    for _ in range(warm):
+        fn()
+    torch.cuda.synchronize()
+    best = float("inf")
+    for _ in range(reps):
+        s, e = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True)
+        s.record()
+        fn()
+        e.record()
+        torch.cuda.synchronize()
+        best = min(best, s.elapsed_time(e))
+    return best / 1e3
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--quick", action="store_true")
+    a = ap.parse_args()
+    shapes = QUICK if a.quick else FULL
+    print(f"geomean over {len(shapes)} shapes ({'quick' if a.quick else 'full'}); the grader uses "
+          f"DIFFERENT sizes in the same regime — optimize for generality\n")
+    vals, allok = [], True
+    for shp in shapes:
+        args = _mk(*shp, seed=sum(int(x) for x in shp) % 9973)
+        ref = _ref(*args)
+        try:
+            out = _agent(*args)
+        except Exception as ex:
+            print(f"  {shp}: RAISED {type(ex).__name__}: {str(ex)[:70]}")
+            allok = False
+            continue
+        ok, val, msg = _check(out, ref)
+        allok = allok and ok
+        t = _bench(lambda: _agent(*args))
+        v = canonical_work(*shp) / t / 1e12 if t > 0 else 0.0
+        vals.append(v)
+        print(f"  {str(shp):28s} {t*1e3:9.2f} ms | {v:9.2f} TFLOP/s | {msg} {'ok' if ok else 'FAIL'}")
+        del args, ref, out
+        torch.cuda.empty_cache()
+    geo = math.exp(sum(math.log(max(v, 1e-9)) for v in vals) / len(vals)) if vals else 0.0
+    print(f"\n  => GEOMEAN {geo:.2f} TFLOP/s   "
+          f"({'all correct' if allok else 'SOME WRONG — a wrong kernel scores 0, fix correctness first'})")
+    print("     This IS your score, and it is uncapped — higher is always better. Keep pushing.")
+
+
+if __name__ == "__main__":
+    main()

tasks/video-sparse-attention/sta-ragged-tile-boundary/environment/reference.py

@@ -0,0 +1,51 @@
+"""Reference implementation — the CORRECTNESS SPEC for `sta_ragged_attention`.
+
+This is correct but slow. It defines exactly what your kernel must reproduce; its speed has no
+bearing on your score, which is an absolute TFLOP/s number. GENERATED by _factory/build.py.
+"""
+import torch
+
+
+def _axis_plan(n, t, w):
+    """Per tile on one axis: (query range, key range) as half-open token intervals. SHAPE ONLY.
+
+    The axis is CEIL-divided into nt tiles, so the last one holds n - (nt-1)*t tokens. The window is nt-tile
+    centred and shifted inward so it never leaves the axis, then converted to tokens and clipped at n.
+    """
+    nt = -(-n // t)
+    out = []
+    for i in range(nt):
+        s = min(max(i - w // 2, 0), nt - w)
+        out.append(((i * t, min(n, (i + 1) * t)), (s * t, min(n, (s + w) * t))))
+    return out
+
+
+def sta_ragged_attention(q, k, v, latent, tile, window, scale=None):
+    """Ragged sliding-tile attention, written as one dense softmax per query tile over its 3D key box.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target: it materialises the
+    whole gathered key box of every query tile.
+    """
+    B, T, NH, D = q.shape
+    F, Hh, Ww = latent
+    tf, th, tw = tile
+    wf, wh, ww = window
+    if scale is None:
+        scale = D ** -0.5
+    dev = q.device
+
+    qv = q.float().view(B, F, Hh, Ww, NH, D)
+    kv = k.float().view(B, F, Hh, Ww, NH, D)
+    vv = v.float().view(B, F, Hh, Ww, NH, D)
+    o = torch.empty(B, F, Hh, Ww, NH, D, device=dev, dtype=torch.float32)
+
+    for (qf0, qf1), (kf0, kf1) in _axis_plan(F, tf, wf):
+        for (qh0, qh1), (kh0, kh1) in _axis_plan(Hh, th, wh):
+            for (qw0, qw1), (kw0, kw1) in _axis_plan(Ww, tw, ww):
+                qc = qv[:, qf0:qf1, qh0:qh1, qw0:qw1].reshape(B, -1, NH, D)
+                kc = kv[:, kf0:kf1, kh0:kh1, kw0:kw1].reshape(B, -1, NH, D)
+                vc = vv[:, kf0:kf1, kh0:kh1, kw0:kw1].reshape(B, -1, NH, D)
+                s = torch.einsum("bqhd,bkhd->bhqk", qc * scale, kc)
+                oc = torch.einsum("bhqk,bkhd->bqhd", torch.softmax(s, dim=-1), vc)
+                o[:, qf0:qf1, qh0:qh1, qw0:qw1] = oc.view(B, qf1 - qf0, qh1 - qh0, qw1 - qw0, NH, D)
+    return o.view(B, T, NH, D)

tasks/video-sparse-attention/sta-ragged-tile-boundary/environment/restrict-network.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+# Outbound firewall (anti-cheat): allow ONLY DNS, loopback, docker-internal networks, and the LLM API
+# endpoints the agent needs. Everything else is dropped — in particular pypi, github, and huggingface,
+# so the agent cannot `pip install vllm` / `pip install sglang` / clone the reference moe_align kernel and
+# copy it. torch + triton are already in the image, and mini-swe-agent is pre-installed (harbor's patched
+# installer skips the network install when it is already present), so no package index is needed at run time.
+#
+# Runs as the container ENTRYPOINT before the CMD. iptables rules are network-namespace-wide, so they also
+# apply to the agent's `docker exec` commands. Requires cap_add: NET_ADMIN.
+set -uo pipefail
+
+# LLM API endpoints the agent may reach. Extend at launch via ALLOWED_HOSTS=host1,host2 (no scheme).
+API_HOSTS=(
+    api.fireworks.ai
+    openrouter.ai openrouter.io
+    api.openai.com api.anthropic.com generativelanguage.googleapis.com
+    api.together.xyz integrate.api.nvidia.com api.moonshot.cn api.kimi.com
+)
+# Auto-allow hosts from any *_BASE_URL / *_ENDPOINT env var (ANTHROPIC_BASE_URL, OPENAI_BASE_URL, …).
+CUSTOM=()
+while IFS='=' read -r n v; do
+    case "$n" in
+        *_BASE_URL|*_URL|*_ENDPOINT)
+            [ -n "$v" ] && CUSTOM+=("$(echo "$v" | sed 's|.*://||; s|[:/].*||')") ;;
+    esac
+done < <(env)
+if [ -n "${ALLOWED_HOSTS:-}" ]; then IFS=',' read -ra E <<< "$ALLOWED_HOSTS"; CUSTOM+=("${E[@]}"); fi
+ALL_HOSTS=("${API_HOSTS[@]}" ${CUSTOM[@]+"${CUSTOM[@]}"})
+
+if iptables -L OUTPUT -n >/dev/null 2>&1; then
+    echo "restrict-network: applying outbound allowlist firewall..."
+    iptables -F OUTPUT 2>/dev/null || true
+    iptables -A OUTPUT -o lo -j ACCEPT
+    iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
+    iptables -A OUTPUT -p udp --dport 53 -j ACCEPT
+    iptables -A OUTPUT -p tcp --dport 53 -j ACCEPT
+    iptables -A OUTPUT -d 10.0.0.0/8 -j ACCEPT
+    iptables -A OUTPUT -d 172.16.0.0/12 -j ACCEPT
+    iptables -A OUTPUT -d 192.168.0.0/16 -j ACCEPT
+    iptables -A OUTPUT -d 127.0.0.11 -j ACCEPT
+    for h in "${ALL_HOSTS[@]}"; do
+        for ip in $(getent ahosts "$h" 2>/dev/null | awk '{print $1}' | sort -u); do
+            iptables -A OUTPUT -d "$ip" -j ACCEPT
+        done
+    done
+    iptables -A OUTPUT -j REJECT --reject-with icmp-admin-prohibited
+    echo "restrict-network: outbound locked to DNS + LLM endpoints; pypi/github/HF blocked."
+else
+    echo "restrict-network: WARNING — iptables unavailable (need cap_add NET_ADMIN); NOT firewalled." >&2
+fi
+
+exec "$@"

tasks/video-sparse-attention/sta-ragged-tile-boundary/environment/sta_ragged.py

@@ -0,0 +1,27 @@
+"""Your implementation goes here.
+
+Replace the body of `sta_ragged_attention` with a FAST implementation that reproduces the output of /app/reference.py
+(same signature, same numerics within tolerance) but is much faster — see /app/instruction.md.
+Run `python /app/measure.py` to check your correctness and achieved TFLOP/s.
+
+You may add helper modules, Triton kernels, CUDA extensions, caches, etc. — only this function's name,
+signature and returned value are fixed by the contract.
+"""
+
+
+def sta_ragged_attention(q, k, v, latent, tile, window, scale=None):
+    """Sliding-tile 3D window attention on a latent that does NOT divide by the tile size.
+
+    Args:
+        q, k, v: (B, T, NH, D) bfloat16 — T = F*Hh*Ww latent tokens in RASTER order (f, then h, then w).
+        latent:  (F, Hh, Ww) tuple of int — latent grid; NONE of these need be a multiple of the tile.
+        tile:    (tf, th, tw) tuple of int — 3D tile size; the grid is ceil-divided, so the last tile on each
+                 axis is SHORT.
+        window:  (wf, wh, ww) tuple of int — window size in TILES on each axis; each is <= the tile count of
+                 that axis and is odd.
+        scale:   float or None — logit scale; None means D ** -0.5.
+
+    Returns:
+        o: (B, T, NH, D), bfloat16 or float32, RASTER order — must match /app/reference.py numerically.
+    """
+    raise NotImplementedError("Implement a fast sta_ragged_attention in /app/sta_ragged.py")

tasks/video-sparse-attention/sta-ragged-tile-boundary/instruction.md

@@ -0,0 +1,194 @@
+# Write a fast ragged-tile 3D sliding-window video attention kernel
+
+You are given a **correct but slow** reference at **`/app/reference.py`** — `sta_ragged_attention(q, k, v, latent, tile, window, scale=None)`. **Read it, run it, profile it.**
+
+Write **`/app/sta_ragged.py`** with the **same signature** and the **same numerical output**, but **as fast as you can make it**.
+
+```python
+def sta_ragged_attention(q, k, v, latent, tile, window, scale=None):
+    ...
+```
+
+## The computation (this is the exact spec)
+
+The latent is `F x Hh x Ww` tokens, flattened raster (`f`, then `h`, then `w`). It is cut into
+3D tiles of `(tf, th, tw)` — but **none of the three dimensions has to divide**. Each axis is **ceil**-divided:
+
+```
+nt = ceil(n / t)                          # tiles on this axis
+tile i covers tokens [ i*t , min(n, (i+1)*t) )
+```
+
+so the **last tile on each axis is short** (it can be as short as one token), and there is no reshape that
+turns the sequence into tile-major order.
+
+**The window** is `(wf, wh, ww)` tiles, centred on the query tile and **shifted inward** so that it never
+leaves the volume — the standard sliding-tile rule, applied independently on each axis in TILE space:
+
+```
+s = clamp(i - w//2, 0, nt - w)            # first key TILE on this axis
+key tokens on this axis: [ s*t , min(n, (s+w)*t) )
+```
+
+The key set of a query tile is the **3D box** formed by the three axis ranges, and every query in that tile
+attends to all of it with a single softmax:
+
+```
+o_t = softmax_r( scale * q_t . k_r ) @ v ,   r in the box of t's tile
+```
+
+**Both counts vary.** A query tile holds between `1` and `tf*th*tw` tokens. Its key box holds between
+`(wf-1)*tf+1` ... `wf*tf` tokens on the `f` axis (and likewise on the others), because the window can contain
+the short last tile — and when `w == nt` the clamp pins every tile to the same box. Two neighbouring query
+tiles routinely have different query counts *and* different key counts.
+
+There is no mask beyond the box, no causality, and no text stream. Attention inside the box is dense and
+bidirectional.
+
+`/app/reference.py` walks the tile grid and runs one dense softmax per tile over its sliced key box. That is
+the exact specification; it is deliberately simple rather than fast.
+
+## The contract (fixed — do not change these)
+
+| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `q`, `k`, `v` | `(B, T, NH, D)` | `bfloat16` | latent tokens, `T = F*Hh*Ww`, RASTER order |
+| `latent` | `(F, Hh, Ww)` | tuple of int | latent grid; **not** multiples of the tile |
+| `tile` | `(tf, th, tw)` | tuple of int | 3D tile size; the grid is ceil-divided |
+| `window` | `(wf, wh, ww)` | tuple of int | window in TILES; odd, and `w <= nt` on that axis |
+| `scale` | scalar | `float` or `None` | logit scale; `None` means `D ** -0.5` |
+
+**Return** `o` of shape `(B, T, NH, D)` in the **same raster order as `q`**, `bfloat16` or `float32`.
+
+Every graded shape is ragged on **at least two axes**, and `F`, `Hh`, `Ww`, `tf`, `th`, `tw` are frequently
+odd or prime. `w == 1` occurs (the window is then the query tile itself, short tail included). All tensors
+are CUDA, contiguous and read-only.
+
+No GQA, no RoPE, no dropout, no causal mask.
+
+**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): latents of
+`F` 11-21 by `Hh` 19-27 by `Ww` 23-31 (5k-15k tokens) with tiles of 3-8 on each axis and a 3x3x3 tile window,
+`NH` 12-20 heads, `D` in {64, 128}, `B` 1-2. That is 0.2-0.5 TFLOP per call, at 30-60% of the dense cost —
+the grids are deliberately small enough (4-6 tiles per axis) that **most tiles are boundary tiles**.
+
+This is the regime real video latents live in: 33 x 45 x 80 with a (6,8,8) tile is 6 x 6 x 10 tiles, of which
+only 1 in 5 is interior.
+
+## How success is decided (runs on GPU)
+
+**1. Correctness — a required gate.** The output must match the reference (evaluated in fp32) within **relative Frobenius
+error `8e-3`** at every graded shape, including the timed ones. The boundary tiles are the majority of the
+output, so getting only the interior right scores **0**. A wrong kernel scores **0**, no matter how fast.
+
+**2. Performance — this is your score, and it is an UNCAPPED leaderboard.**
+
+```
+reward = geomean over graded shapes of ( canonical_work(shape) / your_runtime )   [TFLOP/s]
+reward = 0   if the submission is wrong at any graded shape
+```
+
+`canonical_work` depends **only on the shape**, never on how you implemented it, so every submission is
+credited the same work and this is a pure speed ranking in useful units:
+
+```
+per axis: nt = ceil(n/t);  tile i covers tokens [i*t, min(n,(i+1)*t))
+          window start s = clamp(i - w//2, 0, nt-w);  keys [s*t, min(n,(s+w)*t))
+FLOPs = 4 * D * B * NH * sum over the 3D tile grid of (query count) * (key count)
+```
+
+**There is no cap and no target.** Higher TFLOP/s is always a strictly better score, so **push the
+performance as hard as you can**. Getting a correct implementation is the *start* of the task, not the end of
+it. Once correct, spend the entire remainder of your budget profiling and optimising, re-checking correctness
+after every change. **Use your full time budget.**
+
+Run **`python /app/measure.py`** at any point to see your per-shape and geomean TFLOP/s plus correctness.
+
+## Where the performance comes from
+
+**Do not reshape.** There is no tile-major permutation of a ragged grid, so the tile -> token
+map has to be arithmetic: token `(f,h,w)` lives at `((f*Hh)+h)*Ww + w`, and a query tile is `tf*th` runs of
+`tw*D` contiguous elements with strides `Ww*D` and `Hh*Ww*D`. Compute the three ranges once per tile (six
+integers), then index with two nested strides. A pre-pass that gathers tiles into a padded tile-major buffer
+costs one extra read and one extra write of the whole latent and wastes up to `tf*th*tw / (actual tokens)` of
+every boundary tile.
+
+**Key boxes are shared.** All tiles with the same window start on an axis see the same range on that axis —
+and with `nt` only 4-6 and `w = 3`, the clamp means the *first two* and the *last two* tiles share a start.
+Process query tiles grouped by their key box: the box's K/V then loads once into shared memory and serves
+several query tiles.
+
+**The work per tile is ragged, so a fixed grid wastes waves.** A one-CTA-per-tile launch runs at the pace of
+the largest tile; the short tail tiles finish early and idle. Either persist CTAs and pull query tiles from a
+counter, or flatten (query tile, key block) pairs into a work list with a prefix sum.
+
+**Predicate, do not pad.** The MMA wants a multiple of 16 on both axes and your tiles are 60, 168, 210 tokens
+long. Padding K with zeros injects `exp(0)` into the softmax and is silently wrong; padding with `-inf`
+logits is correct but wastes the lanes. Predicated loads plus a masked score fill is the honest version, and
+the tail is small enough that it should not cost you much.
+
+**`D` is 64 or 128, and the key box is 2k-8k tokens** — this is a normal flash-attention inner loop once the
+indexing is solved. Online softmax, fp32 accumulators, K/V staged through shared memory, and reuse the query
+tile across the whole box.
+
+## Precision and faithfulness (read this)
+
+All tensors are **bfloat16**; the output may be bf16 or fp32.
+
+Matmuls on bf16 tensor cores with **fp32 accumulation**; online-softmax state in fp32. An independent
+flash-style implementation (fp32 accumulators, `p` cast to bf16 for the PV matmul, bf16 output) differs from
+the fp32 reference by about `2e-3` relative, flat in problem size; the gate is `8e-3`.
+
+**The one precision trap here is padding.** Every boundary tile is short, so both the query axis and the key
+axis of the score block are ragged. A key lane that is out of range must contribute **zero probability** —
+set its logit to `-inf` (or mask after the exponential), never to `0`, and never leave a stale value in the
+accumulator. `exp(0) = 1` on a padded lane is a 1-in-`nkeys` error that shows up as a smooth bias across the
+boundary of every frame, which is exactly the kind of error the faithfulness rule forbids.
+
+A query lane that is out of range must not write anything back.
+
+Do **not** infer from the reference that fp32 storage is wanted; it computes in fp32 purely to be a stable
+numerical *specification*.
+
+### What the tolerance does NOT permit
+
+The tolerance exists **only** to absorb low-precision arithmetic noise. You are responsible for a **faithful
+implementation of the specified computation**. It is not a budget to spend on approximation. The following
+are wrong answers even if they happen to land inside the tolerance at some shape:
+
+- changing the algorithm to something that merely *approximates* the spec (dropping terms, truncating a
+  series, low-rank or sketched substitutes, skipping a correction term);
+- shortening the computation (fewer iterations/steps than specified, early exit on a heuristic, subsampling
+  or striding over the sequence, ignoring positions whose contribution "looks small");
+- computing at a coarser granularity than the spec (sharing a decay, scale, or normaliser across positions
+  that the spec gives their own);
+- anything whose error **grows** with sequence length, batch, or head count.
+
+A faithful bf16/fp8 kernel's error is *noise*: it stays flat as the problem grows and sits an order of
+magnitude below the gate. An approximation's error is *bias*: it scales with the problem. The graded shapes
+are deliberately large, so the difference shows up.
+
+## What's available
+
+- **Triton 3.6** (with Gluon), **CUDA C++ via `nvcc`** (`torch.utils.cpp_extension.load` for an inline
+  extension), header-only **CUTLASS** at `/opt/cutlass/include`, and the **CuTe DSL**
+  (`nvidia-cutlass-dsl`). C++ / CuTe DSL is the encouraged route; Triton is fully supported.
+- `torch` 2.11 (CUDA 12.8) and `einops` for bookkeeping.
+- A GPU with compute capability sm≥90 (Hopper or newer).
+- **No internet access.** `pip install` and cloning repos are blocked. Everything you are permitted to use is
+  already installed, and no library implementation of this kernel exists on the machine.
+- Manage any long-running background job (a build, an `ncu`/`nsys` profile) by its **recorded PID** — see
+  `/app/CLAUDE.md` and `/app/PROCESS_MANAGEMENT.md`.
+
+## How the grading actually runs (so there are no surprises)
+
+- **`/app/sta_ragged.py` is the only file that is graded.** The grader imports `sta_ragged_attention` from it and reads nothing
+  else from `/app`.
+- **The grader is not on this machine while you work.** It is copied in only after your session ends and it
+  carries its **own private copy of the reference** and its own input generator. Editing `/app/reference.py`
+  or `/app/measure.py` is allowed — they are yours to experiment with — but it has **no effect whatsoever on
+  your score**. Do not spend budget on them.
+- **Every timed repetition uses freshly generated inputs**, and the output of a timed call is itself checked
+  against the reference. Caching or memoizing a result and replaying it fails the correctness gate rather
+  than producing a fast measurement. Ordinary shape-keyed JIT/autotune caching is fine and is not penalised.
+- **The timed shapes are correctness-checked too.** Being correct only at the small shapes scores **0**.
+- Inputs are random each grade and the graded shapes are not the ones in `measure.py`.