localcode 0.3.31__tar.gz → 0.3.32__tar.gz

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

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

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

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

{localcode-0.3.31 → localcode-0.3.32}/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.32}/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.32}/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.32}/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.32}/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.32}/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.32}/src/localcode/tui/screens/chat.py

@@ -400,13 +400,13 @@ class _ChatTextArea(TextArea):
     DEFAULT_CSS = """
     _ChatTextArea {
         background: ansi_default;
-        /* Scrollbar shows once the input grows past its cap. Force the brand
-           blue + a thin bar — otherwise it inherits the textual-ansi theme's
-           `scrollbar: ansi_blue`, which renders as the terminal's dark navy
-           (the "wrong blue"). */
-        scrollbar-color: #5f87ff;
-        scrollbar-color-hover: #5f87ff;
-        scrollbar-color-active: #7aa2ff;
+        /* Scrollbar shows once the input grows past its cap. Match the rest of
+           the app's grey scrollbars (see styles/app.tcss) instead of a brand
+           blue — otherwise it also inherits the textual-ansi theme's
+           `scrollbar: ansi_blue` navy, which clashes. */
+        scrollbar-color: #333333;
+        scrollbar-color-hover: #555555;
+        scrollbar-color-active: #666666;
         scrollbar-background: ansi_default;
         scrollbar-size-vertical: 1;
         & .text-area--cursor-line {
@@ -1072,6 +1072,7 @@ class ChatScreen(Screen):
         # triangle. Earlier expanded-by-default flooded the chat with
         # multi-paragraph reasoning the user didn't want by default.
         self._thinking_expanded: bool = False
+        self._thinking_streamed: bool = False  # live reasoning shown this turn
         self._slash_matches: list[tuple[str, str]] = []  # current filtered commands
         self._slash_selected: int = 0  # highlighted index in slash menu
         # Search state
@@ -4153,6 +4154,11 @@ class ChatScreen(Screen):
             # Hide animation once content starts flowing
             if self._active_mode:
                 self._hide_active_step()
+            # Close any live reasoning stream before the answer starts so the
+            # dimmed thinking and the answer don't interleave.
+            if getattr(self, "_thinking_streamed", False):
+                log.end_thinking_stream()
+                self._thinking_streamed = False
             chunk = p.get("chunk", "")
             self._stream_buf.append(chunk)
             # Stream tokens to display in real time
@@ -4359,29 +4365,39 @@ class ChatScreen(Screen):
         elif t == "thinking_start":
             self._thinking_phase = "thinking"
             self._thinking_text = ""
+            self._thinking_streamed = False
             self._show_active_thinking("thinking")
         elif t == "thinking_chunk":
             chunk = p.get("chunk", "")
             self._thinking_text += chunk
             self._turn_tokens += max(1, len(chunk) // 4) if chunk else 0
             self._thinking_phase = "thinking"
-            # Do NOT touch the spinner word here — the word rotates on the
-            # 50 ms wall-clock timer in _tick_active, so a fast decode can't
-            # strobe it (and the shimmer stays smooth instead of jumping on
-            # every irregular chunk). Just make sure the animation is running.
-            if self._active_mode != "thinking":
+            # Stream the reasoning to the log live (like Claude Code / Codex)
+            # instead of hiding it. On the first chunk, drop the spinner and
+            # start the dimmed reasoning stream; then feed each chunk.
+            if chunk:
+                if not self._thinking_streamed:
+                    self._hide_active_step()
+                    self._thinking_streamed = True
+                log.stream_thinking(chunk)
+            elif self._active_mode != "thinking" and not self._thinking_streamed:
                 self._show_active_thinking("thinking")
         elif t == "thinking_peek":
             self._thinking_phase = "thinking"
             # thinking_peek carries model text in p["text"]; deliberately
-            # ignore it — the timer picks the placeholder word (see above).
-            if self._active_mode != "thinking":
+            # ignore it — the live stream (thinking_chunk) shows the real text.
+            if self._active_mode != "thinking" and not self._thinking_streamed:
                 self._show_active_thinking("thinking")
         elif t == "thinking_done":
             text = p.get("text", "")
             self._thinking_text = text
             self._hide_active_step()
-            if text.strip():
+            # If we already streamed the reasoning live, it's on screen — just
+            # close the stream. Only fall back to the collapsible block when
+            # nothing streamed (e.g. a model that emits thinking only at the end).
+            if self._thinking_streamed:
+                log.end_thinking_stream()
+            elif text.strip():
                 log.append_thinking(text, expanded=self._thinking_expanded)
         elif t == "stream_start":
             self._thinking_phase = "generating"
@@ -4390,7 +4406,20 @@ class ChatScreen(Screen):
             # Hide any active tool step animation
             if self._active_mode == "tool":
                 self._hide_active_step()
+        elif t == "notice":
+            # User-facing notice (e.g. why a turn ended). Close any live
+            # reasoning stream first so the notice isn't dimmed/indented under it.
+            if getattr(self, "_thinking_streamed", False):
+                log.end_thinking_stream()
+                self._thinking_streamed = False
+            text = p.get("text", "")
+            if text:
+                log.append_info(text)
         elif t == "error":
+            # Close a dangling reasoning stream so the error isn't dimmed/indented.
+            if getattr(self, "_thinking_streamed", False):
+                log.end_thinking_stream()
+                self._thinking_streamed = False
             msg = p.get("message", "Unknown error")
             log.append_error(msg)
         elif t == "stage":

{localcode-0.3.31 → localcode-0.3.32}/src/localcode/tui/widgets/chat_log.py

@@ -770,6 +770,72 @@ class ChatLog(RichLog):
         self._thinking_states[idx] = expanded
         self._render_thinking(text, expanded, idx)
 
+    # ── Live reasoning stream ──────────────────────────────────────────
+    # Show the model's reasoning as it arrives (like Claude Code / Codex),
+    # instead of hiding it behind a spinner and dumping the whole trace at the
+    # end. Each completed line is committed to `_history` as a dimmed
+    # `think_line` entry (with a one-time `think_header`) — append-only, so it
+    # can't flicker, AND it survives `_rerender` (a resize / thinking-toggle
+    # rebuilds the log purely from `_history`, which would otherwise wipe any
+    # lines written outside it).
+
+    def start_thinking_stream(self) -> None:
+        if getattr(self, "_think_stream_active", False):
+            return
+        self._think_stream_buf = ""
+        self._think_stream_active = True
+        self._dispatch_gap("thinking")
+        self._history.append(("think_header",))
+        self._render_think_header()
+
+    def stream_thinking(self, chunk: str) -> None:
+        if not chunk:
+            return
+        if not getattr(self, "_think_stream_active", False):
+            self.start_thinking_stream()
+        self._think_stream_buf += chunk
+        # Commit completed lines; keep the trailing partial buffered so we
+        # never render half a word mid-flight.
+        while "\n" in self._think_stream_buf:
+            line, self._think_stream_buf = self._think_stream_buf.split("\n", 1)
+            self._commit_thinking_line(line)
+
+    def _commit_thinking_line(self, line: str) -> None:
+        line = line.rstrip()
+        if not line:
+            return
+        self._history.append(("think_line", line))
+        self._render_think_line(line)
+
+    def end_thinking_stream(self) -> None:
+        if not getattr(self, "_think_stream_active", False):
+            return
+        if self._think_stream_buf.strip():
+            self._commit_thinking_line(self._think_stream_buf)
+        self._think_stream_buf = ""
+        self._think_stream_active = False
+
+    def _render_think_header(self) -> None:
+        hdr = Text()
+        hdr.append("  ✳ ", style="cyan")
+        hdr.append("thinking…", style="dim italic cyan")
+        self.write(hdr)
+        self._track_lines()
+
+    def _render_think_line(self, line: str) -> None:
+        import textwrap
+        try:
+            avail = self._content_width()
+        except Exception:
+            avail = 76
+        wrapped = textwrap.fill(
+            line, width=max(avail - 4, 30),
+            initial_indent="    ", subsequent_indent="    ",
+        )
+        for wline in wrapped.split("\n"):
+            self.write(Text(wline, style="dim italic"))
+            self._track_lines()
+
     def append_approval(self, tool_name: str, command: str) -> None:
         self._dispatch_gap("approval")
         self._history.append(("approval", tool_name, command))
@@ -1247,6 +1313,15 @@ class ChatLog(RichLog):
             elif kind == "raw":
                 self.write(entry[1])
                 self._track_lines()
+            elif kind == "think_header":
+                # Streamed reasoning header — same gap contract as a thinking
+                # block; the dimmed lines that follow get no inter-line gap.
+                self._dispatch_gap("thinking")
+                self._render_think_header()
+                self._last_kind = "thinking"
+            elif kind == "think_line":
+                self._render_think_line(entry[1])
+                self._last_kind = "thinking"
             else:
                 # Centralized spacing: one rule for every kind transition.
                 self._dispatch_gap(kind)

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

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

{localcode-0.3.31 → localcode-0.3.32}/src/localcode.egg-info/SOURCES.txt

@@ -960,6 +960,7 @@ tests/test_output.py
 tests/test_paste_collapse.py
 tests/test_path_healing.py
 tests/test_prompt_language_steering.py
+tests/test_quant_browser_and_thinking.py
 tests/test_real_models.py
 tests/test_run_json.py
 tests/test_runtime.py

{localcode-0.3.31 → localcode-0.3.32}/tests/test_architecture.py

@@ -511,7 +511,7 @@ def test_model_identity_line_friendly_name_and_quant():
     from localcode.agent.prompts import model_identity_line
 
     cases = {
-        "gemma-4-12B-it-qat-UD-Q4_K_XL.gguf": "Gemma 4 12B QAT (Q4)",
+        "gemma-4-12b-it-UD-Q4_K_XL.gguf": "Gemma 4 12B (Q4)",
         "Qwen3.6-35B-A3B-UD-IQ2_M.gguf": "Qwen 3.6 35B-A3B (Q2)",
         "diffusiongemma-26B-A4B-it-Q4_K_M.gguf": "DiffusionGemma 26B-A4B (Q4)",
     }
@@ -546,7 +546,7 @@ def test_assembled_system_prompt_contains_model_identity():
     app = SimpleNamespace(
         repo_root=Path("/tmp/x"),
         config=SimpleNamespace(
-            runtime=SimpleNamespace(model="gemma-4-12B-it-qat-UD-Q4_K_XL.gguf")
+            runtime=SimpleNamespace(model="gemma-4-12b-it-UD-Q4_K_XL.gguf")
         ),
         _recent_tool_names=[],
         _last_failed_tool_name="",
@@ -560,8 +560,8 @@ def test_assembled_system_prompt_contains_model_identity():
         network_status="Network: ONLINE",
         use_thinking=False,
     )
-    assert "Gemma 4 12B QAT (Q4)" in result.system_prompt
-    assert "Gemma 4 12B QAT (Q4)" in result.system_prompt
+    assert "Gemma 4 12B (Q4)" in result.system_prompt
+    assert "Gemma 4 12B (Q4)" in result.system_prompt
     assert "exactly" in result.system_prompt.lower()
 
 

{localcode-0.3.31 → localcode-0.3.32}/tests/test_comprehensive_bg_download.py

@@ -161,7 +161,7 @@ def test_concurrency_cap_leaves_extras_queued(monkeypatch, not_on_disk):
 
     # Four distinct catalog entries -> four distinct registry keys.
     keys = [bootstrap.start_background_download(_choice(k))
-            for k in ("gemma", "gemma-12b-qat", "gemma-12b-bf16", "qwen")]
+            for k in ("gemma", "gemma-12b", "gemma-12b-bf16", "qwen")]
     assert len(set(keys)) == 4
 
     # Two should reach 'downloading'; the cap holds the other two 'queued'.