# Deeper plain trees d11 / d15 W2 on the Qwen GPTQ-2 7-card drafter: feasibility, GPU bars, golden v3, window commands (2026-11-17)

Program: the 7-card 4C1 drafter (ATT TP4 x4 + MLPV TP2 x2, talon2) for the Qwen3.8-27B target with the Qwen3.8-27B EAGLE-4 GPTQ-2 drafter (Q5120, A16).
Motto: a research track never ends by denying the idea; it engineers toward the fastest correct result, and claims nothing unmeasured.
Lever: an EXACT speed lever. It keeps the same algorithm and only drafts deeper (md 11 / 15 at W2). It is not draft-ahead and not an accuracy trade.
Rules kept: box1 work was CPU-only. No box1 GPU, no talon2 access, no card, no flash, no kills, no deletions.
Tags: **[M]** measured (file + md5 or command); **[R]** read from code (file:line); **[H]** hypothesis or model (only in the bar below).

> **Calculations and hypotheses (everything outside this bar is [M] or [R]).**
> - **Per-level card tree cost [H on M].** The W2 sweep ladder at ctx 45 is md2 3,751 / md3 4,514 / md5 6,231 / md7 8,481 us wall (`D7_TREE_LEVERS_20261117.md` 1.1). That is +0.946 ms per level. Extended linearly, md11 is about 12.3 ms and md15 about 16.1 ms. No Q5120 tree deeper than 7 has ever run on xsim or silicon.
> - **Accept at d15 [H].** The humaneval-80 hazard fit 0.92 % + 0.304 % x level (`DESIGN_FABLE_DRAFT_AHEAD_20261117.md:69`) gives a mean advance of 7.51 at d7 (measured 7.5075), 10.64 at d11 (the GPU measures 10.11) and 13.25 at d15. Scaled by the measured d11/d7 ratio, d15 is about 12.4-13.1.
> - **Round model [H on M].** Base: silicon humaneval-80, config 1, full+KI = 49.50 ms decode per round at 7.4166 (`he80full` jsonl md5 effb947a).
>   - In-RPC KV rows cost 1.27 ms each (draft-ahead doc). Fixed part = 49.50 - 7.42 x 1.27 = 40.1 ms.
>   - Round(d) = 40.1 + 0.946 x (d - 7) + accept(d) x 1.27.
>   - d11: 56.8 ms at 10.17, i.e. +19.6 % decode tok/s vs d7. d15: 64.3 ms at 13.1, i.e. +36 %.
>   - This is above the fable's +11 % / +16 % (which assumed other cost terms), and it ignores any change in GPU verify time with depth. The box1 GPU-only decode ms per round moved +2.9 % from d7 to d11 under demo contention, so that is not a clean measurement either.
>   - **The window rows below are the measurement. This bar is not.**
> - **mt_bench [H].** Each level costs about +0.95 ms per round whatever the accept. mt_bench's full-path rate is 2.9 %, so deeper trees likely cost mt_bench tok/s. A he4 + mt4 mix may not show the humaneval gain.

## 1. Answer

1. **Feasible on the admitted images: 13A9 / 139C ATT with the FR or non-FR MLPVs (13AA, 13E5, 139D, ...).** One window-procedure change is needed, and nothing is built.
   - The RTL ceiling is 15: MLPV MAX_DEPTH_HW 15, 904-node pool, 4-bit levels; ATT lane-chain slot = ctx + j*max_depth + i, 4-bit level.
   - The host already accepts depth 1..15.
   - The STAGE_SHA note "v0 serve limit md <= 8" is about the on-card KV_COMMIT path. The Qwen serve never uses that path. (Section 2.)
2. **Procedure change.** The cards must be armed at **depth 15 at the first bring-up after a cold AC**, and the golden must include md 15 (plan deepest first).
   - The PERSIST md ABI latches at the first AP_START. Arm refuses to raise the depth on a launched card, and the first tree must run at the armed depth.
   - So the existing config-3 bring-up (armed at 7) cannot serve d11/d15 without a new cold AC.
   - Script support: `w3bring_dn.sh` / `w3eager_dn.sh` (section 6).
