localcode 0.5.7__tar.gz → 0.5.8__tar.gz

{localcode-0.5.7/src/localcode.egg-info → localcode-0.5.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.5.7
+Version: 0.5.8
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0

{localcode-0.5.7 → localcode-0.5.8}/llama-cpp-turboquant/tools/server/server-common.cpp

@@ -1426,6 +1426,17 @@ json oaicompat_chat_params_parse(
     // Apply chat template to the list of messages
     auto chat_params = common_chat_templates_apply(opt.tmpls.get(), inputs);
 
+    if (opt.no_forced_thinking && !chat_params.thinking_start_tag.empty()) {
+        // see server_chat_params::no_forced_thinking
+        for (const std::string & opener : { chat_params.thinking_start_tag + "\n", chat_params.thinking_start_tag }) {
+            if (string_ends_with(chat_params.generation_prompt, opener) && string_ends_with(chat_params.prompt, opener)) {
+                chat_params.generation_prompt.resize(chat_params.generation_prompt.size() - opener.size());
+                chat_params.prompt.resize(chat_params.prompt.size() - opener.size());
+                break;
+            }
+        }
+    }
+
     llama_params["chat_format"] = static_cast<int>(chat_params.format);
     llama_params["prompt"]      = chat_params.prompt;
     if (!chat_params.grammar.empty()) {

{localcode-0.5.7 → localcode-0.5.8}/llama-cpp-turboquant/tools/server/server-common.h

@@ -348,6 +348,11 @@ struct server_chat_params {
     std::string reasoning_budget_message;
     std::string media_path;
     bool force_pure_content = false;
+    // fork-local (PATCHES.md 0005): canvas diffusion models decide themselves whether to open a
+    // thought block. A thought opener the template appends after a tool response is never closed
+    // by DiffusionGemma, so the parser filed the whole answer as reasoning and the client saw
+    // nothing. Strip such an opener from the prompt and the parser's generation prompt.
+    bool no_forced_thinking = false;
 };
 
 // used by /completions endpoint

{localcode-0.5.7 → localcode-0.5.8}/llama-cpp-turboquant/tools/server/server-context.cpp

@@ -1646,7 +1646,8 @@ private:
                 /* reasoning_budget      */ params_base.sampling.reasoning_budget_tokens,
                 /* reasoning_budget_msg  */ params_base.sampling.reasoning_budget_message,
                 /* media_path            */ params_base.media_path,
-                /* force_pure_content    */ params_base.force_pure_content_parser
+                /* force_pure_content    */ params_base.force_pure_content_parser,
+                /* no_forced_thinking    */ diffusion.enabled
             };
 
             {
@@ -3297,6 +3298,26 @@ private:
                 }
             }
 
+            if (b == 0) {
+                // DiffusionGemma answers a tool result with an EMPTY thought block
+                // ("<|channel>thought\n<channel|>" + answer). The Gemma 4 parser files
+                // the text after an empty block as reasoning, so the client saw no
+                // answer at all. An empty block carries nothing: drop it before parsing.
+                static const std::string open_tag = "<|channel>thought";
+                static const std::string close_tag = "<channel|>";
+                if (string_starts_with(block_text, open_tag)) {
+                    size_t i = open_tag.size();
+                    while (i < block_text.size() && (block_text[i] == '\n' || block_text[i] == ' ')) i++;
+                    if (block_text.compare(i, close_tag.size(), close_tag) == 0) {
+                        block_text.erase(0, i + close_tag.size());
+                    } else if ((ended_on_eog || block_complete) && block_text.find(close_tag, i) == std::string::npos) {
+                        // The whole reply fits one block and the thought is never closed:
+                        // the model wrote its answer inside the block. It is the answer.
+                        block_text.erase(0, i);
+                    }
+                }
+            }
+
             slot.stats.n_gen += cut;
             if (b == 0) {
                 slot.t_print_last = ggml_time_us();

{localcode-0.5.7 → localcode-0.5.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "localcode"
-version = "0.5.7"
+version = "0.5.8"
 description = "High-performance AI coding on consumer hardware."
 readme = "README.md"
 requires-python = ">=3.10"

{localcode-0.5.7 → localcode-0.5.8}/src/localcode/__init__.py

@@ -8,4 +8,4 @@ from importlib.metadata import PackageNotFoundError, version as _pkg_version
 try:
     __version__ = _pkg_version("localcode")
 except PackageNotFoundError:  # not installed (e.g. raw source checkout)
-    __version__ = "0.5.7"
+    __version__ = "0.5.8"

{localcode-0.5.7 → localcode-0.5.8}/src/localcode/bin/localcode-ui

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
-name: localcode-0.5.7/src/localcode/bin/localcode-ui
+name: localcode-0.5.8/src/localcode/bin/localcode-ui
 size: 102460976 bytes
 sha256: a09d854109bdb8e9b346777e8fa306afcae9edb32ade0780ccd15a0e15fe3c05

{localcode-0.5.7 → localcode-0.5.8}/src/localcode/bootstrap.py

@@ -1060,6 +1060,55 @@ def download_mmproj(
     return ok, result
 
 
+def download_drafter(
+    choice,
+    on_progress: Callable[[str], None] | None = None,
+    cancel_event: "threading.Event | None" = None,
+) -> tuple[bool, str]:
+    """Download the vendor-trained speculative drafter a catalog entry ships
+    with (`choice.drafter`, see models_catalog.Drafter). Idempotent. Reuses
+    download_model via a proxy entry pointing at the drafter file in its own
+    repo, with the drafter's exact size and sha256 so it is verified like a
+    model. Returns (ok, path_or_error); a model without a drafter is not an
+    error (True, "")."""
+    drafter = getattr(choice, "drafter", None)
+    if drafter is None:
+        return True, ""
+    dest = drafter.local_path
+    if dest.is_file() and dest.stat().st_size == drafter.size_bytes:
+        return True, str(dest)
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    from dataclasses import replace
+    proxy = replace(
+        choice,
+        hf_repo=drafter.hf_repo,
+        revision=drafter.revision,
+        filename=drafter.hf_filename,
+        size_gb=drafter.size_gb,
+        size_bytes=drafter.size_bytes,
+        sha256=drafter.sha256,
+        mmproj_filename=None, mmproj_size_gb=0.0, mmproj_hf_filename=None,
+        drafter=None,
+    )
+    ok, result = download_model(proxy, on_progress=on_progress, cancel_event=cancel_event)
+    if not ok:
+        return ok, result
+    downloaded = Path(result)
+    if downloaded != dest:
+        try:
+            if dest.exists():
+                dest.unlink()
+            downloaded.rename(dest)
+            # the HF path may have put it in a subfolder (MTP/...); drop it if empty
+            try:
+                downloaded.parent.rmdir()
+            except OSError:
+                pass
+        except Exception as e:  # noqa: BLE001
+            return False, f"Couldn't rename drafter to {dest.name}: {e}"
+    return True, str(dest)
+
+
 def _is_mmproj_complete(p: Path, choice) -> bool:
     """Cheap completeness check for the mmproj sidecar — like
     `_is_complete_download` but with 10% slack since catalog mmproj

{localcode-0.5.7 → localcode-0.5.8}/src/localcode/config.py

@@ -41,6 +41,7 @@ llama_cpp_threads = 10
 llama_cpp_batch_size = 2048
 llama_cpp_spec_type = ""
 llama_cpp_draft_max = 64
+llama_cpp_mtp_draft = 4
 llama_cpp_expert_offload = false
 llama_cpp_draft_model = ""
 llama_cpp_lookup_cache = false
@@ -125,7 +126,8 @@ class RuntimeConfig:
     llama_cpp_batch_size: int = -1  # -1 = auto-detect from platform at startup
     # Speed optimizations
     llama_cpp_spec_type: str = ""         # "ngram-mod", "ngram-simple" — speculative decoding (1.5-2x)
-    llama_cpp_draft_max: int = 64         # max draft tokens for speculation
+    llama_cpp_draft_max: int = 64         # max draft tokens for an explicit spec_type / draft model
+    llama_cpp_mtp_draft: int = 4          # draft tokens from the model's vendor-trained drafter (catalog Drafter or in-GGUF MTP head); 0 = off
     llama_cpp_expert_offload: bool = False # offload MoE experts to CPU (-ot exps=CPU)
     llama_cpp_draft_model: str = ""       # path to draft GGUF for speculative decoding
     llama_cpp_lookup_cache: bool = False   # prompt lookup decoding (2-4x on code edits)
@@ -276,6 +278,7 @@ def save_config(config: AppConfig) -> Path:
         f"llama_cpp_batch_size = {config.runtime.llama_cpp_batch_size}\n"
         f'llama_cpp_spec_type = {_toml_str(config.runtime.llama_cpp_spec_type)}\n'
         f"llama_cpp_draft_max = {config.runtime.llama_cpp_draft_max}\n"
+        f"llama_cpp_mtp_draft = {config.runtime.llama_cpp_mtp_draft}\n"
         f"llama_cpp_expert_offload = {'true' if config.runtime.llama_cpp_expert_offload else 'false'}\n"
         f'llama_cpp_draft_model = {_toml_str(config.runtime.llama_cpp_draft_model)}\n'
         f"llama_cpp_lookup_cache = {'true' if config.runtime.llama_cpp_lookup_cache else 'false'}\n"
@@ -389,6 +392,7 @@ def load_config() -> AppConfig:
         # unless the user EXPLICITLY opts in via env var.
         llama_cpp_spec_type=os.environ.get("LOCALCODE_LLAMA_CPP_SPEC_TYPE", ""),
         llama_cpp_draft_max=int(os.environ.get("LOCALCODE_LLAMA_CPP_DRAFT_MAX", runtime_data.get("llama_cpp_draft_max", 64))),
+        llama_cpp_mtp_draft=int(os.environ.get("LOCALCODE_LLAMA_CPP_MTP_DRAFT", runtime_data.get("llama_cpp_mtp_draft", 4))),
         llama_cpp_expert_offload=str(os.environ.get("LOCALCODE_LLAMA_CPP_EXPERT_OFFLOAD", runtime_data.get("llama_cpp_expert_offload", False))).lower() in {"1", "true", "yes", "on"},
         llama_cpp_draft_model=os.environ.get("LOCALCODE_LLAMA_CPP_DRAFT_MODEL", runtime_data.get("llama_cpp_draft_model", "")),
         # `llama_cpp_lookup_cache` migration (2026-04-26): old configs

{localcode-0.5.7 → localcode-0.5.8}/src/localcode/hf_quants.py

@@ -98,8 +98,9 @@ def _quant_from_entry(entry: dict) -> Quant | None:
     # selectable weights.
     if "/" in path:
         return None
-    # Vision projectors and MTP draft heads are sidecars, not pickable models.
-    if lowered.startswith("mmproj") or lowered.startswith("mtp-") or lowered.startswith("mtp_"):
+    # Vision projectors and speculative drafters (MTP heads, DFlash) are
+    # sidecars, not pickable models.
+    if lowered.startswith(("mmproj", "mtp-", "mtp_", "dflash-", "dflash_")):
         return None
     label = _parse_label(path)
     # Real weight quants carry a quant code (Q4_K_M, IQ3_S, BF16, …). Anything

{localcode-0.5.7 → localcode-0.5.8}/src/localcode/models_catalog.py

@@ -35,6 +35,65 @@ def model_dir() -> Path:
 CANONICAL_MODEL_DIR = DEFAULT_MODEL_DIR
 
 
+@dataclass(frozen=True)
+class Drafter:
+    """A vendor-trained speculative drafter for ONE target model (MTP head or
+    DFlash block drafter). It ships with the model: the download that installs
+    the model installs the drafter too, and the launcher passes it as
+    `--model-draft` with its `--spec-type`. Every drafted token is verified by
+    the target, so the output is the target's own; measured 1.5x to 2.3x decode
+    on Apple Silicon. Only drafters trained for the exact model are listed:
+    a generic small model as drafter is what failed in the past.
+    """
+    filename: str          # local name (unique across families)
+    hf_repo: str           # repo that ships it (may differ from the model's)
+    hf_filename: str       # path inside that repo
+    spec_type: str         # llama-server --spec-type: "draft-mtp" | "draft-dflash"
+    size_gb: float
+    size_bytes: int        # exact, from the HF API (download completeness)
+    sha256: str            # verified after download
+    revision: str = "main"
+
+    @property
+    def local_path(self) -> Path:
+        return model_dir() / self.filename
+
+
+# Verified live 2026-10-09 (greedy, same coding prompt, bundled v0.6.0 server):
+# gemma-4-12b Q4_K_XL 55 -> 120-139 tok/s; Qwen3.6-35B IQ2_M 129 -> 224 (DFlash);
+# Muse Glimmer Q4_K_XL 30 -> 45 (DFlash). Qwen 3.8 27B carries its head inside
+# the GGUF (`nextn_predict_layers`) and needs no file.
+DRAFTER_GEMMA_12B = Drafter(
+    filename="mtp-gemma-4-12b-it-Q8_0.gguf", hf_repo="unsloth/gemma-4-12b-it-GGUF",
+    hf_filename="MTP/mtp-gemma-4-12b-it-Q8_0.gguf", spec_type="draft-mtp",
+    size_gb=0.47, size_bytes=465109248,
+    sha256="145db9094bc0f85f1701e255a2ed216dcc9800fc8bc8631ad00905b456bd451b",
+    revision="fc034cfff751157913579611efad8462ac1be606",
+)
+DRAFTER_GEMMA_26B = Drafter(
+    filename="mtp-gemma-4-26B-A4B-it-Q8_0.gguf", hf_repo="unsloth/gemma-4-26B-A4B-it-GGUF",
+    hf_filename="MTP/mtp-gemma-4-26B-A4B-it-Q8_0.gguf", spec_type="draft-mtp",
+    size_gb=0.46, size_bytes=461766816,
+    sha256="6326fb9f5e487aa8dcdd313a091e3c67724cb2a666ec3b7d2895b5b26d93ed1b",
+    revision="c099eb48e663fd284577b04978a94ffccb261841",
+)
+DRAFTER_QWEN36 = Drafter(
+    filename="dflash-Qwen3.6-35B-A3B-Q8_0.gguf", hf_repo="ggml-org/Qwen3.6-35B-A3B-GGUF",
+    hf_filename="dflash-Qwen3.6-35B-A3B-Q8_0.gguf", spec_type="draft-dflash",
+    size_gb=0.42, size_bytes=421060800,
+    sha256="339030c9dad4f410c7ef2d6cbd6e38251a84fabb59c44db992538c2451a0efee",
+    revision="baec3ebee244827cda0f4557eafa8b28f7545fa6",
+)
+DRAFTER_MUSE = Drafter(
+    filename="dflash-Muse-Glimmer-30B-Q4_0.gguf", hf_repo="ggml-org/Muse-Glimmer-30B-GGUF",
+    hf_filename="dflash-Muse-Glimmer-30B-Q4_0.gguf", spec_type="draft-dflash",
+    size_gb=1.45, size_bytes=1451096896,
+    sha256="048242c69254627fc11226c9f68dc34fbc82eac1c026ef148c9dbd2f90686db2",
+    revision="c286f180ef572621f5395b55da2d3e3d53d5972e",
+)
+DRAFTERS: list[Drafter] = [DRAFTER_GEMMA_12B, DRAFTER_GEMMA_26B, DRAFTER_QWEN36, DRAFTER_MUSE]
+
+
 @dataclass(frozen=True)
 class ModelChoice:
     key: str               # short id used in config (e.g. "gemma", "qwen")
@@ -99,6 +158,8 @@ class ModelChoice:
     preserves_reasoning: bool = True
     supports_parallel_tools: bool = False
     supports_systemone: bool = False
+    # Vendor-trained speculative drafter shipped with the model (see Drafter).
+    drafter: Drafter | None = None
 
     @property
     def hf_url(self) -> str:
@@ -213,6 +274,7 @@ CHOICES: list[ModelChoice] = [
         mmproj_filename="mmproj-gemma-4-26B-A4B-F16.gguf",
         mmproj_size_gb=1.2,
         mmproj_hf_filename="mmproj-F16.gguf",
+        drafter=DRAFTER_GEMMA_26B,
     ),
     ModelChoice(
         key="gemma-12b",
@@ -237,6 +299,7 @@ CHOICES: list[ModelChoice] = [
         mmproj_filename="mmproj-gemma-4-12b-F16.gguf",
         mmproj_size_gb=0.18,  # 175 MB on HF as of 2026-09 (repo re-exported the projector)
         mmproj_hf_filename="mmproj-F16.gguf",
+        drafter=DRAFTER_GEMMA_12B,
     ),
     ModelChoice(
         key="gemma-12b-bf16",
@@ -262,6 +325,7 @@ CHOICES: list[ModelChoice] = [
         mmproj_filename="mmproj-gemma-4-12b-F16.gguf",
         mmproj_size_gb=0.18,  # 175 MB on HF as of 2026-09
         mmproj_hf_filename="mmproj-F16.gguf",
+        drafter=DRAFTER_GEMMA_12B,
     ),
     ModelChoice(
         key="qwen",
@@ -279,6 +343,7 @@ CHOICES: list[ModelChoice] = [
         mmproj_filename="mmproj-Qwen3.6-35B-A3B-F16.gguf",
         mmproj_size_gb=0.9,
         mmproj_hf_filename="mmproj-F16.gguf",
+        drafter=DRAFTER_QWEN36,
     ),
     ModelChoice(
         key="diffusiongemma",
@@ -350,6 +415,7 @@ CHOICES: list[ModelChoice] = [
         mmproj_hf_filename="mmproj-Muse-Glimmer-30B-BF16.gguf",
         reasoning_control="always",
         reasoning_budget_tokens=0,
+        drafter=DRAFTER_MUSE,
     ),
     ModelChoice(
         key="gemma-q8",
@@ -367,6 +433,7 @@ CHOICES: list[ModelChoice] = [
         mmproj_filename="mmproj-gemma-4-26B-A4B-F16.gguf",
         mmproj_size_gb=1.2,
         mmproj_hf_filename="mmproj-F16.gguf",
+        drafter=DRAFTER_GEMMA_26B,
     ),
     ModelChoice(
         key="qwen-q8",
@@ -384,6 +451,7 @@ CHOICES: list[ModelChoice] = [
         mmproj_filename="mmproj-Qwen3.6-35B-A3B-F16.gguf",
         mmproj_size_gb=0.9,
         mmproj_hf_filename="mmproj-F16.gguf",
+        drafter=DRAFTER_QWEN36,
     ),
     ModelChoice(
         key="qwen38",
@@ -676,6 +744,8 @@ class ModelGroup:
     mmproj_hf_filename: str | None = None
 
     supports_systemone: bool = False
+    # Vendor-trained speculative drafter, same file for every quant of the model.
+    drafter: Drafter | None = None
 
     @property
     def supports_vision(self) -> bool:
@@ -699,6 +769,7 @@ MODEL_GROUPS: list[ModelGroup] = [
         mmproj_filename="mmproj-gemma-4-26B-A4B-F16.gguf",
         mmproj_size_gb=1.2,
         mmproj_hf_filename="mmproj-F16.gguf",
+        drafter=DRAFTER_GEMMA_26B,
     ),
     ModelGroup(
         key="gemma-4-12b",
@@ -716,6 +787,7 @@ MODEL_GROUPS: list[ModelGroup] = [
         mmproj_filename="mmproj-gemma-4-12b-F16.gguf",
         mmproj_size_gb=0.18,  # 175 MB on HF as of 2026-09 (repo re-exported the projector)
         mmproj_hf_filename="mmproj-F16.gguf",
+        drafter=DRAFTER_GEMMA_12B,
     ),
     ModelGroup(
         key="qwen-3.6-35b-a3b",
@@ -734,6 +806,7 @@ MODEL_GROUPS: list[ModelGroup] = [
         mmproj_filename="mmproj-Qwen3.6-35B-A3B-F16.gguf",
         mmproj_size_gb=0.9,
         mmproj_hf_filename="mmproj-F16.gguf",
+        drafter=DRAFTER_QWEN36,
     ),
     ModelGroup(
         key="qwen-3.8-27b",
@@ -789,6 +862,7 @@ MODEL_GROUPS: list[ModelGroup] = [
         mmproj_filename="mmproj-Muse-Glimmer-30B-BF16.gguf",
         mmproj_size_gb=3.85,
         mmproj_hf_filename="mmproj-Muse-Glimmer-30B-BF16.gguf",
+        drafter=DRAFTER_MUSE,
     ),
     ModelGroup(
         key="diffusiongemma-26b-a4b",
@@ -898,6 +972,7 @@ def choice_for_quant(group: ModelGroup, filename: str, size_gb: float) -> ModelC
         mmproj_size_gb=group.mmproj_size_gb,
         mmproj_hf_filename=group.mmproj_hf_filename,
         supports_systemone=group.supports_systemone,
+        drafter=group.drafter,
         reasoning_control=canonical.reasoning_control if canonical else "chat_template",
         reasoning_budget_tokens=canonical.reasoning_budget_tokens if canonical else 8192,
         preserves_reasoning=canonical.preserves_reasoning if canonical else True,

{localcode-0.5.7 → localcode-0.5.8}/src/localcode/runtime.py

@@ -489,17 +489,43 @@ class LocalCodeRuntimeGateway:
         # Speculative decoding (mutual exclusion: draft model > lookup > ngram).
         # Speculative decoding is LOSSLESS — every drafted token is verified
         # against the real model, so output is identical, just faster.
+        # `--draft-max` was removed upstream (2026); the flag is `--spec-draft-n-max`.
+        spec_type = (self.config.llama_cpp_spec_type or "").strip()
         if self.config.llama_cpp_draft_model:
             draft_path = self.config.llama_cpp_draft_model
             cmd.extend(["--model-draft", draft_path,
-                        "--draft-max", str(self.config.llama_cpp_draft_max)])
+                        "--spec-draft-n-max", str(self.config.llama_cpp_draft_max)])
         elif self.config.llama_cpp_lookup_cache:
             # Prompt lookup decoding: matches n-grams from input in output (2-4x on edits)
             cmd.extend(["--lookup-cache-dynamic", "/tmp/localcode-lookup.bin"])
-        elif self.config.llama_cpp_spec_type and self.config.llama_cpp_spec_type != "none":
-            cmd.extend(["--spec-type", self.config.llama_cpp_spec_type,
-                        "--draft-max", str(self.config.llama_cpp_draft_max)])
-        # NO speculative decoding by default. An empty `llama_cpp_spec_type`
+        elif spec_type and spec_type != "none":
+            cmd.extend(["--spec-type", spec_type,
+                        "--spec-draft-n-max", str(self.config.llama_cpp_draft_max)])
+        elif (not spec_type and self.config.llama_cpp_mtp_draft > 0
+              and self._catalog_drafter_path(model_path) is not None):
+            # A vendor-trained drafter shipped with the model (catalog
+            # `Drafter`: Gemma 4 MTP heads, Qwen 3.6 / Muse DFlash). Downloaded
+            # with the model; only used when the file is present and complete.
+            drafter, path = self._catalog_drafter_path(model_path)
+            cmd.extend(["--model-draft", str(path), "--spec-type", drafter.spec_type])
+            if drafter.spec_type == "draft-mtp":
+                # A DFlash drafter emits a whole block per step; its length is
+                # the drafter's own. MTP drafts token by token: 4 measured best.
+                cmd.extend(["--spec-draft-n-max", str(self.config.llama_cpp_mtp_draft)])
+        elif (not spec_type and self.config.llama_cpp_mtp_draft > 0
+              and self._gguf_mtp_layers(model_path) > 0):
+            # The model ships its own multi-token-prediction head(s)
+            # (`<arch>.nextn_predict_layers` > 0, e.g. Qwen 3.8 27B). Drafting
+            # from that head is lossless (every draft token is verified by the
+            # target) and needs no second model. Measured on Qwen 3.8 27B
+            # Q4_K_XL, Apple Silicon: 24-26 tok/s -> 43-49 tok/s at 4 draft
+            # tokens (89% accepted), identical output; 8 tokens is slower
+            # (30 tok/s) because the misses cost more than the hits save.
+            # `llama_cpp_spec_type = "none"` or `llama_cpp_mtp_draft = 0`
+            # turns it off. Models without the metadata are untouched.
+            cmd.extend(["--spec-type", "draft-mtp",
+                        "--spec-draft-n-max", str(self.config.llama_cpp_mtp_draft)])
+        # Otherwise NO speculative decoding. An empty `llama_cpp_spec_type`
         # means OFF — NOT a cue to fall back to in-context n-gram decoding.
         # The previous default here emitted `--spec-type ngram-mod`, which
         # directly contradicted config.py's force-disable of spec_type (added
@@ -789,7 +815,7 @@ class LocalCodeRuntimeGateway:
                         wanted = (
                             ".block_count", ".attention.head_count_kv",
                             ".attention.head_count", ".attention.key_length",
-                            ".embedding_length",
+                            ".embedding_length", ".nextn_predict_layers",
                         )
                         for _ in range(n_kv):
                             k = _rs()
@@ -809,12 +835,55 @@ class LocalCodeRuntimeGateway:
                                 "n_layers": n_layers,
                                 "n_kv_heads": n_kv_heads,
                                 "head_dim": head_dim,
+                                # Multi-token-prediction heads shipped inside
+                                # the GGUF (Qwen 3.6+/3.8 `nextn_predict_layers`).
+                                "n_mtp_layers": found.get(".nextn_predict_layers", 0),
                             }
         except Exception:
             meta = None
         cache[path] = meta
         return meta
 
+    def _catalog_drafter_path(self, model_path: str | None):
+        """(Drafter, path) for the catalog drafter of this GGUF when the file is
+        on disk with its exact size, else None."""
+        try:
+            from pathlib import Path as _P
+            from .models_catalog import by_filename, MODEL_GROUPS, choice_for_quant
+            name = _P(str(model_path or "")).name
+            choice = by_filename(name)
+            drafter = getattr(choice, "drafter", None) if choice is not None else None
+            if drafter is None:
+                # a browsed quant of a group that ships a drafter
+                for g in MODEL_GROUPS:
+                    if getattr(g, "drafter", None) is not None and self._gguf_in_group(name, g):
+                        drafter = g.drafter
+                        break
+            if drafter is None:
+                return None
+            path = drafter.local_path
+            if not path.is_file() or path.stat().st_size != drafter.size_bytes:
+                return None
+            return drafter, path
+        except Exception:
+            return None
+
+    @staticmethod
+    def _gguf_in_group(name: str, group) -> bool:
+        """Does a (browsed) quant filename belong to this group's repo listing?
+        Cheap heuristic on the repo's model name prefix."""
+        stem = group.hf_repo.split("/", 1)[-1].removesuffix("-GGUF").lower()
+        return name.lower().startswith(stem.lower())
+
+    def _gguf_mtp_layers(self, model_path: str | None = None) -> int:
+        """Number of multi-token-prediction (MTP) draft layers stored in the
+        GGUF, 0 when there are none or the file can't be read."""
+        meta = self._gguf_kv_meta(model_path)
+        try:
+            return int((meta or {}).get("n_mtp_layers", 0) or 0)
+        except (TypeError, ValueError):
+            return 0
+
     def _kv_bytes_per_token(self, model_path: str | None = None) -> float | None:
         """KV-cache bytes per token = n_layers × n_kv_heads × head_dim ×
         (bytes_K + bytes_V). Returns None when the metadata or the launched

{localcode-0.5.7 → localcode-0.5.8}/src/localcode/ui/plugin/localcode.ts

@@ -170,6 +170,8 @@ const PLATEAU_NUDGE_AFTER = 6;      // consecutive no-progress rounds -> nudge o
 const PLATEAU_STOP_AFTER = 8;       // further no-progress rounds after the nudge -> stop
 const PLATEAU_RECENT_PASS = 2;      // a check that passed within this many rounds blocks the stop...
 const PLATEAU_PASS_GRACE = 3;       // ...and grants this many more rounds after a "finish now" nudge
+const SAME_CALL_NUDGE_AFTER = 3;    // identical call + identical result, consecutively -> nudge once
+const SAME_CALL_STOP_AFTER = 5;     // ... and still repeating -> stop (a loop burns minutes of GPU per round)
 const PLATEAU_STOP_DENIALS = 3;     // tool calls refused after a stop before the session is aborted as a last resort
 
 type ToolEvent = { tool: string; args: any; output?: string; metadata?: any };
@@ -181,7 +183,7 @@ type ProgressMemory = {
   lastCheckPassed: boolean | null; // null = no check run yet this session
   completedTodos: number;
 };
-type PlateauDecision = "none" | "nudge" | "repair-nudge" | "pass-nudge" | "stop";
+type PlateauDecision = "none" | "nudge" | "repair-nudge" | "same-call-nudge" | "pass-nudge" | "stop";
 
 function newProgressMemory(): ProgressMemory {
   return { changedPaths: new Set(), revisions: new Set(), failureSigs: new Set(), lastFailureCount: null, lastCheckPassed: null, completedTodos: 0 };
@@ -373,6 +375,11 @@ class PlateauTracker {
   private callSigs = new Set<string>();
   readonly repeated = new RepeatedCheckTracker();
   private repairDecision: PlateauDecision = "none";
+  // Exact same call returning the exact same result, back to back. A model
+  // in this state is not exploring or repairing, it is looping; todowrite is
+  // exempt because re-posting an unchanged plan is harmless bookkeeping.
+  private sameCall = { key: "", count: 0 };
+  sameCallEvidence = "";
 
   observe(ev: ToolEvent): void {
     if (this.stopped) return;
@@ -383,6 +390,17 @@ class PlateauTracker {
     if (r) this.reasons.push(r);
     const sig = callSignature(ev);
     if (!this.callSigs.has(sig)) { this.callSigs.add(sig); this.novel = true; }
+    const result = String(ev.output ?? "");
+    if (ev.tool !== "todowrite") {
+      // A call with no result to compare is a different call: it breaks the run.
+      const key = result.trim() ? sig + "\n" + createHash("sha256").update(result).digest("hex") : "";
+      this.sameCall = key && key === this.sameCall.key ? { key, count: this.sameCall.count + 1 } : { key, count: key ? 1 : 0 };
+      if (this.sameCall.count === SAME_CALL_NUDGE_AFTER || this.sameCall.count >= SAME_CALL_STOP_AFTER) {
+        const args = ev.tool === "bash" ? String(ev.args?.command ?? "") : JSON.stringify(ev.args ?? null);
+        this.sameCallEvidence = `${ev.tool} was called ${this.sameCall.count} times in a row with the same arguments and got the same result each time.\nCall: ${args.slice(0, 300)}`;
+        this.repairDecision = this.sameCall.count >= SAME_CALL_STOP_AFTER ? "stop" : "same-call-nudge";
+      }
+    }
     if (ev.tool === "bash" && isCheckCommand(String(ev.args?.command ?? "")) && this.mem.lastCheckPassed) this.lastPassRound = this.round + 1;
   }
 
@@ -584,6 +602,11 @@ const LocalcodePlugin: Plugin = async ({ client, directory }) => {
       nudgeAsync(sessionID, `${NUDGE_PREFIX} ${plateau.repeated.evidence}\nStop repeating this repair. Inspect the exact failing source and its configuration, then test one evidence-based fix. For a module-resolution error, resolve the import relative to the importing file and check that target first. Do not downgrade the toolchain, delete features, or replace components with stubs to make the error disappear. Run the same check unfiltered after the repair.`);
       return decision;
     }
+    if (decision === "same-call-nudge") {
+      plog(`round ${plateau.round}: ${plateau.sameCallEvidence}`);
+      nudgeAsync(sessionID, `${NUDGE_PREFIX} ${plateau.sameCallEvidence}\nRepeating it will give the same result again. Use what it already returned: either act on it, try a different approach, or finish and say what is blocking you.`);
+      return decision;
+    }
     if (decision === "nudge") {
       plog(`round ${plateau.round}: ${PLATEAU_NUDGE_AFTER} no-progress rounds — nudging to deliver`);
       nudgeAsync(sessionID, plateauNudgeText(open));
@@ -823,5 +846,5 @@ const LocalcodePlugin: Plugin = async ({ client, directory }) => {
 // if one is not a function ("Plugin export is not a function") — which silently
 // disabled this whole plugin once test helpers were exported. Expose the helpers
 // as properties on the plugin function instead; tests read them from `default`.
-Object.assign(LocalcodePlugin, { PLATEAU_MIN_ROUND, PLATEAU_NUDGE_AFTER, PLATEAU_STOP_AFTER, PLATEAU_RECENT_PASS, PLATEAU_PASS_GRACE, PLATEAU_STOP_DENIALS, callSignature, newProgressMemory, projectCheck, checkDirectory, CHECK_CMD, isCheckCommand, filteredCheck, isTempPath, editedPaths, failureSignatures, checkPassed, progressOf, referenceOnlyTypecheck, RepeatedCheckTracker, PlateauTracker, plateauNudgeText, PLATEAU_PASS_TEXT });
+Object.assign(LocalcodePlugin, { PLATEAU_MIN_ROUND, PLATEAU_NUDGE_AFTER, PLATEAU_STOP_AFTER, PLATEAU_RECENT_PASS, PLATEAU_PASS_GRACE, PLATEAU_STOP_DENIALS, SAME_CALL_NUDGE_AFTER, SAME_CALL_STOP_AFTER, callSignature, newProgressMemory, projectCheck, checkDirectory, CHECK_CMD, isCheckCommand, filteredCheck, isTempPath, editedPaths, failureSignatures, checkPassed, progressOf, referenceOnlyTypecheck, RepeatedCheckTracker, PlateauTracker, plateauNudgeText, PLATEAU_PASS_TEXT });
 export default LocalcodePlugin;

{localcode-0.5.7 → localcode-0.5.8}/src/localcode/ui/server_cmd.py

@@ -51,10 +51,14 @@ def server_command(gguf: str, port: int, alias: str | None = None) -> list[str]:
         if capabilities.control is ReasoningControl.NONE:
             control = "none"
         if capabilities.family == "diffusion":
-            # Auto extraction can put the entire post-tool answer in
-            # reasoning_content, leaving no visible text. Keep generated text
-            # in content without disabling this model's generation path.
-            cmd += ["--reasoning-format", "none"]
+            # The model always opens a `<|channel>thought` block itself and
+            # cannot be told not to (see above). With the parser off that
+            # block leaked into every reply as literal `<|channel>thought ...`
+            # text; with it on, the thought goes to reasoning_content and the
+            # answer after `<channel|>` is the content, like every other model.
+            # A reply cut off by max_tokens before `<channel|>` has no content
+            # either way: the model had not answered yet.
+            cmd += ["--reasoning-format", "auto"]
     except Exception:  # noqa: BLE001, S110
         pass
     mode = os.environ.get("LOCALCODE_INTERNAL_THINKING_MODE") or cfg.runtime.internal_thinking_mode or "off"

{localcode-0.5.7 → localcode-0.5.8}/src/localcode/ui/supervisor.py

@@ -439,11 +439,15 @@ class Supervisor:
         rows.sort(key=lambda q: q.size_gb)
         rec_idx = self._recommended_quant_idx(rows, g.display_name)
         out = []
+        # A vendor-trained drafter ships with the model (downloaded with it,
+        # loaded with it), so the size the user sees and the RAM fit include it.
+        draft_gb = float(getattr(getattr(g, "drafter", None), "size_gb", 0.0) or 0.0)
         for i, q in enumerate(rows):
             spd = estimate_decode_tok_s(q.size_gb, g.display_name, self.bandwidth)
+            total_gb = q.size_gb + draft_gb
             out.append({
                 "filename": q.filename, "alias": _alias(q.filename), "label": q.label,
-                "size_gb": round(q.size_gb, 1), "fit": fit_badge(q.size_gb, self.ram_gb),
+                "size_gb": round(total_gb, 1), "fit": fit_badge(total_gb, self.ram_gb),
                 "tok_s": spd, "recommended": i == rec_idx,
                 "downloaded": (self.models_dir / q.filename).exists(),
                 "current": _alias(q.filename) == self.current,
@@ -452,6 +456,7 @@ class Supervisor:
             })
         return {"group": g.key, "display_name": g.display_name, "maker": g.maker,
                 "license": g.license, "ram_gb": self.ram_gb, "quants": out,
+                "drafter_size_gb": round(draft_gb, 2),
                 "vision_size_gb": round(float(getattr(g, "mmproj_size_gb", 0.0) or 0.0), 2) if getattr(g, "mmproj_filename", None) else 0.0}
 
     def _recommended_quant_idx(self, rows, name: str) -> int | None:
@@ -526,6 +531,25 @@ class Supervisor:
                 if got.parent != self.models_dir and not (self.models_dir / filename).exists():
                     # download_model saved under localcode's model_dir(); link it here.
                     os.symlink(got, self.models_dir / filename)
+            # The drafter that ships with this model (its size was part of the
+            # figure the user picked). Missing it is not fatal: the model runs
+            # without speculation and the next select retries.
+            drafter = getattr(g, "drafter", None)
+            if drafter is not None and not drafter.local_path.is_file():
+                def on_draft_progress(msg: str) -> None:
+                    pct = None
+                    if "(" in msg and "%)" in msg:
+                        try:
+                            pct = int(msg.rsplit("(", 1)[1].split("%")[0])
+                        except ValueError:
+                            pct = None
+                    self.state = {"state": "downloading", "model": alias, "detail": f"drafter: {msg}", "pct": pct}
+                ok, res = bootstrap.download_drafter(choice_for_quant(g, filename, 0.0), on_progress=on_draft_progress, cancel_event=self.cancel)
+                if self.cancel.is_set():
+                    self.state = {"state": "idle", "model": self.current, "detail": "download cancelled", "pct": None}
+                    return
+                if not ok:
+                    log(f"supervisor: drafter download failed for {alias}: {res}")
             self.state = {"state": "loading", "model": alias, "detail": "loading model…", "pct": None}
             if self.start(alias):
                 self.state = {"state": "ready", "model": alias, "detail": "", "pct": None}

{localcode-0.5.7 → localcode-0.5.8/src/localcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.5.7
+Version: 0.5.8
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0