fix(local-model): rollback copies follow each tag's own draft length

The previous commit counted 4 rollback copies of the recurrent state for every GGUF with a
prediction layer, the runtime's default `draft_num_predict`. A tag can set its own in its
params layer, and the runtime then passes that as `--spec-draft-n-max`, which is what
`need_n_rs_seq()` turns into rollback copies. Read on 2026-11-08:

- qwen3.6:35b-a3b-mtp-q4_k_m: draft_num_predict 2, so 2 copies (was counted as 4).
- qwen3.8:27b-mtp-q4_k_m: draft_num_predict 4.
- qwen3.8:27b-q8_0: none in its params, so the runtime's 4.

The 35B-A3B GGUF row's overhead drops by 132 MB: 0.971 instead of 0.976 on a 36 GB M3 Pro or
M3 Max, the same pick. test/local-model-catalog.test.ts now carries the drafted tokens per row
instead of a yes/no prediction layer.

Also states what was verified about llama.cpp's checkpoint default: 8 from b6800 to b8200,
32 from b8250 together with a checkpoint every 8,192 prompt tokens (common/common.h at those
tags), in place of an inferred reason. Checked in the b12111 source as well: the draft context
of a Qwen-family MTP model caches the prediction block alone (`mtp_on_hybrid_qwen`, layers at
or above n_layer()), and the main context leaves it out, so the row counts that layer once.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

test/local-model-catalog.test.ts

@@ -84,22 +84,26 @@ type ArchitectureName = keyof typeof ARCHITECTURES;
 type Architecture = (typeof ARCHITECTURES)[ArchitectureName];
 
 /**
- * Which architecture each stock row runs, and whether its GGUF carries a
- * multi-token-prediction layer (`nextn_predict_layers` 1 in the GGUF header, read on
- * 2026-11-08 from the first bytes of each model layer). For such a model the runtime turns on
- * prediction, which costs a cache for that layer and rollback copies of the recurrent state
- * (see the catalogue header). A row the catalogue gains must be added here, or the test below
- * fails: its figures cannot be checked without it.
+ * Which architecture each stock row runs, and how many tokens the runtime drafts per step with
+ * its multi-token-prediction layer: 0 when the GGUF has none (`nextn_predict_layers` in the GGUF
+ * header, read on 2026-11-08 from the first bytes of each model layer), else the tag's own
+ * `draft_num_predict` (its params layer) or the runtime's default of 4 when the tag sets none.
+ * Prediction costs a cache for that layer and one rollback copy of the recurrent state per
+ * drafted token (see the catalogue header). A row the catalogue gains must be added here, or the
+ * test below fails: its figures cannot be checked without it.
  */
