# Draft-ahead (card drafts tree t+1 while the H200 verifies tree t): measured hit rates, what is exact, and the price of the inexact variant (2026-11-17)

Program 1: ONE drafter on the talon2 V80s (4 ATT + 2 MLPV), single stream, H200 verifies. Llama-3.2-3B bitnet_721 and Qwen3.8-27B GPTQ-2 W2A16.
Motto: a wall is a measured constraint to engineer around, toward the fastest flashable PDI. User directive: "make the drafter faster".
Fable design agent for box1-two-v2. Read-only study + stdlib replay. No build, flash, card access, GPU run, kill, move or removal. talon2: one read-only `tar` of serve logs, nothing run.
Rescoped mid-task by box1-two-v2: (1) verify that EXACT draft-ahead has hit rate 0; (2) the drafter-own-hidden variant is an ACCURACY TRADE (user ruling): quantify it, do not design toward shipping it; (3) use the window-2 / window-3 Qwen silicon logs; (4) list the exact overlap that remains.
Tags: **[M]** measured (file cited), **[D]** arithmetic on [M], **[P]** projection or assumption.
Short paths: `R/` = this directory, `E/` = `R/draft_ahead_20261117/`, `Q/` = `reports/results/QWEN_GPTQ2_20261116/`, `S/` = `scripts/4c1/`, `B/` = `scripts/qwen27b_open_release_20261102/c4q5120/`.

## 0. Answer first

