# Raising K_C above 64 on the 7-card set (COMBO3 0xE4B713D6 x4 + M1361 0xE4B71361 x2): hardware support, price, and the K_C window plan (2026-11-16)

Program 1: the 7-card Llama-3.2-3B 2-bit EAGLE4 drafter on talon2 (ATT TP4 COMBO3 on 17/3d/bd/e1, MLPV M1361 e24deb3f on 50/63, H200 verify).
Motto: a track does not end by denying the idea. "Enable higher candidate count to get more acc" (user, 2026-11-16) is treated as an engineering problem. Below are the measured price and the window that measures the rest.
Scope (coordinator, 2026-11-16): the depth x width grid at K_C 64 is ALREADY RUNNING on talon2 (box1-two-v2: `runs/acwin_20261116b/dw_sweep/`, doc `DW_SWEEP_7CARD_COMBO3_20261116.md`). This doc covers the K_C > 64 part. Its D x W content is limited to what was measured before the grid and how to pick the K_C cells from the grid. Section 4 part A is kept only as the reference ROUNDS for cells the grid may not cover.
Research worker for box1-two-v2. Read-only plus create-only. talon2 was not touched (no ssh to talon2, no card, no lock). buildx04 got one read-only grep. Nothing was flashed, killed, moved or removed.
Tags: **[M]** measured (the artifact is named) · **[D]** derived / modelled. Every [D] number is in the first section.

## Calculations and hypothesis (every projection in this doc is here)

- **D1. Base.** COMBO3 W2 d11 = 961.43 tok/s, 2,839 steps, 19,615 tokens. That is 20.40 s per run, or **7.186 ms/step**.
- **D2. K_C cost per verify step, from the 0x13BC + M1361 window of 11-12** (`accept_gap_20261112/silicon/serve_ag/SUMMARY.tsv` md5 26bb71b9: time_s / steps).
  - The reference is 7.436 ms/step.
  - K_C 128 adds **+0.179 ms**.
  - K_C 256 adds **+0.863 ms**.
  - With TREE_STOP off, K_C 256 vs 64 adds **+1.222 ms**.
  - Per W=2 item (7.40 / 7.32 forwarded levels x 2 items): **+12 us at K_C 128 and +59 us at K_C 256 (about 800 / 3,890 cycles at 66 MHz)**.
  - The 64 -> 128 step is cheap because the G8 window (2,969 cycles per item at K_C 64) is still mostly hidden under TREE (2,224 cycles per item; M1361 census, `TREE4_SILICON_RCA_20261114.md:73-76`). Past about 128 every extra candidate is exposed.
  - Marginal slope 128 -> 256: **5.34 us per candidate per step = about 24 cycles per candidate per item.**
- **D3. K_C 512 has never run on silicon.** Extrapolating that slope gives +2.23 ms/step. The G8 cycle law gives +2.0 ms. **Range used: +2.0 to +2.2 ms/step.**
- **D4. Steps.**
  - At TREE_STOP on and theta -2.5 [M]: K_C 128 / 256 = 2,851 / 2,857.
  - K_C 512 at theta -2.5: about 2,860 [D].
  - With theta re-tuned so the stop pattern matches K_C 64 (D5): about 2,836. This uses the stop-off K_C gain of -3 steps [M: tz1 2,806 -> kz1 2,803].
- **D5. Theta re-tune per K_C.** A larger K_C lowers every per-parent softmax.
  - Measured shift on silicon: **-0.020 bits per level at K_C 256** (`DESIGN_FABLE_ACCEPT_NOLEVEL_20261112.md:275-283`).
  - The replay maps theta -2.65 at K_C 256 back to the K_C 64 / theta -2.5 stop pattern (same doc, S3).
  - Derived values: **K_C 128 -> theta -2.58** (stop share 0.5641 vs 0.5525 => about 0.01 bit per level). **K_C 512 -> theta -2.72** (extrapolated 0.025-0.03 bit per level).
- **D6. Modelled tok/s on COMBO3, W2 d11**, = 19,615 / (steps x (7.186 + delta) ms):

  | K_C | delta ms/step | TS1, theta -2.5 | TS1, theta re-tuned | accept (TS1 -2.5 / re-tuned / twin ceiling) |
  |---|---|---|---|---|
  | 64 | 0 [M] | 961.4 [M] | — | 6.91 [M] |
  | 128 | +0.179 [M on 0x13BC set] | **934.1 (-2.8 %)** | 939.0 (-2.3 %) | 6.88 [M] / ~6.92 / — |
  | 256 | +0.863 [M on 0x13BC set] | **852.9 (-11.3 %)** | 859.2 (-10.6 %) | 6.87 [M] / ~6.92 / 6.95 |
  | 512 | +2.0..2.2 [D3] | **728-747 (-22..-24 %)** | 734-753 (-22..-24 %) | ~6.86 / ~6.92 / ? |

  - "Twin ceiling" is the extra the silicon would gain if it matched its GPU twin: 15 steps, 2,839 -> 2,824 = 6.95.
  - COMBO3 makes the ATT side faster, which leaves the MLPV G8 more exposed. The deltas could therefore be LARGER on COMBO3. The sweep measures them.