3. **Context.** CTX_WIN is 768 and the host cap is 768 - 8*md: d7 712, d11 680, d15 648. humaneval:80 tops out at 691 tokens (prompt + completion).
   - One of 80 requests crosses the cap at d11 (11 completion tokens, 0.07 %) and at d15 (43 tokens, 0.28 %). That request finishes on GPU trees: still exact, just slower.
   - mt_bench:80 tops out at 489 and fits at every depth.
4. **GPU accept, humaneval:80, W2 V20, same drafter md5 ac46a65b [M]:** d7 7.3751, d11 **10.1145** (+37 %). These come from box1 11-16 runs that already existed; nothing new ran on the box1 H200.
   - talon2 d7 GPU-only: 7.3993 @ 326.83 tok/s.
   - d15 has no measurement yet. The talon2 runs are queued via `w3deep.sh` in the window-3 blackout gap; section 3 lists them as pending.
5. **Golden v3 is built and pinned.** It covers md 15,11,7,5,3,2 x W 2,8 for both classes on the same 8 prompts / rows / kv.
   - Every md 7/5/3/2 tree is identical to v2's (128/128 regions_md5).
   - The committed md 7,5,3,2 fingerprints recompute unchanged from v3: nonfr `e5718cec...`, fra8 `11c233e5...`. They are still served by v2, so their outputs are byte-identical.
   - New full-plan fingerprints: nonfr `710f8080b9521a9dd2fac0cefed5f272`, fra8 `371ac716c1880607fed295a85f5a4f83`.
   - Unit test 60/60; regression all green (section 4).

## 2. Feasibility, by item [R]

| item | md 11 | md 15 | where |
|---|---|---|---|
| MLPV tree depth ceiling | yes | yes | `verilog/forks/fourcard_4c1_qgptq2_mlpv_20261116/src_full/layers/tree_score_pkg.sv:86-87,104`: MAX_DEPTH_HW 15, N_MAX = 8 + 64·14 = 904, DEPTH_W 4. `tree_level_fsm.sv:92,166`: max_depth_i is the loop bound |
| ATT per-branch KV slot | yes | yes | `verilog/forks/fourcard_4c1_qgptq2_att_20261116/src_full/layers/kv_lane_chain.sv` (slot = ctx + j·num_steps + i, 12-bit); `top/eagle4_drafter.sv:4345` (level_i_w [3:0]), `:4408-4421` (num_steps = max_depth[10:0]); `top/top_fsm.sv:195` (level_i [3:0]) |
| KV_COMMIT 7-level limit (`STAGE_SHA` "v0 serve limit md <= 8", `DESIGN_ARCH_SHIFT.md:173,270`) | not used | not used | `eagle4_drafter.sv:4770-4772`: cm_n is 3-bit at DUAL_MODEL 0. The Qwen serve writes K/V only as host KV-only rows; `q5120_serve.py`, `q5120_hostkit.py` and `c4q5120_bridge.py` have no COMMIT_CFG / kvcommit path (grep) |
| host arm / tree | yes | yes | `c4_tp4.py:810` (depth 1..15); `c4_regmap.py:1530` QGPTQ2_MAX_DEPTH_HW 15; `c4_loop.py:313-317` (md <= armed depth; the first tree after arm runs at md == armed depth) |
| raising the depth after launch | refused | refused | `c4_tp4.py:812-816` (parked card: needs a cold AC, or `--accept-latched-depth` >= depth) |
| RoPE (2,048-position ROM) | 767 + 11 | 767 + 15 | `c4_regmap.py:1599-1610`: fine |
| ctx cap (`c4_loop.ctx_cap_for_md`, K_F 8) | 680 | 648 | `c4_loop.py:59-63` with `QGPTQ2_CTX_WIN` 768 (`c4_regmap.py:1501`). At W2 the RTL needs only ctx + 2·md - 1 <= 767 (754 / 746 / 738). A W-aware cap would be a host change and is not made here |
| bridge on ctx > cap | GPU tree for the rest of that request | same | `c4q5120_bridge.py:981, 1034` `_qg_dead("ctx>card_window")` |
| serve shape refusal | needs golden cover | same | `c4q5120_bridge.py:951-957`, `q5120_serve.py:882-883`: md must be in golden_q5120.json "mds". cardsrv `--md` = STEPS (`c4q5120_bridge.py:262`). Mock: cover None |
| verify budget VTOK | V20 >= 12 | V20 >= 16 | a full path is md drafted + root. V24 is an optional d15 arm |
| tree size at W2 | 42 nodes, 21 items | 58 nodes, 29 items | items = 1 + W(D-1); md7 W8 = 49 items already runs on silicon |
| W8 golden trees | 648 nodes | 904 nodes | ctx + 7·md + md - 1 <= 166 + 119: fine |

