localcode 0.3.31__tar.gz → 0.3.33__tar.gz

{localcode-0.3.31/src/localcode.egg-info → localcode-0.3.33}/PKG-INFO

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

{localcode-0.3.31 → localcode-0.3.33}/pyproject.toml

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

{localcode-0.3.31 → localcode-0.3.33}/src/localcode/agent/constants.py

@@ -67,24 +67,26 @@ this; interactive sessions don't)."""
 
 MAX_OUTPUT_TOKENS = -1
 """Per-round generation cap. -1 = unlimited; the model stops at its
-natural EOS. Capping mid-stream truncates valid tool-call JSON into
-unparseable garbage, which then triggers a useless recovery round. A
-prior 5.8-minute round burn was caused by an 8192 cap chopping a
-long-but-valid write_file call.
-
-The system-level `--ctx-size 32768` is the absolute ceiling: prompt
-+ generation cannot exceed it, so the model can't run forever even
-without a per-round cap. With prompts in the 5-8K-token range, that
-leaves ~24-27K tokens of generation headroom — enough for any
-single source file we'd reasonably emit in one call.
-
-Historical note: bumped from -1 → 8192 on 2026-04-26 after a
-36-minute turn died with HTTP 500 when the model emitted a 42K-token
-edit_file dict-literal that filled the (then 64K) context mid-decode.
-That regression is no longer reachable — ctx-size is now 32768, the
-mid-stream tool-arg watchdog has been gutted to a 180K hard ceiling
-only, and the model's natural EOS lands well inside the budget for
-normal file writes."""
+natural EOS. This stays -1 deliberately: capping mid-stream truncates
+valid tool-call JSON into unparseable garbage, which then triggers a
+useless recovery round. A prior 5.8-minute round burn was caused by an
+8192 cap chopping a long-but-valid write_file call. So a small per-round
+token cap is the WRONG lever.
+
+The runaway backstop is NOT ctx-size. An earlier version of this note
+claimed `--ctx-size 32768` bounded prompt+generation so "the model can't
+run forever" — that is FALSE for long-context models. LocalCode launches
+Qwen (262K trained) with `--ctx-size 131072`; a 6K-token prompt then
+leaves ~125K tokens of generation headroom ≈ ~28 minutes of nonstop
+decode. A real 40-minute / no-output hang (thinking on, no answer emitted)
+was traced to exactly this.
+
+The correct backstop is the thinking runaway-guard (Feature.THINKING_CAPS
++ MAX_THINKING_SECONDS / MAX_THINKING_CHARS): it aborts a reasoning-only
+phase at 10 min / ~20k tokens regardless of ctx-size, well before the
+context ceiling, and surfaces a clear message. That is why the cap was
+re-enabled 2026-07-19. Leaving MAX_OUTPUT_TOKENS at -1 keeps valid long
+tool calls intact while the thinking guard handles the runaway case."""
 
 
 # ── Thinking-phase safety caps ──────────────────────────────────────
@@ -94,21 +96,24 @@ normal file writes."""
 # `_thinking_abort`, which surfaces a clear user message and ends
 # the turn.
 #
-# Previously only the time cap existed, at 300 s — which a user
-# watching a screen experiences as "frozen for 5 minutes." 90 s is
-# still generous enough for a genuine slow-reason path on IQ2_M
-# (~27 tok/s decode → ~2400 reasoning tokens) but roughly 3×
-# snappier to bail out.
+# These are a RUNAWAY guard, not a reasoning budget. The earlier tight
+# values (90 s / 4000 chars ≈ 1000 tokens) aborted legitimate long
+# reasoning and were disabled 2026-04-27 (see features.THINKING_CAPS).
+# They are re-enabled now with far more generous bounds after a real
+# 29-minute / 94.8k-token runaway on Qwen Q8 with thinking on: the
+# cap must never touch normal reasoning, only a pathological loop.
 #