- **D7. Break-even.** One verify step = 0.035 % tok/s.
  - K_C 128 must save about 80 steps (accept >= 7.11) to pay for its +2.4 % ms/step. That is above the whole 63-step gap to GPU-only (7.05).
  - **On these images no K_C > 64 can win on tok/s, even if it closed the entire accept gap.** It is an accuracy-for-speed trade, and that is a USER ruling (as K_C 32 was).
- **D8. Hypothesis for the open finding.** On the GPU twin, K_C 256 recovers 15 of the card head's 18 steps. On silicon it recovers 3. Candidate causes:
  - the card's cheap-stream prefilters (the vs_link parity merge prefilter, the tiler threshold);
  - or the bridge bound: `kc_en` = ACCFIX bit2. The K_C-uniform denominator shift seen on silicon implies kc_en is on, but 0x15C has not been read on the MLPVs.
  - Neither has been measured. B0 below discriminates them with GPU time only.
- **D9. Wall time.** Rounds measured on this kit: 65 s per round at W2 d11, 69 s at W4 (start-to-start, box1 `/var/tmp/box1two_scratch_20261116/d6_w2.log`, `d6_w4.log`). Assumed 70-75 s for K_C 512.
  - **K_C part only (B0-B5): 28 serve rounds + 6 K_C goldens + 4 GPU-only twin cells = about 45 min warm** (right after the grid, same boot, T4_GOLDEN_OK present).
  - +25 min per hang recovery (cold AC + bring-up). **Budget 1 h 15 min.**
  - Part A, had it been needed: 42 rounds, about 50 min.

## 0. Answer first

1. **Every K_C from 1 to 512 is a runtime register on the current images. No rebuild is needed.**
   - MLPV `0x150 kc_cfg` defaults to 0, which means the compile K_C, **`EAGLE4_G8_K_C 512`**.
   - Values above 512 silently clamp to 512.
   - The ATT image COMBO3 never reads K_C.
   - K_C 128 and 256 already ran clean on M1361 [M]. K_C 512 has xsim arms MATCH on the G8_OWN source but has never run on silicon.
2. **Prior K_C > 64 data on 7 cards exists and is negative on tok/s** [M, 0x13BC x4 + M1361, d11 W2, 11-12]. With TREE_STOP on, accept FALLS:

   | K_C | tok/s | accept | steps | texts |
   |---|---|---|---|---|
   | 128 | 903.45 (-2.78 %) | 6.88 | 2,851 | record 1b0779cf |
   | 256 | 827.13 (-11.0 %) | 6.87 | 2,857 | 1b1e44c1 |
   | 256, TS off | 760.59 (-18.1 %) | 7.00 | 2,803 (-3 vs K_C 64 TS off) | |

   - Cause, measured: the per-parent softmax runs over K_C candidates. It shifts scores by -0.020 bits per level, so TREE_STOP fires earlier.
   - K_C 32 bought +1.19 % for -0.015 accept.
3. **Shortlist share of the 6.91 vs 7.05 gap (63 steps)** [M]:

   | term | steps | share |
   |---|---|---|
   | TREE_STOP | 33 | 52 % |
   | card cheap head x K_C 64 (GPU twin) | 18 | 29 % |
   | 3 text-divergent requests | 12 | 19 % |

   - With the fp head, K_C makes no difference: GPU K_C 64 = 128 = 256 = 2,776 steps.
   - On the GPU twin, the card head at K_C 256 recovers 15 of its 18 steps. **On silicon, K_C 256 recovers only 3.** That gap is the open item. B0 below is its cheapest probe: GPU-only twin captures plus `kc_cap_compare.py` on the captures already on disk.
4. **Cost.** See D6: about -2.8 % / -11 % / -23 % tok/s at K_C 128 / 256 / 512.
5. **The K_C sweep runs on the current images with host env only: K_C 128 / 256 / 512 are runtime-settable (MLPV 0x150 via `EAGLE4_TREE_KC` = ROUNDS field 6), with no flash and no rebuild.** It can be queued right after the D x W grid on the same boot. I added three create-only kit files:
   - `kcdw_serve_w.sh` / `kcdw_steps.sh`, which add per-round K_C, TREE_STOP, width, VTOK and theta fields to the frozen ATT-combo window scripts, a post-round K_C check and a `kcgolden <kc>` phase;
   - `kcdw_mk_head512.sh` for the twin arm.

   No build spec is needed below K_C 512. Section 6 lists what would make a higher K_C pay.

