400 tasks: kernel-optimization agent, profiler permissions, relaxed exact gates (part 14)

Every task now states that ncu needs GPU performance counters (ERR_NVGPUCTRPERM without them) and that nsys is the fallback; task.toml records the SYS_ADMIN requirement for the runner.

26 tasks previously gated at tol=0. Ten emit only integers and stay exact. The other sixteen carry a float payload and now accept a real tolerance -- 1e-3 for bf16, 1e-5 for fp32. The ceiling comes from the metric: GB/s is credited from the shape-derived byte count, so re-encoding the payload narrower moves less data than it is paid for. Measured fp8 round-trip 2.7e-2 (27x the bf16 gate) and fp16-for-fp32 2.1e-4 (21x the fp32 gate) -- both still rejected, while a kernel at 0.4x the gate passes.

26 legacy task.toml files normalized to schema 1.1.

tasks/quantization-gemm/w4a16-dequant-gemm/instruction.md

@@ -202,6 +202,12 @@ p.shared_memory_per_block_optin   # opt-in dynamic smem, the number that matters
   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`.
+- **Profilers.** `nsys` works here and answers the first question — is the time actually inside your
+  kernel, or in launch gaps and dispatch? `ncu` reads GPU performance counters, which the container may
+  not be permitted to access: if it prints `ERR_NVGPUCTRPERM`, counters are unavailable on this run.
+  That is an environment permission, not something you can fix from inside — fall back to `nsys` plus
+  A/B ablation (change one thing, re-time it) instead of spending your budget fighting it. Note that
+  `ncu --version` succeeds either way; it never touches a counter.
 
 ## How the grading actually runs (so there are no surprises)
 

tasks/quantization-gemm/w4a16-dequant-gemm/task.toml

@@ -22,6 +22,9 @@ 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).
+# Profiling: `ncu` needs GPU performance counters — the runner must add the SYS_ADMIN capability
+# (docker `--cap-add SYS_ADMIN`) or the host must set NVreg_RestrictProfilingToAdminUsers=0.
+# Without it ncu exits with ERR_NVGPUCTRPERM. `nsys` works without any extra capability.
 [environment]
 build_timeout_sec = 3600.0
 cpus = 8

tasks/quantization-gemm/zamba-shared-attn-lora-backward/instruction.md

@@ -197,6 +197,12 @@ p.shared_memory_per_block_optin   # opt-in dynamic smem, the number that matters
   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`.
+- **Profilers.** `nsys` works here and answers the first question — is the time actually inside your
+  kernel, or in launch gaps and dispatch? `ncu` reads GPU performance counters, which the container may
+  not be permitted to access: if it prints `ERR_NVGPUCTRPERM`, counters are unavailable on this run.
+  That is an environment permission, not something you can fix from inside — fall back to `nsys` plus
+  A/B ablation (change one thing, re-time it) instead of spending your budget fighting it. Note that
+  `ncu --version` succeeds either way; it never touches a counter.
 
 ## How the grading actually runs (so there are no surprises)
 

tasks/quantization-gemm/zamba-shared-attn-lora-backward/task.toml

@@ -22,6 +22,9 @@ 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).
+# Profiling: `ncu` needs GPU performance counters — the runner must add the SYS_ADMIN capability
+# (docker `--cap-add SYS_ADMIN`) or the host must set NVreg_RestrictProfilingToAdminUsers=0.
+# Without it ncu exits with ERR_NVGPUCTRPERM. `nsys` works without any extra capability.
 [environment]
 build_timeout_sec = 3600.0
 cpus = 8

tasks/quantization-gemm/zamba-shared-attn-lora-qkv/instruction.md

