agent/: cite and fetch NVIDIA's official docs (not redistributable)

Adds agent/ref/official-docs.md and agent/tools/fetch_nvidia_docs.sh.

NVIDIA's CUDA/PTX documentation is copyrighted and cannot be redistributed here: the CUDA EULA distributes only the runtime libraries enumerated in its Attachment A, which contains no documentation, and separately forbids making the SDK subject to a licence requiring it be redistributable at no charge. So this ships an index, a citation, and a fetcher -- each user downloads their own copy direct from NVIDIA under NVIDIA's terms.

The fetcher matches docs to the toolkit: docs.nvidia.com serves the newest CUDA, but CUDA 12.8 ships PTX ISA 8.7 rather than the 9.3 now published. Verified live: 8/8 documents fetch, 6 with PDFs.

agent/README.md

@@ -43,6 +43,7 @@ faster", "implement a fused attention kernel", or "solve this KBench task".
 | `ref/cuda-cpp.md` | CUDA C++: opt-in shared memory, `cuda::pipeline`, cooperative groups, clusters/DSMEM, host-side TMA descriptors, build and debug flags |
 | `ref/triton.md` | the Triton 3.6 API surface, launch knobs, idioms, and where it caps out |
 | `ref/cute-cutlass.md` | CuTe layout algebra, swizzles, atoms, and where CUTLASS lives in the image |