Limit, stated plainly: no Q5120 run on xsim or silicon has gone deeper than md 7. The md 11/15 silicon golden is the first proof that the deeper paths of these netlists are bit-true.

## 3. Measurements

### 3.1 GPU-only, existing box1 11-16 runs [M]
Recomputed with the same arithmetic as the talon2 summaries: accept = sum completion / sum spec_verify_ct.

| run (`/mnt/hdd_data/eagle4_scratch/qwen_gptq2_20261116/runs/`) | set | d / W / V | tokens / verifies | accept | md5 |
|---|---|---|---|---:|---|
| e4kc64_s_w2d7v20_20261116_041040 | humaneval:80 | 7 / 2 / 20 | 15,377 / 2,085 | **7.3751** | 52546198 |
| e4kc64_s_w2d11v20_20261116_035423 | humaneval:80 | 11 / 2 / 20 | 15,374 / 1,520 | **10.1145** | da5a130b |
| e4kc64_s_w2d11v20_20261116_044853 | mt_bench:80 | 11 / 2 / 20 | 17,062 / 4,240 | 4.0241 | 7173a1bb |
| talon2 qgserve_none_d7w2v20kc64_w3c1h_he80gpu (evidence copy) | humaneval:80 | 7 / 2 / 20 | 15,398 / 2,081 | 7.3993 @ **326.83 tok/s** | 95491610 |

- Drafter `drafter_kc64` md5 ac46a65b, config c23e2f73 is the same on box1 and talon2 (client logs).
- The box1 runs used `--max-running-requests 4` beside the demo (GPU 99 % busy at start), so their tok/s (132 / 172) is not a bar. Accept is.

### 3.2 talon2 runs (queued in `w3/w3deep.sh`, window-3 blackout gap): PENDING
GPU-only humaneval:80 at d7 / d11 / d15 V20 + d15 V24, mt_bench:80 at d7 / d15, and CARD=mock best stack at d11 / d15 (he4 + mt4). Results go here when the jsonls arrive. Then `draft_ahead_20261117/qwen_hit_rates.py` runs on the mock / silicon jsonls. It needs `trees_log`, so the GPU-only runs cannot feed it.

### 3.3 Bit-true reference, round 0, per prompt [M] (ref_v3 generator logs)
Accept = longest prefix of the GPU golden's continuation found among the survivors + 1. It is capped at md + 1.

| class / W | md 7 | md 11 | md 15 |
|---|---|---|---|
| nonfr = fra8, W2 (he0-3 / mt81-84) | 8 8 8 8 / 1 2 3 2 | 12 12 12 11 / 1 2 3 2 | **16 16 15 11** / 1 2 3 2 |
| nonfr = fra8, W8 | 8 8 8 8 / 1 3 3 2 | 12 12 12 12 / 1 3 3 2 | 16 16 16 16 / 1 3 3 2 |

humaneval round 0 still saturates at md 15 (W8: all 4 prompts; W2: 2 of 4). mt_bench round 0 does not grow with depth.

