agent/: greppable offline docs, and a chapter-level guide to NVIDIA's documentation

PDFs dropped. A 700-page reference you cannot grep is not useful offline, so the fetcher now emits greppable text -- 7 documents, ~11 MB instead of 36 MB, with code examples keeping their indentation.

ref/official-docs.md is now a working guide: what each official document contains chapter by chapter, with section numbers read out of the CUDA 12.8 documents themselves. Includes a routing table from question to chapter, and the two things not to look up on the web -- device properties (query them) and runtime API signatures (grep the installed headers).

search_docs.sh greps the fetched corpus and falls back to the CUDA headers. Verified with --network none: wgmma syntax, fence.proxy.async ordering, and the cuTensorMapEncodeTiled signature all resolve offline.

The documents themselves remain un-redistributable and are not included; each user fetches their own copy from NVIDIA under NVIDIA's terms.

agent/README.md

@@ -43,7 +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 |
+| `ref/official-docs.md` | a working guide to NVIDIA's own documentation: what each guide contains, chapter by chapter, which one 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 —
@@ -71,12 +71,14 @@ 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.
+- **`fetch_nvidia_docs.sh`** / **`search_docs.sh`** — downloads NVIDIA's official CUDA/PTX guides as
+  **greppable text** (~11 MB) and searches them offline. The documents 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 — so you fetch your own copy under NVIDIA's
+  terms. Task containers have network at image-build time and none at run time, so a Dockerfile `RUN`
+  step puts the guides inside an offline container. It auto-matches your CUDA version, which matters:
+  the live docs always serve the newest CUDA, and 12.8 wants PTX ISA 8.7, not the 9.3 now published.
+  PDFs are deliberately not fetched — a 700-page reference you cannot grep is not useful offline.
 - **`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,7 +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 |
+| `ref/official-docs.md` | NVIDIA's own documentation, chapter by chapter: which guide answers which question, and how to consult them offline |
 
 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

@@ -1,89 +1,200 @@
-# NVIDIA official documentation — index and citation
+# NVIDIA official documentation — a working guide for agents
 
-The authoritative sources. This file **links and cites**; it does not reproduce them.
+The other files in `ref/` are verified summaries of what *works*. This file is about the **authorities**:
+what each official document contains, which chapter answers which question, and how to consult them with
+no internet.
 
-## Licence — why the documents are not in this repo
+Section numbers below were read out of the **CUDA 12.8** documents, the version in the task containers.
 
-> © 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.
+## 1. Getting them offline
 
-So: **fetch your own copy**, direct from NVIDIA, under their terms.
+Task containers have network at **image build time** and none at run time. So fetch during the build:
 
-```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
+```dockerfile
+RUN bash fetch_nvidia_docs.sh /opt/nvidia-docs 12.8.0
 ```
 
-For an offline container, run it at **image build time** — task images have network during `docker
-build` and none at run time:
+or by hand:
 