+| `ref/official-docs.md` | index of NVIDIA's own guides — which answers which question, version matching, and the licence position |
 
 **These are verified, not recalled.** Every instruction and API was compiled with the container's own
 `nvcc` on `sm_90a` / CUDA 12.8: 39/41 PTX instructions assemble (the two that do not are recorded —
@@ -70,6 +71,12 @@ in `ref/triton.md`.
 - **`check_toolchain.py`** — re-derives every table in `ref/` by compiling on the machine you are
   actually on. The docs were verified on sm_90a / CUDA 12.8; on a different GPU or toolkit some rows
   change, and this tool wins over the docs.
+- **`fetch_nvidia_docs.sh`** — downloads NVIDIA's official CUDA/PTX guides for offline use. They are
+  **not bundled here**: NVIDIA's documentation is copyrighted and the CUDA EULA distributes only the
+  runtime libraries listed in its Attachment A, which does not include documentation. You fetch your own
+  copy under NVIDIA's terms. It auto-matches your CUDA version — the live docs always serve the newest
+  CUDA, and CUDA 12.8 wants PTX ISA 8.7, not the 9.3 currently published. Run it in a Dockerfile
+  `RUN` step to have the guides available inside an offline container.
 - **`ledger.md`** — one row per variant. The column that matters records whether an abandoned variant
   was *slower* or merely *broken*; dropping a good optimization over a fixable bug is the most common
   way to leave 2x on the table.

agent/SKILL.md

@@ -20,6 +20,7 @@ as you hit the corresponding phase. Tools are in `tools/`.
 | `ref/cuda-cpp.md` | CUDA C++: opt-in shared memory, pipelines, cooperative groups, clusters, TMA descriptors, build flags |
 | `ref/triton.md` | Triton 3.6 API surface, launch knobs, idioms, and the traps |
 | `ref/cute-cutlass.md` | CuTe layout algebra and where CUTLASS lives in the image |
+| `ref/official-docs.md` | NVIDIA's own guides: which one answers which question, and how to fetch them |
 
 Every instruction and API in `ref/` was verified by compiling it on the container toolchain (sm_90a,
 CUDA 12.8) — but **you may not be on that machine**. Run `python3 tools/check_toolchain.py` to

agent/ref/official-docs.md

@@ -0,0 +1,89 @@
+# NVIDIA official documentation — index and citation
+
+The authoritative sources. This file **links and cites**; it does not reproduce them.
+
+## Licence — why the documents are not in this repo
+
+> © NVIDIA Corporation. All rights reserved.
+> CUDA EULA: <https://docs.nvidia.com/cuda/eula/>
+
+NVIDIA's documentation is copyrighted and **not redistributable**. The CUDA EULA distributes only the
+files enumerated in its **Attachment A** — runtime libraries such as `libcudart.so`, `cufft.dll` — and
+documentation does not appear there. §1.2.5 separately prohibits using the SDK in a way that would make
+it subject to a licence requiring it be "redistributable at no charge", which is what publishing it in
+an open dataset would do. The documents are also no longer shipped inside the toolkit: `$CUDA_HOME/DOCS`
+says so and points at docs.nvidia.com.
+
+So: **fetch your own copy**, direct from NVIDIA, under their terms.
+
+```bash
+tools/fetch_nvidia_docs.sh /opt/nvidia-docs            # auto-matches your CUDA version
+tools/fetch_nvidia_docs.sh /opt/nvidia-docs 12.8.0     # or pin it
+```
+
+For an offline container, run it at **image build time** — task images have network during `docker
+build` and none at run time:
+
+```dockerfile
+RUN bash fetch_nvidia_docs.sh /opt/nvidia-docs 12.8.0
+```
+
+## Match the version to your toolkit
+
+`docs.nvidia.com/cuda/` always serves the **newest** CUDA. An instruction documented there may not
+assemble on an older `ptxas`. Archived versions live at
+`https://docs.nvidia.com/cuda/archive/<version>/…`.
+
+| your toolkit | PTX ISA version |
+|---|---|
+| CUDA 12.8 (the KBench containers) | **8.7** |
+| current live docs at time of writing | 9.3 |
+
+Reading 9.3 while compiling with 12.8 is a real way to lose an hour to *"Instruction not supported on
+target"*.
+
+## Which document answers which question
+
+| question | document |
+|---|---|
+| What does this CUDA C++ construct mean? Memory model, `__syncthreads`, streams, unified memory, clusters, TMA | **CUDA C++ Programming Guide** — <https://docs.nvidia.com/cuda/cuda-c-programming-guide/> |
+| Is my access pattern coalesced? How should I think about occupancy vs latency hiding? | **CUDA C++ Best Practices Guide** — <https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/> |
+| Exact syntax/semantics of a PTX instruction, its modifiers and which `.target` it needs | **PTX ISA** — <https://docs.nvidia.com/cuda/parallel-thread-execution/> |
+| How do I write inline PTX, and what do the operand constraints mean? | **Inline PTX Assembly** — <https://docs.nvidia.com/cuda/inline-ptx-assembly/> |
+| What is different about Hopper — clusters, TMA, wgmma, DSMEM? | **Hopper Tuning Guide** — <https://docs.nvidia.com/cuda/hopper-tuning-guide/> |
+| Exact signature/semantics of a runtime call | **CUDA Runtime API** — <https://docs.nvidia.com/cuda/cuda-runtime-api/> |
+| What does this `ncu` metric mean? Which section reports it? | **Nsight Compute Profiling Guide** — <https://docs.nvidia.com/nsight-compute/ProfilingGuide/> |
+| `ncu` command-line flags, `--replay-mode`, filtering kernels | **Nsight Compute CLI** — <https://docs.nvidia.com/nsight-compute/NsightComputeCli/> |
+
+Blackwell instead of Hopper: swap in the **Blackwell Tuning Guide**
+(<https://docs.nvidia.com/cuda/blackwell-tuning-guide/>).
+
+## How to use them alongside `ref/`
+
+The other files in `ref/` are **verified summaries** — every instruction in them was compiled on the
+container toolchain, so they tell you what actually works *here*. The official documents are the
+**authority on semantics** — what an instruction means, every modifier it accepts, the precise memory
+ordering it guarantees.
+
+Practical division:
+
+- *"Does this assemble on my target, and what does it cost me?"* → `ref/ptx.md`, `ref/cuda-cpp.md`, or
+  run `tools/check_toolchain.py`.
+- *"What exactly does `.multicast::cluster` do to the mbarrier transaction count?"* → PTX ISA.
+
+When the two disagree about availability, believe the compiler. When they disagree about meaning,
+believe NVIDIA.
+
+## Other upstream references
+
+Not NVIDIA, separately licensed, all publicly readable — cite, do not vendor:
+
+| project | licence | where |
+|---|---|---|
+| CUTLASS / CuTe | BSD-3-Clause | <https://github.com/NVIDIA/cutlass> |
+| Triton | MIT | <https://github.com/triton-lang/triton> |
+| FlashAttention | BSD-3-Clause | <https://github.com/Dao-AILab/flash-attention> |
+| FlashInfer | Apache-2.0 | <https://github.com/flashinfer-ai/flashinfer> |
+| Liger-Kernel | Apache-2.0 | <https://github.com/linkedin/Liger-Kernel> |
+
+`references.md` says what to learn from each.

agent/tools/fetch_nvidia_docs.sh

@@ -0,0 +1,109 @@
+#!/bin/bash
+# Fetch NVIDIA's official CUDA/PTX documentation into a local directory, for offline use.
+#
+#   ./fetch_nvidia_docs.sh [dest]        # default: ./nvidia-docs
+#
+# WHY A FETCHER AND NOT BUNDLED FILES
+# NVIDIA's documentation is copyrighted and is NOT redistributable. The CUDA EULA distributes only the
+# files listed in its Attachment A -- runtime libraries such as libcudart.so -- and documentation is not
+# among them. So this repo cannot ship the guides; you download your own copy, direct from NVIDIA, under
+# their terms. Linking and citing is fine; copying is not.
+#
+# OFFLINE USE: task containers have network at IMAGE BUILD time and none at run time. Run this in a
+# Dockerfile RUN step and the agent has the official docs available offline while it works:
+#
+#     RUN bash fetch_nvidia_docs.sh /opt/nvidia-docs
+#
+# (c) NVIDIA Corporation. Terms: https://docs.nvidia.com/cuda/eula/
+set -uo pipefail
+DEST=${1:-./nvidia-docs}
+VER=${2:-}          # e.g. 12.8.0 -> fetch the archived docs matching your toolkit
+mkdir -p "$DEST"
+
+# Match the docs to the toolkit you compile with. docs.nvidia.com/cuda/ always serves the NEWEST CUDA,
+# and instructions documented there may not assemble on an older ptxas. CUDA 12.8, for instance, ships
+# PTX ISA 8.7 while the live page currently documents 9.3. Auto-detect unless told otherwise.
+if [ -z "$VER" ] && command -v nvcc >/dev/null 2>&1; then
+  V=$(nvcc --version | grep -oE 'release [0-9]+\.[0-9]+' | head -1 | cut -d' ' -f2)
+  [ -n "$V" ] && VER="$V.0"
+fi
+if [ -n "$VER" ] && curl -sSL --fail --max-time 60 -o /dev/null \
+     "https://docs.nvidia.com/cuda/archive/$VER/cuda-c-programming-guide/index.html" 2>/dev/null; then
+  BASE=https://docs.nvidia.com/cuda/archive/$VER
+  BASE_NS=$BASE
+  echo "fetching docs for CUDA $VER (matched to this toolkit)"
+else
+  [ -n "$VER" ] && echo "no archive for CUDA $VER; falling back to the current docs"
+  BASE=https://docs.nvidia.com/cuda
+  BASE_NS=https://docs.nvidia.com/cuda
+fi
+NSIGHT=https://docs.nvidia.com
+
+# name|html index|pdf hint (optional)
+# The hint is tried first; if it 404s we fall back to whatever PDF the page itself advertises. Both
+# paths are needed: the PTX ISA pdf is version-stamped (ptx_isa_9.3.pdf) so it MUST be discovered,
+# while the Programming Guide page advertises a link that 404s so it MUST be hinted.
+DOCS="
+cuda-c-programming-guide|$BASE/cuda-c-programming-guide/index.html|$BASE/pdf/CUDA_C_Programming_Guide.pdf
+cuda-c-best-practices-guide|$BASE/cuda-c-best-practices-guide/index.html|$BASE/pdf/CUDA_C_Best_Practices_Guide.pdf
+parallel-thread-execution|$BASE/parallel-thread-execution/index.html|
+inline-ptx-assembly|$BASE/inline-ptx-assembly/index.html|$BASE/pdf/Inline_PTX_Assembly.pdf
+hopper-tuning-guide|$BASE/hopper-tuning-guide/index.html|$BASE/pdf/Hopper_Tuning_Guide.pdf
+cuda-runtime-api|$BASE/cuda-runtime-api/index.html|$BASE/pdf/CUDA_Runtime_API.pdf
+nsight-compute-profiling-guide|$NSIGHT/nsight-compute/ProfilingGuide/index.html|
+nsight-compute-cli|$NSIGHT/nsight-compute/NsightComputeCli/index.html|
+"
+
+ok=0; fail=0
+for entry in $DOCS; do
+  name=${entry%%|*}; rest=${entry#*|}
+  url=${rest%%|*}; hint=${rest#*|}
+  [ "$hint" = "$url" ] && hint=""
+  dir=$(dirname "$url")
+  html="$DEST/$name.html"
+  if ! curl -sSL --fail --max-time 120 -o "$html" "$url" 2>/dev/null; then
+    echo "  FAIL (html) $name"; fail=$((fail+1)); continue
+  fi
+  # candidate PDFs: the hint, then whatever the page advertises
+  rel=$(grep -oE '\.\./pdf/[A-Za-z0-9_.-]+\.pdf|/pdf/[A-Za-z0-9_.-]+\.pdf' "$html" | head -1)
+  disc=""
+  if [ -n "$rel" ]; then
+    case "$rel" in
+      # "../pdf/x.pdf" is relative to the page's directory, so go UP one level -- for
+      # .../cuda/parallel-thread-execution/index.html that resolves to .../cuda/pdf/x.pdf
+      ../*) disc="$(dirname "$dir")/${rel#../}" ;;
+      *)    disc="https://docs.nvidia.com$rel" ;;
+    esac
+  fi
+  got=""
+  for pdf in "$hint" "$disc"; do
+    [ -z "$pdf" ] && continue
+    if curl -sSL --fail --max-time 300 -o "$DEST/$name.pdf" "$pdf" 2>/dev/null; then
+      got="$pdf"; break
+    fi
+  done
+  if [ -n "$got" ]; then
+    echo "  ok   $name  (html + pdf $(du -h "$DEST/$name.pdf" | cut -f1))"
+  else
+    rm -f "$DEST/$name.pdf"
+    echo "  ok   $name  (html only)"
+  fi
+  ok=$((ok+1))
+done
+
+cat > "$DEST/LICENSE-NOTICE.txt" <<'NOTE'
+These documents were downloaded from https://docs.nvidia.com and are
+Copyright (c) NVIDIA Corporation. All rights reserved.
+
+They are NOT covered by the license of the repository that shipped this script,
+and they are NOT redistributable. The CUDA EULA (https://docs.nvidia.com/cuda/eula/)
+permits distribution only of the files enumerated in its Attachment A -- runtime
+libraries such as libcudart.so -- and documentation is not among them.
+
+You obtained this copy directly from NVIDIA, for your own use, under NVIDIA's terms.
+Do not re-publish these files. If you need to share them, share this script instead.
+NOTE
+
+echo
+echo "$ok fetched, $fail failed -> $DEST"
+echo "Copyright (c) NVIDIA Corporation. Not redistributable; see $DEST/LICENSE-NOTICE.txt"