## 4. Golden v3 [M]

| file (repo `reports/results/QWEN_GPTQ2_20261116/golden_fp/`) | md5 | what |
|---|---|---|
| `qgptq2_golden_suite_nonfr_kc64_md15117532_v3.json` | `22888ca1c652a7d8a76193fcde2d0aea` | 8 prompts x md 15,11,7,5,3,2 x W 2,8 (96 trees) |
| `qgptq2_golden_suite_fra8_kc64_md15117532_v3.json` | `9dbd9a9186da83178116c462b7b1935d` | same, FR_A8 |
| `ref_v3_MD5SUMS.txt` | `38861e4ead50e7ae9854b62f0ab47a15` | manifest of `/mnt/hdd_data/eagle4_scratch/qwen_gptq2_20261116/golden_fp/ref_v3/` (16 refs + 32 bins) |
| `ref_v3_run.sh` | (= ref_v3/run.sh) | CPU-only generation: `CUDA_VISIBLE_DEVICES=` OMP 2, nice 15, 2 waves of 8 |
| `mock_nonfr_139C_139D_md15117532_golden.json` | `90fc61b71716267feef9bb6298c5162b` | mock-card golden, full v3 plan |
| `mock_fra8_13A9_13AA_md15117532_golden.json` | `6b848b1542e1fa3c62967ff945fe0f3e` | same, the window's FR pair |

- **Generator:** unchanged, `q5120_7c_golden_ref.py` md5 b316cbed, run with `--md 15,11,7,5,3,2 --widths 8,2 --kc 64`. Wall 83-177 s per (prompt, arm); 113-135 items computed per prompt.
- **Inputs:** all 32 rows / kv bins are md5-identical to ref_v2, hence to ref_v1. talon2's `~/eagle4_artifacts/qgptq2_golden/` copies already serve v3.
- **Code changes:**
  - `scripts/4c1/qgptq2/q5120_golden.py`: v3 added LAST in `QGPTQ2_GOLDEN_SUITE_VERSIONS` with md5 pins. `suite_for` still returns v1 for md {7,2} subsets and v2 for {7,5,3,2} subsets, so those outputs are byte-identical. Only a plan with md 11 or 15 reaches v3.
  - `scripts/4c1/golden_fp_gate.py`: 16 new `QGPTQ2_REF_FP` keys; the record path is untouched.
  - `scripts/4c1/tests/test_qgptq2_golden.py`: + the v3 section.

Fingerprints (`golden_fp_gate.QGPTQ2_REF_FP`, key (class, 64, mds, widths, 'kvonly')):

| plan | nonfr | fra8 |
|---|---|---|
| md 15,11,7,5,3,2 x W 2,8 (the window golden) | `710f8080b9521a9dd2fac0cefed5f272` | `371ac716c1880607fed295a85f5a4f83` |
| md 15,11,7,5,3,2 x W 2 (fallback / BEST 0x30 golden) | `a5e0ae95835665fb574eefc07c259560` | `d5ab9c39621df26abc298e52049cb08d` |
| md 15,11,7,5,3,2 x W 8 | `ac530058e55451b4b7038a681b276d0b` | `f61251dc71547f43ecccbc76801cfaeb` |
| md 15 W2 / W8 | `afcff551ced473ad4a08ca3ca7e7ab4a` / `815f2722736325e0c4647c5971f8217e` | `f6c5892a1c03f0dcaf3ba885de6b15f0` / `4531535ae21d6ce53ac15f9b0f87bf53` |
| md 11 W2 / W8 | `156a84ec379ae2089e038cf3e160403f` / `eb77dca10233ac07d48fc6c26a061177` | `60763d36223fb1bef40de9e1dd6f830f` / `b96ac60907da30367d100afafef05730` |
| md 15,11 W2 | `1c818dea1871223d367b050bcb6ad3e5` | `59f066f56187a6beb1331909f42c1656` |
| md 7,5,3,2 x W 2,8 (UNCHANGED, recomputed from v3) | `e5718cec624fb9cddfc34034a8c70419` | `11c233e5b3c832eabffc7bbf585d2b6c` |