-# The character cap catches the other failure mode: the model
-# produces reasoning tokens FAST (not slow) but endlessly — tree
-# diagrams, vocabulary lists, full SPAs drafted inline. Rule 23 in
-# the system prompt bans those, but IQ2 compliance is imperfect;
-# 4000 chars ≈ 45 lines ≈ the point where reasoning has clearly
-# exceeded any legit planning budget.
-
-MAX_THINKING_SECONDS = 90
-MAX_THINKING_CHARS = 4000
+#   * 600 s (10 min): a genuine slow-reason path on a heavy Q8 model
+#     (~50-75 tok/s) fits comfortably; a 29-minute loop does not.
+#   * 80000 chars (~20k reasoning tokens): well above any legitimate
+#     planning trace; the observed runaway was ~380k chars.
+#
+# With reasoning now streamed live in the TUI, the user also SEES a
+# runaway and can `esc` — the cap is the backstop for unattended /
+# headless runs where no one is watching.
+
+MAX_THINKING_SECONDS = 600
+MAX_THINKING_CHARS = 80000
 
 
 # ── Tool-result size policy ─────────────────────────────────────────

{localcode-0.3.31 → localcode-0.3.33}/src/localcode/agent/loop.py

@@ -965,12 +965,12 @@ def run_agent_loop(
         # If we bailed on a stuck thinking loop, tell the user explicitly so
         # they know why the turn ended and can try a different prompt.
         if _stream_result.thinking_abort:
-            out.print_info(
+            out.notice(
                 f"Stopped: model reasoning exceeded the per-round cap "
                 f"({MAX_THINKING_SECONDS}s or {MAX_THINKING_CHARS} chars) without "
-                f"emitting a response. Small quantized models (IQ2_M, IQ3_S) often "
-                f"produce better output in fast mode — try `/mode` to switch, or "
-                f"rephrase the task in smaller steps."
+                f"emitting a response. Turn off deep reasoning with `/thinking off`, "
+                f"switch to a faster model with `/model`, or rephrase the task in "
+                f"smaller steps."
             )
 
         # Show thinking summary if present (collapsed, dim)

{localcode-0.3.31 → localcode-0.3.33}/src/localcode/features.py

@@ -162,11 +162,13 @@ FEATURE_DEFAULTS: dict[Feature, bool] = {
     Feature.TOOL_RESULT_AGING: True,
     Feature.CONTEXT_SHIFT: True,
 
-    # Decode safety. THINKING_CAPS disabled by user request 2026-04-27 —
-    # the per-round caps were aborting useful long-reasoning rounds and
-    # causing more failures than they prevented. Re-enable only if the
-    # "15-minute reasoning" failure mode reappears.
-    Feature.THINKING_CAPS: False,
+    # Decode safety. Re-enabled 2026-07-19 after a real 29-minute /
+    # 94.8k-token thinking runaway (Qwen Q8, thinking on) that never
+    # produced output. Disabled 2026-04-27 because the caps were far too
+    # tight (90 s / 4000 chars) and aborted useful reasoning; now paired
+    # with GENEROUS bounds (600 s / 80000 chars, see constants.py) that
+    # only catch a pathological loop, never normal reasoning.
+    Feature.THINKING_CAPS: True,
     Feature.AUTO_NUDGE_RECOVERY: True,
 
     # Runtime — on. The pressure monitor specifically is what

{localcode-0.3.31 → localcode-0.3.33}/src/localcode/hf_quants.py

@@ -76,18 +76,37 @@ class Quant:
 
 
 def _quant_from_entry(entry: dict) -> Quant | None:
-    """Build a Quant from one HF tree entry, or None if it's not a .gguf."""
+    """Build a Quant from one HF tree entry, or None if it's not a selectable
+    model-weight quant.
+
+    The browser lists things the user PICKS. It must show only real model-weight
+    quants — never sidecar files, which are tiny and confusing next to a
+    multi-GB model (a 12B repo showing "BF16 · 0.9 GB" rows is the vision
+    projector, not a 12B model). Dropped here:
+      - vision projectors (`mmproj-*.gguf`) — auto-paired with the chosen quant
+        via the catalog's mmproj fields, never selected directly
+      - speculative-decoding draft heads (`mtp-*.gguf`) and anything in a
+        subfolder (e.g. `MTP/…`) — not standalone models
+      - any file with no recognizable quant code (`…-it.gguf` extras)
+    """
     path = entry.get("path", "")
     if not path.lower().endswith(".gguf"):
         return None
     base = path.rsplit("/", 1)[-1]
-    is_mmproj = base.lower().startswith("mmproj")
+    lowered = base.lower()
+    # Subfolder files (e.g. `MTP/gemma-…-Q4_0.gguf`) are never top-level
+    # 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_"):
+        return None
     label = _parse_label(path)
-    # Keep only real weight quants and vision projectors. Anything else with
-    # no quant code (MTP drafters, `…-it.gguf` extras) is repo noise — drop it
-    # so the picker never shows rows like "it · 0.5 GB" / "MTP · 0.5 GB".
-    if label is None and not is_mmproj:
+    # Real weight quants carry a quant code (Q4_K_M, IQ3_S, BF16, …). Anything
+    # else is repo noise — drop it so the picker never shows junk rows.
+    if label is None:
         return None
+    is_mmproj = False
     # LFS weights store the true size under entry["lfs"]["size"]; fall back to
     # the top-level "size" for non-LFS files.
     lfs = entry.get("lfs") or {}
@@ -95,8 +114,7 @@ def _quant_from_entry(entry: dict) -> Quant | None:
     return Quant(
         filename=path,
         size_gb=round(size_bytes / 1e9, 3),
-        # mmproj sidecars have no quant code — show their precision instead.
-        label=label or (base[:-5].split("-")[-1] if base.lower().endswith(".gguf") else base),
+        label=label,
         is_mmproj=is_mmproj,
     )
 

{localcode-0.3.31 → localcode-0.3.33}/src/localcode/models_catalog.py

@@ -191,6 +191,28 @@ CHOICES: list[ModelChoice] = [
         mmproj_size_gb=1.2,
         mmproj_hf_filename="mmproj-F16.gguf",
     ),
+    ModelChoice(
+        key="gemma-12b",
+        name="Gemma 4 12B (Q4)",
+        hf_repo="unsloth/gemma-4-12b-it-GGUF",
+        filename="gemma-4-12b-it-UD-Q4_K_XL.gguf",
+        size_gb=7.37,
+        active_params="12B (dense)",
+        architecture="gemma4-iswa",
+        license="Apache 2.0",
+        humaneval_pass_at_1=None,
+        notes=(
+            "Mid-sized dense Gemma 4 — sits between E4B and the 26B MoE. "
+            "UD-Q4_K_XL fits 16 GB unified memory (~7.4 GB weights + KV + mmproj). "
+            "Native multimodal (vision + audio). Apache 2.0. Upstream silently "
+            "refreshed these weights 2026-07-16 (tool-calling + vision fixes, same "
+            "filenames) — copies downloaded before then are stale; delete and "
+            "re-download to pick up the fixes."
+        ),
+        mmproj_filename="mmproj-gemma-4-12b-F16.gguf",
+        mmproj_size_gb=0.86,
+        mmproj_hf_filename="mmproj-F16.gguf",
+    ),
     ModelChoice(
         key="gemma-12b-bf16",
         name="Gemma 4 12B (BF16, full)",
@@ -214,73 +236,6 @@ CHOICES: list[ModelChoice] = [
         mmproj_size_gb=0.86,  # 862 MB; repo offers BF16 + F16, both 862 MB
         mmproj_hf_filename="mmproj-F16.gguf",
     ),
-    ModelChoice(
-        key="gemma-12b-qat",
-        name="Gemma 4 12B QAT (Q4)",
-        hf_repo="unsloth/gemma-4-12B-it-qat-GGUF",
-        filename="gemma-4-12B-it-qat-UD-Q4_K_XL.gguf",
-        size_gb=6.72,
-        active_params="12B (dense)",
-        architecture="gemma4-iswa",
-        license="Apache 2.0",
-        humaneval_pass_at_1=None,
-        notes=(
-            "Quantization-aware-trained 12B — Google trained the quantized weights "
-            "directly, so Q4 keeps near-BF16 quality at 6.7 GB (vs 7.4 GB for the "
-            "post-hoc Q4 entry). Lightest full-quality Gemma pick for 16 GB Macs. "
-            "Repo ships a single UD-Q4_K_XL quant. NOTE: its mmproj sidecar is a "
-            "smaller ~175 MB projector than the 862 MB one in the non-QAT repo — "
-            "vision output is untested on this stack. Filenames verified against "
-            "the repo (2026-07-19); weights carry the 2026-07-17 upstream refresh."
-        ),
-        mmproj_filename="mmproj-gemma-4-12B-qat-F16.gguf",
-        mmproj_size_gb=0.18,
-        mmproj_hf_filename="mmproj-F16.gguf",
-    ),
-    ModelChoice(
-        key="gemma-qat",
-        name="Gemma 4 26B-A4B QAT (Q4)",
-        hf_repo="unsloth/gemma-4-26B-A4B-it-qat-GGUF",
-        filename="gemma-4-26B-A4B-it-qat-UD-Q4_K_XL.gguf",
-        size_gb=14.25,
-        active_params="3.8B (top-8 of 128 experts)",
-        architecture="gemma4-iswa",
-        license="Apache 2.0",
-        humaneval_pass_at_1=None,
-        notes=(
-            "Quantization-aware-trained 26B MoE — same architecture and decode "
-            "speed class as the IQ3_S entry but QAT preserves near-BF16 quality "
-            "at Q4. 14.3 GB weights → needs 32 GB unified memory (the IQ3_S entry "
-            "remains the 16 GB pick). Repo ships a single UD-Q4_K_XL quant. "
-            "Filenames verified against the repo (2026-07-19); weights carry the "
-            "2026-07-17 upstream refresh (tool-calling + vision fixes)."
-        ),
-        mmproj_filename="mmproj-gemma-4-26B-A4B-qat-F16.gguf",
-        mmproj_size_gb=1.19,
-        mmproj_hf_filename="mmproj-F16.gguf",
-    ),
-    ModelChoice(
-        key="gemma-31b-qat",
-        name="Gemma 4 31B QAT (Q4)",
-        hf_repo="unsloth/gemma-4-31B-it-qat-GGUF",
-        filename="gemma-4-31B-it-qat-UD-Q4_K_XL.gguf",
-        size_gb=17.29,
-        active_params="31B (dense)",
-        architecture="gemma4-iswa",
-        license="Apache 2.0",
-        humaneval_pass_at_1=None,
-        notes=(
-            "Largest dense Gemma 4 — first 31B entry in the catalog. QAT Q4 keeps "
-            "near-BF16 quality at 17.3 GB, but dense 31B decode is memory-bandwidth "
-            "bound: expect roughly a third of the 26B MoE's speed. Needs ≥32 GB "
-            "unified memory (tight); comfortable at 48-64 GB. Repo ships a single "
-            "UD-Q4_K_XL quant. Filenames verified against the repo (2026-07-19); "
-            "weights carry the 2026-07-17 upstream refresh."
-        ),
-        mmproj_filename="mmproj-gemma-4-31B-qat-F16.gguf",
-        mmproj_size_gb=1.2,
-        mmproj_hf_filename="mmproj-F16.gguf",
-    ),
     ModelChoice(
         key="qwen",
         name="Qwen 3.6 35B-A3B (Q2)",
@@ -400,12 +355,10 @@ _NO_AUTO_RECOMMEND_ARCHS = {"diffusion_gemma", "cohere2_moe"}
 _RECOMMEND_ORDER = [
     "qwen-q8",         # 35B-A3B MoE, near-lossless Q8
     "gemma-q8",        # 26B-A4B MoE, near-lossless Q8
-    "gemma-qat",       # 26B-A4B MoE, QAT Q4 — near-BF16 at half the Q8 size
     "qwen",            # 35B-A3B MoE Q2 — 94.7% HumanEval
     "gemma",           # 26B-A4B MoE Q3 — 95.1% HumanEval
-    "gemma-31b-qat",   # 31B dense QAT Q4 — capable but dense-slow decode
     "gemma-12b-bf16",  # 12B dense, full precision
-    "gemma-12b-qat",   # 12B dense QAT Q4 — lightest full-quality pick
+    "gemma-12b",       # 12B dense Q4
 ]
 
 
@@ -581,57 +534,6 @@ MODEL_GROUPS: list[ModelGroup] = [
         mmproj_size_gb=0.86,
         mmproj_hf_filename="mmproj-F16.gguf",
     ),
-    ModelGroup(
-        key="gemma-4-12b-qat",
-        display_name="Gemma 4 12B QAT",
-        maker="Google",
-        hf_repo="unsloth/gemma-4-12B-it-qat-GGUF",
-        family="gemma4",
-        architecture="gemma4-iswa",
-        license="Apache 2.0",
-        notes=(
-            "Quantization-aware-trained 12B — near-BF16 quality at Q4. The repo "
-            "ships a single UD-Q4_K_XL quant plus a smaller ~175 MB mmproj "
-            "(vision untested on this stack)."
-        ),
-        mmproj_filename="mmproj-gemma-4-12B-qat-F16.gguf",
-        mmproj_size_gb=0.18,
-        mmproj_hf_filename="mmproj-F16.gguf",
-    ),
-    ModelGroup(
-        key="gemma-4-26b-a4b-qat",
-        display_name="Gemma 4 26B-A4B QAT",
-        maker="Google",
-        hf_repo="unsloth/gemma-4-26B-A4B-it-qat-GGUF",
-        family="gemma4",
-        architecture="gemma4-iswa",
-        license="Apache 2.0",
-        notes=(
-            "Quantization-aware-trained 26B MoE — near-BF16 quality at Q4, "
-            "~3.8B active (top-8 of 128 experts). Single UD-Q4_K_XL quant; "
-            "needs 32 GB unified memory."
-        ),
-        mmproj_filename="mmproj-gemma-4-26B-A4B-qat-F16.gguf",
-        mmproj_size_gb=1.19,
-        mmproj_hf_filename="mmproj-F16.gguf",
-    ),
-    ModelGroup(
-        key="gemma-4-31b-qat",
-        display_name="Gemma 4 31B QAT",
-        maker="Google",
-        hf_repo="unsloth/gemma-4-31B-it-qat-GGUF",
-        family="gemma4",
-        architecture="gemma4-iswa",
-        license="Apache 2.0",
-        notes=(
-            "Largest dense Gemma 4 — QAT Q4, near-BF16 quality. Single "
-            "UD-Q4_K_XL quant (~17.3 GB); needs ≥32 GB unified memory, "
-            "comfortable at 48-64 GB."
-        ),
-        mmproj_filename="mmproj-gemma-4-31B-qat-F16.gguf",
-        mmproj_size_gb=1.2,
-        mmproj_hf_filename="mmproj-F16.gguf",
-    ),
     ModelGroup(
         key="qwen-3.6-35b-a3b",
         display_name="Qwen 3.6 35B-A3B",

{localcode-0.3.31 → localcode-0.3.33}/src/localcode/output.py

@@ -355,6 +355,14 @@ class OutputManager:
         if was_running:
             self._start_indicator()
 
+    def notice(self, text: str) -> None:
+        """User-facing notice shown in BOTH the CLI (dim stdout) and the TUI
+        (as an info line). Unlike print_info — which is stdout-only and so is
+        invisible in the TUI — this emits an event the TUI renders. Use it for
+        anything the user must actually see (e.g. why a turn ended)."""
+        self.print_info(text)
+        self._emit_event("notice", text=text)
+
     # ── Indicator (background thread) ────────────────────────────────
 
     def _start_indicator(self) -> None:

{localcode-0.3.31 → localcode-0.3.33}/src/localcode/runtime.py

@@ -16,31 +16,6 @@ from .model_families import (
 )
 
 
-#: Low default sampling temperature for coding. On quantized local models a
-#: low temperature is the single strongest anti-hallucination lever — Gemma's
-#: 1.0 and Qwen's 0.7 were tuned for prose, not code. Overridable per-user via
-#: the LOCALCODE_CODING_TEMP env var so the change is fully reversible
-#: (=0.7 restores the old Qwen cap, =1.0 the old Gemma behaviour).
-_CODING_TEMPERATURE_DEFAULT = 0.25
-
-
-def _coding_temperature() -> float:
-    """The coding temperature ceiling (default 0.25), overridable via
-    LOCALCODE_CODING_TEMP. A malformed value falls back to the default."""
-    import os
-    raw = os.environ.get("LOCALCODE_CODING_TEMP")
-    if raw is None:
-        return _CODING_TEMPERATURE_DEFAULT
-    try:
-        val = float(raw)
-    except (TypeError, ValueError):
-        return _CODING_TEMPERATURE_DEFAULT
-    # Clamp to a sane range; temperature must be > 0 for the sampler.
-    if val <= 0:
-        return _CODING_TEMPERATURE_DEFAULT
-    return min(val, 2.0)
-
-
 def _strip_thinking_tokens(text: str, family: ModelFamily | None = None) -> str:
     """Strip thinking-channel tokens that leak through in decoded text.
 
@@ -1088,56 +1063,25 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
         return min(num_ctx, self._model_max_ctx(model_path))
 
     def _options(self, num_ctx_override: int | None = None, num_predict_override: int | None = None) -> dict[str, Any]:
-        # Sampler stack that is ACTUALLY forwarded to llama-server by _payload:
-        # temperature + DRY + min_p. Nothing else. (This dict used to also carry
-        # top_p / top_k / repeat_penalty / repeat_last_n / presence_penalty and a
-        # num_ctx — all DEAD: the llama_cpp _payload path never read them, and the
-        # ollama-shaped branch that did has been removed. Deleted to stop the
-        # confusion of "tuned" values that never reached the server.)
-        #
-        # Why only DRY + min_p as anti-loop, and NOT the top_p=0.8 / top_k=20 /
-        # repeat_penalty=1.10 bundle: re-adding that bundle caused the documented
-        # 2026-04-29 paraphrase-loop regression — repeat_penalty starved the EOS
-        # token so the model rephrased the same answer 2-3× instead of stopping.
-        #   * DRY (Don't Repeat Yourself) penalises repeated N-GRAMS, scaling the
-        #     penalty exponentially with match length. Unlike repeat_penalty it
-        #     is EOS-neutral (single tokens aren't N-grams), so it breaks phrasal
-        #     loops without suppressing the stop token.
-        #   * min_p trims the low-probability tail that token-collapse loops feed
-        #     on (Unsloth's Gemma-4 repetition fix recommends 0.05 for heavily-
-        #     quantized MoE; Qwen 0.0).
+        # Temperature + num_predict only. The FULL sampler (top_p/top_k/min_p/
+        # presence_penalty/repeat_penalty) is family- and thinking-aware and is
+        # assembled in _payload via _sampler_params — the single source of truth,
+        # forwarded verbatim to llama-server. `temperature` here mirrors that
+        # family value (thinking mode, localcode's default) so the retry/
+        # escalation path that reads _options()["temperature"] stays consistent.
         family = infer_family_from_profile(
             getattr(self.config, "model", "") or getattr(self.config, "profile", "") or ""
         )
-        # Coding temperature ceiling — low temp is the single strongest anti-
-        # hallucination lever on quantized models, so we cap ALL families to a
-        # low coding default (Gemma's 1.0 / Qwen's 0.7 were prose tunings). This
-        # only ever LOWERS temperature (a user who set a lower config temperature
-        # keeps it) and the ceiling is overridable via LOCALCODE_CODING_TEMP, so
-        # the change is fully reversible.
-        temperature = min(float(self.config.temperature), _coding_temperature())
-        # Qwen wants min_p off; Gemma-4 wants 0.05 (Unsloth's quantized-MoE fix).
-        min_p = 0.0 if family == ModelFamily.QWEN else 0.05
+        # Vendor-recommended temperature for this family; a user-set config
+        # temperature (LOCALCODE_TEMPERATURE) only ever LOWERS it, never raises.
+        _vendor_t = self._sampler_params(family, thinking=True)["temperature"]
+        try:
+            temperature = min(_vendor_t, float(self.config.temperature))
+        except Exception:
+            temperature = _vendor_t
 
         opts: dict[str, Any] = {
             "temperature": temperature,
-            "min_p": min_p,
-            "dry_multiplier": 1.5,
-            "dry_base": 1.75,
-            # allowed_length=2 catches phrasal loops (which span many tokens)
-            # but lets single tokens like "marc" or path components repeat.
-            "dry_allowed_length": 2,
-            # Limit DRY to the last 256 GENERATED tokens — NOT the whole prompt
-            # (-1). With -1, DRY penalised any string anywhere in the system
-            # prompt / file paths / prior tool results — including the user's
-            # username when it tried to emit a path (2026-04-27: mangled username
-            # variants). Scoping to 256 generated tokens catches loops the model
-            # CREATES this round while leaving prompt-side repetition untouched.
-            "dry_penalty_last_n": 256,
-            # Sequence breakers RESET DRY's n-gram matching at these tokens so a
-            # repeated file PATH / identifier isn't treated as a penalizable loop
-            # (llama.cpp's default breakers don't include path chars).
-            "dry_sequence_breakers": ["\n", "/", ".", "_", "-", " ", ":", "\"", "'"],
         }
         if self.config.mode == "fast":
             opts["num_predict"] = 4096  # cap generation for speed
@@ -1162,6 +1106,49 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
                 opts["num_predict"] = cap
         return opts
 
+    def _sampler_params(self, family: "ModelFamily", thinking: bool) -> dict[str, Any]:
+        """Vendor-recommended sampling for the active family + mode.
+
+        These are the EXACT values forwarded to llama-server — no "tuned but
+        never sent" dead knobs. LocalCode is a coding agent, so families with a
+        distinct coding profile use it. Sources (verified 2026-07):
+          * Qwen3.6-35B-A3B model card + Unsloth guide — thinking/precise-coding
+            vs general vs instruct.
+          * Gemma team / Unsloth Gemma inference config.
+
+        Key point on the loop we hit: Qwen's coding profile turns penalties OFF
+        (presence_penalty 0, repeat_penalty 1.0) and relies on a TIGHT sampler
+        (temp 0.6, top_k 20) to stay on-track. A repeat_penalty (the old 1.05)
+        penalises the EOS token → the model never stops → endless reasoning. And
+        top_k had been left at the server default 40, twice Qwen's 20, widening
+        the pool the loop wandered in. min_p 0.0 is a REAL value Qwen wants (keep
+        the tail), so it is forwarded explicitly, never dropped as falsy.
+        """
+        if family == ModelFamily.QWEN:
+            if thinking:
+                # Thinking, precise coding (WebDev) — the localcode default.
+                return {"temperature": 0.6, "top_p": 0.95, "top_k": 20,
+                        "min_p": 0.0, "presence_penalty": 0.0, "repeat_penalty": 1.0}
+            # Non-thinking / instruct.
+            return {"temperature": 0.7, "top_p": 0.80, "top_k": 20,
+                    "min_p": 0.0, "presence_penalty": 1.5, "repeat_penalty": 1.0}
+        if family == ModelFamily.GEMMA4:
+            # Gemma team optimal: temp 1.0, top_k 64, top_p 0.95, min_p 0, rp 1.0.
+            return {"temperature": 1.0, "top_p": 0.95, "top_k": 64,
+                    "min_p": 0.0, "presence_penalty": 0.0, "repeat_penalty": 1.0}
+        if family == ModelFamily.COHERE:
+            # Cohere North-Mini-Code official (used in their own coding
+            # benchmarks): temp 1.0, top_p 0.95, top_k disabled (0 → use p).
+            # It reasons every turn, so the per-turn generation cap in _options
+            # (cohere_generation_cap) is the runaway backstop, not a penalty.
+            return {"temperature": 1.0, "top_p": 0.95, "top_k": 0,
+                    "min_p": 0.0, "presence_penalty": 0.0, "repeat_penalty": 1.0}
+        # Llama / DeepSeek / unknown — safe coding default.
+        # (DiffusionGemma does NOT reach here: it runs through the diffusion
+        # runner with its own Entropy-Bound sampler, not llama-server sampling.)
+        return {"temperature": 0.6, "top_p": 0.95, "top_k": 40,
+                "min_p": 0.05, "presence_penalty": 0.0, "repeat_penalty": 1.05}
+
     def chat_once(
         self,
         messages: list[dict[str, Any]],
@@ -2175,11 +2162,23 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
         # body. (The old ollama-shaped `{"options": opts, ...}` branch and the
         # never-merged `extra` dict were dead code and have been removed.)
         opts = self._options(num_ctx_override=num_ctx, num_predict_override=num_predict)
+        family = infer_family_from_profile(
+            getattr(self.config, "model", "") or getattr(self.config, "profile", "") or ""
+        )
+        sampler = self._sampler_params(family, bool(think))
+        # A user-set temperature only ever LOWERS the vendor value (anti-
+        # hallucination), never raises it. config.temperature defaults to 1.0,
+        # so by default the vendor value stands.
+        try:
+            _user_t = float(self.config.temperature)
+        except Exception:
+            _user_t = sampler["temperature"]
+        temperature = min(sampler["temperature"], _user_t)
         payload: dict[str, Any] = {
             "model": self.config.model,
             "stream": stream,
             "messages": messages,
-            "temperature": opts["temperature"],
+            "temperature": temperature,
             "chat_template_kwargs": {"enable_thinking": think},
             # Explicit KV prefix-cache opt-in. Recent llama.cpp builds default
             # this to true for /v1/chat/completions, but TurboQuant is a fork —
@@ -2191,40 +2190,19 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
             # few hundred new tokens.
             "cache_prompt": True,
         }
-        # Single-knob anti-rephrase: `repeat_penalty=1.05` only.
-        # Added 2026-04-29 after stripping the full sampler stack
-        # killed multi-round looping but left intra-decode rephrase
-        # intact ("hows weather in tokyo" → 3 paraphrased sentences
-        # in one 80-token decode). Why ONLY this one and at 1.05
-        # (not the previous 1.10): the loop with the full stack was
-        # penalty=1.10 + top_p=0.8 + top_k=20 + DRY, which trapped
-        # the model into rephrasing because EOS was penalised AND
-        # the candidate pool was tiny. Server defaults give us
-        # top_p=0.95 / top_k=40 — plenty of escape room — so a
-        # mild 1.05 penalty discourages exact phrase repeats
-        # without starving EOS. If this re-introduces a loop,
-        # revert this hunk and accept occasional rephrase as a
-        # model property of Qwen3.6 IQ2_M.
-        payload["repeat_penalty"] = 1.05
-        # Forward the EOS-NEUTRAL anti-loop samplers (DRY + min_p). DRY
-        # penalises repeated N-GRAMS — not single tokens — so unlike
-        # repeat_penalty it does NOT suppress the EOS/sentence-end tokens that
-        # caused the 2026-04-29 paraphrase regression; min_p trims the low-
-        # probability tail that token-collapse loops feed on. llama-server has
-        # DRY OFF by default, so NOT forwarding these lets repeat-collapse loops
-        # through. We deliberately do NOT re-add the aggressive repeat_penalty
-        # /top_k/top_p bundle (that was the regression). A/B back to
-        # temperature-only with LOCALCODE_SAMPLER_MINIMAL=1.
+        # Forward the FULL vendor-recommended sampler (see _sampler_params).
+        # Previously top_k / top_p / presence_penalty were never sent (server
+        # defaults top_k=40 / top_p=0.95 stood) and min_p=0.0 was dropped as
+        # falsy — so Qwen never got its tight top_k=20 / min_p=0 profile and ran
+        # away. These are the exact vendor values; min_p 0.0 is forwarded
+        # explicitly. A/B back to temperature-only with LOCALCODE_SAMPLER_MINIMAL=1.
         import os as _os
         if _os.environ.get("LOCALCODE_SAMPLER_MINIMAL") != "1":
-            payload["dry_multiplier"] = opts["dry_multiplier"]
-            payload["dry_base"] = opts["dry_base"]
-            payload["dry_allowed_length"] = opts["dry_allowed_length"]
-            payload["dry_penalty_last_n"] = opts["dry_penalty_last_n"]
-            if opts.get("dry_sequence_breakers"):
-                payload["dry_sequence_breakers"] = opts["dry_sequence_breakers"]
-            if opts.get("min_p", 0):
-                payload["min_p"] = opts["min_p"]
+            payload["top_p"] = sampler["top_p"]
+            payload["top_k"] = sampler["top_k"]
+            payload["min_p"] = sampler["min_p"]
+            payload["presence_penalty"] = sampler["presence_penalty"]
+            payload["repeat_penalty"] = sampler["repeat_penalty"]
         if "num_predict" in opts:
             _np = opts["num_predict"]
             # llama-server treats max_tokens=-1 as "use default", which on