-```dockerfile
-RUN bash fetch_nvidia_docs.sh /opt/nvidia-docs 12.8.0
+```bash
+tools/fetch_nvidia_docs.sh /opt/nvidia-docs          # auto-matches your CUDA version
+KDOCS=/opt/nvidia-docs tools/search_docs.sh "mbarrier.arrive.expect_tx"
 ```
 
-## Match the version to your toolkit
+The fetcher writes `<name>.html` and **`<name>.txt`** per document (~11 MB total). The `.txt` is the one
+that matters: a 700-page reference is only usable offline if you can `grep` it. Code examples keep their
+indentation, so a worked TMA example reads correctly.
 
-`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>/…`.
+**PDFs are deliberately not fetched.** They cannot be grepped, are read in 20-page slices, and cost
+~30 MB for no capability you do not already have.
 
-| your toolkit | PTX ISA version |
-|---|---|
-| CUDA 12.8 (the KBench containers) | **8.7** |
-| current live docs at time of writing | 9.3 |
+**If you have no fetched corpus**, you are not stuck — `ref/ptx.md`, `ref/cuda-cpp.md`, `ref/triton.md`
+and `ref/cute-cutlass.md` cover the working set, `tools/check_toolchain.py` tells you what compiles, and
+`$CUDA_HOME/include` has the headers.
+
+### Licence — why the documents are not in this repo
+
+> © NVIDIA Corporation. All rights reserved. CUDA EULA: <https://docs.nvidia.com/cuda/eula/>
 
-Reading 9.3 while compiling with 12.8 is a real way to lose an hour to *"Instruction not supported on
-target"*.
+NVIDIA's documentation is copyrighted and **not redistributable**. The EULA distributes only what its
+**Attachment A** enumerates — runtime libraries such as `libcudart.so` — and documentation is not in that
+list. §1.2.5 separately forbids using the SDK in a way that subjects it to a licence requiring it be
+"redistributable at no charge". You fetch your own copy under NVIDIA's terms; do not re-publish it.
 
-## Which document answers which question
+### Match the version to your toolkit
 
-| question | document |
+`docs.nvidia.com/cuda/` always serves the **newest** CUDA. Archives live at
+`docs.nvidia.com/cuda/archive/<version>/`.
+
+| toolkit | PTX ISA |
 |---|---|
-| 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/> |
+| CUDA 12.8 (KBench containers) | **8.7** |
+| current live docs | 9.3 |
 
-Blackwell instead of Hopper: swap in the **Blackwell Tuning Guide**
-(<https://docs.nvidia.com/cuda/blackwell-tuning-guide/>).
+Reading 9.3 while compiling with 12.8 is how you reach for an instruction `ptxas` rejects with
+*"not supported on target"*.
 
-## 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.
+## 2. CUDA C++ Programming Guide — the semantics authority
 
-Practical division:
+22 chapters. The reference for *what a construct means*. Four chapters carry almost everything a kernel
+author needs.
 
-- *"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.
+**§2 Programming Model** — thread/block/cluster/grid hierarchy, memory spaces, the fact that blocks are
+scheduled in **no guaranteed order**. Read the cluster part before writing anything Hopper-specific.
 
-When the two disagree about availability, believe the compiler. When they disagree about meaning,
-believe NVIDIA.
+**§5 Performance Guidelines** — the official statement of the three levers: maximize utilization,
+maximize memory throughput, maximize instruction throughput. Where coalescing rules are stated normatively.
 
-## Other upstream references
+**§7 C++ Language Extensions** — the chapter you will actually live in. 43 sections; the ones that matter:
 
-Not NVIDIA, separately licensed, all publicly readable — cite, do not vendor:
+| § | topic | why you care |
+|---|---|---|
+| 7.5 | Memory Fence Functions | `__threadfence*`, and what ordering each actually guarantees |
+| 7.6 | Synchronization Functions | `__syncthreads`, `__syncwarp`, and the variants with predicates |
+| 7.10–7.12 | Read-only / cache-hint load and store | `__ldg`, `__ldcs`, `__ldlu`, `__stcs` — the C++ face of the PTX cache modifiers |
+| 7.14 | Atomic Functions | scopes (`_block`, `_system`), which types have native atomics |
+| 7.19–7.22 | Warp vote / match / reduce / shuffle | `__ballot_sync`, `__reduce_add_sync`, `__shfl_xor_sync` |
+| 7.24 | Warp Matrix Functions | the `wmma` fragment API |
+| 7.26 | Asynchronous Barrier | `cuda::barrier`, the C++ face of `mbarrier` |
+| 7.27–7.28 | Asynchronous Data Copies (+ `cuda::pipeline`) | `memcpy_async`, the pipeline object, and how `cp.async` groups commit |
+| 7.29–7.30 | TMA transfers, encoding a tensor map | the worked TMA example — read this before writing your own descriptor code |
+| 7.38–7.39 | Launch Bounds, Max Registers per Thread | `__launch_bounds__` and how it caps registers |
+| 7.40 | `#pragma unroll` | |
 
-| project | licence | where |
+**§16 Compute Capabilities** — the per-architecture tables: registers per SM, shared memory per block,
+max blocks per SM, warp scheduler counts. When you need a hard architectural number, this is the source
+— but prefer querying the device (see below), which cannot go stale.
+
+Also: §8 Cooperative Groups (tiles, `grid_group::sync` and its co-residency requirement), §19 Unified
+Memory, §18 Environment Variables.
+
+---
+
+## 3. PTX ISA — the instruction authority
+
+14 chapters. Consult it for *exact syntax, every modifier, and which `.target` an instruction needs*.
+
+**§9.7 Instruction Set** is the bulk, organized by family:
+
+| § | family | contains |
 |---|---|---|