Any other plan: `python3 -I scripts/4c1/qgptq2/q5120_golden.py expect --cls <c> --mds .. --widths ..`.

**Tests** (box1, eagle4 env; outputs in `/mnt/hdd_data/eagle4_scratch/qwen_gptq2_20261116/deeper_tree_20261117/`):

`test_qgptq2_golden.py`: **PASS 60/60** in 66 s (`--quick` 53/53). The new rows:

| row | result |
|---|---|
| suite_for | v1 / v2 unchanged; md 11 / 15 -> v3 |
| v3 vs v2 | same prompts / rows / kv; v2 trees == v3 (0 diffs); 12 shapes |
| beam prefix | md 11/7/5/3/2 r0 + r4 == md 15's first n slots (0 mismatches) |
| old fingerprints | the committed md 7,5,3,2 / 7,2 / single-md fps recompute from v3 unchanged |
| new fingerprints | 7 v3 keys per class == the expected fp |
| md15 W2 shape | n = 58 with 15 survivor levels (all 8 prompts) |
| GREEN | 139C+139D and 13A9+13AA, 96 trees each, through `gate_q5120` without `--ref-fp`; 13A9+13AA W2-only 48 trees; first tree md 15 |
| RED 13 | md-15 level-12 score fault: FAIL at level 12 on (15,2) + (15,8); cover [11,7,5,3,2]; plan_mds kept |
| RED 14 | md-11 level-10 token fault: FAIL at level 10; cover [15,7,5,3,2] |
| RED 15 | md-15 plan on a depth-7 arm: refused ("md 15 > PERSIST-armed depth 7") |
| RED 16 | depth-15 arm + a plan without md 15: refused (first-launch md ABI) |
| RED 16b | md 13: refused |

The pre-existing default-plan mock goldens (v1 and v2) are byte-identical to the committed files, timing dropped.

**Regression, all PASS:**
- record_profile_identity;
- golden_fp_gate record identity 111/111 under both eagle4 py and /usr/bin/python3 (old 662ab6cb vs new b0cb7527);
- `golden_fp_gate --selftest` (record + Q5120);
- q5120_hostkit;
- qgptq2_profile 160/0;
- hostguard 67/0;
- slot_geom;
- `test_q5120_serve --quick` 70/70.

Limit: the mock plants the reference tree, so it proves the host plumbing and the comparator at md 15, not the RTL. Round 0 only.

## 5. Scripts
- `reports/results/QWEN_GPTQ2_20261116/qgwin_20261116/w3/w3bring_dn.sh`: w3bring.sh plus arm depth (`DEPTH_ARM`, default 15), GMDS (default 15,11,7,5,3,2) and GWIDTHS (default 2,8). Bring-up is judged by `ARM OK depth $DA`, not the literal 7. A stub dry-run printed the remote strings, including `grep -q 'ARM OK depth 15'`.
- `w3eager_dn.sh`: w3eager.sh plus GMDS / GWIDTHS for the 0x30 golden in a new RBE.
- `w3deep.sh` (coordinator, 22d44a0f0): the gated GPU / mock runner for the blackout gaps.

## 6. Exact window commands