1. **Exact draft-ahead has hit rate 0 by construction, on both models. Confirmed in code [M].** The next tree's root row is `embed[bonus token] | fc(target hidden of the last accepted node)`, and every KV row of an accepted token is built from the target's hidden of that token. All of these are outputs of the verify that draft-ahead wants to overlap. Citations in section 1. box1-qwen-junior's finding (`Q/D7_HOSTGAP_20261117.md:278-296`) is correct, and the same holds for Llama.
2. **The "hit rates" below are therefore hit rates of the INEXACT variant only** (root = the drafter's own leaf state; output tokens stay exact because the target still verifies, but trees and accept change). That variant is an accuracy trade and a user ruling. Nothing here is designed toward shipping it; sections 3-4 are its price list.
3. **Measured hit rates [M].**
   | drafter, set, config | full path accepted (upper bound of any single-path guess) | h1: on the best leaf and next token = drafter top-1 | h2: accepted path is a prefix of the best path | h3: 2 leaves x top-1 / x top-2 |
   |---|---:|---:|---:|---:|
   | **Qwen GPTQ-2 silicon, humaneval-80, d7 W2** (1,994 rounds) | **85.96 %** (1,714) | about 82-84 % [D] (leaf top-1 not observable; x 0.975-0.987 level-1 rate) | not observable (log holds level 1 only) | not observable |
   | Qwen silicon, mt_bench:4, d7 W2 (275 rounds) | 2.9 % (8) | <= 2.9 % | – | – |
   | Qwen silicon, he4 + mt4 mix, d7 (363 rounds) | 22.0 % (80) | <= 22 % | – | – |
   | Qwen silicon, humaneval:4, d5 / d2 | 89.5 % / 98.6 % | – | – | – |
   | Llama GPU fp16 drafter, humaneval 20 x 512, D = 7 (863 trees) | 41.6 % | **26.0 %** (224) | 57.2 % | 32.6 % / 35.5 % |
   | same, D = 11 | 23.5 % | **15.3 %** (132) | 50.3 % | 18.8 % / 20.2 % |
   - The ARCH_RETHINK fit for Qwen humaneval (0.86 full depth, hit 0.84) is now a measurement: 0.8596.
   - h2 buys nothing: when the accept stops inside the tree, the bonus token is by construction not a drafted child, so no resident node can be the next root.
   - A Qwen humaneval-80 silicon serve DOES exist (talon2 `runs/qgwin_20261117w3c01/serve/*he80full*`, copied to `E/evidence/`). The Llama 2-bit card drafter and Llama humaneval-80 still have no per-step log.
4. **Price of the inexact variant on Qwen humaneval-80 (replay of the 2,074 logged silicon rounds, section 3) [D on M, continuation accept is P].**
   | continuation accept assumption | tokens per verify | wall tok/s (measured base 140.15; replay base 140.7) | gain |
   |---|---:|---:|---:|
   | upper bound: a continuation tree accepts what the logged fresh tree accepted | 7.42 (unchanged) | 200.6 | **+42.6 %** |
   | hazard saturates at the level-7 value (what Llama's measured deep levels do) | 7.07 (−4.7 %) | 187.4 | +33 % |
   | hazard keeps its measured linear growth with depth | 6.31 (−15 %) | 160-164 | +14 to +16 % |
   | twice that slope | 6.10 (−18 %) | 155-157 | +10 to +11 % |
   - GPU-only on the same 80 prompts is 326.83 tok/s [M]. **Even the upper bound does not reach GPU-only** (200.6 / 326.8 = 0.61). The ARCH_RETHINK "36.5 → 25 ms" was on the he4 + mt4 round; on humaneval-80 the decode round is 49.5 ms [M] and falls to 33.5 ms at best.
   - Accept of a continuation tree is NOT-MEASURED for Qwen. Llama's measured analogue: a continuation collects 4.79 drafted tokens against 5.47 for a fresh tree at the same kind of position (−12 %), with a per-level hazard that is flat from level 3 to level 15 (section 2.2).
5. **Llama: unchanged verdict, marginal.** Hit 15.3 % at d11. `R/ARCH_RETHINK_7CARD_20261117.md:192-198`: +3.3 % at zero miss cost, break-even at 0.3 ms miss cost. It is the same accuracy trade.
6. **Exact overlap that remains is small: about 1.5-2 ms of a 49.5 ms Qwen round (<= 4 %) and nothing new on Llama** (section 5). The exact route to the same window is a faster verify-to-tree path: the in-RPC KV rows cost 1.27 ms each [D on M] and are 9.6 ms of a steady humaneval round plus 17.4 s of 102.7 s (16.9 %) as prompt rows; c5 KV_MROW addresses exactly that.
7. **One exact, config-only alternative has about the same modelled gain as the pessimistic draft-ahead rows: a deeper plain tree.** With the measured hazards extended linearly, d11 gives about +11 % and d15 about +16 % decode tok/s on humaneval [P], no RTL, same exactness regime as every depth sweep. It needs goldens at md 11 / 15 and a window. It and draft-ahead rest on the same unknown, the Qwen hazard at levels 8-15.
8. **Cheapest measurement that decides both (no card):** one `CARD=mock` (or GPU-only with a per-round trace) humaneval run at depth 15 on a free H200; `E/qwen_hit_rates.py` then prints the level 1-15 hazards. Recipe in section 6. Not run here: the box1 H200 belongs to the demo and talon2 is junior's.

## 1. Why the exact variant cannot hit [M, code]

| input of tree t+1 | Qwen GPTQ-2 path | Llama 7-card path | a verify-t output? |
|---|---|---|---|
| root token | `B/c4q5120_bridge.py:797-799` `r = ext.last[0]`, `tok = ext.tokens[r]` (extend buffers written by the verify's accept); first round `:808` `b.spec_info.bonus_tokens[0]` | `S/c4_cardproc.py:668` `drv.root_image(ids[n - 1], …)`, `ids` = the verify-extend gather's input ids | yes |
| root feature h_fc | `B/c4q5120_bridge.py:803-805` `_c4q_orig_ptf(inner, ext.input_hidden[r:r+1])` = fc(target aux hidden, 15,360) | `S/c4_cardproc.py:654,668` `entry = pm.get(S-1)`, `entry[1]` = the captured target 3H row; `scripts/fpga_tree_marshaller.py:1414-1428` | yes |
| KV rows of accepted tokens | `B/c4q5120_bridge.py:23-24` and `:1047,1059`: row j = `embed[tok_j] | fc(aux row j)` sent as KV-only rows | `S/c4_cardproc.py:659-663` `ses.add_rows(ps, k, v)` + `ses.sync`: K/V of the GPU drafter's extend on target features, imported by KV_LOAD | yes |
| ctx_len, md | host arithmetic | host arithmetic | known once the accept length is known |

- md5: `c4q5120_bridge.py` d169011d, `c4_cardproc.py` a6c31890, `c4_kvi.py` de1c40b5.
- What is already overlapped exactly: Llama launches the next tree at the verify-extend gather (`S/c4_cardproc.py:615`, record run 3,200 / 3,200 early launches, 0 misses, `reports/results/VERIFY_OVERLAP_SPECULATIVE_TREE_20261110.md:99`); Qwen writes the previous root's row in the idle window (PREROOT, 1.26 ms, `Q/D7_HOSTGAP_20261117.md:101`).
- So "predict the accepted endpoint" is not enough. Even a perfect guess of the endpoint lacks the target's hidden state there. Any tree drafted before the verify returns is rooted on something else.

## 2. Measured hit rates

### 2.1 Qwen GPTQ-2, silicon [M]
Source: `STATS["trees_log"]` of the serve bridge (`B/c4q5120_bridge.py:1125-1126`: request, ctx, root token, md, W, level-1 children) joined with the per-request `output_ids`. Advance per round = difference of consecutive root positions (accepted drafted tokens + bonus). Analyser `E/qwen_hit_rates.py` (md5 9ed11e89), output `E/qwen_hit_rates.out`. Asserted per round: root token == `output_ids[ctx − prompt_tokens]`.

| run (ATT + MLPV) | set | rounds (non-final) | advance histogram | full path | mean advance | level-1 accepted; by rank 0 |
|---|---|---:|---|---:|---:|---|
| `…w3c1g_he80full_20261117_154118` (0x13A9 + 0x13E5), d7 W2 V20 K_C 64 | humaneval 80 x 256 | 1,994 | 1:24 2:30 3:35 4:44 5:44 6:48 7:55 **8:1714** | **0.8596** | 7.5075 | 98.80 %; 98.73 % of those |
| `…w3c1b_full_20261117_152512` (same images) | humaneval:4 | 88 | 8:72 | 0.818 | 7.35 | 98.9 %; 98.9 % |
| same | mt_bench:4 | 275 | 1:64 2:69 3:52 4:33 5:21 6:22 7:6 8:8 | 0.029 | 3.03 | 76.7 %; 85.3 % |
| window 2 arm d `Q/d7_hostgap_evidence/silicon_w2/…w2d_fullki…` (0x139C + 0x139D) | he4 / mt4 | 88 / 276 | (8:72) / (8:7) | 0.818 / 0.025 | 7.35 / 3.02 | – |
| `…w3c1d_full5…` d5 | he4 / mt4 | 114 / 274 | – | 0.895 / 0.131 | 5.71 / 3.00 | – |
| `…hgd2_best…` d2 | he4 / mt4 | 219 / 361 | – | 0.986 / 0.540 | 2.97 / 2.33 | – |

- Evidence md5: he80full jsonl effb947a, stats ce4f729d, client.log 40448024; w3c1b jsonl 30afd4f3, stats 71a6a910. Copied from talon2 `/home/carrick/eagle4_talon2_4c1/runs/qgwin_20261117w3c01/serve/` (read-only tar, 35 jsonl + 31 stats kept at `/mnt/data/eagle4_scratch/draft_ahead_20261117/talon2_ro/`).
- Junior's "21.7 % full depth" (`Q/D7_HOSTGAP_20261117.md:183`) is the he4 + mt4 mix: 79 / 364. Split by task it is 81.8 % on humaneval and 2.5 % on mt_bench.
- Per-level stop hazard on humaneval-80 (stop at level l given level l reached): **1.20, 1.52, 1.80, 2.31, 2.36, 2.64, 3.11 %** for levels 1-7 [D]. It rises about 0.30 points per level (fit 0.92 % + 0.304 % x level). That rise is the only Qwen evidence on how a drafter-rooted continuation ages.
- Full-path rounds cluster: runs of consecutive full-path rounds have mean length 7.9, up to 31.
- Limits, stated plainly: the log holds level-1 children only, so (h1) "bonus = drafter top-1 below the leaf", (h2) and (h3) are not observable for Qwen; one mt_bench round shows advance 1 with the next token among the level-1 children (a stop-token case, 1 of 275). No per-step log exists for Qwen at depth > 7.

### 2.2 Llama [M, GPU fp16 drafter traces of 10-20; 2-bit card drafter: no per-step log]
Traces `/mnt/data/eagle4_scratch/4c1_spec_20261020/e1_traces/d3trace_he_d15_20261020_214838.jsonl` (863 trees) and `d3trace_he_d7_20261020_215113.jsonl` (1,099). Analyser `E/llama_hit_rates.py` (md5 c77f8504, reuses `S/d3_trace/analyze_overlap.py` e35292a5), output `E/llama_hit_rates.out`.

| | D = 7 | D = 11 |
|---|---:|---:|
| h1 (best leaf accepted and next token = drafter top-1) | 26.0 % (224 / 863) | 15.3 % (132 / 863) |
| h2 (accepted path, k >= 1, is a prefix of the best path) | 57.2 % | 50.3 % |
| h3, 2 leaves x top-1 (2 parallel continuations) | 32.6 % | 18.8 % |
| h3, 2 leaves x top-2 (4 continuations) | 35.5 % | 20.2 % |

- **Continuation accept, measured:** after an h1 hit at D = 7 the continuation (levels 9-15 of the same beam, rooted on the drafter's own state) collects **4.79** drafted tokens (48 % reach the 7-level cap). A FRESH d7 tree on the step after a full-accept step collects **5.47** (native d7 trace, n 491). The continuation is worth 12 % less per verify.
- **Hazard by level, d15 beam:** 5.5, 6.9, 13.0, 14.2, 15.2, 14.6, 12.7 % for levels 1-7 and 14.8, 12.1, 12.3, 14.0, 14.3, 8.6, 13.2, 12.3 % for levels 8-15. It is flat from level 3 on. A target-rooted tree is better only in its first two levels; drafting on the drafter's own state does not keep degrading.

## 3. The inexact variant as a decision input (Qwen)

### 3.1 What it is, stated once (not a shipping design)
While verify t runs, the cards (a) body-pass the best leaf of tree t, (b) take its top-1 child as the root, (c) draft a d-level tree below it on the K/V the tree's own path left in the lane-chain slots. If verify t accepts the whole best path and its bonus token equals that root, tree t+1 is already there and goes straight to verify t+1; the exact KV rows of round t are ingested lazily in the next window. Otherwise the result is dropped and today's serial round runs. It is the same computation as a 2x deeper tree whose beam collapses to its best node at the split, verified in two halves.
- Output tokens: exact in every case (greedy target verify decides them).
- Trees and accept: different from today's whenever a continuation is used. This is the accuracy trade.

### 3.2 Round costs used [M / D], all on the humaneval-80 silicon run
| constant | value | derivation |
|---|---:|---|
| decode per round, silicon | 49.50 ms | sum(wall − ttft) / 2,074 rounds, `he80full.jsonl` |
| decode per round, GPU-only | 20.11 ms | `…w3c1h_he80gpu….jsonl` (95491610), 2,081 rounds; wall 326.83 tok/s |
| TREE (card tree + IPC) | 9.32 ms | `…hgt_tim….stats.json` (f94e06ae): `srv.tree_ms` mean 8.73 over 363 rounds + (RPC − busy) median 0.60 |
| KVROW (one in-RPC KV-only row) | 1.275 ms | (t_card 53.35 s − 2,074 x TREE) / 26,685 in-RPC rows; the timing arm fits 1.20 ms |
| ROWB (bridge row build) | 0.158 ms / row | t_row 4.87 s / rows |
| REST (verify + scheduler + inject) | 21.43 ms | (decode − t_card − t_row) / rounds |
| prompt rows | 17.4 s of 102.7 s decode (16.9 %) | 13,630 rows x KVROW; mean prompt 171 tokens |
| CONT_X (continuation tree / plain tree) | 14 / 13 | one extra body pass for the leaf [P] |
- The replay's baseline reproduces the measured decode time to −0.42 % and the wall tok/s as 140.7 against 140.15.
- Window fit: deferred rows 8 x 1.275 + continuation tree 10.04 = 20.2 ms against REST 21.43 ms. It fits with 1.2 ms to spare, so the replay's miss wait is 0.0 ms in every arm. A hit round costs max(REST, window work).

### 3.3 Replay mock
`E/draft_ahead_mock.py` (stdlib; header documents policy and every assumption). It replays the logged rounds of each request on their real token stream and re-chunks them under the policy.
- Token check: in every arm and seed the concatenation of accepted chunks equals the logged `output_ids` (`chunks==output True`). Exactness of the output is structural; the mock proves the bookkeeping only.
- Continuation accept is the unknown. Four scenarios: `opt` (= the logged fresh tree's advance at that position; the replay stays on the logged round grid, so this arm is pure [D on M]), `flat`, `lin`, `lin2` (extra per-level stops from the hazard models of section 2.1 [P]). A continuation that stops early is followed by a serial fresh round up to the logged grid point (conservative).
- Chain cap C = how many continuation rounds may follow each other before a serial re-root.
- Outputs: `E/mock_he80.out`, `E/mock_mix_w3c1b.out`, `E/predictions.out`. Re-run: `cd E && python3 draft_ahead_mock.py evidence/qgserve_silicon_d7w2v20kc64_w3c1g_he80full_20261117_154118.jsonl`.

humaneval-80, 20 seeds, wall tok/s (base 140.7):
| scenario | C = 1 | C = 2 | C = 4 | no cap | hit per opportunity (no cap) | tokens per verify (no cap) |
|---|---:|---:|---:|---:|---:|---:|
| opt | 167.8 (+19.2 %) | 179.2 (+27.4 %) | 188.9 (+34.3 %) | **200.6 (+42.6 %)** | 0.839 | 7.42 |
| flat | 164.3 (+16.7 %) | 173.4 (+23.3 %) | 180.7 (+28.5 %) | 187.4 (+33.2 %) | 0.740 | 7.07 |
| lin | 160.3 (+13.9 %) | 163.7 (+16.3 %) | 163.2 (+16.0 %) | 162.5 (+15.5 %) | 0.548 | 6.31 |
| lin2 | 156.6 (+11.3 %) | 157.0 (+11.6 %) | 155.4 (+10.4 %) | 155.2 (+10.3 %) | 0.491 | 6.10 |

tok/s against hit rate (scenario opt, a logged full-path round hits with probability p): hit per round 0 → 140.7; 0.17 → 149.8; 0.35 → 160.5; 0.52 → 172.3; 0.69 → 186.2; 0.86 → 202.7. About +0.5 % tok/s per point of hit rate.

he4 + mt4 mix (`w3c1b`, base 107.7): opt +5.1 % (C = 1) to +8.6 % (no cap), hit per opportunity 0.12-0.18. The hazard scenarios are not meaningful on a two-task mix and are not quoted. **mt_bench alone is at most 2.9 % hits: no gain.**

### 3.4 Miss cost and the abort path [M code, U silicon]
- With the measured costs the window work ends before the verify returns, so a miss costs no wait and no abort on Qwen d7. Abort matters only if the continuation is deeper than the window.
- A safe mid-tree stop exists in RTL but not as a host abort. `loop_seq_d2.sv` (207c9b66, `verilog/forks/mlpv_cardstop_w8_20261113/tb/world/mlpv_cs1ad1/loop_seq_d2.sv`): TREE_STOP ends a tree at a level boundary (`:22-23` "stop -> W 0x174 = 1 + STOP msg", HEAD retires every issued level-(L+1) item, `:13`); the host can force it through `TS_VERDICT [1] stop` (`:68`, taken at `:315`) only when the card has raised `ts_req` (`:566-571`).
- **CARDSTOP_V is not an abort.** It moves the TREE_STOP mass verdict onto the card for W != 2 (`:96-103`, `S/c4_cardstop.py:2-13`), which removes the host's chance to answer. **ARM_DRAIN_V is not an abort either:** it drains outstanding AXI-lite master transactions before a re-ARM (`:105-108`, `:308-309`, `:379`). It is the piece that makes a re-arm after a stop safe (the re-arm race, memory `project_loopseq_rearm_race_and_d7_20261113`).
- The MLPV has a host STOP bit (`S/c4_regmap.py:768` TREE_CTL 0x174 [0]) that no kit path uses mid-tree. A host-initiated abort is NOT-MEASURED on any image.
- KV state on a miss, today's mechanism: tree rows live in lane-chain slots above `ctx_len` (`S/c4_kvcommit.py:10-11`, slot = ctx_hw + j x max_depth + l) and are never attended by the next tree; discarding a speculation is free and the next tree is byte-identical to a never-speculated run (measured on Llama 4C1, 0x12B1 + 0x128B, `reports/results/FOURCARD_DESIGN_20261016/SPEC_DRAFT_KV_LATCH_20261020.md:60-74`). Persistent rows are written only by host KV-only rows (Qwen) or KV_LOAD / COMMIT_PATH (Llama). Not re-measured on the Qwen 40 x 128 ATT images.

### 3.5 What the variant would need (spec level only, in case the user rules for it)
1. Loop sequencer: a CONTINUE arm rooted at a resident node (leaf body pass, then the tree below its top-1 child, K/V read from the lane-chain path slots). No array change.
2. MLPV: export of the leaf's top-1 token before the continuation (the host needs it to test the hit).
3. Host: queue of one pending tree; hit test = advance == md + 1 and bonus == exported token; lazy exact row ingest ordered before the next continuation; goldens for the continuation tree from a bit-true model (it is a deterministic function of the same inputs as today's tree t).
4. A host abort only if depth is pushed past the verify window.
First gate, before any RTL: the level 8-15 hazard measurement of section 6. Kill line from ARCH_RETHINK (`R/ARCH_RETHINK_7CARD_20261117.md:214`): humaneval hit rate below 0.4; measured 0.86, so the gate that remains is the continuation accept.

## 4. Llama
- Root and rows are verify outputs (section 1), so exact = 0 hits.
- Inexact variant, measured inputs: h1 26.0 % at d7, 15.3 % at d11; continuation worth 4.79 against 5.47 drafted tokens.
- Gain: `reports/results/VERIFY_OVERLAP_SPECULATIVE_TREE_20261110.md:120-128` models d11 at +2.5 to +5.3 % (extrapolated tail); `R/ARCH_RETHINK_7CARD_20261117.md:192-198` gives +3.3 % at zero miss cost on the 961.43 record and break-even at a 0.3 ms miss cost. No new Llama number is claimed here.
- The verify is 3.45 ms and a d11 tree 2.0-2.6 ms, so the window is tight and a miss can cost real wait, unlike Qwen.

## 5. Exact overlap that remains (same trees, same accept)
| item | status | ceiling per Qwen d7 round | source |
|---|---|---:|---|
| PREROOT: previous root's row written in the idle window | on | 1.26 ms (taken) | `Q/D7_HOSTGAP_20261117.md:101` |
| EARLY (extend rows sent at prelaunch) | built, default off | 0.30-0.40 ms | same `:33` |
| ROWVEC / TREEPIN / PREPOISON | built | 0.40-0.57 / <= 0.60 / about 0.1 ms | same `:31-34` |
| cfg + loop-register pre-write in the idle window | not built | <= 0.2 ms | same `:287` |
| pre-quantised embedding half of every row (static Q4.12 table instead of gather + q16 per round) | not built | <= about 1.0 ms: (t_row 2.35 − t_fc 0.32) x the emb share; overlaps ROWVEC | [D] he80 stats |
| prefetch of top-k bonus candidates | no ceiling | 0 | on a mid-tree stop the bonus is by construction not a drafted child; on a full path it is a child of the never-forwarded leaf |
| KV rows of predicted tokens during verify | impossible exactly | 0 | row = f(target hidden) |
| batch-2 ping-pong | preserved lever | aggregate only, not single stream | policy |
- Sum of what is still open and exact on the host: about 1.5-2 ms of 49.5 ms. Llama: the early launch and VERIFY_PRE (0.506 ms / step) are already in the record.
- The exact way to shrink the same gap is the row and tree time itself. On humaneval-80 the card RPC is 25.7 ms per round [M]: about 9.3 ms tree, 8.3 ms steady rows, 8.4 ms amortised prompt rows [D]. c5 KV_MROW (one sweep for N rows, `Q/DESIGN_C5_MULTIROW_KV_20261117.md`) attacks 16.7 of those 25.7 ms; no draft-ahead variant touches the prompt rows.

## 6. One measurement decides the continuation accept and the plain-depth alternative
- Needed: Qwen GPTQ-2 advance histogram at depth 15, humaneval. It gives the hazard at levels 8-15 directly.
- Predictions to test (`E/predictions.out`) [P]: mean tokens per verify of a plain W2 tree at d7 / d11 / d15 = 7.51 / 10.69 / 13.49 (flat), 7.51 / 10.64 / 13.25 (lin), 7.51 / 10.60 / 13.00 (lin2). The means are close; the histogram separates them (level-15 hazard 3.1 % / 5.5 % / 7.9 %).
- Recipe for box1-qwen-junior (their kit, their window; nothing modified here): the window-3 launcher `Q/qgwin_20261116/w3/serveW3_remote.sh` with `CM=mock QS=15 QV=36 TK=humaneval:80` (mock = CPU bit-true card model + real target, writes `trees_log`), then `python3 E/qwen_hit_rates.py <arm>.jsonl`. If the mock is too slow at d15, `CM=none QS=15` plus `QS=11` gives the two means only. About 5 minutes of H200 each. `QV=36` is my guess for the verify-token budget at d15 (20 at d7, 16 at d5); junior should set it.
- Plain depth as the exact alternative [P]: steady round = REST + rows + tree with tree linear in depth. d7 187 → d11 213 → d15 224 tok/s steady; with prompt rows 149 → 167 (+11 %) → 174 (+16 %) decode tok/s. Needs goldens at md 11 / 15 (golden cover today: 2, 3, 5, 7) and the ctx window check.

## 7. NOT-MEASURED
- Accept of a continuation tree on Qwen; any Qwen per-step log beyond depth 7; (h1) leaf top-1, (h2), (h3) for Qwen.
- Llama hit rates on the 2-bit card drafter and on humaneval-80 x 256.
- A host-initiated mid-tree abort on any image; lane-chain discard and COMMIT_PATH on the Qwen ATT images.
- Tree time against depth on Qwen silicon beyond d7 (linear is assumed in section 6).

## 8. Files
`E/qwen_hit_rates.py` 9ed11e89, `E/llama_hit_rates.py` c77f8504, `E/draft_ahead_mock.py` (md5 in `E/MD5SUMS.txt`), outputs `E/*.out`, `E/mock_constants.json`, evidence copies `E/evidence/` (md5 in `E/MD5SUMS.txt`).