-| 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> |
+| 9.7.3–9.7.5 | Floating-point, half, mixed precision | `fma`, `ex2.approx`, `rcp.approx`, `cvt` including the fp8 packing forms |
+| 9.7.8 | Logic and shift | |
+| 9.7.9 | **Data Movement and Conversion** | `ld`/`st` with every cache modifier, `cp.async`, `cp.async.bulk.tensor` (TMA), `ldmatrix`, `stmatrix` |
+| 9.7.12 | Control flow | |
+| 9.7.13 | **Parallel Synchronization and Communication** | `bar`, `mbarrier` (init/arrive/expect_tx/try_wait), `fence` including `fence.proxy.async`, `redux`, `vote`, `shfl`, `elect`, cluster barriers, `atom`/`red` |
+| 9.7.14 | Warp-level MMA | `mma.sync` — every shape and dtype combination |
+| 9.7.15 | **Warpgroup** | `wgmma.mma_async` and its descriptors — Hopper's top instruction |
+| 9.7.16 | TensorCore 5th generation | `tcgen05` — **Blackwell only**, will not assemble on sm_90a |
+
+**§8 Memory Consistency Model** — the formal ordering rules. Go here when a hand-written barrier is
+"almost" working: it defines what `.relaxed`/`.acquire`/`.release` and each `.scope` actually promise,
+and why `fence.proxy.async` is required between a TMA write and a generic read.
+
+**§5 State Spaces, Types, Variables** and **§6 Instruction Operands** — how `.shared`/`.global`/`.param`
+differ and the addressing rules. Relevant when an inline-asm constraint will not bind: shared addresses
+are 32-bit (`"r"`), global are 64-bit (`"l"`).
+
+**§10 Special Registers** — `%laneid`, `%warpid`, `%smid`, `%clock`, `%globaltimer`.
+
+---
+
+## 4. Inline PTX Assembly — the glue
+
+Short. Read it once, fully. Operand constraint letters, how `%0` numbering maps to the output-then-input
+order, `volatile`, the `"memory"` clobber, and why a multi-instruction `asm` block needs `{ }` and `.reg`
+declarations. Every inline-asm bug you will hit is described here.
+
+## 5. Best Practices Guide — the optimization argument
+
+Read **§9 Memory Optimizations** (coalescing, shared memory bank conflicts, the cost of each memory
+space), **§10 Execution Configuration** (occupancy and *why more is not always better*), **§11
+Instruction Optimization**, **§12 Control Flow** (warp divergence). §3 Application Profiling states the
+profile-first discipline. Ignore the deployment chapters (§13–§18).
+
+## 6. Hopper Tuning Guide — what changed on sm_90
+
+Short and worth reading end to end if you target Hopper: thread block clusters and distributed shared
+memory, TMA, the wgmma warpgroup MMA, the larger shared memory, and the async transaction barrier. It is
+the fastest way to learn what Hopper added over Ampere. Swap in the **Blackwell Tuning Guide** for sm_100.
+
+## 7. Nsight Compute Profiling Guide + CLI
+
+The Profiling Guide defines **what each metric means** and which section reports it — the authority when
+you are unsure whether a counter says what you think. The CLI reference covers `--section`, `--metrics`,
+`--kernel-name regex:`, `--launch-skip/--launch-count`, and `--replay-mode` (use `application` for
+persistent or grid-synchronizing kernels, which kernel replay breaks).
+
+See `profiling.md` for the practical order — nsys before ncu — and `pitfalls.md` for reading counters
+without chasing a healthy-looking number.
+
+---
+
+## 8. Routing table
+
+| question | where |
+|---|---|
+| What does this CUDA C++ construct mean? | Programming Guide §7 |
+| Exact PTX syntax / modifiers / required target | PTX ISA §9.7 |
+| Is my barrier actually ordered correctly? | PTX ISA §8 |
+| How do I write inline asm and bind operands? | Inline PTX Assembly |
+| Why is my access pattern slow? | Best Practices §9 |
+| Should I raise occupancy? | Best Practices §10, then `pitfalls.md` |
+| What is new on Hopper? | Hopper Tuning Guide |
+| What does this ncu metric mean? | Nsight Compute Profiling Guide |
+| What is my device's SM count / shared memory / registers? | **query the device** — see below |
+| What is the signature of a runtime call? | **the installed headers** — see below |
+
+## 9. Two things NOT to look up on the web
+
+**Device properties — query them.** Any hard number you copy from a table is wrong on the next GPU:
+
+```python
+p = torch.cuda.get_device_properties(0)
+p.multi_processor_count, p.shared_memory_per_block_optin, p.regs_per_multiprocessor
+```
+
+Measured on the H200 NVL in this environment: 132 SMs, 232,448 B opt-in shared memory per block,
+233,472 B per SM, 65,536 registers per SM, 2,048 threads per SM, 60 MB L2. Those are *this* machine's
+numbers, quoted to show the shape of the answer — not to be pasted into a kernel.
+
+**Runtime API signatures — grep the headers.** `$CUDA_HOME/include` is authoritative, always present,
+and never version-skewed against your compiler. The Runtime API web page is only a table of contents
+(its content is on generated subpages), which is why the fetcher skips it.
+
+```bash
+grep -rn "cuTensorMapEncodeTiled" /usr/local/cuda/targets/*/include/
+```
+
+## 10. Precedence
 