### 6.1 Off-card (queued in `w3deep.sh`; listed for the record)
```
S=/tmp/claude-1000/-home-y344shi-workspace-eagle4-adaptation-hardware-cleanup-EAGLE/5b98fbdb-fb52-4379-b9a1-d845b01dd68f/scratchpad
RB=/home/carrick/eagle4_talon2_4c1/runs/qgwin_20261117deep
FULL="EAGLE4_Q5120_KVBATCH=1 EAGLE4_Q5120_PREROOT=1 EAGLE4_Q5120_SKIP_GPU_TREE=1 EAGLE4_Q5120_STATS_EVERY=50 EAGLE4_Q5120_KVINTERLEAVE=1"; BEST="$FULL EAGLE4_Q5120_TREEPIN=1 EAGLE4_Q5120_PREPOISON=1"
$S/w3arm.sh $RB 0xE4B713A9 0xE4B713AA 7  20 none dt_he80gpu_d7  "" "" humaneval:80 0 0 49f488822
$S/w3arm.sh $RB 0xE4B713A9 0xE4B713AA 11 20 none dt_he80gpu_d11 "" "" humaneval:80 0 0 49f488822
$S/w3arm.sh $RB 0xE4B713A9 0xE4B713AA 15 20 none dt_he80gpu_d15 "" "" humaneval:80 0 0 49f488822
$S/w3arm.sh $RB 0xE4B713A9 0xE4B713AA 15 24 none dt_he80gpu_d15 "" "" humaneval:80 0 0 49f488822
$S/w3arm.sh $RB 0xE4B713A9 0xE4B713AA 11 20 mock dt_mockbest_d11 "SRV_PY=/usr/bin/python3 $BEST" "" humaneval:4,mt_bench:4 1 1 49f488822
$S/w3arm.sh $RB 0xE4B713A9 0xE4B713AA 15 20 mock dt_mockbest_d15 "SRV_PY=/usr/bin/python3 $BEST" "" humaneval:4,mt_bench:4 1 1 49f488822
```

### 6.2 Silicon d11 / d15 on 13A9 x4 + 13AA x2 (FR; the config-3 BEST pair, 117.35 @ d7)
- **Kit.** `X` = a kit staged from the commit that carries this doc (`stage_kits_talon2.sh <sha> ship`). It is needed because the v3 suites, the v3 pins and the gate table must be in both `kit_qgptq2_X` (golden) and `serve_q5120_X` (serve gate). ship/ and qgenv are unchanged, so `qgenv.sh.X` == `qgenv.sh.20298af07`.
- **Pair choice.** If config 4 (13A9 + 13A1) beats 13AA on d7 BEST, swap the MLPV. Same class (fra8), same fingerprints.
- **Precondition.** A cold AC with 13A9 x4 + 13AA x2 resident and NO launch since then. That means the w3cfg flash + guarded cold AC, or a re-cold-AC of the same images: config 3's cards are latched at depth 7.