-const ROW_ARCHITECTURE: Record<string, { architecture: ArchitectureName; predictionLayer: boolean }> = {
-  'qwen3.5:9b-q4_k_m': { architecture: 'Qwen3.5-9B', predictionLayer: false },
-  'mimo-v2.6:9b-q4_k_m': { architecture: 'Qwen3.5-9B', predictionLayer: false },
-  'north-mini-code-1.0:q4_k_m': { architecture: 'North-Mini-Code-1.0', predictionLayer: false },
-  'qwen3.6:35b-a3b-mtp-q4_k_m': { architecture: 'Qwen3.6-35B-A3B', predictionLayer: true },
-  'qwen3.6:35b-a3b': { architecture: 'Qwen3.6-35B-A3B', predictionLayer: false },
-  'qwen3.8:27b-q8_0': { architecture: 'Qwen3.8-27B', predictionLayer: true },
-  'qwen3.8:27b-mtp-q4_k_m': { architecture: 'Qwen3.8-27B', predictionLayer: true },
-  'ornith-1.5:122b': { architecture: 'Qwen3.5-122B-A10B', predictionLayer: false },
+const ROW_ARCHITECTURE: Record<string, { architecture: ArchitectureName; draftTokens: number }> = {
+  'qwen3.5:9b-q4_k_m': { architecture: 'Qwen3.5-9B', draftTokens: 0 },
+  'mimo-v2.6:9b-q4_k_m': { architecture: 'Qwen3.5-9B', draftTokens: 0 },
+  'north-mini-code-1.0:q4_k_m': { architecture: 'North-Mini-Code-1.0', draftTokens: 0 },
+  // Its params layer sets `draft_num_predict` 2.
+  'qwen3.6:35b-a3b-mtp-q4_k_m': { architecture: 'Qwen3.6-35B-A3B', draftTokens: 2 },
+  'qwen3.6:35b-a3b': { architecture: 'Qwen3.6-35B-A3B', draftTokens: 0 },
+  // A prediction layer, and no `draft_num_predict`: the runtime's 4.
+  'qwen3.8:27b-q8_0': { architecture: 'Qwen3.8-27B', draftTokens: 4 },
+  // Its params layer sets `draft_num_predict` 4.
+  'qwen3.8:27b-mtp-q4_k_m': { architecture: 'Qwen3.8-27B', draftTokens: 4 },
+  'ornith-1.5:122b': { architecture: 'Qwen3.5-122B-A10B', draftTokens: 0 },
 };
 
 /** Bytes per cached value in each K/V cache type of llama.cpp: q8_0 keeps 32 values in 34 bytes. */
@@ -109,12 +113,6 @@ const KV_BYTES_PER_VALUE: Record<string, number> = { f16: 2, q8_0: 34 / 32 };
  * default, because the runtime sets only the main context's (`--cache-type-k`).
  */
 const DRAFT_KV_CACHE_TYPE = 'f16';
-/**
- * The recurrent states llama.cpp keeps beside the live one for a model with prediction: the
- * runtime's draft length (`draft_num_predict` 4, passed as `--spec-draft-n-max`), which
- * `need_n_rs_seq()` turns into that many rollback copies.
- */
-const MTP_ROLLBACK_STATES = 4;
 /** The sliding-window cache holds the window plus one batch of 512 tokens (`n_swa + n_ubatch`). */
 const SLIDING_EXTRA_CELLS = 512;
 /** The head size of a Gated DeltaNet layer's keys and values, and its convolution kernel, in every model above. */
@@ -132,7 +130,8 @@ function recurrentStateBytes(arch: Architecture, convBytes: number): number {
 }
 
 /** What a `llamacpp` row's three figures must be, from its architecture and the runtime's settings. */
-function llamaCppFigures(arch: Architecture, predictionLayer: boolean): [number, number, number] {
+function llamaCppFigures(arch: Architecture, draftTokens: number): [number, number, number] {
+  const predictionLayer = draftTokens > 0;
   const perValue = KV_BYTES_PER_VALUE[RUNTIME_KV_CACHE_TYPE];
   const perLayer = arch.kvHeads * arch.headDim * 2;
   // The prediction layer's cache sits in the draft context, in the draft's cache type.
@@ -143,8 +142,9 @@ function llamaCppFigures(arch: Architecture, predictionLayer: boolean): [number,
   const recurrent = recurrentStateBytes(arch, 4);
   const sliding =
     'sliding' in arch ? arch.sliding.layers * (arch.sliding.window + SLIDING_EXTRA_CELLS) * perLayer * perValue : 0;
-  // Live: the sliding window, and the recurrent state with its rollback copies under prediction.
-  const live = sliding + recurrent * (1 + (predictionLayer ? MTP_ROLLBACK_STATES : 0));
+  // Live: the sliding window, and the recurrent state with one rollback copy per drafted token
+  // (`--spec-draft-n-max`, which `need_n_rs_seq()` turns into that many copies).
+  const live = sliding + recurrent * (1 + draftTokens);
   // A context checkpoint is a copy of what cannot be rolled back: the recurrent state or the window.
   const checkpoints = RUNTIME_CTX_CHECKPOINTS * (recurrent + sliding);
   return [held, live + checkpoints + 1_000_000_000 + RUNTIME_HOST_PROMPT_CACHE_MIB * MIB, 0];
@@ -337,9 +337,9 @@ describe('the memory figures of the stock rows: each row has its own', () => {
 
   it("recomputes every estimated row's figures from its own model's architecture and runner", () => {
     for (const model of models.filter((m) => m.figures === 'estimated')) {
-      const { architecture, predictionLayer } = ROW_ARCHITECTURE[model.id];
+      const { architecture, draftTokens } = ROW_ARCHITECTURE[model.id];
       const arch = ARCHITECTURES[architecture];
-      const expected = model.runner === 'llamacpp' ? llamaCppFigures(arch, predictionLayer) : mlxFigures(arch);
+      const expected = model.runner === 'llamacpp' ? llamaCppFigures(arch, draftTokens) : mlxFigures(arch);
       expect(figuresOf(model), `${model.id} (${architecture}, ${model.runner})`).toEqual(expected);
     }
   });
@@ -351,9 +351,9 @@ describe('the memory figures of the stock rows: each row has its own', () => {
       'mimo-v2.6:9b-q4_k_m': [17_408, 2_547_960_320, 0],
       // The sliding window x (1 live + 8 checkpoints) + 1.0 GB + 1 GiB.
       'north-mini-code-1.0:q4_k_m': [14_144, 3_698_117_120, 0],
-      // State x (1 live + 4 rollback copies + 8 checkpoints) + 1.0 GB + 1 GiB; the prediction
-      // layer's cache in f16 per token.
-      'qwen3.6:35b-a3b-mtp-q4_k_m': [12_928, 2_929_969_664, 0],
+      // State x (1 live + 2 rollback copies + 8 checkpoints) + 1.0 GB + 1 GiB; the prediction
+      // layer's cache in f16 per token. The 27B rows below draft 4 tokens: 4 rollback copies.
+      'qwen3.6:35b-a3b-mtp-q4_k_m': [12_928, 2_798_242_304, 0],
       'qwen3.6:35b-a3b': [37_000, 3_000_000_000, 5_000_000_000],
       'qwen3.8:27b-q8_0': [38_912, 4_113_353_216, 0],
       'qwen3.8:27b-mtp-q4_k_m': [38_912, 4_113_353_216, 0],
@@ -367,7 +367,7 @@ describe('the memory figures of the stock rows: each row has its own', () => {
     expect(mlxComputedPerToken(ARCHITECTURES['Qwen3.5-122B-A10B'])).toBe(43_332);
   });
 
-  it('lets two rows share figures only when they share the architecture, the prediction layer and the runner', () => {
+  it('lets two rows share figures only when they share the architecture, the drafted tokens and the runner', () => {
     const byFigures = new Map<string, LocalModelEntry[]>();
     for (const model of models) {
       const key = figuresOf(model).join('/');

test/local-model-fits-budget.test.ts

@@ -97,7 +97,7 @@ describe('modelFitsBudget', () => {
     // A runtime that reports less than the estimate rules out what the estimate allowed.
     expect(modelFitsBudget(mac(48), catalog, id, 131072, { measuredTotalBytes: 33 * 1024 ** 3 })).toBe(false);
     // And one that reports more admits what the estimate ruled out: on a 36 GB Mac the GGUF
-    // 35B-A3B at its full window needs 28.9 GB, 1.037 of the 27.9 GB estimate and 0.963 of 28 GiB.
+    // 35B-A3B at its full window needs 28.8 GB, 1.032 of the 27.9 GB estimate and 0.958 of 28 GiB.
     const moeGguf = 'qwen3.6:35b-a3b-mtp-q4_k_m';
     expect(modelFitsBudget(mac(36), catalog, moeGguf, 262144)).toBe(false);
     expect(modelFitsBudget(mac(36), catalog, moeGguf, 262144, { measuredTotalBytes: 28 * 1024 ** 3 })).toBe(true);

test/local-model-recommend.test.ts

@@ -489,7 +489,7 @@ describe('needBytes', () => {
       'qwen3.5:9b-q4_k_m': 11_380_487_246,
       'mimo-v2.6:9b-q4_k_m': 11_380_472_729,
       'north-mini-code-1.0:q4_k_m': 25_999_848_864,
-      'qwen3.6:35b-a3b-mtp-q4_k_m': 28_940_281_677,
+      'qwen3.6:35b-a3b-mtp-q4_k_m': 28_808_554_317,
       'qwen3.6:35b-a3b': 35_955_462_956,
       'qwen3.8:27b-q8_0': 44_292_142_594,
       'qwen3.8:27b-mtp-q4_k_m': 32_055_772_698,
@@ -647,7 +647,7 @@ describe('the MacBook Pro (Mac17,13: Apple M5 Pro, 48 GB)', () => {
     expect(
       result.alternatives.map((c) => [c.modelId, c.context, c.fit, c.speed, c.tokensPerSecond ?? null, c.tag?.kind])
     ).toEqual([
-      // The same model as a GGUF build: its fixed footprint holds the full window, 28.9 GB.
+      // The same model as a GGUF build: its fixed footprint holds the full window, 28.8 GB.
       ['qwen3.6:35b-a3b-mtp-q4_k_m', 262144, 'good', 'ok', 41.8, undefined],
       ['north-mini-code-1.0:q4_k_m', 262144, 'good', 'ok', 41.8, undefined],
       ['mimo-v2.6:9b-q4_k_m', 131072, 'good', 'ok', 28.6, 'small'],
@@ -809,7 +809,7 @@ describe('every memory size, with the stock catalogue', () => {
     [32, 'Apple M1 Max', 'limited mimo-v2.6:9b-q4_k_m@131072 good ok'],
     // A Max chip runs the dense 27B fast enough (12.1); an M3 Max (300 GB/s) does not (8.9),
     // and takes the 35B-A3B as a GGUF build, whose memory does not grow after it loaded. Both
-    // at 131072 tokens, 0.966 and 0.976 of the budget.
+    // at 131072 tokens, 0.966 and 0.971 of the budget.
     [36, 'Apple M4 Max', 'ok qwen3.8:27b-mtp-q4_k_m@131072 tight ok'],
     [36, 'Apple M3 Max', 'ok qwen3.6:35b-a3b-mtp-q4_k_m@131072 tight ok'],
     // The tested pair on the tested Mac; on a Pro chip the 27B is slow (8.1), so the same pick.
@@ -2077,8 +2077,8 @@ describe('the measured budget, end to end', () => {
     expect([measured.budgetSource, measured.budgetGb]).toEqual(['measured', '40.2']);
     // The same rows in the same order; only the share of each changes.
     expect(order(measured)).toEqual(order(estimated));
-    expect(rows(estimated).map((c) => c.budgetShare)).toEqual([0.957, 0.77, 0.692, 0.303, 0.303]);
-    expect(rows(measured).map((c) => c.budgetShare)).toEqual([0.895, 0.721, 0.647, 0.283, 0.283]);
+    expect(rows(estimated).map((c) => c.budgetShare)).toEqual([0.957, 0.767, 0.692, 0.303, 0.303]);
+    expect(rows(measured).map((c) => c.budgetShare)).toEqual([0.895, 0.717, 0.647, 0.283, 0.283]);
     for (const candidate of rows(measured)) {
       expect(candidate.budgetShare).toBeCloseTo(candidate.needBytes / MACBOOK_MEASURED_TOTAL, 3);
     }