-`references.md` says what to learn from each.
+1. **The compiler.** If `nvcc`/`ptxas` rejects it, it does not exist on your target, whatever any
+   document says. `tools/check_toolchain.py` settles this in seconds.
+2. **The device.** For counts and capacities, query it.
+3. **The official docs.** For *meaning* — semantics, ordering, modifier effects — NVIDIA is the authority.
+4. **`ref/*.md`.** Verified working sets and the traps, but summaries; where they disagree with NVIDIA on
+   semantics, NVIDIA wins.

agent/tools/_html2txt.py

@@ -0,0 +1,70 @@
+"""HTML -> greppable plain text. Pure stdlib: the task images have no bs4 and no internet to get it.
+
+Whitespace inside <pre>/<code> is preserved -- these documents carry their worked examples in code
+blocks, and a collapsed one ("mbarrier_init(&bar,1);// Initialize barrier") is unreadable.
+"""
+import re
+import sys
+from html.parser import HTMLParser
+
+DROP = {"script", "style", "nav", "head", "noscript", "svg", "form"}
+BLOCK = {"p", "div", "li", "tr", "br", "section", "article"}
+HEAD = {"h1", "h2", "h3", "h4", "h5", "h6"}
+
+
+class T(HTMLParser):
+    def __init__(self):
+        super().__init__(convert_charrefs=True)
+        self.out, self.skip, self.pre = [], 0, 0
+
+    def handle_starttag(self, tag, attrs):
+        if tag in DROP:
+            self.skip += 1
+        elif tag in ("pre", "code"):
+            if tag == "pre":
+                self.out.append("\n")
+            self.pre += 1
+        elif self.pre:
+            if tag == "br":
+                self.out.append("\n")
+        elif tag in HEAD:
+            self.out.append("\n\n### ")
+        elif tag in BLOCK:
+            self.out.append("\n")
+        elif tag in ("td", "th"):
+            self.out.append("  ")
+
+    def handle_endtag(self, tag):
+        if tag in DROP and self.skip:
+            self.skip -= 1
+        elif tag in ("pre", "code"):
+            if self.pre:
+                self.pre -= 1
+            if tag == "pre":
+                self.out.append("\n")
+        elif not self.pre and tag in HEAD | {"table"}:
+            self.out.append("\n")
+
+    def handle_data(self, d):
+        if self.skip:
+            return
+        if self.pre:
+            self.out.append(d)          # verbatim: newlines and indentation are the content
+        elif d.strip():
+            self.out.append(d)
+
+
+def convert(src):
+    p = T()
+    p.feed(src)
+    t = "".join(p.out)
+    # collapse runs of spaces only OUTSIDE code: do it line-wise, leaving indented lines alone
+    lines = []
+    for ln in t.splitlines():
+        lines.append(ln if ln[:1] in (" ", "\t") else re.sub(r"[ \t]{2,}", " ", ln).rstrip())
+    t = "\n".join(lines)
+    return re.sub(r"\n{3,}", "\n\n", t).strip() + "\n"
+
+
+if __name__ == "__main__":
+    sys.stdout.write(convert(open(sys.argv[1], encoding="utf-8", errors="ignore").read()))

agent/tools/fetch_nvidia_docs.sh

@@ -1,10 +1,14 @@
 #!/bin/bash
 # Fetch NVIDIA's official CUDA/PTX documentation into a local directory, for offline use.
 #
-#   ./fetch_nvidia_docs.sh [dest]        # default: ./nvidia-docs
+#   ./fetch_nvidia_docs.sh [dest] [cuda-version]   # default: ./nvidia-docs, version auto-detected
+#
+# Emits <name>.html and <name>.txt per document. The .txt is the one that matters: it is greppable,
+# which is the only way a ~700-page reference is usable offline. PDFs are deliberately NOT fetched --
+# they cannot be grepped, are read in 20-page slices, and cost ~30 MB for no added capability.
 #
 # WHY A FETCHER AND NOT BUNDLED FILES
-# NVIDIA's documentation is copyrighted and is NOT redistributable. The CUDA EULA distributes only the
+# NVIDIA's documentation is copyrighted and 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.
@@ -12,83 +16,65 @@
 # 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
+#     RUN bash fetch_nvidia_docs.sh /opt/nvidia-docs 12.8.0
 #
 # (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
+VER=${2:-}
 mkdir -p "$DEST"
+HERE=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+PY=$(command -v python3 || command -v python || true)
 
 # 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.
