diff --git a/README.md b/README.md
index c96121653..9c1cdac22 100644
--- a/README.md
+++ b/README.md
@@ -198,67 +198,67 @@ Call resolution the fork adds:
 
 ### Measured results
 
-Upstream `main` at `cd04b21a` against the fork at `c63e3d7c`, Node.js 24.22.2 on the same 24-core bare-metal Linux host, measured 2026-10-31 under the host benchmark lock. This is the second 2026-10-31 run, after the prerequisite-pool fix below; the first one exposed that regression and is kept as [its own record](docs/benchmarks/fork-vs-upstream-2026-10-31.md). Seven corpora, arms in mirrored order; index figures are the median of two runs and sync figures the median of four. A comparison counts as a change only when the gap exceeds that comparison's own run-to-run spread — the larger of the two arms' (max − min) / median — and cells that cannot show that are marked no clear change rather than given a fixed band. Bun was not re-measured in this run; the Bun figures below are from the 2026-10-28 campaign, and the CLI table is from the 2026-10-27 run at `bc27fdb4`. The numbers, method, spreads, graph sizes and admission receipts are in [`docs/benchmarks/fork-vs-upstream-2026-10-31b.md`](docs/benchmarks/fork-vs-upstream-2026-10-31b.md). The scripts are in [`scripts/benchmarks/runtime/`](scripts/benchmarks/runtime/).
+Upstream `main` at `cd04b21a` against the fork at `8313e9a0`, Node.js 24.22.2 on the same 24-core bare-metal Linux host, measured 2026-11-01 under the host benchmark lock with Hyperfine 2.0.0. Seven corpora, arms in mirrored order; index figures are the median of two runs and sync figures the median of four. A comparison counts as a change only when the gap exceeds that comparison's own run-to-run spread — the larger of the two arms' (max − min) / median — and cells that cannot show that are marked no clear change rather than given a fixed band. Bun was not re-measured in this run; the Bun figures below are from the 2026-10-28 campaign, and the CLI table is from the 2026-10-27 run at `bc27fdb4`. The numbers, method, spreads, graph sizes and admission receipts are in [`docs/benchmarks/fork-vs-upstream-2026-11-01.md`](docs/benchmarks/fork-vs-upstream-2026-11-01.md). The scripts are in [`scripts/benchmarks/runtime/`](scripts/benchmarks/runtime/).
 
-![Fork against upstream CodeGraph on seven corpora, Node, 2026-10-31: the fork syncs a one-file edit 1.08 to 2.69 times faster, indexes CPython 1.71 times faster and n8n 1.32 times faster, and trails gin by 8% and supabase by 11% on a graph with 33% more nodes.](assets/fork-vs-upstream-performance.svg?v=13)
+![Fork against upstream CodeGraph on seven corpora, Node, 2026-11-01: the fork syncs six of seven one-file edits 1.22 to 2.63 times faster (discourse 3% slower), indexes CPython 1.79 times faster and n8n 1.43 times faster, and is level with gin and supabase, the latter on 18.5% more nodes.](assets/fork-vs-upstream-performance.svg?v=16)
 
-*2026-10-31 Node run, fork `c63e3d7c` against upstream `cd04b21a`. Ratios are exact; the tables mark which gaps clear the run-to-run spread.*
+*2026-11-01 Node run, fork `8313e9a0` against upstream `cd04b21a`. Ratios are exact; the tables mark which gaps clear the run-to-run spread.*
 
-The fork's one-file sync is faster on all seven corpora: 8% (discourse) to 63% (n8n), or 1.08× to 2.69×. Full indexing: CPython is 1.71× faster (27.06 s against 46.34 s), n8n 1.32× faster (53.95 s against 71.36 s), pretix 11% faster and Alamofire and discourse 4–5% faster; gin is 8% slower (0.07 s absolute on a 119-file repo) and supabase 11% slower on a graph with 33% more nodes and 12% more edges. The speed costs memory on the smaller corpora — index peaks +50% on gin, +37% on Alamofire, +23% on pretix and +1% on supabase — while it is lower on CPython (−17%), discourse (−12%) and n8n (−27%). MCP on n8n: warm explore 1.75× faster, the eight-explore wave 1.26× faster and `initialize` 1.79× faster, with busy memory 21% lower and idle memory 51% lower; the watcher's one-file re-index is the one loss, 9% slower (766 ms against 702 ms).
+The fork's one-file sync is faster on six of seven corpora: 18% (gin) to 62% (n8n) less elapsed time, or 1.22× to 2.63× reciprocal speed; discourse is 3% slower. Full indexing: CPython is 1.79× faster (25.84 s against 46.36 s), n8n 1.43× faster (50.16 s against 71.75 s), discourse 8% faster, Alamofire 5% faster and pretix 1% faster; gin and supabase are no clear change. Supabase is 1.9% slower inside a 2.1% fork spread, on a graph with 18.5% more nodes and 6.7% more edges. The speed costs memory on the smaller corpora — index peaks +49% on gin, +34% on Alamofire and +16% on pretix — while it is lower on CPython (−20%), discourse (−8%), supabase (−1%) and n8n (−29%). MCP on n8n: warm explore 1.72× faster, the eight-explore wave 1.27× faster and `initialize` 1.94× faster, with busy memory 19% lower and idle memory 52% lower; the watcher's one-file re-index is the one loss, 12% slower (754 ms against 676 ms).
 