@@ -183,6 +183,12 @@ p.shared_memory_per_block_optin   # opt-in dynamic smem, the number that matters
   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`.
+- **Profilers.** `nsys` works here and answers the first question — is the time actually inside your
+  kernel, or in launch gaps and dispatch? `ncu` reads GPU performance counters, which the container may
+  not be permitted to access: if it prints `ERR_NVGPUCTRPERM`, counters are unavailable on this run.
+  That is an environment permission, not something you can fix from inside — fall back to `nsys` plus
+  A/B ablation (change one thing, re-time it) instead of spending your budget fighting it. Note that
+  `ncu --version` succeeds either way; it never touches a counter.
 
 ## How the grading actually runs (so there are no surprises)
 

tasks/quantization-gemm/zamba-shared-attn-lora-qkv/task.toml

@@ -22,6 +22,9 @@ 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).
+# Profiling: `ncu` needs GPU performance counters — the runner must add the SYS_ADMIN capability
+# (docker `--cap-add SYS_ADMIN`) or the host must set NVreg_RestrictProfilingToAdminUsers=0.
+# Without it ncu exits with ERR_NVGPUCTRPERM. `nsys` works without any extra capability.
 [environment]
 build_timeout_sec = 3600.0
 cpus = 8

tasks/raw-cuda/cuda-blockwise-softmax/instruction.md

@@ -62,3 +62,10 @@ Both must pass for reward 1.0.
   uses a different seed). `/app/harness.cu` is the same harness used for grading — read it to see exactly how
   you are measured; you only edit `solution.cu`.
 - **No internet access.**
+
+**Profilers.** `nsys` works here and answers the first question — is the time actually inside your
+kernel, or in launch gaps and dispatch? `ncu` reads GPU performance counters, which the container may
+not be permitted to access: if it prints `ERR_NVGPUCTRPERM`, counters are unavailable on this run. That
+is an environment permission, not something you can fix from inside — fall back to `nsys` plus A/B
+ablation (change one thing, re-time it) rather than spending your budget fighting it. `ncu --version`
+succeeds either way; it never touches a counter.

tasks/raw-cuda/cuda-blockwise-softmax/task.toml

@@ -20,6 +20,9 @@ timeout_sec = 600.0
 [agent]
 timeout_sec = 14400.0
 
+# Profiling: `ncu` needs GPU performance counters — the runner must add the SYS_ADMIN capability
+# (docker `--cap-add SYS_ADMIN`) or the host must set NVreg_RestrictProfilingToAdminUsers=0.
+# Without it ncu exits with ERR_NVGPUCTRPERM. `nsys` works without any extra capability.
 [environment]
 build_timeout_sec = 3600.0
 cpus = 8

tasks/raw-cuda/cuda-fp8-cast-pack/instruction.md

@@ -59,3 +59,10 @@ Both must pass for reward 1.0.
   uses a different seed). `/app/harness.cu` is the same harness used for grading — read it to see exactly how
   you are measured; you only edit `solution.cu`.
 - **No internet access.**
+
+**Profilers.** `nsys` works here and answers the first question — is the time actually inside your
+kernel, or in launch gaps and dispatch? `ncu` reads GPU performance counters, which the container may
+not be permitted to access: if it prints `ERR_NVGPUCTRPERM`, counters are unavailable on this run. That
+is an environment permission, not something you can fix from inside — fall back to `nsys` plus A/B
+ablation (change one thing, re-time it) rather than spending your budget fighting it. `ncu --version`
+succeeds either way; it never touches a counter.

tasks/raw-cuda/cuda-fp8-cast-pack/task.toml

@@ -20,6 +20,9 @@ timeout_sec = 600.0
 [agent]
 timeout_sec = 14400.0
 
+# Profiling: `ncu` needs GPU performance counters — the runner must add the SYS_ADMIN capability
+# (docker `--cap-add SYS_ADMIN`) or the host must set NVreg_RestrictProfilingToAdminUsers=0.
+# Without it ncu exits with ERR_NVGPUCTRPERM. `nsys` works without any extra capability.
 [environment]
 build_timeout_sec = 3600.0
 cpus = 8

tasks/raw-cuda/cuda-histogram-atomics/instruction.md

@@ -59,3 +59,10 @@ Both must pass for reward 1.0.
   uses a different seed). `/app/harness.cu` is the same harness used for grading — read it to see exactly how
   you are measured; you only edit `solution.cu`.
 - **No internet access.**
+
+**Profilers.** `nsys` works here and answers the first question — is the time actually inside your
+kernel, or in launch gaps and dispatch? `ncu` reads GPU performance counters, which the container may
+not be permitted to access: if it prints `ERR_NVGPUCTRPERM`, counters are unavailable on this run. That
+is an environment permission, not something you can fix from inside — fall back to `nsys` plus A/B
+ablation (change one thing, re-time it) rather than spending your budget fighting it. `ncu --version`
+succeeds either way; it never touches a counter.

tasks/raw-cuda/cuda-histogram-atomics/task.toml

@@ -20,6 +20,9 @@ timeout_sec = 600.0
 [agent]
 timeout_sec = 14400.0
 
+# Profiling: `ncu` needs GPU performance counters — the runner must add the SYS_ADMIN capability
+# (docker `--cap-add SYS_ADMIN`) or the host must set NVreg_RestrictProfilingToAdminUsers=0.
+# Without it ncu exits with ERR_NVGPUCTRPERM. `nsys` works without any extra capability.
 [environment]
 build_timeout_sec = 3600.0
 cpus = 8

tasks/raw-cuda/cuda-linear-recurrence/instruction.md

@@ -54,3 +54,10 @@ submission is graded on whatever device it lands on.
   uses a different seed). `/app/harness.cu` is the same harness used for grading — read it to see exactly how
   you're measured, but you only edit `solution.cu`.
 - **No internet access.**
+
+**Profilers.** `nsys` works here and answers the first question — is the time actually inside your
+kernel, or in launch gaps and dispatch? `ncu` reads GPU performance counters, which the container may
+not be permitted to access: if it prints `ERR_NVGPUCTRPERM`, counters are unavailable on this run. That
+is an environment permission, not something you can fix from inside — fall back to `nsys` plus A/B
+ablation (change one thing, re-time it) rather than spending your budget fighting it. `ncu --version`
+succeeds either way; it never touches a counter.

tasks/raw-cuda/cuda-linear-recurrence/task.toml

@@ -20,6 +20,9 @@ timeout_sec = 600.0
 [agent]
 timeout_sec = 14400.0
 
+# Profiling: `ncu` needs GPU performance counters — the runner must add the SYS_ADMIN capability
+# (docker `--cap-add SYS_ADMIN`) or the host must set NVreg_RestrictProfilingToAdminUsers=0.
+# Without it ncu exits with ERR_NVGPUCTRPERM. `nsys` works without any extra capability.
 [environment]
 build_timeout_sec = 3600.0
 cpus = 8

tasks/raw-cuda/cuda-radix-partition/instruction.md

@@ -64,3 +64,10 @@ Both must pass for reward 1.0.
   uses a different seed). `/app/harness.cu` is the same harness used for grading — read it to see exactly how
   you are measured; you only edit `solution.cu`.
 - **No internet access.**
+
+**Profilers.** `nsys` works here and answers the first question — is the time actually inside your
+kernel, or in launch gaps and dispatch? `ncu` reads GPU performance counters, which the container may
+not be permitted to access: if it prints `ERR_NVGPUCTRPERM`, counters are unavailable on this run. That
+is an environment permission, not something you can fix from inside — fall back to `nsys` plus A/B
+ablation (change one thing, re-time it) rather than spending your budget fighting it. `ncu --version`
+succeeds either way; it never touches a counter.

tasks/raw-cuda/cuda-radix-partition/task.toml

@@ -20,6 +20,9 @@ timeout_sec = 600.0
 [agent]
 timeout_sec = 14400.0
 
+# Profiling: `ncu` needs GPU performance counters — the runner must add the SYS_ADMIN capability
+# (docker `--cap-add SYS_ADMIN`) or the host must set NVreg_RestrictProfilingToAdminUsers=0.
+# Without it ncu exits with ERR_NVGPUCTRPERM. `nsys` works without any extra capability.
 [environment]
 build_timeout_sec = 3600.0
 cpus = 8

tasks/raw-cuda/cuda-relu2-aggregation/instruction.md

@@ -55,3 +55,10 @@ submission is graded on whatever device it lands on.
   uses a different seed). `/app/harness.cu` is the same harness used for grading — read it to see exactly how
   you're measured; you only edit `solution.cu`.
 - **No internet access.**
+
+**Profilers.** `nsys` works here and answers the first question — is the time actually inside your
+kernel, or in launch gaps and dispatch? `ncu` reads GPU performance counters, which the container may
+not be permitted to access: if it prints `ERR_NVGPUCTRPERM`, counters are unavailable on this run. That
+is an environment permission, not something you can fix from inside — fall back to `nsys` plus A/B
+ablation (change one thing, re-time it) rather than spending your budget fighting it. `ncu --version`
+succeeds either way; it never touches a counter.

tasks/raw-cuda/cuda-relu2-aggregation/task.toml

@@ -20,6 +20,9 @@ timeout_sec = 600.0
 [agent]
 timeout_sec = 14400.0
 
+# Profiling: `ncu` needs GPU performance counters — the runner must add the SYS_ADMIN capability
+# (docker `--cap-add SYS_ADMIN`) or the host must set NVreg_RestrictProfilingToAdminUsers=0.
+# Without it ncu exits with ERR_NVGPUCTRPERM. `nsys` works without any extra capability.
 [environment]
 build_timeout_sec = 3600.0
 cpus = 8

tasks/raw-cuda/cuda-topk-indices/instruction.md

@@ -54,3 +54,10 @@ submission is graded on whatever device it lands on.
   uses a different seed). `/app/harness.cu` is the same harness used for grading — read it to see exactly how
   you're measured; you only edit `solution.cu`.
 - **No internet access.**
+
+**Profilers.** `nsys` works here and answers the first question — is the time actually inside your
+kernel, or in launch gaps and dispatch? `ncu` reads GPU performance counters, which the container may
+not be permitted to access: if it prints `ERR_NVGPUCTRPERM`, counters are unavailable on this run. That
+is an environment permission, not something you can fix from inside — fall back to `nsys` plus A/B
+ablation (change one thing, re-time it) rather than spending your budget fighting it. `ncu --version`
+succeeds either way; it never touches a counter.

tasks/raw-cuda/cuda-topk-indices/task.toml

@@ -20,6 +20,9 @@ timeout_sec = 600.0
 [agent]
 timeout_sec = 14400.0
 
+# Profiling: `ncu` needs GPU performance counters — the runner must add the SYS_ADMIN capability
+# (docker `--cap-add SYS_ADMIN`) or the host must set NVreg_RestrictProfilingToAdminUsers=0.
+# Without it ncu exits with ERR_NVGPUCTRPERM. `nsys` works without any extra capability.
 [environment]
 build_timeout_sec = 3600.0
 cpus = 8

tasks/raw-cuda/cuda-transpose-vectorized/instruction.md

@@ -59,3 +59,10 @@ Both must pass for reward 1.0.
   uses a different seed). `/app/harness.cu` is the same harness used for grading — read it to see exactly how
   you are measured; you only edit `solution.cu`.
 - **No internet access.**
+
+**Profilers.** `nsys` works here and answers the first question — is the time actually inside your
+kernel, or in launch gaps and dispatch? `ncu` reads GPU performance counters, which the container may
+not be permitted to access: if it prints `ERR_NVGPUCTRPERM`, counters are unavailable on this run. That
+is an environment permission, not something you can fix from inside — fall back to `nsys` plus A/B
+ablation (change one thing, re-time it) rather than spending your budget fighting it. `ncu --version`
+succeeds either way; it never touches a counter.

tasks/raw-cuda/cuda-transpose-vectorized/task.toml

@@ -20,6 +20,9 @@ timeout_sec = 600.0
 [agent]
 timeout_sec = 14400.0
 
+# Profiling: `ncu` needs GPU performance counters — the runner must add the SYS_ADMIN capability
+# (docker `--cap-add SYS_ADMIN`) or the host must set NVreg_RestrictProfilingToAdminUsers=0.
+# Without it ncu exits with ERR_NVGPUCTRPERM. `nsys` works without any extra capability.
 [environment]
 build_timeout_sec = 3600.0
 cpus = 8

tasks/raw-cuda/cuda-warp-scan-segmented/instruction.md

@@ -60,3 +60,10 @@ Both must pass for reward 1.0.
   uses a different seed). `/app/harness.cu` is the same harness used for grading — read it to see exactly how
   you are measured; you only edit `solution.cu`.
 - **No internet access.**
+
+**Profilers.** `nsys` works here and answers the first question — is the time actually inside your
+kernel, or in launch gaps and dispatch? `ncu` reads GPU performance counters, which the container may
+not be permitted to access: if it prints `ERR_NVGPUCTRPERM`, counters are unavailable on this run. That
+is an environment permission, not something you can fix from inside — fall back to `nsys` plus A/B
+ablation (change one thing, re-time it) rather than spending your budget fighting it. `ncu --version`
+succeeds either way; it never touches a counter.

tasks/raw-cuda/cuda-warp-scan-segmented/task.toml

@@ -20,6 +20,9 @@ timeout_sec = 600.0
 [agent]
 timeout_sec = 14400.0
 
+# Profiling: `ncu` needs GPU performance counters — the runner must add the SYS_ADMIN capability
+# (docker `--cap-add SYS_ADMIN`) or the host must set NVreg_RestrictProfilingToAdminUsers=0.
+# Without it ncu exits with ERR_NVGPUCTRPERM. `nsys` works without any extra capability.
 [environment]
 build_timeout_sec = 3600.0
 cpus = 8

tasks/raw-cuda/flash-attention-fwd/instruction.md

@@ -66,3 +66,10 @@ submission is graded on whatever device it lands on.
   grader uses a different seed). `/app/harness.cu` is the same harness used for grading — read it to
   see exactly how you're measured; you only edit `solution.cu`.
 - **No internet access.**
+
+**Profilers.** `nsys` works here and answers the first question — is the time actually inside your
+kernel, or in launch gaps and dispatch? `ncu` reads GPU performance counters, which the container may
+not be permitted to access: if it prints `ERR_NVGPUCTRPERM`, counters are unavailable on this run. That
+is an environment permission, not something you can fix from inside — fall back to `nsys` plus A/B
+ablation (change one thing, re-time it) rather than spending your budget fighting it. `ncu --version`
+succeeds either way; it never touches a counter.

tasks/raw-cuda/flash-attention-fwd/task.toml

@@ -20,6 +20,9 @@ timeout_sec = 600.0
 [agent]
 timeout_sec = 14400.0
 
+# Profiling: `ncu` needs GPU performance counters — the runner must add the SYS_ADMIN capability
+# (docker `--cap-add SYS_ADMIN`) or the host must set NVreg_RestrictProfilingToAdminUsers=0.
+# Without it ncu exits with ERR_NVGPUCTRPERM. `nsys` works without any extra capability.
 [environment]
 build_timeout_sec = 3600.0
 cpus = 8

tasks/raw-cuda/gptq-w4a16-gemm/instruction.md

@@ -95,3 +95,10 @@ submission is graded on whatever device it lands on.
   grader uses a different seed). `/app/harness.cu` is the same harness used for grading — read it to see
   exactly how you're measured; you only edit `solution.cu`.
 - **No internet access.**
+
+**Profilers.** `nsys` works here and answers the first question — is the time actually inside your
+kernel, or in launch gaps and dispatch? `ncu` reads GPU performance counters, which the container may
+not be permitted to access: if it prints `ERR_NVGPUCTRPERM`, counters are unavailable on this run. That
+is an environment permission, not something you can fix from inside — fall back to `nsys` plus A/B
+ablation (change one thing, re-time it) rather than spending your budget fighting it. `ncu --version`
+succeeds either way; it never touches a counter.

tasks/raw-cuda/gptq-w4a16-gemm/task.toml

@@ -20,6 +20,9 @@ timeout_sec = 600.0
 [agent]
 timeout_sec = 14400.0
 
+# Profiling: `ncu` needs GPU performance counters — the runner must add the SYS_ADMIN capability
+# (docker `--cap-add SYS_ADMIN`) or the host must set NVreg_RestrictProfilingToAdminUsers=0.
+# Without it ncu exits with ERR_NVGPUCTRPERM. `nsys` works without any extra capability.
 [environment]
 build_timeout_sec = 3600.0
 cpus = 8

tasks/raw-cuda/qserve-w4a8-gemm/instruction.md

@@ -107,3 +107,10 @@ submission is graded on whatever device it lands on.
   grader uses a different seed). `/app/harness.cu` is the same harness used for grading — read it to see
   exactly how you're measured; you only edit `solution.cu`.
 - **No internet access.**
+
+**Profilers.** `nsys` works here and answers the first question — is the time actually inside your
+kernel, or in launch gaps and dispatch? `ncu` reads GPU performance counters, which the container may
+not be permitted to access: if it prints `ERR_NVGPUCTRPERM`, counters are unavailable on this run. That
+is an environment permission, not something you can fix from inside — fall back to `nsys` plus A/B
+ablation (change one thing, re-time it) rather than spending your budget fighting it. `ncu --version`
+succeeds either way; it never touches a counter.

tasks/raw-cuda/qserve-w4a8-gemm/task.toml

@@ -20,6 +20,9 @@ timeout_sec = 600.0
 [agent]
 timeout_sec = 14400.0
 
+# Profiling: `ncu` needs GPU performance counters — the runner must add the SYS_ADMIN capability
+# (docker `--cap-add SYS_ADMIN`) or the host must set NVreg_RestrictProfilingToAdminUsers=0.
+# Without it ncu exits with ERR_NVGPUCTRPERM. `nsys` works without any extra capability.
 [environment]
 build_timeout_sec = 3600.0
 cpus = 8

tasks/sampling-speculative-decoding/beam-search-step/environment/measure.py

@@ -20,7 +20,7 @@ sys.path.insert(0, "/app")
 from reference import beam_search_step as _ref
 from beam_step import beam_search_step as _agent
 
-TOL = 0.0
+TOL = 1e-05
 NAMES = ('next_beam', 'next_token', 'next_score')
 
 FULL = [(896, 4, 131072), (448, 8, 131072), (224, 16, 131072), (448, 4, 262144), (640, 6, 131072)]

tasks/sampling-speculative-decoding/beam-search-step/instruction.md

@@ -99,7 +99,7 @@ as a **single `float32` addition** of two `float32` inputs: computing it in fp32
 rounding once, gives bit-identical results. **One candidate ranked out of order, or one score computed as
 `logprob + beam_score` in bf16, scores 0.**
 
-**`tol = 0` here is a measured, deliberate choice, not a defaulted one.** This is a *selection* kernel, not
+**`tol` here is a measured, deliberate choice, not a defaulted one.** This is a *selection* kernel, not
 an arithmetic one: the only float operation is one fp32 add, and the specified ordering (score descending,
 then flat index ascending) is a **total order**, so the correct answer is a single well-defined bit pattern
 and every correct implementation must produce it. That was verified rather than assumed — two independent
@@ -168,7 +168,7 @@ Everything here is **float32** — log-probabilities in, scores out — and it m
 float32. This is a *ranking* path: `bfloat16` has 8 mantissa bits, and the graded data's smallest gap at the
 top-`W` boundary is about **16 ulps of fp32**, i.e. far below one bf16 ulp, so a bf16 comparison merges
 candidates that are genuinely distinct and reorders the beam. **fp8 and bf16 are not permitted anywhere on
-the value path**, and there is no tolerance to hide it in: the gate is exactly `0`.
+the value path**, and the gate is far too tight to hide it in.
 
 The candidate score is `beam_scores[b, w] + logprobs[b, w, v]`, a **single fp32 add**. Do it in fp32 (or in
 a wider type, rounding once at the end) and the result is bit-identical to the reference. Do not
@@ -183,11 +183,21 @@ The **tie-break** is a correctness requirement, not an optimisation: equal score
 index. Implement every comparison in your reduction as a lexicographic `(score desc, index asc)` compare —
 the cheapest way is the packed `uint64` key the reference builds.
 
-This is one of the few tasks in this suite where the gate is **exactly zero**, and that is measured: two
+The gate here is **`1e-05`** — tight, because this is a ranking path — and that is measured: two
 independently written selection algorithms reproduce the reference bit-for-bit on every graded shape. It is
 achievable precisely *because* nothing here accumulates. If you find yourself needing tolerance, you have
 introduced arithmetic that the specification does not contain.
 
+**Where the tolerance comes from (measured, not guessed).** The numerical *floor* here is `0.0`: this
+kernel moves values rather than recomputing them, and an independently written implementation reproduces
+the reference bit for bit. The gate is nonetheless set at **`1e-05`**, deliberately above that floor, so a
+correct kernel that reaches the same values by a slightly different numerical route is not rejected on a
+technicality. What the gate must still catch is a **re-encoding of the payload**: your score is
+`bytes / time` with the byte count derived from the float32 shapes, so storing the payload narrower moves less
+data than you are credited for. Round-tripping the payload through fp16 measures **2.1e-4**,
+i.e. **21x** this gate, and is rejected. Integer outputs are compared **exactly** and no tolerance
+applies to them.
+
 ### What the tolerance does NOT permit
 
 The tolerance exists **only** to absorb low-precision arithmetic noise. You are responsible for a **faithful
@@ -232,6 +242,12 @@ p.shared_memory_per_block_optin   # opt-in dynamic smem, the number that matters
   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`.