+# and instructions documented there may not assemble on an older ptxas -- CUDA 12.8 ships PTX ISA 8.7
+# while the live page currently documents 9.3.
 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
+  BASE="https://docs.nvidia.com/cuda/archive/$VER"
   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
+  BASE="https://docs.nvidia.com/cuda"
 fi
-NSIGHT=https://docs.nvidia.com
+NSIGHT="https://docs.nvidia.com/nsight-compute"
+# NOTE: the CUDA Runtime API reference is deliberately absent. Its index page is only a table of
+# contents -- the real content is on generated per-module subpages -- and for signatures the installed
+# headers under $CUDA_HOME/include are both authoritative and already local. Grep those instead.
 
-# 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|
+cuda-c-programming-guide|$BASE/cuda-c-programming-guide/index.html
+cuda-c-best-practices-guide|$BASE/cuda-c-best-practices-guide/index.html
+parallel-thread-execution|$BASE/parallel-thread-execution/index.html
+inline-ptx-assembly|$BASE/inline-ptx-assembly/index.html
+hopper-tuning-guide|$BASE/hopper-tuning-guide/index.html
+nsight-compute-profiling-guide|$NSIGHT/ProfilingGuide/index.html
+nsight-compute-cli|$NSIGHT/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")
+  name=${entry%%|*}
+  url=${entry#*|}
   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
+    echo "  FAIL $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
+  if [ -n "$PY" ] && [ -f "$HERE/_html2txt.py" ]; then
+    "$PY" "$HERE/_html2txt.py" "$html" > "$DEST/$name.txt" 2>/dev/null || rm -f "$DEST/$name.txt"
   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))"
+  if [ -f "$DEST/$name.txt" ]; then
+    echo "  ok   $name  ($(du -h "$DEST/$name.txt" | cut -f1) text)"
   else
-    rm -f "$DEST/$name.pdf"
-    echo "  ok   $name  (html only)"
+    echo "  ok   $name  (html only -- no python3 for the text rendering)"
   fi
-  ok=$((ok+1))
+  ok=$((ok + 1))
 done
 
 cat > "$DEST/LICENSE-NOTICE.txt" <<'NOTE'
@@ -101,9 +87,10 @@ 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.
+Do not re-publish these files. If you need to share them, share the fetch script instead.
 NOTE
 
 echo
 echo "$ok fetched, $fail failed -> $DEST"
+echo "search with: KDOCS=$DEST tools/search_docs.sh <pattern>"
 echo "Copyright (c) NVIDIA Corporation. Not redistributable; see $DEST/LICENSE-NOTICE.txt"

agent/tools/search_docs.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+# Search the offline NVIDIA docs corpus fetched by fetch_nvidia_docs.sh.
+#
+#   KDOCS=/opt/nvidia-docs ./search_docs.sh "cp.async.bulk"        # find it
+#   KDOCS=/opt/nvidia-docs ./search_docs.sh -C 12 "expect_tx"      # with more context
+#
+# Searches the .txt renderings (greppable); falls back to the installed CUDA headers for API
+# signatures, which are more authoritative than any web page and are always present.
+set -uo pipefail
+DOCS=${KDOCS:-/opt/nvidia-docs}
+CTX=4
+if [ "${1:-}" = "-C" ]; then CTX=$2; shift 2; fi
+PAT=${1:-}
+[ -z "$PAT" ] && { echo "usage: [KDOCS=dir] search_docs.sh [-C n] <pattern>" >&2; exit 1; }
+
+if [ -d "$DOCS" ] && ls "$DOCS"/*.txt >/dev/null 2>&1; then
+  echo "== $DOCS =="
+  grep -rn --color=never -C "$CTX" -- "$PAT" "$DOCS"/*.txt 2>/dev/null | head -80
+else
+  echo "no fetched docs at $DOCS (run fetch_nvidia_docs.sh, or set KDOCS)" >&2
+fi
+
+# Search EVERY include root, deduped by real path: /usr/local/cuda/include and
+# /usr/local/cuda/targets/<arch>/include are different trees, and cuda.h (where the driver API lives)
+# is only in the latter -- picking just the first one silently finds nothing.
+INCS=$(for d in /usr/local/cuda*/targets/*/include /usr/local/cuda*/include; do
+         [ -d "$d" ] && readlink -f "$d"
+       done | sort -u)
+if [ -n "$INCS" ]; then
+  echo
+  echo "== CUDA headers -- authoritative for signatures =="
+  # shellcheck disable=SC2086
+  grep -rn --include="*.h" --include="*.hpp" --include="*.cuh" --color=never -- "$PAT" $INCS 2>/dev/null | head -15
+fi