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>

src/config/local-model-catalog.ts

@@ -75,13 +75,15 @@
  *    "MTP" below is a GGUF with a multi-token-prediction layer (`nextn_predict_layers` 1 in
  *    its header, read on 2026-11-08 from the first bytes of each model layer: the two `-mtp`
  *    tags and `qwen3.8:27b-q8_0` have it, the two 9B tags and North Mini Code do not). For
- *    such a model the runtime always passes `--spec-type draft-mtp --spec-draft-n-max 4`
- *    (its default `draft_num_predict` is 4).
+ *    such a model the runtime always passes `--spec-type draft-mtp --spec-draft-n-max N`, N
+ *    being the tag's own `draft_num_predict` (its params layer: 4 for
+ *    `qwen3.8:27b-mtp-q4_k_m`, 2 for `qwen3.6:35b-a3b-mtp-q4_k_m`) or the runtime's default
+ *    of 4 (`qwen3.8:27b-q8_0` sets none).
  *     - held = attention layers x K/V heads x head dim x 2 (K and V) x 34/32. An MTP model
  *       adds its prediction layer, whose cache llama-server keeps in a draft context of the
  *       same length in the draft's own cache type, f16 by default (2 bytes per value).
  *     - overhead = the fixed caches (the f32 recurrent state of the linear-attention layers,
- *       or the sliding-window cache of `n_swa + 512` cells), held 1 + 4 times for an MTP
+ *       or the sliding-window cache of `n_swa + 512` cells), held 1 + N times for an MTP
  *       model (llama.cpp keeps one recurrent state per drafted token for rollback,
  *       `need_n_rs_seq()`), + the context checkpoints: `LLAMA_ARG_CTX_CHECKPOINTS` host copies
  *       (`RUNTIME_CTX_CHECKPOINTS`, 8) of the state that cannot be rolled back (the recurrent
@@ -323,8 +325,8 @@ const LLAMACPP_RUNNER_BYTES = 1_000_000_000;
 const LLAMACPP_PROMPT_CACHE_BYTES = 1024 * 1024 * 1024;
 /** The context checkpoints llama-server may keep: `LLAMA_ARG_CTX_CHECKPOINTS`, 8 (`RUNTIME_CTX_CHECKPOINTS`). */
 const LLAMACPP_CTX_CHECKPOINTS = 8;
-/** The recurrent states llama.cpp keeps beside the live one for an MTP model: the runtime's draft length, 4. */
-const LLAMACPP_MTP_ROLLBACK_STATES = 4;
+/** The tokens the runtime drafts per step for an MTP model whose tag sets no `draft_num_predict`, 4: so many rollback states. */
+const LLAMACPP_DEFAULT_DRAFT_TOKENS = 4;
 /** The prefix snapshots the MLX runner may keep: `maxPagedOutBytes`, 8 GiB. */
 const MLX_PREFIX_CACHE_BYTES = 8 * 1024 * 1024 * 1024;
 
@@ -420,12 +422,11 @@ export const STOCK_LOCAL_MODEL_CATALOG: LocalModelCatalog = {
       // 10 attention layers x 2 K/V heads x 256 x 2 x 34/32 = 10,880, + the prediction layer in
       // f16: 2 x 256 x 2 x 2 = 2,048.
       heldBytesPerToken: 12_928,
-      // 30 linear-attention layers hold 65,863,680 bytes of f32 state: live, in the 4 rollback
-      // copies of prediction, and in each context checkpoint.
+      // 30 linear-attention layers hold 65,863,680 bytes of f32 state: live, in the 2 rollback
+      // copies of prediction (this tag drafts 2 tokens, `draft_num_predict` 2), and in each
+      // context checkpoint.
       overheadBytes:
-        65_863_680 * (1 + LLAMACPP_MTP_ROLLBACK_STATES + LLAMACPP_CTX_CHECKPOINTS) +
-        LLAMACPP_RUNNER_BYTES +
-        LLAMACPP_PROMPT_CACHE_BYTES,
+        65_863_680 * (1 + 2 + LLAMACPP_CTX_CHECKPOINTS) + LLAMACPP_RUNNER_BYTES + LLAMACPP_PROMPT_CACHE_BYTES,
       peakExtraBytes: 0,
       figures: 'estimated',
       contexts: [262144, 131072, 65536],
@@ -462,11 +463,11 @@ export const STOCK_LOCAL_MODEL_CATALOG: LocalModelCatalog = {
       paramsB: 27.8,
       runner: 'llamacpp',
       bytes: 29_978_242_050,
-      // The architecture of the row below, prediction layer included (its GGUF has one), so its
-      // figures.
+      // The architecture of the row below, prediction layer included (its GGUF has one), and the
+      // runtime's 4 drafted tokens (the tag sets none), so its figures.
       heldBytesPerToken: 38_912,
       overheadBytes:
-        156_893_184 * (1 + LLAMACPP_MTP_ROLLBACK_STATES + LLAMACPP_CTX_CHECKPOINTS) +
+        156_893_184 * (1 + LLAMACPP_DEFAULT_DRAFT_TOKENS + LLAMACPP_CTX_CHECKPOINTS) +
         LLAMACPP_RUNNER_BYTES +
         LLAMACPP_PROMPT_CACHE_BYTES,
       peakExtraBytes: 0,
@@ -490,11 +491,9 @@ export const STOCK_LOCAL_MODEL_CATALOG: LocalModelCatalog = {
       // f16: 4 x 256 x 2 x 2 = 4,096.
       heldBytesPerToken: 38_912,
       // 48 linear-attention layers hold 156,893,184 bytes of f32 state: live, in the 4 rollback
-      // copies of prediction, and in each context checkpoint.
+      // copies of prediction (`draft_num_predict` 4), and in each context checkpoint.
       overheadBytes:
-        156_893_184 * (1 + LLAMACPP_MTP_ROLLBACK_STATES + LLAMACPP_CTX_CHECKPOINTS) +
-        LLAMACPP_RUNNER_BYTES +
-        LLAMACPP_PROMPT_CACHE_BYTES,
+        156_893_184 * (1 + 4 + LLAMACPP_CTX_CHECKPOINTS) + LLAMACPP_RUNNER_BYTES + LLAMACPP_PROMPT_CACHE_BYTES,
       peakExtraBytes: 0,
       figures: 'estimated',
       contexts: [262144, 131072, 65536],

src/local-model/runtime.ts

@@ -40,13 +40,13 @@
  *       of the catalogue's `llamacpp` rows: a checkpoint is a host copy of the state that
  *       cannot be rolled back (the recurrent state of the linear-attention layers, or the
  *       sliding-window cache), two or three per request, and llama-server keeps up to 32 by
- *       default. 32 copies of the 27B's 157 MB state are 5 GB that the session holds for
- *       nothing: an agent's next request restores the newest checkpoint of the previous one.
- *       8 (llama.cpp's own default before it went to 32 to cover a 262,144-token window in
- *       8,192-token steps) keeps the last few requests. The cost: a prompt that differs from
- *       the last checkpoints further back (a compaction, a cleared old tool result) is
- *       processed again from the newest checkpoint before that point, or from its start.
- *       8 checkpoints are counted in every `llamacpp` row's `overheadBytes`.
+ *       default. 32 copies of the 27B's 157 MB state are 5 GB, most of which an agent never
+ *       uses: its next request restores the newest checkpoint of the previous one. 8
+ *       (llama.cpp's own default from b6800 to b8200; it became 32 at b8250, together with a
+ *       checkpoint every 8,192 tokens of a long prompt) keeps the last few requests. The cost:
+ *       a prompt that differs from the last checkpoints further back (a compaction, a cleared
+ *       old tool result) is processed again from the newest checkpoint before that point, or
+ *       from its start. 8 checkpoints are counted in every `llamacpp` row's `overheadBytes`.
  *    The MLX runner reads none of the four (nothing under mlxrunner/ does): an `mlx` row's
  *    figures do not depend on them.
  *  - PORT (`chooseRuntimePort()`). Chosen ONCE by binding, from `RUNTIME_PORT_FIRST` across