```
S=/tmp/claude-1000/-home-y344shi-workspace-eagle4-adaptation-hardware-cleanup-EAGLE/5b98fbdb-fb52-4379-b9a1-d845b01dd68f/scratchpad
W=~/workspace/eagle4_adaptation/hardware/cleanup_EAGLE/reports/results/QWEN_GPTQ2_20261116/qgwin_20261116/w3
X=<kit sha>; A=0xE4B713A9; M=0xE4B713AA; T=humaneval:4,mt_bench:4
RB=/home/carrick/eagle4_talon2_4c1/runs/qgwin_20261118dt; RBE=${RB}e
FULL="EAGLE4_Q5120_KVBATCH=1 EAGLE4_Q5120_PREROOT=1 EAGLE4_Q5120_SKIP_GPU_TREE=1 EAGLE4_Q5120_STATS_EVERY=50 EAGLE4_Q5120_KVINTERLEAVE=1"; BEST="$FULL EAGLE4_Q5120_TREEPIN=1 EAGLE4_Q5120_PREPOISON=1"
# 1. bring-up armed at 15 + mode-0 golden, full plan (96 trees; diagnostic for W8 too)
$W/w3bring_dn.sh $RB $A $M $X "qdma status2 ident check bringup golden" 15 15,11,7,5,3,2 2,8
#    want: BRINGUP_DONE (... ARM OK depth 15); Q5120 GOLDEN PASS class fra8 96/96 ... fp 371ac716c1880607fed295a85f5a4f83; QG_GOLDEN_OK
# 2. EAGER/EARLY_A (0x30) golden for BEST, W2 only (the served width: a W8-only defect cannot block the d11/d15 serve)
$W/w3eager_dn.sh $RB $RBE $A $M $X 15,11,7,5,3,2 2
#    want: GOLDEN PASS ... 48/48 fp d5ab9c39621df26abc298e52049cb08d; mode_bits 48
# 3. serves, he4+mt4 (REF = the off-card mock jsonl at the same shape: bit-true card == bit-true mock => SAME 8/8)
D=/home/carrick/eagle4_talon2_4c1/runs/qgwin_20261117deep/serve      # the talon2 paths, resolved over the same ssh as w3arm.sh
MK11=$(timeout 60 $S/t2.sh "ls -t $D/qgserve_mock_d11w2v20kc64_dt_mockbest_d11_*.jsonl | head -1" </dev/null)
MK15=$(timeout 60 $S/t2.sh "ls -t $D/qgserve_mock_d15w2v20kc64_dt_mockbest_d15_*.jsonl | head -1" </dev/null)
$S/w3arm.sh $RB  $A $M 7  20 silicon dtc_d7off   ""      ""     $T 0 0 $X      # d7 off at the depth-15 latch (comparability row; needs step 1 PASS)
$S/w3arm.sh $RBE $A $M 7  20 silicon dtc_d7best  "$BEST" ""     $T 1 1 $X      # d7 BEST at the depth-15 latch (vs config 3's 117.35)
$S/w3arm.sh $RBE $A $M 11 20 silicon dtc_d11best "$BEST" "$MK11" $T 1 1 $X
$S/w3arm.sh $RBE $A $M 15 20 silicon dtc_d15best "$BEST" "$MK15" $T 1 1 $X
# 4. the deciding rows: humaneval:80 BEST at d7 / d11 / d15 (also the trees_log for the level 8-15 hazards)
$S/w3arm.sh $RBE $A $M 7  20 silicon dtc_he80_d7best  "$BEST" "" humaneval:80 1 1 $X
$S/w3arm.sh $RBE $A $M 11 20 silicon dtc_he80_d11best "$BEST" "" humaneval:80 1 1 $X
$S/w3arm.sh $RBE $A $M 15 20 silicon dtc_he80_d15best "$BEST" "" humaneval:80 1 1 $X
# then on box1: python3 reports/results/DRAFTER_SPEED_RESEARCH_20261107/draft_ahead_20261117/qwen_hit_rates.py <he80 jsonls> (stats beside them)
```

**Fallback.**
- If step 1 fails only on W8 trees: its RB carries NO_REARM and its golden_q5120.json is FAIL, so the mode-0 rows (d7off) do not run. Step 2 (W2 only) still gates the BEST rows independently. Read the tooth in `$RB/qg/golden_q5120.out`.
- If step 2 fails at md 15 but not at md 11: the cover keeps md 11, and the d11 rows still run (the serve refuses only shapes outside the cover).

## 7. Open items
- The d15 GPU accept and all tok/s at d11 / d15 on talon2: pending the w3deep arms.
- Silicon md 11 / 15: never run. The step 1 / 2 goldens are the first test of the deep paths on these netlists.
- A W-aware ctx cap (768 - 2·md at W2) would remove the one humaneval:80 request that falls back to GPU trees. It is a shared `c4_loop` host change and is not made here.
- mt_bench: deeper trees are expected to cost tok/s (top bar). Measure it with the mt_bench:80 GPU arms and the he4 + mt4 silicon rows, then choose the depth per task if the window shows a split.