+- **Profilers.** `nsys` works here and answers the first question — is the time actually inside your
+  kernel, or in launch gaps and dispatch? `ncu` reads GPU performance counters, which the container may
+  not be permitted to access: if it prints `ERR_NVGPUCTRPERM`, counters are unavailable on this run.
+  That is an environment permission, not something you can fix from inside — fall back to `nsys` plus
+  A/B ablation (change one thing, re-time it) instead of spending your budget fighting it. Note that
+  `ncu --version` succeeds either way; it never touches a counter.
 
 ## How the grading actually runs (so there are no surprises)
 

tasks/sampling-speculative-decoding/beam-search-step/task.toml

@@ -22,6 +22,9 @@ 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).
+# Profiling: `ncu` needs GPU performance counters — the runner must add the SYS_ADMIN capability
+# (docker `--cap-add SYS_ADMIN`) or the host must set NVreg_RestrictProfilingToAdminUsers=0.
+# Without it ncu exits with ERR_NVGPUCTRPERM. `nsys` works without any extra capability.
 [environment]
 build_timeout_sec = 3600.0
 cpus = 8

tasks/sampling-speculative-decoding/beam-search-step/tests/verify_env.py

@@ -31,7 +31,7 @@ import torch
 
 REWARD_DIR = "/logs/verifier"
 MODULE_PATH = "/app/beam_step.py"