## 1. What the images support [M of the RTL / host, file:line]

Fork provenance (derived from the stage records, not memory):
- **MLPV M1361**: `/mnt/models/stage_E4B71361/STAGE_SHA_E4B71361.txt`, fork `forks/mlpv_g8_own_20261111` v3 on parent `fourcard_4c1_mlpv_tp4_20261109` (the 0x134D source).
  - Staged tree: `/mnt/data/eagle4_scratch/mlpv_g8own_20261111/4c1tp4_1361_g8own_mlpv_stage/forks/tail_fgi_20260930/src_full`.
  - md5s: drafter 845ca21c, config c7c25ed2, rescore 2cb84fc7, own_link ffd8d5b9, bridge 2768551a, control_regs 2172ed4d. Deriver `scripts/4c1/hedge/derive_1361_g8own.py`.
- **ATT COMBO3**: `combo3_20261113/DERIVATION_COMBO3.txt` (8e15bb02). Stage `lutg_d9_tp4stk_D6_stage` from the 0x13BC BC stage, fork `forks/head_hxf_cons/src_full`, = 0x13BC + G5_P2W 8 + R3_EARLY 1 + KV1H2C 1 + HANDOFF_CUT 1.

| item | value | evidence |
|---|---|---|
| compile K_C (max) | **512** | `eagle4_config.svh:875-876` `EAGLE4_G8_K_C 512` |
| runtime K_C register | MLPV `0x150 kc_cfg[15:0]`, reset 0 (= 512), read-back | `control_regs.sv:177,693,923,1164`; `eagle4_drafter.sv:1239-1241` |
| clamp | `kc_eff = (kc_cfg == 0 \|\| kc_cfg > K_C) ? K_C : kc_cfg`, sampled per item at G8 launch (`kcq <= kc_eff`) | `g8_rescore_p.sv:542-543,1604` |
| G8 buffers | `sel_score / sel_idx [0:K_C-1]`, `rescored[]` sized at K_C 512; the FG8 frontier has n_rows `[$clog2(K_C):0]` | `g8_rescore_p.sv:548-549`; `g8_spec_frontend.sv:60,82` |
| softmax bridge bound | follows kcq only when `accfix_kc_en` (= `ACCFIX_KC_P` 1 AND 0x15C bit2); otherwise it sweeps all 512 | `tree_softmax_bridge.sv:374-375,621`; `eagle4_drafter.sv:1249,5483`; `eagle4_config.svh:937-938` |
| G8_OWN link payload | `ceil(kcq/7)` score beats per item (NE 7, WIN 32): 10 / 19 / 37 / 74 beats at K_C 64 / 128 / 256 / 512; kcq field `[$clog2(K_C):0]` = 10 bits | `mlpv_g8_own_link.sv:14,33,49,60` |
| both MLPVs must hold the same K_C | unequal kcq misaligns the score beats with the next G9 exchange (audit M1) | `mlpv_g8_own_link.sv:14-15`; host writes both, `c4_loop.py:354-355`, `c4_hx7.py:471-472` |
| ATT side | G8_* straps are inert on PIPE_ROLE 1 (module absent from the ATT netlist); the host writes 0x150 only to MLPVs | `ATT_CARD_CONSOLIDATION_20261109.md:357`; `c4_loop.py:354` |
| host knob | `EAGLE4_TREE_KC=$KC` (runner `KC=${KC:-64}`); window kit ROUNDS field 6 | `scripts/4c1/run_4c1_sglang.sh:36,99`; `attcombo_20261116/ship/ac_serve_w.sh:19,37,49` |
| xsim at K_C > 64, G8_OWN source | 128 / 256 (plain, stressed LAT 200 JIT 40 SKEW 300, LAT 0): **8/8 walks MATCH**, slot / rescore / frontier mismatches 0, beats 19 / 37 both cards, own_sum = K_C; K_C 512 MATCH (11-11) | buildx04 `/shared/scratch/mlpv_g8_own_20261111/arms/k4_*/vs.out` (read 2026-11-16, XSIM_EXIT 0, end 00:15-00:18Z 11-13); `AUDIT_MLPV_G8_OWN_20261111.md:133,262` |
| tree width | RTL `TREE_WIDTH_MAX 8`, runtime `0x1CC tree_width[3:0]` 1..8, latched per tree | `eagle4_config.svh:821-822`; `control_regs.sv:835,1052` |
| host width gate | W > 2 refused (rc 61) unless `EAGLE4_4C1_ALLOW_WIDE=1` | `run_4c1_sglang.sh:48-49` |
| card-side TREE_STOP verdict | **only at W == 2**: at any other width, W=1 included, every level waits for a host verdict over PCIe | `common/rtl/loop_seq_d2.sv:516,528` (stage copy b086b6b0) |
| verify tokens | VTOK must be **D+1 at W=1**: SGLang refused V20 with a 12-node tree (rc 247, `can not run cuda graph ... verify_num = 12`); W>=2 at d>=7 has >= 27 nodes, so V20 is fine | `DESIGN_FABLE_ACCEPT_NOLEVEL_20261112.md` S2 row wc1 |