## Silicon evidence from window 3 config 4 (box1-qwen-junior, appended 2026-11-17 23:4xZ)
Pair 0xE4B713A9 x4 + 0xE4B713A1 x2 (FR), kit 248efe09d, armed depth 15, talon2 boot 4df21ab2. Golden v3 fra8 96/96 fp 371ac716 (== ref); EAGER/EARLY_A W2 golden 48/48 fp d5ab9c39 (== ref). All serves d* W2 V20 K_C 64, BEST = KVBATCH PREROOT SKIP_GPU_TREE STATS_EVERY=50 KVINTERLEAVE TREEPIN PREPOISON + EAGER/EARLY_A. jsonl paths (talon2, md5[:8]):
- d7 off he4+mt4: runs/qgwin_20261117w3c04/serve/qgserve_silicon_d7w2v20kc64_w3c04a_off_20261117_230630.jsonl (0288ef95) 87.70 tok/s @4.0674
- d7 BEST: runs/qgwin_20261117w3c04e/serve/qgserve_silicon_d7w2v20kc64_w3c04c_best_20261117_231318.jsonl (a0a9a001) 115.04 @4.0674
- d11 BEST: runs/qgwin_20261117w3c04e/serve/qgserve_silicon_d11w2v20kc64_w3c04d_best11_20261117_231629.jsonl (33fba756) 115.43 @4.3362
- d15 BEST: runs/qgwin_20261117w3c04e/serve/qgserve_silicon_d15w2v20kc64_w3c04e_best15_20261117_231938.jsonl (ac0eff91) 107.14 @4.4513
- he80 d7 BEST: .../qgserve_silicon_d7w2v20kc64_w3c04f_he80best7_20261117_232253.jsonl (27ed05cd) 159.64 @7.4166
- he80 d11 BEST: .../qgserve_silicon_d11w2v20kc64_w3c04f_he80best11_20261117_232742.jsonl (832c8242) 170.75 @10.1652
- he80 d15 BEST: .../qgserve_silicon_d15w2v20kc64_w3c04f_he80best15_20261117_233231.jsonl (0c154edc) 181.79 @12.1405 (req65 2 rounds ctx>card_window GPU fallback)
d11/d15 `--same` vs the mock BEST jsonls: pending (the blackout deep runner's mock arms, runs/qgwin_20261117deep/serve/qgserve_mock_d{11,15}w2v20kc64_dt_mockbest_*).

### Deep GPU-only bars (CARD=none, talon2 H200, kit 49f488822, runs/qgwin_20261117deep/serve/, blackout gap 23:40-00:05Z, campaign idle/flashing)
| arm | tasks | tok/s | accept | jsonl (md5[:8]) |
|---|---|---|---|---|
| d7 V20 | humaneval:80 | 325.88 | 7.3993 (15398/2081) | qgserve_none_d7w2v20kc64_dt_he80gpu_d7_20261117_234051.jsonl (b2ef05d5) |
| d11 V20 | humaneval:80 | 408.39 | 10.2261 (15380/1504) | qgserve_none_d11w2v20kc64_dt_he80gpu_d11_20261117_234434.jsonl (01210921) |
| d15 V20 | humaneval:80 | **450.60** | 12.1983 (15382/1261) | qgserve_none_d15w2v20kc64_dt_he80gpu_d15_20261117_234819.jsonl (e6d6b3f7) |
| d15 V24 | humaneval:80 | 446.15 | 12.4349 (15382/1237) | qgserve_none_d15w2v24kc64_dt_he80gpu_d15_20261117_235203.jsonl (03546efa) |
| d7 V20 | mt_bench:80 | 182.13 | 3.8880 (17045/4384) | qgserve_none_d7w2v20kc64_dt_mt80gpu_d7_20261117_235552.jsonl (8f1d3875) |
| d15 V20 | mt_bench:80 | 168.70 | 4.0644 (17050/4195) | qgserve_none_d15w2v20kc64_dt_mt80gpu_d15_20261118_000041.jsonl (736b69fe) |
Silicon config 4 he80 BEST vs these: d7 159.64 / 325.88 = 49.0 %, d11 170.75 / 408.39 = 41.8 %, d15 181.79 / 450.60 = 40.3 %; accept silicon vs GPU d7 7.4166 / 7.3993, d11 10.1652 / 10.2261, d15 12.1405 / 12.1983. Mock BEST d11 / d15 (70-80 min each) did not fit before 00:58Z: PENDING for the next card-idle gap.