-TOL = 0.0
+TOL = 1e-05
 NAMES = ('next_beam', 'next_token', 'next_score')
 
 GRADER_SHAPES = [(1024, 4, 131072), (512, 8, 131072), (256, 16, 131072), (512, 4, 262144), (768, 5, 131072)]

tasks/sampling-speculative-decoding/draft-tree-build/instruction.md

@@ -253,6 +253,12 @@ p.shared_memory_per_block_optin   # opt-in dynamic smem, the number that matters
   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`.
+- **Profilers.** `nsys` works here and answers the first question — is the time actually inside your
+  kernel, or in launch gaps and dispatch? `ncu` reads GPU performance counters, which the container may
+  not be permitted to access: if it prints `ERR_NVGPUCTRPERM`, counters are unavailable on this run.
+  That is an environment permission, not something you can fix from inside — fall back to `nsys` plus
+  A/B ablation (change one thing, re-time it) instead of spending your budget fighting it. Note that
+  `ncu --version` succeeds either way; it never touches a counter.
 
 ## How the grading actually runs (so there are no surprises)
 

tasks/sampling-speculative-decoding/draft-tree-build/task.toml

@@ -22,6 +22,9 @@ 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).
+# Profiling: `ncu` needs GPU performance counters — the runner must add the SYS_ADMIN capability
+# (docker `--cap-add SYS_ADMIN`) or the host must set NVreg_RestrictProfilingToAdminUsers=0.
+# Without it ncu exits with ERR_NVGPUCTRPERM. `nsys` works without any extra capability.
 [environment]
 build_timeout_sec = 3600.0
 cpus = 8

tasks/sampling-speculative-decoding/fused-topk-topp-filter/instruction.md

@@ -217,6 +217,12 @@ p.shared_memory_per_block_optin   # opt-in dynamic smem, the number that matters
   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`.
+- **Profilers.** `nsys` works here and answers the first question — is the time actually inside your
+  kernel, or in launch gaps and dispatch? `ncu` reads GPU performance counters, which the container may
+  not be permitted to access: if it prints `ERR_NVGPUCTRPERM`, counters are unavailable on this run.
+  That is an environment permission, not something you can fix from inside — fall back to `nsys` plus
+  A/B ablation (change one thing, re-time it) instead of spending your budget fighting it. Note that
+  `ncu --version` succeeds either way; it never touches a counter.
 
 ## How the grading actually runs (so there are no surprises)
 

tasks/sampling-speculative-decoding/fused-topk-topp-filter/task.toml

@@ -22,6 +22,9 @@ 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).
+# Profiling: `ncu` needs GPU performance counters — the runner must add the SYS_ADMIN capability
+# (docker `--cap-add SYS_ADMIN`) or the host must set NVreg_RestrictProfilingToAdminUsers=0.
+# Without it ncu exits with ERR_NVGPUCTRPERM. `nsys` works without any extra capability.
 [environment]
 build_timeout_sec = 3600.0
 cpus = 8