Unknown to close (one read-only MMIO): MLPV 0x15C bit2 (kc_en). [D] It is on, because the K_C-uniform score shift seen on silicon needs the bridge to normalise over kcq. Read 0x15C on 50/63 with `c4 status` or `read` before B.

## 2. Measured cells already in hand (do not re-run) [M]

| set | cell (humaneval 80x256, fa3 fg4 cp1, V20) | tok/s | accept | steps | texts | source |
|---|---|---|---|---|---|---|
| **COMBO3** boot 79cc9d1b | W2 d11 TS1 K_C 64 | 960.23 / 960.97 / 963.10 (KV1H2C off 955.22) | 6.91 | 2,839 | 1b0779cf | `ATT_COMBO_SILICON_20261116.md`; box1 `/var/tmp/box1two_scratch_20261116/d6_w2.log`, `d6_off.log` |
| COMBO3 | W2 d15 TS1 (smoke, 1 round) | 959.34 | 7.17 | 2,735 | 3c26f0b0 | `d6_smoke.log` |
| COMBO3 | W4 d11 TS0 | 792.67 / 792.32 | 7.20 | 2,715 | 54f88d49 | `d6_w4.log` |
| D5F 0x13DB (same MLPV) | W2 d11 / d15 / W4 d11 TS0 | 942.53 / 942.49 / 782.22 | 6.91 / 7.17 / 7.20 | | same texts as COMBO3 | `db_*.log` |
| 0x13BE + M1361 | W2 d11 TS1 | 938.94 | 6.91 | 2,839 | 1b0779cf | tracker 11-13 23:5x |
| 0x13BE + M1361 | W2 d11 TS0 | 887.36 | 6.99 | 2,806 | c1422a7e | `W4_SERVE_BOUND_20261115.md:213` |
| 0x13BE + M1361 | W3 d11 TS1 | 789.58 / 790.92 | 7.18 | | | tracker 11-14 12:07 (`4C1_DELIVERY_TRACKER.md:1735`) |
| 0x13BE + M1361 | W4 d11 TS1 / TS0 | 714.59 / 756.05 | 7.19 / 7.20 | 2,721 / 2,715 | 54f88d49 | `W4_SERVE_BOUND_20261115.md:210-211` |
| 0x13BE + M1361 | W8 d11 TS1 | 475.83 / 476.66 | 7.21 | | | tracker :1735 |
| 0x13BE + M1361 | W2 d15 TS1 | 935.83 | 7.17 | | | tracker 11-14 02:45 |
| 0x13BC + M1361 | W2 d9 TS1 | 894.47 / 891.36 | 6.51 | 3,012 | a3f2c08a | `BEST_VS_BEST_GPU_20261112.md:19-21` |
| 0x13BC + M1361 | W3 d11 TS1 | 782.20 / 787.55 | 7.18 | 2,724 | | tracker :1681 |
| 0x13BC + M1361 | K_C 128 / 256 / 256 TS0 (W2 d11) | 903.45 / 827.13 / 760.59 | 6.88 / 6.87 / 7.00 | 2,851 / 2,857 / 2,803 | 1b0779cf / 1b1e44c1 / a2cc35a1 | `accept_gap_20261112/silicon/ag_table.txt` |
| 0x13BC + M1361 | W1 d11 V12 / d15 V16 TS1 | 719.34 / 720.03 | 5.59 / 5.83 | 3,506 / 3,365 | baf31f4e | `DESIGN_FABLE_ACCEPT_NOLEVEL_20261112.md` S2 |
| GPU-only (same H200) | d9 / d11 / d13 fa3 | 841.27 / 825.91 / 778.82 | 6.63 / 7.05 / 7.26 | 2,960 / 2,776 / 2,696 | | `BEST_VS_BEST_GPU_20261112.md`; `F3T_CONFIG_SWEEP_20261109.md:122` |