-The [2026-10-28 Node+Bun campaign](docs/benchmarks/fork-vs-upstream-node-bun-2026-10-27.md), the [2026-10-30 Node re-measurement](docs/benchmarks/fork-vs-upstream-node-2026-10-30.md) and the [first 2026-10-31 run](docs/benchmarks/fork-vs-upstream-2026-10-31.md) are superseded by this run and kept with their original dates and commits.
+The [2026-10-28 Node+Bun campaign](docs/benchmarks/fork-vs-upstream-node-bun-2026-10-27.md), the [2026-10-30 Node re-measurement](docs/benchmarks/fork-vs-upstream-node-2026-10-30.md), the [first 2026-10-31 run](docs/benchmarks/fork-vs-upstream-2026-10-31.md) and the [second 2026-10-31 run](docs/benchmarks/fork-vs-upstream-2026-10-31b.md) are superseded by this run and kept with their original dates and commits.
 
 The fork starts its resolver pool at 12,000 pending references on a full index (150,000 before #590). Below that, it can start the pool part-way through if at least 20,000 unresolved references remain and the estimated main-thread work is at least 0.4 s. An explicit `CODEGRAPH_PARALLEL_RESOLVE_MIN` replaces both gates. The pool sizes itself at about one worker per 2,000 refs, capped at 25,000 refs per worker and by CPU and memory headroom (8 workers on gin, 12 on the larger corpora here); the bulk edge/ref index windows keep their own 150,000-ref floor. Workers spawn as the pool is gated in and open a pre-prerequisite snapshot, so the prerequisite batches resolve across the pool; a second snapshot is taken once their supertype edges persist and the workers recycle onto it. Resolution proceeds in pages of 40,000 references (`CODEGRAPH_RESOLVE_BATCH` overrides), across up to 12 workers (`CODEGRAPH_RESOLVE_WORKERS` sets the count, `0` disables the pool; `CODEGRAPH_NO_PARALLEL_RESOLVE=1` does the same).
 
-**Full index** (`codegraph init`), Node, 2026-10-31; time, peak memory and graph:
+**Full index** (`codegraph init`), Node, 2026-11-01; time, peak memory and graph:
 
 | Corpus | Upstream | Fork | Fork / upstream | Upstream nodes / edges | Fork nodes / edges |
 |---|---:|---:|---:|---:|---:|
-| gin (Go, 119 files) | 0.81 s, 496 MiB | 0.88 s, 744 MiB | **8% slower** | 2,660 / 8,050 | 3,089 / 8,546 |
-| Alamofire (Swift, 129 files) | 1.23 s, 850 MiB | 1.17 s, 1,168 MiB | **4% faster** | 4,600 / 12,512 | 5,614 / 13,682 |
-| pretix (Python + JS, 1,472 files) | 9.13 s, 3,547 MiB | 8.08 s, 4,367 MiB | **11% faster** | 32,783 / 79,319 | 32,799 / 73,769 |
-| CPython (C + Python, 3,708 files) | 46.34 s, 7,388 MiB | 27.06 s, 6,168 MiB | **1.71× faster** | 169,618 / 615,814 | 170,311 / 605,273 |
-| discourse (Ruby + JS, 20,277 files) | 15.13 s, 4,440 MiB | 14.38 s, 3,906 MiB | **5% faster** | 163,411 / 314,691 | 168,110 / 310,348 |
-| supabase (React + Next.js + TS, 10,716 files) | 15.70 s, 5,830 MiB | 17.37 s, 5,877 MiB | **11% slower** | 114,440 / 292,021 | 152,274 / 328,137 |
-| n8n (Vue + TS, 24,434 files) | 71.36 s, 12,219 MiB | 53.95 s, 8,867 MiB | **1.32× faster** | 315,422 / 1,239,521 | 328,519 / 1,236,342 |
+| gin (Go, 119 files) | 0.90 s, 484 MiB | 0.89 s, 721 MiB | **no clear change** | 2,660 / 8,050 | 2,985 / 8,442 |
+| Alamofire (Swift, 129 files) | 1.24 s, 844 MiB | 1.18 s, 1,133 MiB | **5% faster** | 4,600 / 12,512 | 5,587 / 13,655 |
+| pretix (Python + JS, 1,472 files) | 9.20 s, 3,574 MiB | 9.08 s, 4,129 MiB | **1% faster** | 32,781 / 79,317 | 32,795 / 73,765 |
+| CPython (C + Python, 3,708 files) | 46.36 s, 7,588 MiB | 25.84 s, 6,051 MiB | **1.79× faster** | 169,618 / 615,814 | 169,698 / 604,660 |
+| discourse (Ruby + JS, 20,277 files) | 15.33 s, 4,398 MiB | 14.13 s, 4,064 MiB | **8% faster** | 163,411 / 314,691 | 166,865 / 309,103 |
+| supabase (React + Next.js + TS, 10,716 files) | 15.73 s, 5,891 MiB | 16.03 s, 5,822 MiB | **no clear change** | 114,440 / 292,021 | 135,658 / 311,496 |
+| n8n (Vue + TS, 24,434 files) | 71.75 s, 12,252 MiB | 50.16 s, 8,754 MiB | **1.43× faster** | 315,422 / 1,239,521 | 324,381 / 1,232,201 |
 
-The fork indexes faster on five of seven corpora, by 4% (Alamofire) to 1.71× (CPython). pretix's 11% is close to its 9% fork spread but clears it. The two losses are gin (8%, 0.07 s absolute on a 119-file repo) and supabase (11% on a graph with 33% more nodes and 12% more edges; per node the fork is faster). The fork's larger graphs are part of the gin, Alamofire and supabase difference; pretix and CPython are within 1% on nodes. Peak-memory change, fork against upstream: gin +50%, Alamofire +37%, pretix +23%, CPython −17%, discourse −12%, supabase +1%, n8n −27%.
+The fork indexes faster on five of seven corpora, by 1% (pretix) to 1.79× (CPython). Gin and supabase are no clear change: gin's 0.7% gap is inside its 5.7% spread, and supabase's 1.9% is inside its 2.1% fork spread on a graph with 18.5% more nodes and 6.7% more edges. Peak-memory change, fork against upstream: gin +49%, Alamofire +34%, pretix +16%, CPython −20%, discourse −8%, supabase −1%, n8n −29%.
 
 **The 2026-10-31 regression is closed.** The first run that day showed supabase 36% and n8n level, but the fork's own index had slowed at matched graph sizes. A bisect named #591 (`05077514`): it moved the prerequisite (imports/extends/implements) batches to the main-thread kernel so the workers could open one post-prerequisite snapshot, serializing that phase on one core — supabase 17.27/17.46 s to 21.84/22.51 s, n8n 54.46/57.22 s to 70.34/70.70 s, index CPU ~630% to ~460%. #590 alone was inside the pre-#590 spread. `c63e3d7c` opens the pool on the pre-prerequisite snapshot again and recycles it onto a second snapshot after the supertypes persist; the interleaved A/B at fixed graph sizes was supabase 21.60/21.88 s → 17.11/17.27 s and n8n 70.72/73.17 s → 53.58/53.91 s. The cost is peak memory on n8n: 8.8–8.9 GiB against 8.2–8.5 GiB, still below upstream's 11.9 GiB. Evidence: [the fix's measurement doc](docs/benchmarks/fork-vs-upstream-2026-10-31b.md) and the [pre-fix run](docs/benchmarks/fork-vs-upstream-2026-10-31.md).
 
-**One-file sync** (edit one file, `codegraph sync`), Node, 2026-10-31:
+**One-file sync** (edit one file, `codegraph sync`), Node, 2026-11-01:
 
 | Corpus | Upstream | Fork | Upstream / fork |
 |---|---:|---:|---:|
-| gin | 0.37 s | 0.30 s | **1.23×** |
-| Alamofire | 0.39 s | 0.28 s | **1.39×** |
-| pretix | 1.50 s | 0.93 s | **1.62×** |
-| CPython | 5.21 s | 2.54 s | **2.05×** |
-| discourse | 1.06 s | 0.98 s | **1.08×** |
-| supabase | 7.49 s | 3.45 s | **2.17×** |
-| n8n | 11.37 s | 4.23 s | **2.69×** |
+| gin | 0.395 s | 0.325 s | **1.22×** |
+| Alamofire | 0.412 s | 0.295 s | **1.40×** |
+| pretix | 1.513 s | 0.901 s | **1.68×** |
+| CPython | 5.231 s | 2.596 s | **2.02×** |
+| discourse | 1.070 s | 1.101 s | **0.97× (3% slower)** |
+| supabase | 7.585 s | 3.450 s | **2.20×** |
+| n8n | 11.481 s | 4.368 s | **2.63×** |
 
-Every cell clears its run-to-run spread; discourse's 8% is the smallest.
+Six of seven clear their run-to-run spread and are faster; discourse is 3% slower, the one sync loss.
 
 Both builds rebuild the links inferred from events, callbacks and function pointers after a sync, so a sync ends with the graph a full index would build ([colbymchenry/codegraph#1988](https://github.com/colbymchenry/codegraph/issues/1988)). Upstream reruns every inference pass inside each sync that touches an inferred link; the fork reruns the same passes a full index runs once edits pause. `CODEGRAPH_SYNC_RESYNTHESIS=0` turns the fork's rebuild off, trading it for stale inferred links.
 
-**MCP server** on n8n (`codegraph serve --mcp`; memory and CPU summed over the server and the daemon), Node, 2026-10-31:
+**MCP server** on n8n (`codegraph serve --mcp`; memory and CPU summed over the server and the daemon), Node, 2026-11-01. This table uses the existing process-tree harness (`scripts/benchmarks/runtime/mcp-bench.mjs`), not Hyperfine; the required runners cannot measure per-query MCP latency, concurrent explores, process-tree memory/CPU or the watcher sync. It is a separate measurement from the Hyperfine index/sync figures:
 
 | | Upstream | Fork |
 |---|---:|---:|
-| `initialize` answered | 115 ms | 64 ms |
-| Start to first explore answer | 2.91 s | 2.70 s |
-| Explore, warm median | 240 ms | 138 ms |
-| Explore, p90 | 282 ms | 178 ms |
-| 8 explores at once | 2.38 s | 1.88 s |
-| Memory while busy | 3.81 GiB | 3.02 GiB |
-| Edited file re-indexed by the watcher | 702 ms | 766 ms |
-| Memory at idle | 4.46 GiB | 2.19 GiB |
-| CPU at idle, share of one core | 0.40% | 0.20% |
+| `initialize` answered | 120 ms | 62 ms |
+| Start to first explore answer | 2.85 s | 2.75 s |
+| Explore, warm median | 244 ms | 142 ms |
+| Explore, p90 | 286 ms | 186 ms |
+| 8 explores at once | 2.40 s | 1.89 s |
+| Memory while busy | 3.66 GiB | 2.97 GiB |
+| Edited file re-indexed by the watcher | 676 ms | 754 ms |
+| Memory at idle | 4.31 GiB | 2.08 GiB |
+| CPU at idle, share of one core | 0.38% | 0.19% |
 
-The idle row is the process tree's RSS at the harness's idle sample, 70 s after the last query. The same measure across runs: **3.58 GiB** on 2026-10-27 (`bc27fdb4`, the old README row), **4.21 GiB** on 2026-10-28 (`5784e289`, the clean re-measure), **19.7 GiB** on 2026-10-30 (`a9dc5a61`, a real regression), **2.13 GiB** in the first 2026-10-31 run (`cf2a37a5`, #593) and **2.19 GiB** now (`c63e3d7c`). The “20 GB → 2 GB” statement is the 2026-10-30 to 2026-10-31 change on this harness, not a different definition from the earlier rows.
+The idle row is the process tree's RSS at the harness's idle sample, 70 s after the last query. The same measure across runs: **3.58 GiB** on 2026-10-27 (`bc27fdb4`, the old README row), **4.21 GiB** on 2026-10-28 (`5784e289`, the clean re-measure), **19.7 GiB** on 2026-10-30 (`a9dc5a61`, a real regression), **2.13 GiB** in the first 2026-10-31 run (`cf2a37a5`, #593), **2.19 GiB** at the 2026-10-31 run (`c63e3d7c`) and **2.08 GiB** on 2026-11-01 (`8313e9a0`). The “20 GB → 2 GB” statement is the 2026-10-30 to 2026-10-31 change on this harness, not a different definition from the earlier rows.
 
-**CLI startup** on gin (`hyperfine`, mean of 20 runs), 2026-10-27, fork `bc27fdb4` against upstream `69af19ac`; not re-measured on 2026-10-31:
+**CLI startup** on gin (`hyperfine`, mean of 20 runs), 2026-10-27, fork `bc27fdb4` against upstream `69af19ac`; not re-measured on 2026-11-01:
 
 | Command | Upstream, Node | Fork, Node | Fork, Bun |
 |---|---|---|---|
@@ -281,10 +281,10 @@ The [benchmark](#benchmark-results) and [speed](#built-for-speed--the-rust-kerne
 
 ### What it costs
 
-- **Larger database:** 12–20% bigger on six of the seven corpora above, and 38% on supabase, which has 1,978 Markdown files. It holds Markdown, binding rows and more nodes.
+- **Larger database:** 11–20% bigger on six of the seven corpora above, and 31.5% on supabase, which has 1,978 Markdown files. It holds Markdown, binding rows and more nodes.
 - **Fewer edges on some projects:** 7% fewer on pretix and 1.7% fewer on CPython, because the fork declines links it cannot confirm. Some of those were correct links.
-- **More memory while indexing on four projects:** in the 2026-10-31 comparison the fork's full index peaks higher on gin (+50%), Alamofire (+37%), pretix (+23%) and supabase (+1%) — the in-process resolver-pool workers used on small and mid-size projects, plus the second pool snapshot on large ones — while it is lower on CPython (−17%), discourse (−12%) and n8n (−27%).
-- **MCP watcher sync:** the daemon's one-file re-index is 9% slower (766 ms against 702 ms) because it also runs the deferred synthesized-edge refresh; the CLI one-file sync is faster on all seven corpora.
+- **More memory while indexing on the smaller projects:** in the 2026-11-01 comparison the fork's full index peaks higher on gin (+49%), Alamofire (+34%) and pretix (+16%) — the in-process resolver-pool workers used on small and mid-size projects — while it is lower on CPython (−20%), discourse (−8%), supabase (−1%) and n8n (−29%).
+- **MCP watcher sync:** the daemon's one-file re-index is 9% slower (766 ms against 702 ms) because it also runs the deferred synthesized-edge refresh; the CLI one-file sync is faster on six of the seven corpora (discourse is 3% slower).
 
 ---
 
diff --git a/assets/fork-vs-upstream-performance.svg b/assets/fork-vs-upstream-performance.svg
index ec1d74ec3..40b6e74b7 100644
--- a/assets/fork-vs-upstream-performance.svg
+++ b/assets/fork-vs-upstream-performance.svg
@@ -1,16 +1,16 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1000" height="780" viewBox="0 0 1000 780" role="img" aria-label="Fork versus upstream on seven corpora, Node, 2026-10-31">
-<title>Fork versus upstream on seven corpora, Node, 2026-10-31</title>
-<desc>Two panels: full index fork/upstream ratios and one-file sync upstream/fork speedups for gin, Alamofire, pretix, CPython, discourse, supabase and n8n.</desc>
+<svg xmlns="http://www.w3.org/2000/svg" width="1000" height="780" viewBox="0 0 1000 780" role="img" aria-label="Fork versus upstream on seven corpora, Node, 2026-11-01">
+<title>Fork versus upstream on seven corpora, Node, 2026-11-01</title>
+<desc>Two panels: full index candidate/base ratios and one-file sync base/candidate speedups for gin, Alamofire, pretix, CPython, discourse, supabase and n8n.</desc>
 <rect width="1000" height="780" fill="#0d1117"/>
 <style>text{font-family:Inter,Segoe UI,system-ui,sans-serif;fill:#e6edf3}.title{font-size:26px;font-weight:700}.sub{font-size:14px;fill:#9da7b3}.corpus{font-size:15px;font-weight:600}.val{font-size:14px;font-weight:700}.axis{font-size:12px;fill:#8b949e}.good{fill:#3fb950}.bad{fill:#f85149}.tie{fill:#8b949e}</style>
-<text x="46" y="56" class="title">Fork vs upstream on Node — seven corpora, 2026-10-31</text>
-<text x="46" y="82" class="sub">Upstream cd04b21a · fork c63e3d7c · Node 24.22.2 · Node-only run</text>
-<text x="46" y="104" class="sub">Index: median of 2 runs, fork / upstream (lower is better). Sync: median of 4 runs, upstream / fork (higher is better).</text>
+<text x="46" y="56" class="title">Fork vs upstream on Node — seven corpora, 2026-11-01</text>
+<text x="46" y="82" class="sub">Upstream cd04b21a · Fork 8313e9a0 · Node 24.22.2 · Hyperfine 2.0.0</text>
+<text x="46" y="104" class="sub">Index: median of 2 runs, candidate / base (lower is better). Sync: median of 4 runs, base / candidate (higher is better).</text>
 <text x="46" y="140" style="font-size:17px;font-weight:700">Full index</text>
-<line x1="46.0" y1="180" x2="46.0" y2="602" stroke="#30363d" stroke-width="1"/>
-<text x="46.0" y="174" class="axis" text-anchor="middle">0.5×</text>
-<line x1="144.0" y1="180" x2="144.0" y2="602" stroke="#30363d" stroke-width="1"/>
-<text x="144.0" y="174" class="axis" text-anchor="middle">0.75×</text>
+<line x1="46" y1="180" x2="46" y2="602" stroke="#30363d" stroke-width="1"/>
+<text x="46" y="174" class="axis" text-anchor="middle">0.5×</text>
+<line x1="144" y1="180" x2="144" y2="602" stroke="#30363d" stroke-width="1"/>
+<text x="144" y="174" class="axis" text-anchor="middle">0.75×</text>
 <line x1="241.9" y1="180" x2="241.9" y2="602" stroke="#8b949e" stroke-width="1"/>
 <text x="241.9" y="174" class="axis" text-anchor="middle">1×</text>
 <line x1="339.9" y1="180" x2="339.9" y2="602" stroke="#30363d" stroke-width="1"/>
@@ -18,29 +18,29 @@
 <line x1="437.8" y1="180" x2="437.8" y2="602" stroke="#30363d" stroke-width="1"/>
 <text x="437.8" y="174" class="axis" text-anchor="middle">1.5×</text>
 <text x="46" y="200" class="corpus">gin (Go)</text>
-<rect x="241.9" y="188" width="31.2" height="18" rx="3" class="tie"/>
-<text x="279.2" y="200" class="val tie" text-anchor="start">1.08×</text>
+<rect x="239.0" y="188" width="2.9" height="18" rx="3" class="tie"/>
+<text x="233.0" y="200" class="val tie" text-anchor="end">0.99×</text>
 <text x="46" y="258" class="corpus">Alamofire (Swift)</text>
-<rect x="224.4" y="246" width="17.5" height="18" rx="3" class="tie"/>
-<text x="218.4" y="258" class="val tie" text-anchor="end">0.96×</text>
+<rect x="222.0" y="246" width="19.9" height="18" rx="3" class="tie"/>
+<text x="216.0" y="258" class="val tie" text-anchor="end">0.95×</text>
 <text x="46" y="316" class="corpus">pretix (Python)</text>
-<rect x="197.1" y="304" width="44.8" height="18" rx="3" class="tie"/>
-<text x="191.1" y="316" class="val tie" text-anchor="end">0.89×</text>
+<rect x="236.8" y="304" width="5.1" height="18" rx="3" class="tie"/>
+<text x="230.8" y="316" class="val tie" text-anchor="end">0.99×</text>
 <text x="46" y="374" class="corpus">CPython (C/Py)</text>
-<rect x="79.0" y="362" width="163.0" height="18" rx="3" class="tie"/>
-<text x="73.0" y="374" class="val tie" text-anchor="end">0.58×</text>
+<rect x="68.5" y="362" width="173.4" height="18" rx="3" class="tie"/>
+<text x="62.5" y="374" class="val tie" text-anchor="end">0.56×</text>
 <text x="46" y="432" class="corpus">discourse (Ruby)</text>
-<rect x="222.4" y="420" width="19.5" height="18" rx="3" class="tie"/>
-<text x="216.4" y="432" class="val tie" text-anchor="end">0.95×</text>
+<rect x="211.2" y="420" width="30.7" height="18" rx="3" class="tie"/>
+<text x="205.2" y="432" class="val tie" text-anchor="end">0.92×</text>
 <text x="46" y="490" class="corpus">supabase (TS)</text>
-<rect x="241.9" y="478" width="41.7" height="18" rx="3" class="tie"/>
-<text x="289.6" y="490" class="val tie" text-anchor="start">1.11×</text>
+<rect x="241.9" y="478" width="7.4" height="18" rx="3" class="tie"/>
+<text x="255.3" y="490" class="val tie" text-anchor="start">1.02×</text>
 <text x="46" y="548" class="corpus">n8n (Vue/TS)</text>
-<rect x="146.3" y="536" width="95.6" height="18" rx="3" class="tie"/>
-<text x="140.3" y="548" class="val tie" text-anchor="end">0.76×</text>
+<rect x="124.0" y="536" width="117.9" height="18" rx="3" class="tie"/>
+<text x="118.0" y="548" class="val tie" text-anchor="end">0.70×</text>
 <text x="523.0" y="140" style="font-size:17px;font-weight:700">One-file sync</text>
-<line x1="523.0" y1="180" x2="523.0" y2="602" stroke="#30363d" stroke-width="1"/>
-<text x="523.0" y="174" class="axis" text-anchor="middle">0.5×</text>
+<line x1="523" y1="180" x2="523" y2="602" stroke="#30363d" stroke-width="1"/>
+<text x="523" y="174" class="axis" text-anchor="middle">0.5×</text>
 <line x1="609.2" y1="180" x2="609.2" y2="602" stroke="#8b949e" stroke-width="1"/>
 <text x="609.2" y="174" class="axis" text-anchor="middle">1×</text>
 <line x1="695.4" y1="180" x2="695.4" y2="602" stroke="#30363d" stroke-width="1"/>
@@ -49,30 +49,30 @@
 <text x="781.6" y="174" class="axis" text-anchor="middle">2×</text>
 <line x1="867.8" y1="180" x2="867.8" y2="602" stroke="#30363d" stroke-width="1"/>
 <text x="867.8" y="174" class="axis" text-anchor="middle">2.5×</text>
-<line x1="954.0" y1="180" x2="954.0" y2="602" stroke="#30363d" stroke-width="1"/>
-<text x="954.0" y="174" class="axis" text-anchor="middle">3×</text>
+<line x1="954" y1="180" x2="954" y2="602" stroke="#30363d" stroke-width="1"/>
+<text x="954" y="174" class="axis" text-anchor="middle">3×</text>
 <text x="523.0" y="200" class="corpus">gin (Go)</text>
-<rect x="609.2" y="188" width="40.2" height="18" rx="3" class="good"/>
-<text x="655.4" y="200" class="val good" text-anchor="start">1.23×</text>
+<rect x="609.2" y="188" width="37.3" height="18" rx="3" class="good"/>
+<text x="652.5" y="200" class="val good" text-anchor="start">1.22×</text>
 <text x="523.0" y="258" class="corpus">Alamofire (Swift)</text>
-<rect x="609.2" y="246" width="67.7" height="18" rx="3" class="good"/>
-<text x="682.9" y="258" class="val good" text-anchor="start">1.39×</text>
+<rect x="609.2" y="246" width="68.2" height="18" rx="3" class="good"/>
+<text x="683.4" y="258" class="val good" text-anchor="start">1.40×</text>
 <text x="523.0" y="316" class="corpus">pretix (Python)</text>
-<rect x="609.2" y="304" width="106.2" height="18" rx="3" class="good"/>
-<text x="721.4" y="316" class="val good" text-anchor="start">1.62×</text>
+<rect x="609.2" y="304" width="116.9" height="18" rx="3" class="good"/>
+<text x="732.1" y="316" class="val good" text-anchor="start">1.68×</text>
 <text x="523.0" y="374" class="corpus">CPython (C/Py)</text>
-<rect x="609.2" y="362" width="180.5" height="18" rx="3" class="good"/>
-<text x="795.7" y="374" class="val good" text-anchor="start">2.05×</text>
+<rect x="609.2" y="362" width="175.0" height="18" rx="3" class="good"/>
+<text x="790.2" y="374" class="val good" text-anchor="start">2.01×</text>
 <text x="523.0" y="432" class="corpus">discourse (Ruby)</text>
-<rect x="609.2" y="420" width="13.2" height="18" rx="3" class="good"/>
-<text x="628.4" y="432" class="val good" text-anchor="start">1.08×</text>
+<rect x="604.3" y="420" width="4.9" height="18" rx="3" class="bad"/>
+<text x="598.3" y="432" class="val bad" text-anchor="end">0.97×</text>
 <text x="523.0" y="490" class="corpus">supabase (TS)</text>
-<rect x="609.2" y="478" width="202.4" height="18" rx="3" class="good"/>
-<text x="817.6" y="490" class="val good" text-anchor="start">2.17×</text>
+<rect x="609.2" y="478" width="206.7" height="18" rx="3" class="good"/>
+<text x="821.9" y="490" class="val good" text-anchor="start">2.20×</text>
 <text x="523.0" y="548" class="corpus">n8n (Vue/TS)</text>
-<rect x="609.2" y="536" width="291.0" height="18" rx="3" class="good"/>
-<text x="906.2" y="548" class="val good" text-anchor="start">2.69×</text>
+<rect x="609.2" y="536" width="280.7" height="18" rx="3" class="good"/>
+<text x="895.9" y="548" class="val good" text-anchor="start">2.63×</text>
 <text x="46" y="708" class="axis">Exact ratios; the tables mark which gaps clear the larger arm's run-to-run spread.</text>
-<text x="46" y="726" class="axis">Method, spreads, graph sizes, admission receipts: docs/benchmarks/fork-vs-upstream-2026-10-31b.md</text>
+<text x="46" y="726" class="axis">Method, spreads, graph sizes, admission receipts: docs/benchmarks/fork-vs-upstream-2026-11-01.md</text>
 <text x="46" y="762" class="axis">CodeGraph fork · bompus/codegraph · measured under the host benchmark lock</text>
-</svg>
\ No newline at end of file
+</svg>
diff --git a/docs/benchmarks/fork-vs-upstream-2026-11-01.md b/docs/benchmarks/fork-vs-upstream-2026-11-01.md
new file mode 100644
index 000000000..24b292784
--- /dev/null
+++ b/docs/benchmarks/fork-vs-upstream-2026-11-01.md
@@ -0,0 +1,79 @@
+# Fork against upstream on Node, 2026-11-01, after the Markdown node-model work
+
+A Node-only comparison at the fork head that lands the Markdown node-model work (#612 and #613). It supersedes [fork-vs-upstream-2026-10-31b.md](fork-vs-upstream-2026-10-31b.md) for every figure it covers. The runner changed from the hand-written `/usr/bin/time` loop to Hyperfine 2.0.0, so every arm was re-run here; figures are not directly comparable to the earlier run.
+
+- Upstream: `cd04b21a` (`fix(python): a base's type argument is no supertype…`).
+- Fork: `8313e9a0` (`fix(markdown): fold commands and table rows into their section (#613)`).
+- Host: 24-core bare-metal Ubuntu, 122 GiB, Node.js 24.22.2, release kernel.
+- Corpora: gin, Alamofire, pretix, CPython, discourse, supabase, n8n.
+- Runner: Hyperfine 2.0.0 for whole commands. Index is one Hyperfine run per invocation and two invocations per arm (median of 2); one-file sync is two Hyperfine runs per invocation and two invocations per arm (median of 4). Arms run in mirrored order (upstream, fork, fork, upstream).
+- Peak memory is Hyperfine's `memory_peak_resident` maximum. Graph counts are read from the fresh index after its timed run.
+- A difference counts only when the fork/upstream gap exceeds the larger of the two arms' `(max − min) / median` for that metric. Spreads are listed per cell.
+- The host benchmark lock was held for each corpus and a fresh 10-second admission check passed before it started. Receipts: `~/cg-scratch/bench-2026-11-01/admission-<corpus>.json`; raw Hyperfine JSON and `graph.tsv` beside them.
+
+## Full index
+
+| Corpus | Upstream | Fork | Fork / upstream | Verdict | Upstream RSS | Fork RSS | Nodes up/fork | Edges up/fork |
+|---|---:|---:|---:|---|---:|---:|---:|---:|
+| gin | 0.899 s | 0.893 s | 0.993 | no clear change (spreads 5.3% / 5.7%) | 484 MiB | 721 MiB | 2,660 / 2,985 | 8,050 / 8,442 |
+| Alamofire | 1.238 s | 1.175 s | 0.949 | **5% faster** (0.7% / 0.7%) | 844 MiB | 1,133 MiB | 4,600 / 5,587 | 12,512 / 13,655 |
+| pretix | 9.198 s | 9.079 s | 0.987 | **1% faster** (0.2% / 0.7%) | 3,574 MiB | 4,129 MiB | 32,781 / 32,795 | 79,317 / 73,765 |
+| CPython | 46.357 s | 25.842 s | 0.557 | **1.79× faster** (0.0% / 0.1%) | 7,588 MiB | 6,051 MiB | 169,618 / 169,698 | 615,814 / 604,660 |
+| discourse | 15.329 s | 14.128 s | 0.922 | **8% faster** (0.4% / 0.7%) | 4,398 MiB | 4,064 MiB | 163,411 / 166,865 | 314,691 / 309,103 |
+| supabase | 15.732 s | 16.028 s | 1.019 | no clear change (0.4% / 2.1%), 18.5% more nodes | 5,891 MiB | 5,822 MiB | 114,440 / 135,658 | 292,021 / 311,496 |
+| n8n | 71.748 s | 50.159 s | 0.699 | **1.43× faster** (0.4% / 0.4%) | 12,252 MiB | 8,754 MiB | 315,422 / 324,381 | 1,239,521 / 1,232,201 |
+
+The fork indexes faster on five of seven corpora, by 1% (pretix) to 1.79× (CPython). Gin and supabase are no clear change: gin's 0.7% gap is far inside its 5.7% spread, and supabase's 1.9% is inside its 2.1% fork spread. Supabase is no longer an 11% loss; its graph is 18.5% larger in nodes and 6.7% larger in edges than upstream's. Peak-memory change, fork against upstream: gin +49%, Alamofire +34%, pretix +16%, CPython −20%, discourse −8%, supabase −1%, n8n −29%.
+
+The supabase node count fell from 152,274 to 135,658 across #612 and #613; the import-node and command/table-row work removed 16,616 nodes and 16,641 edges. CPython's fork graph stays within 0.1% of upstream's node count.
+
+## One-file sync
+
+| Corpus | Upstream | Fork | Upstream / fork | Verdict |
+|---|---:|---:|---:|---|
+| gin | 0.395 s | 0.325 s | 1.22× | **18% faster** (2.7% / 3.4%) |
+| Alamofire | 0.412 s | 0.295 s | 1.40× | **28% faster** (0.4% / 2.9%) |
+| pretix | 1.513 s | 0.901 s | 1.68× | **40% faster** (1.3% / 2.7%) |
+| CPython | 5.231 s | 2.596 s | 2.02× | **50% faster** (0.5% / 1.1%) |
+| discourse | 1.070 s | 1.101 s | 0.97× | **3% slower** (1.8% / 1.5%) |
+| supabase | 7.585 s | 3.450 s | 2.20× | **55% faster** (2.3% / 0.8%) |
+| n8n | 11.481 s | 4.368 s | 2.63× | **62% faster** (0.4% / 1.4%) |
+
+The fork syncs faster on six of seven corpora. Discourse is 3% slower, the one sync loss; its 2.9% gap clears the larger arm spread (1.8%). The other six clear their spreads too.
+
+## Reproduce
+
+The campaign runner is [`scripts/benchmarks/runtime/hyperfine-index-sync.sh`](../../../scripts/benchmarks/runtime/hyperfine-index-sync.sh) with [`hyperfine-append-probe.sh`](../../../scripts/benchmarks/runtime/hyperfine-append-probe.sh); the chart and summary are generated by [`hyperfine-chart.mjs`](../../../scripts/benchmarks/runtime/hyperfine-chart.mjs). This is separate from the earlier `run-index-sync.sh`, which uses `/usr/bin/time` and is not comparable.
+
+```bash
+export BENCH_OUT=$HOME/cg-scratch/bench-2026-11-01
+export BENCH_ARMS="upstream=$(fnm exec --using codegraph which node)@/path/to/upstream-checkout fork=$(fnm exec --using codegraph which node)@/path/to/fork-checkout"
+bash scripts/benchmarks/runtime/hyperfine-index-sync.sh index-sync.list
+node scripts/benchmarks/runtime/hyperfine-chart.mjs "$BENCH_OUT" \
+  --svg assets/fork-vs-upstream-performance.svg \
+  --date 2026-11-01 --upstream cd04b21a --fork 8313e9a0
+```
+
+`index-sync.list` is one corpus per line, `<corpus-path> <rel-file> <comment-prefix>`: the seven entries in `~/cg-scratch/index-sync-2026-10-28.list` (gin `auth.go` `//`, Alamofire `Source/Alamofire.swift` `//`, pretix `src/pretix/base/addressvalidation.py` `#`, CPython `Lib/__future__.py` `#`, discourse `config/boot.rb` `#`, supabase `apps/studio/lib/base64url.ts` `//`, n8n `packages/cli/src/abstract-server.ts` `//`).
+
+The corpus checkouts were clean at these commits; the edited file was restored after every arm. Untracked benchmark index directories (`.cg-*`, `.codegraph`) are omitted and do not affect the source tree.
+
+| Corpus | Commit | Edited file |
+|---|---|---|
+| gin | `1bd0ecf` | `auth.go` |
+| Alamofire | `bda9ed5` | `Source/Alamofire.swift` |
+| pretix | `aa14505` | `src/pretix/base/addressvalidation.py` |
+| CPython | `1e8ff18a` | `Lib/__future__.py` |
+| discourse | `ae5ba2c4` | `config/boot.rb` |
+| supabase | `36371de1` | `apps/studio/lib/base64url.ts` |
+| n8n | `7cc0450a` | `packages/cli/src/abstract-server.ts` |
+
+Each invocation uses an exclusively named `CODEGRAPH_DIR` (`.cg-bench-<campaign>`), so a corpus's own `.cg-bench` is never touched, and runs one Hyperfine index command with `--prepare` removing only that directory, then two sync commands against that index. Every sync run's `--prepare` calls `hyperfine-append-probe.sh`, which appends a unique comment plus `void_probe_marker_<ns> = 1`; the runner restores the file from a verified byte copy after each arm and on exit. That is how repeated sync runs each see a fresh one-file edit. The runner rejects a probe with uncommitted changes, saves its original bytes outside the repository and restores them on success, failure and interruption. It also rejects a `BENCH_OUT` that already holds a Hyperfine campaign, verifies the probe is in each fresh index, and checks that the last sync stored the last appended bytes; the chart rejects a sample count that does not match one campaign. Peak RSS is Hyperfine's `memory_peak_resident`.
+
+The campaign wrapped each corpus in the host benchmark lock and a fresh 10-second admission (`flock ~/.cache/setupLinuxHost/post-upgrade-bench.lock`, then `python3 admission.py`); the runner itself takes no lock.
+
+## Notes
+
+- **Runner change.** This is the first campaign timed with Hyperfine 2.0.0 end to end. Every arm was re-run; the 2026-10-31 figures are not directly comparable and should not be mixed with these.
+- **MCP.** The n8n MCP table was re-run on 2026-11-01 with the existing process-tree harness (`scripts/benchmarks/runtime/mcp-bench.mjs`), not Hyperfine: warm explore 142 ms against 244 ms, the eight-explore wave 1.89 s against 2.40 s, `initialize` 62 ms against 120 ms, and idle memory 2.08 GiB against 4.31 GiB. The watcher sync is 754 ms against 676 ms (12% slower). Keep this table separate from the Hyperfine index/sync figures, as the README does.
+- **Raw evidence.** `~/cg-scratch/bench-2026-11-01/`: `*-index.json` / `*-sync.json`, `graph.tsv`, `*-index.txt` / `*-sync.txt`, and `admission-*.json`.
diff --git a/scripts/benchmarks/runtime/README.md b/scripts/benchmarks/runtime/README.md
index 4582f26e9..04b290d1b 100644
--- a/scripts/benchmarks/runtime/README.md
+++ b/scripts/benchmarks/runtime/README.md
@@ -7,7 +7,9 @@ The arms can differ in build, in runtime, or in both.
 
 | Script | Measures | Output in `$BENCH_OUT` |
 |---|---|---|
-| `run-index-sync.sh <list>` | Full index, then two one-file syncs: wall time, peak RSS, CPU, database size, node and edge counts | `index-sync.tsv`, `logs/` |
+| `run-index-sync.sh <list>` | Pre-Hyperfine harness: full index, then two one-file syncs with `/usr/bin/time`: wall time, peak RSS, CPU, database size, node and edge counts. Not comparable with the Hyperfine rows. | `index-sync.tsv`, `logs/` |
+| `hyperfine-index-sync.sh <list>` | Full index and two one-file syncs timed with Hyperfine whole commands, mirrored arms; peak RSS from Hyperfine's JSON, graph counts from the fresh index | `*-index.json`, `*-sync.json`, `graph.tsv` |
+| `hyperfine-chart.mjs <dir> [--svg … --date … --upstream … --fork … --arms base,candidate]` | The README chart and a Markdown summary (medians, spreads, verdicts) from `hyperfine-index-sync.sh` output. Arm names default to `upstream,fork`; corpus names are matched case-insensitively, and a sample count that does not match one campaign is rejected | SVG + stdout |
 | `run-mcp.sh <list>` | MCP server: start to first explore answer, warm explore median and p90, 8 explores at once, watcher sync, idle memory and CPU | `mcp.jsonl` |
 | `run-cli.sh <corpus> <query>` | CLI start: `--version`, `status`, one `explore` (hyperfine, 20 runs) | `cli-*.json`, `cli.txt` |
 | `sync-ab.mjs --corpus … --arm base=… --arm cand=…` | One change on one corpus: a one-file sync before and after, with same-build controls, until the result qualifies or stays inside run-to-run variation (see below) | `runs.jsonl`, `summary.md`, `summary.json`, `chart.json`, `logs/` in `--out` |
@@ -42,7 +44,9 @@ export BENCH_WRAP="nice -n 10 systemd-run --user --scope -p MemoryMax=16G --"
 
 `BENCH_ARMS` entries are `name=RUNTIME@BUILD`. `BENCH_WRAP` prefixes every
 timed command; it defaults to `nice -n 10`. `run-mcp.sh` runs `mcp-bench.mjs`
-with `$BENCH_NODE` (default `node`, 22.13 or newer).
+with `$BENCH_NODE` (default `node`, 22.13 or newer). `hyperfine-index-sync.sh`
+takes the same arms and list; it does not wait for a quiet host or take the
+benchmark lock, so wrap it in the host's admission and lock for a campaign.
 
 ## Corpus lists
 
diff --git a/scripts/benchmarks/runtime/hyperfine-append-probe.sh b/scripts/benchmarks/runtime/hyperfine-append-probe.sh
new file mode 100644
index 000000000..821d8e7f4
--- /dev/null
+++ b/scripts/benchmarks/runtime/hyperfine-append-probe.sh
@@ -0,0 +1,8 @@
+#!/bin/bash
+# Append a unique one-file change for one Hyperfine sync run. The timestamp is
+# the new content, so every repetition of `codegraph sync` sees a real edit;
+# the caller restores the file after the arm.
+set -u
+file=$1; cm=$2
+n=$(date +%s%N)
+printf '\n%s cg bench probe %s\nvoid_probe_marker_%s = 1\n' "$cm" "$n" "$n" >> "$file"
diff --git a/scripts/benchmarks/runtime/hyperfine-chart.mjs b/scripts/benchmarks/runtime/hyperfine-chart.mjs
new file mode 100644
index 000000000..32e150f12
--- /dev/null
+++ b/scripts/benchmarks/runtime/hyperfine-chart.mjs
@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+// Render the README chart and a Markdown summary from a Hyperfine campaign
+// directory produced by hyperfine-index-sync.sh.
+//
+// usage: node hyperfine-chart.mjs <results-dir> [--svg <path>] [--date YYYY-MM-DD]
+//          [--upstream <sha>] [--fork <sha>] [--arms <base>,<candidate>]
+//          [--base-label <label>] [--cand-label <label>]
+//          [--corpora <csv>] [--allow-missing]
+//          [--expect-index <n>] [--expect-sync <n>]
+//
+// Files are named <corpus>-<arm>-<ns>-<index|sync>.json by the runner; arm
+// names default to upstream,fork and follow --arms. Corpus names are matched
+// case-insensitively. Peak RSS is Hyperfine's memory_peak_resident. A
+// comparison counts as a change only when the fork/base elapsed-time gap
+// exceeds the larger arm's (max-min)/median spread, matching the benchmark
+// record's rule. A directory must hold one campaign: the default sample counts
+// are 2 index and 4 sync measurements per arm, and a mismatch is rejected.
+
+import { readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+
+const args = process.argv.slice(2);
+const dir = args.shift();
+if (!dir || dir.startsWith('--')) {
+  console.error('usage: hyperfine-chart.mjs <results-dir> [--svg <path>] [--date YYYY-MM-DD] [--upstream <sha>] [--fork <sha>]');
+  process.exit(2);
+}
+const flag = (name) => {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : undefined;
+};
+const has = (name) => args.includes(name);
+const date = flag('--date') ?? new Date().toISOString().slice(0, 10);
+const upstream = flag('--upstream') ?? 'upstream';
+const fork = flag('--fork') ?? 'fork';
+const baseLabel = flag('--base-label') ?? 'Upstream';
+const candLabel = flag('--cand-label') ?? 'Fork';
+const svgPath = flag('--svg') ?? 'assets/fork-vs-upstream-performance.svg';
+const arms = (flag('--arms') ?? 'upstream,fork').split(',').map((a) => a.trim()).filter(Boolean);
+if (arms.length !== 2) {
+  console.error('--arms needs exactly two names: <base>,<candidate>');
+  process.exit(2);
+}
+const [baseArm, candArm] = arms;
+const expectedIndex = Number(flag('--expect-index') ?? 2);
+const expectedSync = Number(flag('--expect-sync') ?? 4);
+
+const LABELS = {
+  gin: 'gin (Go)',
+  alamofire: 'Alamofire (Swift)',
+  pretix: 'pretix (Python)',
+  cpython: 'CPython (C/Py)',
+  discourse: 'discourse (Ruby)',
+  supabase: 'supabase (TS)',
+  n8n: 'n8n (Vue/TS)',
+};
+const ORDER = ['gin', 'alamofire', 'pretix', 'cpython', 'discourse', 'supabase', 'n8n'];
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const FILE = new RegExp(`^(.*)-(${arms.map(escapeRe).join('|')})-\\d+-(index|sync)\\.json$`);
+
+const samples = new Map(); // corpus -> arm -> kind -> { times, rss }
+for (const file of readdirSync(dir)) {
+  const m = FILE.exec(file);
+  if (!m) continue;
+  const corpus = m[1].toLowerCase();
+  const arm = m[2];
+  const kind = m[3];
+  const data = JSON.parse(readFileSync(join(dir, file), 'utf8'));
+  for (const result of data.results ?? []) {
+    for (const run of result.measurements ?? []) {
+      const key = `${corpus}\0${arm}\0${kind}`;
+      const slot = samples.get(key) ?? { times: [], rss: [] };
+      slot.times.push(run.time_wall_clock.value);
+      slot.rss.push(run.memory_peak_resident.value / 2 ** 20);
+      samples.set(key, slot);
+    }
+  }
+}
+
+function stats(corpus, arm, kind) {
+  const s = samples.get(`${corpus}\0${arm}\0${kind}`);
+  if (!s || s.times.length === 0) return null;
+  const sorted = [...s.times].sort((a, b) => a - b);
+  const mid = sorted.length >> 1;
+  const median = sorted.length % 2 === 1 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+  return {
+    median,
+    min: sorted[0],
+    max: sorted[sorted.length - 1],
+    spread: sorted[sorted.length - 1] > 0 ? (sorted[sorted.length - 1] - sorted[0]) / median : 0,
+    rss: Math.max(...s.rss),
+    n: sorted.length,
+  };
+}
+
+const expectedCorpora = (flag('--corpora') ?? ORDER.join(',')).split(',').map((c) => c.trim().toLowerCase()).filter(Boolean);
+const present = ORDER.filter((c) => stats(c, baseArm, 'index') && stats(c, candArm, 'index'));
+const missing = expectedCorpora.filter((c) => !present.includes(c));
+if (missing.length > 0 && !has('--allow-missing')) {
+  console.error(`missing results for: ${missing.join(', ')} (use --allow-missing for a partial corpus set)`);
+  process.exit(1);
+}
+const corpora = expectedCorpora.filter((c) => present.includes(c));
+if (corpora.length === 0) {
+  console.error(`no ${basename(dir)} Hyperfine results found for arms ${baseArm},${candArm}`);
+  process.exit(1);
+}
+
+for (const corpus of corpora) {
+  for (const arm of [baseArm, candArm]) {
+    for (const kind of ['index', 'sync']) {
+      const expected = kind === 'index' ? expectedIndex : expectedSync;
+      const s = stats(corpus, arm, kind);
+      if (!s) {
+        console.error(`missing ${kind} results for ${corpus}/${arm}`);
+        process.exit(1);
+      }
+      if (s.n !== expected) {
+        console.error(
+          `expected ${expected} ${kind} measurements for ${corpus}/${arm}, found ${s.n}; ` +
+            'use a fresh BENCH_OUT (or pass --expect-index/--expect-sync for a different protocol)',
+        );
+        process.exit(1);
+      }
+    }
+  }
+}
+
+const fmt = (n, digits = 2) => n.toFixed(digits);
+const pct = (n) => `${(Math.abs(n) * 100).toFixed(0)}%`;
+function verdict(displayRatio, a, b, higherIsBetter = false) {
+  // displayRatio is candidate/base for index and base/candidate for sync. The
+  // qualification gap is always the elapsed-time ratio fork/base.
+  const elapsedRatio = higherIsBetter ? 1 / displayRatio : displayRatio;
+  const spread = Math.max(a.spread, b.spread);
+  const gap = Math.abs(elapsedRatio - 1);
+  if (gap <= spread) return 'no clear change';
+  const faster = elapsedRatio < 1;
+  return `${pct(gap)} ${faster ? 'faster' : 'slower'}`;
+}
+
+console.log('| Corpus | Index base | Index candidate | Candidate / base | Verdict | Sync base | Sync candidate | Base / candidate | Verdict |');
+console.log('|---|---:|---:|---:|---|---:|---:|---:|---|');
+for (const corpus of corpora) {
+  const bi = stats(corpus, baseArm, 'index');
+  const ci = stats(corpus, candArm, 'index');
+  const bs = stats(corpus, baseArm, 'sync');
+  const cs = stats(corpus, candArm, 'sync');
+  const ir = ci.median / bi.median;
+  const sr = bs.median / cs.median;
+  console.log(
+    `| ${corpus} | ${fmt(bi.median, 3)} s | ${fmt(ci.median, 3)} s | ${fmt(ir, 3)} | ${verdict(ir, bi, ci)} | ` +
+      `${fmt(bs.median, 3)} s | ${fmt(cs.median, 3)} s | ${fmt(sr, 3)} | ${verdict(sr, bs, cs, true)} |`,
+  );
+}
+
+// Chart geometry copied from the 2026-10-31 chart: index panel 0.5x-1.5x,
+// sync panel 0.5x-3x, seven rows.
+const indexX1 = 241.9;
+const indexScale = 391.8;
+const syncX1 = 609.2;
+const syncScale = 172.4;
+function bar(x1, scale, ratio) {
+  if (ratio <= 1) {
+    const w = (1 - ratio) * scale;
+    return { x: x1 - w, w, tx: x1 - w - 6, anchor: 'end' };
+  }
+  const w = (ratio - 1) * scale;
+  return { x: x1, w, tx: x1 + w + 6, anchor: 'start' };
+}
+const lines = [];
+lines.push('<svg xmlns="http://www.w3.org/2000/svg" width="1000" height="780" viewBox="0 0 1000 780" role="img" aria-label="Fork versus upstream on seven corpora, Node, ' + date + '">');
+lines.push('<title>Fork versus upstream on seven corpora, Node, ' + date + '</title>');
+lines.push('<desc>Two panels: full index candidate/base ratios and one-file sync base/candidate speedups for gin, Alamofire, pretix, CPython, discourse, supabase and n8n.</desc>');
+lines.push('<rect width="1000" height="780" fill="#0d1117"/>');
+lines.push('<style>text{font-family:Inter,Segoe UI,system-ui,sans-serif;fill:#e6edf3}.title{font-size:26px;font-weight:700}.sub{font-size:14px;fill:#9da7b3}.corpus{font-size:15px;font-weight:600}.val{font-size:14px;font-weight:700}.axis{font-size:12px;fill:#8b949e}.good{fill:#3fb950}.bad{fill:#f85149}.tie{fill:#8b949e}</style>');
+lines.push('<text x="46" y="56" class="title">Fork vs upstream on Node — seven corpora, ' + date + '</text>');
+lines.push('<text x="46" y="82" class="sub">' + baseLabel + ' ' + upstream + ' · ' + candLabel + ' ' + fork + ' · Node 24.22.2 · Hyperfine 2.0.0</text>');
+lines.push('<text x="46" y="104" class="sub">Index: median of 2 runs, candidate / base (lower is better). Sync: median of 4 runs, base / candidate (higher is better).</text>');
+lines.push('<text x="46" y="140" style="font-size:17px;font-weight:700">Full index</text>');
+for (const [label, x, muted] of [['0.5×', 46.0, false], ['0.75×', 144.0, false], ['1×', indexX1, true], ['1.25×', 339.9, false], ['1.5×', 437.8, false]]) {
+  lines.push(`<line x1="${x}" y1="180" x2="${x}" y2="602" stroke="${muted ? '#8b949e' : '#30363d'}" stroke-width="1"/>`);
+  lines.push(`<text x="${x}" y="174" class="axis" text-anchor="middle">${label}</text>`);
+}
+let y = 200;
+for (const corpus of corpora) {
+  const bi = stats(corpus, baseArm, 'index');
+  const ci = stats(corpus, candArm, 'index');
+  const ratio = ci.median / bi.median;
+  const b = bar(indexX1, indexScale, ratio);
+  lines.push(`<text x="46" y="${y}" class="corpus">${LABELS[corpus] ?? corpus}</text>`);
+  lines.push(`<rect x="${b.x.toFixed(1)}" y="${y - 12}" width="${Math.max(b.w, 1).toFixed(1)}" height="18" rx="3" class="tie"/>`);
+  lines.push(`<text x="${b.tx.toFixed(1)}" y="${y}" class="val tie" text-anchor="${b.anchor}">${fmt(ratio)}×</text>`);
+  y += 58;
+}
+lines.push('<text x="523.0" y="140" style="font-size:17px;font-weight:700">One-file sync</text>');
+for (const [label, x, muted] of [['0.5×', 523.0, false], ['1×', syncX1, true], ['1.5×', 695.4, false], ['2×', 781.6, false], ['2.5×', 867.8, false], ['3×', 954.0, false]]) {
+  lines.push(`<line x1="${x}" y1="180" x2="${x}" y2="602" stroke="${muted ? '#8b949e' : '#30363d'}" stroke-width="1"/>`);
+  lines.push(`<text x="${x}" y="174" class="axis" text-anchor="middle">${label}</text>`);
+}
+y = 200;
+for (const corpus of corpora) {
+  const bs = stats(corpus, baseArm, 'sync');
+  const cs = stats(corpus, candArm, 'sync');
+  const ratio = bs.median / cs.median;
+  const b = bar(syncX1, syncScale, ratio);
+  const cls = ratio >= 1 ? 'good' : 'bad';
+  lines.push(`<text x="523.0" y="${y}" class="corpus">${LABELS[corpus] ?? corpus}</text>`);
+  lines.push(`<rect x="${b.x.toFixed(1)}" y="${y - 12}" width="${Math.max(b.w, 1).toFixed(1)}" height="18" rx="3" class="${cls}"/>`);
+  lines.push(`<text x="${b.tx.toFixed(1)}" y="${y}" class="val ${cls}" text-anchor="${b.anchor}">${fmt(ratio)}×</text>`);
+  y += 58;
+}
+lines.push('<text x="46" y="708" class="axis">Exact ratios; the tables mark which gaps clear the larger arm\'s run-to-run spread.</text>');
+lines.push(`<text x="46" y="726" class="axis">Method, spreads, graph sizes, admission receipts: docs/benchmarks/fork-vs-upstream-${date}.md</text>`);
+lines.push('<text x="46" y="762" class="axis">CodeGraph fork · bompus/codegraph · measured under the host benchmark lock</text>');
+lines.push('</svg>');
+writeFileSync(svgPath, lines.join('\n') + '\n');
+console.log(`wrote ${svgPath}`);
diff --git a/scripts/benchmarks/runtime/hyperfine-index-sync.sh b/scripts/benchmarks/runtime/hyperfine-index-sync.sh
new file mode 100644
index 000000000..17c225d02
--- /dev/null
+++ b/scripts/benchmarks/runtime/hyperfine-index-sync.sh
@@ -0,0 +1,145 @@
+#!/bin/bash
+# Hyperfine whole-command runner for the seven-corpus index/sync campaign.
+#
+# usage: BENCH_ARMS="base=<node>@<build> cand=<node>@<build>" \
+#          BENCH_OUT=<fresh-results-dir> \
+#          hyperfine-index-sync.sh <list-file>
+#
+# Each list line: <corpus-path> <rel-file-to-edit> <comment-prefix: // or #>.
+# For each corpus the arms run in mirrored order (base, candidate, candidate,
+# base). Each invocation builds a fresh, uniquely named .cg-bench-<campaign> with one Hyperfine run and
+# records the graph counts, then times two `codegraph sync` runs against that
+# index. Hyperfine's --prepare appends a unique marker before every sync
+# (hyperfine-append-probe.sh), so each run sees a one-file change. The probe
+# file must be tracked and clean; its original bytes are kept outside the repo
+# and restored after every arm and on exit.
+#
+# Peak RSS comes from Hyperfine's memory_peak_resident in the exported JSON.
+# This script does no host admission or locking; a campaign wraps it in the
+# host's benchmark lock and admission check.
+set -u
+HERE=$(cd "$(dirname "$0")" && pwd); . "$HERE/arms.sh"
+LIST=${1:?usage: hyperfine-index-sync.sh <list-file>}
+[ -f "$LIST" ] || { echo "list file not found: $LIST" >&2; exit 2; }
+if compgen -G "$BENCH_OUT/*-index.json" >/dev/null; then
+  echo "results directory already contains a Hyperfine campaign; use a fresh BENCH_OUT" >&2
+  exit 2
+fi
+WRAP_PREFIX=""
+((${#WRAP[@]})) && WRAP_PREFIX="${WRAP[*]} "
+# An exclusively owned index directory, never the corpus's own .cg-bench (which
+# may hold a real index and viewer trails). CODEGRAPH_DIR must be a plain name,
+# so the campaign id cannot contain a path separator.
+RUN_ID="$(date -u +%Y%m%dT%H%M%SZ)-$$"
+CG_DIR=".cg-bench-$RUN_ID"
+
+CURRENT_FILE=""
+CURRENT_BACKUP=""
+CURRENT_CM=""
+# True when the current file is exactly the original bytes plus the runner's
+# appended marker blocks. This compares bytes, not a diff: an added source line
+# such as `++ retries;` is `+++ retries;` in a diff and must not be mistaken for
+# a file header. The probe was clean at the start, so any other suffix is an
+# edit made while the benchmark ran.
+probe_only_runner_edits() {
+  local file=$1 backup=$2 cm=$3
+  local size
+  size=$(stat -c %s "$backup") || return 1
+  if ! head -c "$size" -- "$file" | cmp -s - "$backup"; then
+    return 1
+  fi
+  tail -c +$((size + 1)) -- "$file" | awk -v cm="$cm" '
+    { line[NR] = $0 }
+    END {
+      i = 1
+      while (i <= NR) {
+        if (line[i] != "") exit 1
+        if (line[i + 1] !~ ("^" cm " cg bench probe [0-9]+$")) exit 1
+        if (line[i + 2] !~ /^void_probe_marker_[0-9]+ = 1$/) exit 1
+        i += 3
+      }
+      exit 0
+    }
+  '
+}
+cleanup() {
+  if [ -n "$CURRENT_FILE" ] && [ -n "$CURRENT_BACKUP" ] && [ -f "$CURRENT_BACKUP" ]; then
+    # Never overwrite an edit another process made during the run.
+    if ! probe_only_runner_edits "$CURRENT_FILE" "$CURRENT_BACKUP" "${CURRENT_CM:-//}"; then
+      echo "probe changed by another process; not restoring $CURRENT_FILE; original bytes kept at $CURRENT_BACKUP" >&2
+    # Never delete the only copy of the probe's original bytes. A failed
+    # restore keeps the backup and says where it is.
+    elif cp -- "$CURRENT_BACKUP" "$CURRENT_FILE"; then
+      rm -f "$CURRENT_BACKUP"
+    else
+      echo "could not restore $CURRENT_FILE; original bytes kept at $CURRENT_BACKUP" >&2
+    fi
+  fi
+}
+trap cleanup EXIT INT TERM
+
+while read -r corpus file cm; do
+  [ -z "$corpus" ] || [ "${corpus:0:1}" = "#" ] && continue
+  NAME=$(basename "$corpus" | tr '[:upper:]' '[:lower:]')
+  cd "$corpus" || exit 1
+  git ls-files --error-unmatch -- "$file" >/dev/null 2>&1 || {
+    echo "probe file is not tracked: $corpus/$file" >&2; exit 2
+  }
+  if ! git diff --quiet -- "$file" || ! git diff --cached --quiet -- "$file"; then
+    echo "probe file has uncommitted changes: $corpus/$file" >&2; exit 2
+  fi
+  backup=$(mktemp "$BENCH_OUT/.probe.XXXXXX") || exit 2
+  # Register the backup only after it is a verified byte copy. A full results
+  # filesystem can leave mktemp's file empty or partial, and the EXIT handler
+  # would then copy that over the probe.
+  if ! cp -- "$file" "$backup" || ! cmp -s -- "$file" "$backup"; then
+    rm -f "$backup"
+    echo "could not back up probe file: $corpus/$file" >&2
+    exit 2
+  fi
+  CURRENT_FILE="$file"; CURRENT_BACKUP="$backup"; CURRENT_CM="$cm"
+
+  for arm in "${MIRRORED[@]}"; do
+    runtime=${RUNTIME[$arm]}; build=${BUILD[$arm]}
+    rm -rf -- "$CG_DIR"
+    hyperfine --warmup 0 --runs 1 --style basic --prepare "rm -rf -- $CG_DIR" \
+      --export-json "$BENCH_OUT/$NAME-$arm-$(date +%s%N)-index.json" \
+      "$WRAP_PREFIX""env CODEGRAPH_TELEMETRY=0 DO_NOT_TRACK=1 CODEGRAPH_NO_DAEMON=1 CODEGRAPH_ALLOW_UNSAFE_NODE=1 CODEGRAPH_DIR=$CG_DIR $runtime $build/dist/bin/codegraph.js init --yes ." \
+      >> "$BENCH_OUT/$NAME-index.txt" 2>&1 || exit 7
+    db=$CG_DIR/codegraph.db
+    printf '%s\t%s\t%s\t%s\t%s\n' "$NAME" "$arm" \
+      "$(sqlite3 "$db" 'select count(*) from nodes')" \
+      "$(sqlite3 "$db" 'select count(*) from edges')" \
+      "$(stat -c %s "$db")" >> "$BENCH_OUT/graph.tsv"
+    # A probe excluded by codegraph.json is silently absent from the index and
+    # every sync below would be a no-op. Reject the arm instead.
+    indexed=$(sqlite3 "$db" "select content_hash from files where path = '$file'")
+    [ -n "$indexed" ] || {
+      echo "probe file is not in the fresh index: $corpus/$file" >&2; exit 7
+    }
+
+    hyperfine --warmup 0 --runs 2 --style basic \
+      --prepare "bash $HERE/hyperfine-append-probe.sh '$file' '$cm'" \
+      --export-json "$BENCH_OUT/$NAME-$arm-$(date +%s%N)-sync.json" \
+      "$WRAP_PREFIX""env CODEGRAPH_TELEMETRY=0 DO_NOT_TRACK=1 CODEGRAPH_NO_DAEMON=1 CODEGRAPH_ALLOW_UNSAFE_NODE=1 CODEGRAPH_DIR=$CG_DIR $runtime $build/dist/bin/codegraph.js sync ." \
+      >> "$BENCH_OUT/$NAME-sync.txt" 2>&1 || exit 7
+    # The last sync must have stored the last appended bytes. A mismatch means
+    # the run timed an "already up to date" no-op (excluded file, failed watch,
+    # or a stale index), not a one-file sync.
+    file_hash=$(sha256sum -- "$file" | cut -d' ' -f1)
+    db_hash=$(sqlite3 "$db" "select content_hash from files where path = '$file'")
+    [ "$file_hash" = "$db_hash" ] || {
+      echo "sync did not process the probe: $corpus/$file" >&2; exit 7
+    }
+    if ! probe_only_runner_edits "$file" "$backup" "$cm"; then
+      echo "probe changed by another process during the arm: $corpus/$file; not restoring (backup: $backup)" >&2
+      exit 7
+    fi
+    if ! cp -- "$backup" "$file" || ! cmp -s -- "$file" "$backup"; then
+      echo "could not restore probe file: $corpus/$file" >&2; exit 7
+    fi
+    rm -rf -- "$CG_DIR"
+  done
+  rm -f "$backup"
+  CURRENT_FILE=""; CURRENT_BACKUP=""; CURRENT_CM=""
+done < "$LIST"