- Texts and steps are identical across ATT images at the same MLPV and config: COMBO3 / D5F / 0x13BE all give 1b0779cf at W2 d11 and 54f88d49 at W4 TS0. So **accept and steps carry over from 0x13BE / 0x13BC cells; tok/s does not.**
- **Has W3 run on 7 cards?** Yes, with TREE_STOP on: 0x13BC 11-13, 0x13BE 11-14, and SIBW B3 11-13 (728.79 serial). **W3 with TREE_STOP off: never. W3 on COMBO3: never.**
- **W > 4:** W8 ran (0x13BE, and C1 W8 427.4). W5-7 never ran. The RTL and host allow W up to 8 with ALLOW_WIDE.
- **Never measured on COMBO3:** W2 d7 / d9 / d13, W3 at any depth, W4 at d != 11, W1 at any depth, every K_C != 64.

## 3. Kit (create-only, `kcdw_20261116/ship/`)

| file | md5 | what |
|---|---|---|
| `derive_kcdw.py` | 1effaa1f | count-asserted derivation from the frozen window scripts (asserts `ac_serve_w.sh` 07602f90, `ac_steps.sh` 4b69ec38 = the talon2 `att_combo_20261116/` copies, MD5SUMS -c clean 13:29Z) |
| `kcdw_serve_w.sh` | b5f63650 | = `ac_serve_w.sh` + per-round fields, out dir `$RUN/serve_kcdw`, SUMMARY cols 16-20, post-round **KC_CHECK** (m1_kc_cfg EQUAL on 50/63 AND == round K_C, else NO_REARM_kc_* and stop). Diff `kcdw_serve_w.diff` (14cbe805) |
| `kcdw_steps.sh` | abebc903 | = `ac_steps.sh`; serve / smoke call kcdw_serve_w.sh; NEW phase **`kcgolden <kc>`** (record golden at that K_C; the 1st of the boot is that K_C's reference, the 2nd must match it; exact tooth; M1 read; NO_REARM on hang). Diff `kcdw_steps.diff` (e6b9bfb5) |
| `kcdw_table.py` | fc1b5092 | per-cell table (W, d, K_C, TS, theta, V) + anchor sequence; failed rows never averaged |
| `kcdw_mk_head512.sh` | 7ccaae5c | config-only K_C 512 clone of the card-head twin `ckpt/head256` (978541fb) for the GPU-only arm |

**Zero-install path:** the frozen `ac_steps.sh serve` ALREADY takes K_C as ROUNDS field 6 (`ac_serve_w.sh:37,49`). These run today with no new file, at W2, TS1 and theta -2.5 only:
- `bash $T2ROOT "STAGE=d6 RUNB=<run base> ROUNDS='a5:11:fa3:4:1:64 ka2:11:fa3:4:1:128 kb2:11:fa3:4:1:256 a6:11:fa3:4:1:64 k512n:11:fa3:4:1:512 a7:11:fa3:4:1:64' bash $TW/ac_steps.sh serve"`
- Use the 512 row only after a clean `kcgolden 512`, or accept the risk and place it last.

The kcdw files are needed for: theta re-tune, TS0, width, VTOK per round, KC_CHECK and kcgolden.

**ROUNDS syntax (kcdw):** `tag:depth:backend:fastglue:cudapack:kc:ts:width:vtok:theta`.
- Defaults: kc 64, ts 1, width $SW (2), vtok 20, theta -2.5. Old 5-field strings behave as before.
- Width > 2 adds `EAGLE4_4C1_ALLOW_WIDE=1` per round.
- `bash -n` is clean on both scripts. The field parser was unit-run on 4 sample rounds. Not yet run on talon2.

**Install** (box1, create-only, before the window; `T2` / `T2ROOT` / `TW` as in `WINDOW_RUNBOOK_ATTCOMBO_20261116.md:39`):

```
for f in kcdw_serve_w.sh kcdw_steps.sh kcdw_table.py kcdw_mk_head512.sh; do
  $T2 "f=$TW/$f; [ -e \$f ] && { echo EXISTS \$f; exit 3; }; cat > \$f; md5sum \$f" < reports/results/DRAFTER_SPEED_RESEARCH_20261107/kcdw_20261116/ship/$f
done
```

`E="STAGE=d6 RUNB=<this boot's run base, e.g. runs/acwin_20261116b> KTAG=kcdw"` (the keeper boot's env, `ATT_COMBO_SILICON_20261116.md` last line).

## 4. Window plan (cells ordered safe first, untested last; HANG RULE)

**HANG RULE (coordinator 11-13):** any rc != 0, errs != 0, KVRD_ABORT or KC_CHECK FAIL writes NO_REARM. The serve loop stops, and every later arm / golden / serve phase refuses on this boot.
- Next step is a **cold AC, then runbook steps 5-8** (drv qdma status2 ident, kvread, bringup with fp 51524c4f + tooth, d15 smoke).
- No re-flash is needed: COMBO3 is the keeper.
- Resume at the cell after the one that failed. Never re-arm onto a hung card.

**Before B**, if this boot has no T4_GOLDEN_OK: runbook steps 5-8. Then read 0x15C on 50/63 (section 1). **Part A below is box1-two-v2's running grid.** Do not re-run it. Its rows are listed only as kcdw ROUNDS for any cell the grid skipped. Pick C1 / C2 / C3 from the grid's table (`DW_SWEEP_7CARD_COMBO3_20261116.md`).

**Rounds:** 2 per new cell, the pass reversed on the second round (ABBA against drift), and a W2 d11 TS1 K_C 64 anchor `aN` between phases.
- W1 uses VTOK = d+1. Everything else uses V20.
- TREE_STOP per the measured rule: **TS1 at W <= 2, TS0 at W >= 3** (W2: TS0 887 vs TS1 936 = -5.2 %; W4: TS0 756.05 vs TS1 714.59 = +5.8 %, `W4_SERVE_BOUND_20261115.md:210-227`).
- W1 also takes the host verdict (loop_seq W != 2), so A4 adds a W1 TS0 probe.

| phase | cells (new, x2 unless noted) | risk class | command (`bash $T2ROOT "$E ROUNDS='...' bash $TW/kcdw_steps.sh serve"`) |
|---|---|---|---|
| A1a (grid) | anchor; W2 d9, d13, d7 TS1; W2 d15 TS1 (x1, plus the smoke = 2); W4 d9, d13, d7, d15 TS0 | paths run today on COMBO3 (W2 TS1 card stop at d11 / d15; W4 TS0 at d11) | `a0:11:fa3:4:1:64:1:2:20:-2.5 w2d9a:9:fa3:4:1:64:1:2:20:-2.5 w2d13a:13:fa3:4:1:64:1:2:20:-2.5 w2d7a:7:fa3:4:1:64:1:2:20:-2.5 w2d15b:15:fa3:4:1:64:1:2:20:-2.5 w4d9a:9:fa3:4:1:64:0:4:20:-2.5 w4d13a:13:fa3:4:1:64:0:4:20:-2.5 w4d7a:7:fa3:4:1:64:0:4:20:-2.5 w4d15a:15:fa3:4:1:64:0:4:20:-2.5 a1:11:fa3:4:1:64:1:2:20:-2.5` |
| A1b (grid) | second pass, reversed | same | `w4d15b:15:fa3:4:1:64:0:4:20:-2.5 w4d7b:7:fa3:4:1:64:0:4:20:-2.5 w4d13b:13:fa3:4:1:64:0:4:20:-2.5 w4d9b:9:fa3:4:1:64:0:4:20:-2.5 w2d7b:7:fa3:4:1:64:1:2:20:-2.5 w2d13b:13:fa3:4:1:64:1:2:20:-2.5 w2d9b:9:fa3:4:1:64:1:2:20:-2.5 a2:11:fa3:4:1:64:1:2:20:-2.5` |
| A2 (grid) | W3 d11, d9, d13, d7, d15 TS0 | W3 ran TS1 on 7 cards; W3 TS0 and W3 on COMBO3 never | `w3d11a:11:fa3:4:1:64:0:3:20:-2.5 w3d9a:9:fa3:4:1:64:0:3:20:-2.5 w3d13a:13:fa3:4:1:64:0:3:20:-2.5 w3d7a:7:fa3:4:1:64:0:3:20:-2.5 w3d15a:15:fa3:4:1:64:0:3:20:-2.5 w3d15b:15:fa3:4:1:64:0:3:20:-2.5 w3d7b:7:fa3:4:1:64:0:3:20:-2.5 w3d13b:13:fa3:4:1:64:0:3:20:-2.5 w3d9b:9:fa3:4:1:64:0:3:20:-2.5 w3d11b:11:fa3:4:1:64:0:3:20:-2.5 a3:11:fa3:4:1:64:1:2:20:-2.5` |
| A3 (grid) | W1 d11 V12, d15 V16, d9 V10, d13 V14, d7 V8, TS1 | W1 ran at d11 V12 / d15 V16 (0x13BC); V8 / V10 / V14 never (a wrong V = host rc 247, card clean) | `w1d11a:11:fa3:4:1:64:1:1:12:-2.5 w1d15a:15:fa3:4:1:64:1:1:16:-2.5 w1d9a:9:fa3:4:1:64:1:1:10:-2.5 w1d13a:13:fa3:4:1:64:1:1:14:-2.5 w1d7a:7:fa3:4:1:64:1:1:8:-2.5 w1d7b:7:fa3:4:1:64:1:1:8:-2.5 w1d13b:13:fa3:4:1:64:1:1:14:-2.5 w1d9b:9:fa3:4:1:64:1:1:10:-2.5 w1d15b:15:fa3:4:1:64:1:1:16:-2.5 w1d11b:11:fa3:4:1:64:1:1:12:-2.5 a4:11:fa3:4:1:64:1:2:20:-2.5` |
| A4 (grid, optional) | W1 d11 TS0 | W1 TS0 never | `w1d11z1:11:fa3:4:1:64:0:1:12:-2.5 w1d11z2:11:fa3:4:1:64:0:1:12:-2.5` |
| *read the grid* | the DW_SWEEP table (or `kcdw_table.py <RUN>/serve_kcdw` for kcdw rows) | | choose B cells: **C1 = W2 d11 TS1** (fixed: it has cross-image K_C references), **C2 = the fastest W2 depth != 11**, **C3 = the fastest W>=3 TS0 cell** (the stop-free accept read of K_C) |
| **B0** (GPU only, no card) | twin captures + K_C 512 twin: g_head64 / g_head256 d11 with `CAP=`, g_head512 d11, g_head256 d<C2> | none (H200 only; run inside the card lock as on 11-12) | `$T2 "bash $TW/kcdw_mk_head512.sh"`, then `accept_gap_20261112/ship/ag_gpu_cell.sh` with `FAST=~/eagle4_talon2_4c1/accept_gap_20261112/ckpt/head{64,256,512} CAP=<prefix>` (the 11-12 GPU-arm invocation, `ag_gpu_cells.sh`) |
| **B1** | `kcgolden 128` x2, `kcgolden 256` x2 (separate calls) | K_C 128 / 256 ran clean on M1361 | `bash $T2ROOT "$E bash $TW/kcdw_steps.sh kcgolden 128"` (repeat; then 256): `KC128 REPEAT ... PASS` = deterministic; tooth RC 0 |
| **B2** C1 | cross-image checks at theta -2.5 (x1), then re-tuned theta (x2), alternating with K_C 64 anchors | ran clean on M1361 | `a5:11:fa3:4:1:64:1:2:20:-2.5 ka2:11:fa3:4:1:128:1:2:20:-2.5 kb2:11:fa3:4:1:256:1:2:20:-2.5 a6:11:fa3:4:1:64:1:2:20:-2.5 k128r1:11:fa3:4:1:128:1:2:20:-2.58 k256r1:11:fa3:4:1:256:1:2:20:-2.65 a7:11:fa3:4:1:64:1:2:20:-2.5 k256r2:11:fa3:4:1:256:1:2:20:-2.65 k128r2:11:fa3:4:1:128:1:2:20:-2.58 a8:11:fa3:4:1:64:1:2:20:-2.5` |
| B3 C3 | K_C 128 / 256 at TS0 (no theta interaction = the clean accept number) | ran clean (kz1 = 256 TS0) | `kz128a:<d>:fa3:4:1:128:0:<W>:20:-2.5 kz256a:<d>:fa3:4:1:256:0:<W>:20:-2.5 kz64m:<d>:fa3:4:1:64:0:<W>:20:-2.5 kz256b:<d>:fa3:4:1:256:0:<W>:20:-2.5 kz128b:<d>:fa3:4:1:128:0:<W>:20:-2.5` |
| B4 C2 | K_C 128 / 256 re-tuned at the best W2 depth | new depth, known K_C | `c2a:<dB>:fa3:4:1:64:1:2:20:-2.5 c2k128a:<dB>:fa3:4:1:128:1:2:20:-2.58 c2k256a:<dB>:fa3:4:1:256:1:2:20:-2.65 c2k256b:<dB>:fa3:4:1:256:1:2:20:-2.65 c2k128b:<dB>:fa3:4:1:128:1:2:20:-2.58 c2b:<dB>:fa3:4:1:64:1:2:20:-2.5` |
| **B5 (LAST)** | `kcgolden 512` x2 (= the K_C 512 smoke: the first K_C 512 trees ever on G8_OWN silicon, 74 score beats per item), then C1 512 re-tuned x2 + theta -2.5 x1, C3 512 TS0 x2, C2 512 re-tuned x2 | **never on silicon** | `kcgolden 512` (x2) then `k512r1:11:fa3:4:1:512:1:2:20:-2.72 a9:11:fa3:4:1:64:1:2:20:-2.5 k512n:11:fa3:4:1:512:1:2:20:-2.5 k512r2:11:fa3:4:1:512:1:2:20:-2.72 kz512a:<d>:fa3:4:1:512:0:<W>:20:-2.5 kz512b:<d>:fa3:4:1:512:0:<W>:20:-2.5 c2k512a:<dB>:fa3:4:1:512:1:2:20:-2.72 c2k512b:<dB>:fa3:4:1:512:1:2:20:-2.72 a10:11:fa3:4:1:64:1:2:20:-2.5` |

Round count for the K_C part: B 28 serves + 6 goldens + 4 GPU cells, **about 45 min warm, 1 h 15 min budget** (D9). If the window is short: run B1 + B2 (the C1 cross-image checks) + B5 kcgolden 512 first, and cut B4.

## 5. Correctness per K_C (what replaces golden_fp_gate)

- `golden_fp_gate.py` is the K_C 64 record reference. It hashes K_C, so K_C != 64 has **no built-in reference** (`golden_fp_gate.py:77-84`; K_C 32 hashed de4e5697 by design).
- What stands in its place:
  1. **The image gate stays the K_C 64 bring-up gate:** fp 51524c4f + EXACT_TOOTH x2 on this boot. K_C is a runtime bound in the same datapath, xsim MATCH at 128 / 256 / 512.
  2. **`kcgolden <kc>` x2 per K_C.** The first run is the reference of that K_C on this boot; the second must hash identical (deterministic, 0 discarded, gate rc 0). EXACT_TOOTH must pass; it is K_C-robust: T1 dominant token at rank 0, T2 L0 mass within 0.5 log2, and the K_C 32 control moved the mass by <= 0.10.
  3. **Cross-image serve references** (same MLPV, same config, ATT-independent texts): `ka2` must give 2,851 steps and texts 1b0779cf; `kb2` must give 2,857 steps and texts 1b1e44c1 (the 11-12 rows). TS0 K_C 256 at W2 d11 would give 2,803 / a2cc35a1.
  4. **Every round:** KC_CHECK OK (0x150 = K_C on both MLPVs), 0x1D4 0x3000 x4, rc 0, errs 0.
  5. **K_C 512 has no prior reference:** the two kcgolden 512 must match each other, and the two rounds of each 512 cell must be text- and step-identical.

## 6. If the user wants accept from K_C to pay: levers with the right shape [D, not built]

- The cost is G8 exposure: about 24 cycles per candidate per item past K_C ~128 (D2). Each lever has to cut that slope:
  - **(a) More gather channels or a wider owner split** (G8_NCH 4 -> 8, or more lm-head owners). This halves the per-candidate cycles.
  - **(b) Per-level K_C:** a large K_C only at the levels where the shortlist binds. The card already samples kcq per item at G8 launch (`g8_rescore_p.sv:1604`), so this needs a per-depth table register, still written equal on both MLPVs.
  - **(c) A cheap head that makes K_C 64 lossless:** finer G12 levels or grouped scales. This targets the 18-step card-head term directly, at no G8 cost.
- B0 decides between them. If the twin's K_C 256 / 512 captures pick children the card does not, the defect is upstream of G8 (prefilters or the bound), and (c) or a prefilter fix is the lever. If they agree, the 15 vs 3 discrepancy sits elsewhere.
- **K_C > 512 needs a rebuild:** `EAGLE4_G8_K_C 1024`, sel / rescored / FG8 key_mem x2, and an 11-bit kcq on the own link. It is not recommended: D7 already prices 512 at -23 %.

## Evidence index
- RTL: the staged M1361 tree above (md5s in section 1). Stage record `/mnt/models/stage_E4B71361/STAGE_SHA_E4B71361.txt`.
- Prior silicon: `accept_gap_20261112/silicon/{ag_table.txt,serve_ag/SUMMARY.tsv (26bb71b9),serve_ag/SUMX.tsv,gpu/GPU_POINTS.tsv}`, `DESIGN_FABLE_ACCEPT_GAP_7C_20261112.md:240-275`, `DESIGN_FABLE_ACCEPT_NOLEVEL_20261112.md` (S1-S3), `KC32_7CARD_AB_20261111.md`, `W4_SERVE_BOUND_20261115.md:197-231`, `ATT_COMBO_SILICON_20261116.md`, `FOURCARD_DESIGN_20261016/4C1_DELIVERY_TRACKER.md:1657,1671-1681,1705-1707,1735`.
- Captures for B0: `accept_gap_20261112/silicon/serve_ag/cap_cq1.8171.jsonl`, `cap_cp1.9205.jsonl` (+ box1 `/mnt/data/eagle4_scratch/nolevel_win_20261112/`), tool `accept_nolevel_20261112/kc_cap_compare.py` (6c1eca3b); twin ckpts box1 `/mnt/data/eagle4_scratch/accept_gap_split_20261019/ckpt/head256` (978541fb, num_candidates 256), talon2 `~/eagle4_talon2_4c1/accept_gap_20261112/ckpt/`.
- Window kit parents: `attcombo_20261116/ship/` (MD5SUMS.txt 549d83fc).
