localcode 0.3.32__py3-none-any.whl → 0.3.34__py3-none-any.whl

localcode/agent/constants.py

@@ -81,20 +81,20 @@ 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."""
+The primary control is llama.cpp's per-request `thinking_budget_tokens`: it
+forces the template's end-thinking sequence and lets the SAME generation move
+on to a tool call. Feature.THINKING_CAPS + MAX_THINKING_SECONDS / CHARS are
+compatibility backstops for templates whose thinking tags the server cannot
+identify. Leaving MAX_OUTPUT_TOKENS at -1 keeps valid long tool calls intact
+without leaving the reasoning channel unbounded."""
 
 
 # ── Thinking-phase safety caps ──────────────────────────────────────
 #
-# Bound how much reasoning the model emits before we force a
-# transition to content / tool_calls. Either cap trips a
-# `_thinking_abort`, which surfaces a clear user message and ends
-# the turn.
+# Bound how much reasoning Python will accept if the server-side token budget
+# cannot recognize the model's thinking delimiters. Either cap trips a
+# `_thinking_abort`. Exact periodic loops retry once with thinking disabled;
+# other runaways surface a clear user message.
 #
 # These are a RUNAWAY guard, not a reasoning budget. The earlier tight
 # values (90 s / 4000 chars ≈ 1000 tokens) aborted legitimate long

localcode/agent/loop.py

@@ -262,11 +262,18 @@ def run_agent_loop(
     from ..app import is_online
     online = is_online()
     if online:
-        network_status = "Network: ONLINE — you can download files, install packages, fetch URLs."
+        network_status = (
+            "Network: ONLINE — you can download files, install packages, fetch URLs. "
+            "PREFER your tools over writing from memory: web_search / web_fetch to "
+            "confirm current facts, versions, and library docs; your skills and other "
+            "tools for anything they cover. Don't hand-write what a tool can get right."
+        )
     else:
         network_status = (
             "Network: OFFLINE — NO internet. Do NOT attempt downloads, pip install, curl, wget, or any network requests. "
-            "Use only local files and already-installed packages. Generate sample/mock data locally instead of downloading."
+            "Use only local files, already-installed packages, and your LOCAL skills and "
+            "tools (read/grep/edit, installed CLIs). Generate sample/mock data locally "
+            "instead of downloading."
         )
     def _current_task_stage_for_thinking() -> str:
         stage = str(_last_announced_task_stage or getattr(_task_state, "current_stage", "") or "").strip()
@@ -431,6 +438,9 @@ def run_agent_loop(
     _todo_stuck_count = 0
     _last_todo_remaining = 10**9
     _edit_recovery_nudges = 0
+    # Set when a round aborts on a detected reasoning loop; forces the very next
+    # round to decode with thinking off so the retry escapes the attractor.
+    _force_no_think_next_round = False
     _MAX_CONSECUTIVE_CORRECTIONS = 2
     _generic_correction_nudges = 0
     # Fires at most once per turn when an identical failing call crosses the
@@ -454,6 +464,11 @@ def run_agent_loop(
     # agent/recovery.py (T0.1-d split).
     _empty_rounds_this_turn = 0
     _MAX_EMPTY_ROUND_RETRIES = MAX_EMPTY_ROUND_RETRIES
+    # Loop-abort decode-recovery: how many times this turn a detected reasoning
+    # loop forced a no-thinking retry. Capped so a model that keeps degenerating
+    # even without the reasoning channel can't spin the turn forever.
+    _thinking_loop_recoveries = 0
+    _MAX_THINKING_LOOP_RECOVERIES = 2
     _last_round_signature: tuple[int, str] | None = None
     _same_round_signature_count = 0
     _same_round_synthetic_rejections = 0
@@ -785,6 +800,16 @@ def run_agent_loop(
             task_stage=round_task_stage,
             user_text=user_text,
         )
+        # Cycle-breaker: the PREVIOUS round degenerated into a reasoning loop and
+        # aborted. Retrying with the reasoning channel still on re-enters the same
+        # attractor (same prompt, same samplers, same template) — a text nudge
+        # alone doesn't change the decode. So force this one retry to decode with
+        # thinking OFF, which actually changes the generation path and lets the
+        # model emit a tool call. This is fault recovery, not a reinterpretation
+        # of the user's `on` setting: normal rounds keep thinking.
+        if _force_no_think_next_round:
+            round_use_thinking = False
+            _force_no_think_next_round = False
         try:
             _ctx_chars = None
             try:
@@ -962,9 +987,48 @@ def run_agent_loop(
             _loop_exit_reason = f"stream_error:{type(exc).__name__}"
             break
 
-        # 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 the server-side reasoning budget could not transition the model,
+        # recover a periodic loop automatically; report other cap aborts.
         if _stream_result.thinking_abort:
+            try:
+                from ..events import emit as _emit_ta
+                _emit_ta(
+                    "thinking_abort",
+                    round_idx=round_num,
+                    reason=_stream_result.thinking_abort_reason or "unknown",
+                )
+            except Exception:
+                pass
+            if (
+                _stream_result.thinking_abort_reason == "loop"
+                and _thinking_loop_recoveries < _MAX_THINKING_LOOP_RECOVERIES
+            ):
+                # Detected a degenerate repetition loop early. This is DECODE
+                # recovery, not an optional textual nudge — do it explicitly and
+                # independently of AUTO_NUDGE_RECOVERY. Drop the aborted (empty)
+                # round entirely (never append its assistant message) and re-run
+                # the SAME round with thinking off (consumed at the top of the
+                # loop), which changes the generation path and breaks the loop.
+                _thinking_loop_recoveries += 1
+                _force_no_think_next_round = True
+                out.notice(
+                    "Model reasoning started repeating itself — retrying this "
+                    "step without deep reasoning so it acts instead of looping."
+                )
+                out._stop_indicator()
+                sys.stdout.write("\r\033[K")
+                sys.stdout.flush()
+                continue  # next round: decodes with think=False
+            if _stream_result.thinking_abort_reason == "loop":
+                # Recovery budget exhausted: the model kept looping even without
+                # the reasoning channel. End the turn with an honest message.
+                out.notice(
+                    "Model kept repeating itself even without deep reasoning — "
+                    "ending the turn. Try `/model` to switch models or split the "
+                    "task into smaller steps."
+                )
+                _loop_exit_reason = "thinking_loop_exhausted"
+                break
             out.notice(
                 f"Stopped: model reasoning exceeded the per-round cap "
                 f"({MAX_THINKING_SECONDS}s or {MAX_THINKING_CHARS} chars) without "

localcode/agent/prompt_context.py

@@ -122,6 +122,18 @@ def build_target_grounding_block(repo_root: Any, goal_state: Any) -> str:
         root = str(repo_root or "")
     if not root:
         return ""
+    # Don't anchor to $HOME. When localcode is launched outside any project
+    # (no .git/package.json/etc. marker found), repo_root falls back to the
+    # user's home dir. Telling the model "the project root is /Users/<name>,
+    # create all files under that root" then makes it try to build in $HOME —
+    # or conflict with the path the user actually named in the task ("work at
+    # root vs. the Anki/... path they gave"). In that unanchored case, emit no
+    # directive and let the model follow the location from the user's request.
+    try:
+        if Path(root) == Path.home():
+            return ""
+    except Exception:
+        pass
     return (
         "\n\nTarget location (work here, do not drift):\n"
         f"- The project root is: {root}\n"

localcode/agent/prompts.py

@@ -68,6 +68,10 @@ VERIFY BEFORE YOU CLAIM DONE:
 - After building something runnable, actually run it (build, tests, or a real probe) and read the output. "It should work" is not verification.
 - Report outcomes faithfully: if a build/test fails, say so with the output; if you skipped a step, say that.
 
+END WITH A SUMMARY, NOT A DEBUG NOTE:
+- Your FINAL message (the one where you stop and hand back to the user) must be a short completion summary — never a low-level note like "cleared the cache" or "that fixed it". The user needs to know what they got and how to use it.
+- Say, in a few lines: WHAT you built, WHERE it lives (the project path), and the EXACT commands to run it — e.g. `cd <project-dir> && npm install && npm run dev`, and the URL/port it serves on. For a library/script, show the run/import command. Note anything the user still needs to do.
+
 If the request is ambiguous in a way that changes your approach (stack, interface, scope), ask ONE short question first — otherwise pick the sensible default and proceed.
 
 Working directory: {cwd}

localcode/agent/reasoning_loop.py

@@ -0,0 +1,79 @@
+"""Detect a degenerate reasoning loop in the model's thinking stream.
+
+Small quantized local models sometimes collapse the reasoning channel into a
+repetition loop: the same short phrase ("let me read the file", "OK let me call
+read_file") is emitted over and over without ever transitioning to a tool call.
+Token-level sampler penalties (presence/repeat) don't reliably break a tight
+periodic oscillation, and the length cap (MAX_THINKING_CHARS) only fires after
+tens of thousands of wasted characters — minutes later on a local model.
+
+Detection is by STRUCTURE, not content: we look for exact *periodicity* in the
+tail of the reasoning stream — a substring that repeats with a fixed period.
+That is what an autoregressive degeneration loop actually is, and it catches the
+phrase in any language on any task within a few repetitions.
+
+Design notes (why this shape):
+- Operate on a raw character tail, NOT on split lines. The reasoning arrives as
+  arbitrary streaming chunks; the repeated unit may contain no newline and the
+  chunk boundaries fall differently each time, so line-splitting is fragile.
+- Anchor on the final n-gram and find its previous occurrence to derive the
+  period in one `str.rfind` (C-fast), then verify true periodicity by scanning
+  back. Cost is O(window), independent of total reasoning length, so the caller
+  can pass a bounded tail buffer and stay linear overall.
+- Require the periodic run to be both long enough (absolute chars) and to repeat
+  enough times before firing, so genuine reasoning — which is not exactly
+  periodic — is never cut.
+"""
+from __future__ import annotations
+
+__all__ = ["reasoning_is_looping"]
+
+# Need this many chars of uninterrupted reasoning before we judge at all — a
+# floor against cutting short, legitimately-repetitive planning.
+_MIN_TAIL = 300
+# Rolling tail we actually score. The caller passes a bounded buffer; we also
+# clamp here so a full-transcript caller stays cheap.
+_WINDOW = 2400
+# Length of the trailing n-gram we anchor on to recover the period. Long enough
+# to be specific (won't coincidentally reappear in prose), short enough that a
+# tight loop still contains two copies inside the window.
+_ANCHOR = 32
+# Only fire early on TIGHT loops; a very long period is better left to the
+# length/time cap (and is far likelier to be genuine varied reasoning).
+_MAX_PERIOD = 400
+# The periodic unit must repeat at least this many times...
+_MIN_REPEATS = 4
+# ...spanning at least this many characters. Whichever is larger gates.
+_MIN_SPAN = 240
+
+
+def reasoning_is_looping(text: str) -> bool:
+    """True when the tail of `text` has collapsed into an exact periodic loop.
+
+    Content-agnostic and chunk-boundary robust. Conservative: returns False on
+    short input and only fires on a genuinely periodic, sufficiently-repeated
+    tail, so varied reasoning is never aborted.
+    """
+    if not text or len(text) < _MIN_TAIL:
+        return False
+    tail = text[-_WINDOW:]
+    n = len(tail)
+    if n < _ANCHOR * 2:
+        return False
+    anchor = tail[-_ANCHOR:]
+    # Where did the final n-gram last occur before its trailing copy? The gap
+    # between the two occurrences is the loop period.
+    prev = tail.rfind(anchor, 0, n - _ANCHOR)
+    if prev == -1:
+        return False
+    period = (n - _ANCHOR) - prev
+    if period <= 0 or period > _MAX_PERIOD:
+        return False
+    # Verify the tail really is periodic with this period, measuring how far the
+    # exact repetition extends back from the end.
+    span = 0
+    i = n - 1
+    while i - period >= 0 and tail[i] == tail[i - period]:
+        span += 1
+        i -= 1
+    return span >= max(_MIN_SPAN, _MIN_REPEATS * period)

localcode/agent/streaming.py

@@ -8,8 +8,16 @@ import time
 from typing import Any, TYPE_CHECKING
 
 from .constants import MAX_OUTPUT_TOKENS, MAX_THINKING_CHARS, MAX_THINKING_SECONDS
+from .reasoning_loop import reasoning_is_looping
 from ..tools import ALL_SCHEMAS as TOOL_SCHEMAS
 
+# Rolling reasoning-tail window handed to the loop detector, and how many new
+# reasoning chars to accumulate between rescans. The window comfortably exceeds
+# the detector's own clamp so a tight loop always has two copies to anchor on;
+# the stride keeps detection to O(window) amortized per chunk.
+_THINKING_TAIL_CHARS = 2600
+_LOOP_SCAN_STRIDE = 200
+
 if TYPE_CHECKING:
     from ..app import LocalCodeApp
     from ..output import OutputManager
@@ -97,6 +105,16 @@ class StreamRoundResult:
     thinking_shown: bool = False
     content_streaming: bool = False
     thinking_abort: bool = False
+    # Why the thinking phase was aborted: "loop" (degenerate repetition detected
+    # early) or "length" (per-round char/time cap). Drives both the user-facing
+    # notice and the recovery decision (a loop-abort forces a no-thinking retry).
+    thinking_abort_reason: str = ""
+    # Bounded rolling tail of the reasoning stream, kept for the loop detector so
+    # detection stays O(window) per chunk instead of O(total) — see the thinking
+    # handler. Not part of the model transcript.
+    _thinking_tail: str = ""
+    _thinking_total_chars: int = 0
+    _last_loop_scan_total: int = 0
     finish_reason: str = ""
     raw_tail: str = ""
     content_chars: int = 0
@@ -177,14 +195,35 @@ def stream_model_round(
             out.feed_thinking(chunk)
             if result.content_streaming or result.tool_calls:
                 return
+            # Running total (avoids re-summing thinking_parts every chunk) and a
+            # bounded rolling tail for the loop detector, so both guards stay
+            # O(window) per chunk regardless of how long reasoning gets.
+            result._thinking_total_chars += len(chunk)
+            tail = result._thinking_tail + chunk
+            if len(tail) > _THINKING_TAIL_CHARS:
+                tail = tail[-_THINKING_TAIL_CHARS:]
+            result._thinking_tail = tail
             from ..features import Feature, is_enabled
             if is_enabled(Feature.THINKING_CAPS):
-                thinking_chars = sum(len(p) for p in result.thinking_parts)
+                # Degenerate-repetition guard fires FIRST: it catches a tight
+                # loop within a few repeats (~1s), where the length/time cap
+                # would burn minutes. Only rescan every _LOOP_SCAN_STRIDE new
+                # chars to bound cost.
+                if (
+                    result._thinking_total_chars - result._last_loop_scan_total
+                    >= _LOOP_SCAN_STRIDE
+                ):
+                    result._last_loop_scan_total = result._thinking_total_chars
+                    if reasoning_is_looping(result._thinking_tail):
+                        result.thinking_abort = True
+                        result.thinking_abort_reason = "loop"
+                        return
                 if (
                     time.monotonic() - stream_start > MAX_THINKING_SECONDS
-                    or thinking_chars > MAX_THINKING_CHARS
+                    or result._thinking_total_chars > MAX_THINKING_CHARS
                 ):
                     result.thinking_abort = True
+                    result.thinking_abort_reason = "length"
             return
         if typ == "content":
             chunk = _strip_thinking_tokens(event.get("content", ""))

localcode/compaction.py

@@ -113,6 +113,29 @@ def estimate_tokens(messages: list[dict[str, Any]]) -> int:
     return total_chars // _CHARS_PER_TOKEN
 
 
+def _compact_fraction() -> float:
+    """The fraction of the usable window at which auto-compaction fires.
+
+    Default COMPACT_THRESHOLD_FRACTION (0.70). Overridable via
+    LOCALCODE_COMPACT_PCT (1-100, like Claude Code's CLAUDE_AUTOCOMPACT_PCT_
+    OVERRIDE) so a user with a big machine can let context grow closer to the
+    full window before summarising, or compact earlier on a small one. Always
+    relative to the machine's real RAM-scaled context window — never a fixed
+    token count.
+    """
+    import os
+    raw = os.environ.get("LOCALCODE_COMPACT_PCT")
+    if raw is None:
+        return COMPACT_THRESHOLD_FRACTION
+    try:
+        pct = float(raw)
+    except (TypeError, ValueError):
+        return COMPACT_THRESHOLD_FRACTION
+    # Accept either a percent (1-100) or a fraction (0-1); clamp to a sane band.
+    frac = pct / 100.0 if pct > 1.0 else pct
+    return min(max(frac, 0.30), 0.95)
+
+
 def should_compact(
     messages: list[dict[str, Any]],
     context_window: int,
@@ -121,13 +144,16 @@ def should_compact(
     """Return True when the prompt is about to crowd out new generation.
 
     `context_window` is the number of tokens llama-server was launched
-    with (`-c`). `reserve_tokens` is headroom we promise to keep free.
+    with (`-c`) — the machine's real RAM-scaled window. `reserve_tokens` is
+    headroom we promise to keep free. The trigger is always a fraction of THAT
+    window (see `_compact_fraction`), so a 256K-capable machine compacts near
+    256K and a 64K one near 64K.
     """
     est = estimate_tokens(messages)
     available = context_window - reserve_tokens
     if available <= 0:
         return True
-    return est > int(available * COMPACT_THRESHOLD_FRACTION)
+    return est > int(available * _compact_fraction())
 
 
 def _split_at_keep_recent(

localcode/entrypoint.py

@@ -371,8 +371,16 @@ def main(argv: list[str] | None = None) -> None:
     # prior session's messages before showing the chat screen.
     if getattr(args, "resume", None):
         app._resume_session_id = args.resume
+    # Mouse capture OFF by default (same as tui.app.main). Capturing the mouse
+    # disables the terminal's NATIVE text selection, so Cmd+C on an empty
+    # native selection makes the terminal ring its bell — the persistent copy
+    # "beep". This is the entry point `localcode` actually uses; it previously
+    # called app.run() with Textual's mouse=True default, so the beep fix in
+    # tui.app.main never reached it. Opt back in with LOCALCODE_MOUSE=1.
+    import os as _os
+    _mouse = _os.environ.get("LOCALCODE_MOUSE", "0") == "1"
     try:
-        app.run()
+        app.run(mouse=_mouse)
     finally:
         try:
             _reset_terminal_state()

localcode/model_config.py

@@ -36,12 +36,30 @@ from __future__ import annotations
 # Qwen checkpoint path is disabled due a measured Metal SIGKILL, forcing a
 # full prompt prefill every round. 128K keeps four checkpoints and is faster
 # for long agentic tasks; 256K remains an explicit override.
+# Dedicated tier for every Apple Silicon RAM variant (MBA/MBP/Studio/Mini).
+# The VALIDATED anchors are 16→64K, 48→96K, 64→128K; every other tier is
+# INTERPOLATED strictly between its validated neighbours (or below the 16 GB
+# floor), so no tier ever exceeds a value that's already been validated on real
+# hardware — a 32 GB machine at 80K uses less KV than the 48 GB-validated 96K
+# and more than the 16 GB-validated 64K. Sizes are multiples of 8192 (clean
+# batch alignment). 256K stays an explicit override, never an auto default
+# (its checkpoint path SIGKILLs on Metal — see runtime.py).
 RAM_CTX_CEILING_TIERS: tuple[tuple[int, int], ...] = (
-    (96, 131072),   # 128K — checkpointed fast path; 256K is experimental
-    (64, 131072),   # 128K (validated; 256K KV is tight beside a Q8 model on 64 GB)
-    (48, 98304),    # 96K
+    (192, 131072),  # 192-512 GB (Studio/Pro) — 128K default; 256K via override
+    (128, 131072),  # 128 GB — 128K
+    (96,  131072),  # 96 GB  — 128K
+    (64,  131072),  # 64 GB  — 128K (validated)
+    (48,  98304),   # 48 GB  — 96K  (validated)
+    (36,  90112),   # 36 GB  — 88K  (interp 64K@16 → 96K@48)
+    (32,  81920),   # 32 GB  — 80K  (was lumped at 64K — the gap, now dedicated)
+    (24,  73728),   # 24 GB  — 72K  (interp)
+    (18,  65536),   # 18 GB  — 64K
+    (16,  65536),   # 16 GB  — 64K  (validated floor)
 )
-RAM_CTX_CEILING_DEFAULT = 65536  # 16-47 GB: 64K (validated on 16 GB)
+# <16 GB is below LocalCode's supported floor; keep the validated 64K rather
+# than a lower value, since _target_num_ctx floors there anyway (a smaller
+# ceiling would just contradict it). 16 GB is the smallest supported Mac.
+RAM_CTX_CEILING_DEFAULT = 65536
 
 
 def ram_ctx_ceiling(ram_gb: int) -> int:
@@ -57,12 +75,22 @@ def ram_ctx_ceiling(ram_gb: int) -> int:
 # (~4x heavier per token, no -fit guard). Much tighter than the turbo ladder
 # so a long unconditional-reasoning turn can't grow the KV cache until OOM.
 # Monotonic; same (min_ram_gb, ctx) high→low form.
+# Dedicated per-variant tier for the cohere2moe model too. Validated anchors:
+# 16→16K, 32→32K, 48→48K, 128→64K; intermediates interpolated between them.
+# Uncompressed f16 KV (~4x heavier than turbo), so every value is much tighter
+# than the turbo ladder above.
 COHERE_CTX_CEILING_TIERS: tuple[tuple[int, int], ...] = (
-    (96, 65536),    # 64K
-    (48, 49152),    # 48K
-    (32, 32768),    # 32K
+    (192, 65536),   # 64K
+    (128, 65536),   # 64K (validated)
+    (96,  65536),   # 64K
+    (64,  57344),   # 56K (interp 48K@48 → 64K@96)
+    (48,  49152),   # 48K (validated)
+    (36,  40960),   # 40K (interp 32K@32 → 48K@48)
+    (32,  32768),   # 32K (validated)
+    (24,  24576),   # 24K (interp 16K@16 → 32K@32)
+    (16,  16384),   # 16K (validated)
 )
-COHERE_CTX_CEILING_DEFAULT = 16384  # <32 GB: 16K (32 GB+ is the recommended floor)
+COHERE_CTX_CEILING_DEFAULT = 16384  # <16 GB: 16K (32 GB+ is the recommended floor)
 
 
 def cohere_ctx_ceiling(ram_gb: int) -> int:

localcode/runtime.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import os
 import re
 from typing import Any, Iterator
 
@@ -10,37 +11,30 @@ from .config import RuntimeConfig
 from .runtime_diffusion import _DiffusionMixin
 
 
+def _thinking_budget_tokens() -> int:
+    """Per-request reasoning-token budget sent to llama.cpp on thinking rounds.
+
+    8192 tokens ≈ 32K chars of genuine planning, but caps a degenerate phrase
+    before it eats the remaining 100K+ context. Overridable per deployment /
+    model family via LOCALCODE_THINKING_BUDGET; <= 0 disables the budget (falls
+    back to the Python-side char/time/periodicity guards only). Not yet
+    calibrated per model — see the open item to tune it against eval data.
+    """
+    raw = os.environ.get("LOCALCODE_THINKING_BUDGET", "").strip()
+    if not raw:
+        return 8192
+    try:
+        return int(raw)
+    except ValueError:
+        return 8192
+
+
 from .model_families import (
     ModelFamily, get_adapter, infer_family_from_profile,
     strip_thinking_tokens as _family_strip,
 )
 
 
-#: 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 +1082,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 +1125,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 +2181,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 +2209,38 @@ 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.
+        if think:
+            # Bound the reasoning channel at the sampler, before the stream
+            # reaches the Python-side runaway guards.  The bundled llama.cpp
+            # recognizes the active chat template's think tags and, when this
+            # budget is exhausted, forces the matching end tag so the SAME
+            # generation can proceed to text/tool calls.  This preserves the
+            # one-pass reasoning -> action protocol used by Codex, OpenCode,
+            # and pi while adopting Claude Code's separately bounded thinking
+            # budget.  It is the primary transition mechanism; the streaming
+            # char/time/periodicity checks remain compatibility backstops for
+            # templates whose reasoning tags cannot be identified.
+            #
+            # 8K tokens is deliberately not a terse "reasoning quality" cap:
+            # it allows roughly 32K chars of genuine planning, but prevents a
+            # degenerate phrase from consuming the remaining 100K+ context.
+            # Named + env-overridable (LOCALCODE_THINKING_BUDGET); <=0 omits it.
+            _budget = _thinking_budget_tokens()
+            if _budget > 0:
+                payload["thinking_budget_tokens"] = _budget
+        # 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

localcode/thinking.py

@@ -80,7 +80,17 @@ def should_use_thinking(
     if policy in {"0", "false", "no", "off", "none", ""}:
         return False
     if policy in {"1", "true", "yes", "on"}:
-        return True
+        # `on` forces reasoning on genuine decision rounds — but still skips the
+        # channel on rounds we've explicitly marked mechanical (post-write
+        # implement / verify / running / complete): there is nothing to reason
+        # about there, and forcing the degeneration-prone channel onto a
+        # mechanical round is what lets a small quantized model spiral into a
+        # repetition loop. Gating loop INCIDENCE here at the policy layer
+        # composes with the sampler thinking-budget + periodicity detector +
+        # no-think retry, which catch any residual. Reasoning stages and
+        # un-staged rounds still think, so `on` still means "reason deeply".
+        stage = (task_stage or "").strip().lower()
+        return stage not in _NO_THINKING_STAGES
     if policy == "legacy":
         return runtime_mode.endswith("-think")
     if policy == "auto":

localcode/tui/app.py

@@ -85,6 +85,11 @@ class LocalCodeTUI(App):
 
     BINDINGS = [
         Binding("ctrl+c", "copy_or_quit", "Copy/Quit", show=False, priority=True),
+        # Attach an image from the OS clipboard. Cmd+V can't be relied on for
+        # images: most terminals send NO paste event when the clipboard holds
+        # an image and no text, so the paste hook never fires. This dedicated
+        # key reads the clipboard directly, terminal-independent.
+        Binding("ctrl+g", "attach_image", "Attach image", show=False, priority=True),
     ]
 
     SCREENS = {
@@ -395,6 +400,19 @@ class LocalCodeTUI(App):
         if callable(_hint):
             _hint()
 
+    def action_attach_image(self) -> None:
+        """Ctrl+G: pull an image off the OS clipboard and attach it (works even
+        when the terminal won't deliver a Cmd+V paste event for an image)."""
+        screen = self.screen
+        handler = getattr(screen, "_attach_clipboard_image", None)
+        if callable(handler):
+            try:
+                if not handler():
+                    log = screen.query_one("#chat-log")
+                    log.append_info("[dim]No image on the clipboard — copy or screenshot one first.[/]")
+            except Exception:
+                pass
+
     # Route bridge messages to the active screen
     def on_agent_event(self, event: AgentEvent) -> None:
         screen = self.screen

localcode/tui/screens/chat.py

@@ -699,6 +699,7 @@ _SLASH_COMMANDS = [
     ("/model", "List available models / switch (e.g. /model qwen)"),
     ("/delete", "Delete a downloaded model to free disk space (asks first)"),
     ("/hooks", "Show this repo's .localcode/hooks.toml and trust it (runs shell)"),
+    ("/paste", "Attach an image/screenshot from the clipboard (or press Ctrl+G)"),
     ("/thinking", "Show / set hidden reasoning policy (off|auto)"),
     ("/sounds", "Toggle completion + approval notification sounds"),
     ("/voice", "Toggle voice mode (push-to-talk dictation into the input box)"),
@@ -718,7 +719,7 @@ _SLASH_COMMANDS = [
 # /Users/you/project — is sent to the model as a normal message instead of
 # being rejected as an "Unknown command". Only `!` enters shell mode.
 _KNOWN_COMMANDS = {name for name, _desc in _SLASH_COMMANDS} | {
-    "/quit", "/search", "/copy",
+    "/quit", "/search", "/copy", "/image",
 }
 
 
@@ -1589,15 +1590,6 @@ class ChatScreen(Screen):
                 model = "local gguf"
             else:
                 model = raw_model or "no model selected"
-        task_stage = ""
-        try:
-            task = getattr(getattr(self.tui.engine, "session", None), "current_task", None)
-            if task is not None and getattr(task, "current_stage", ""):
-                task_stage = str(getattr(task, "current_stage", "")).strip()
-            elif getattr(self.tui.engine, "_last_turn_task_stage", ""):
-                task_stage = str(getattr(self.tui.engine, "_last_turn_task_stage", "")).strip()
-        except Exception:
-            task_stage = ""
         # Server status — short, plain-English action label ("ready",
         # "loading", "stopped", "not connected") — the value word IS the state.
         provider = (config.runtime.provider or "").lower()
@@ -1725,7 +1717,6 @@ class ChatScreen(Screen):
             + f" · {server_label} · permissions: {self._permissions_label()} · "
             f"context: {pct_remaining}% free · "
             f"thinking: {thinking_label}"
-            + (f" · task: {task_stage}" if task_stage else "")
             + f" · model: {short_model}"
         )
         # Use the adaptive `build_tag` chosen above; honour the
@@ -2247,6 +2238,10 @@ class ChatScreen(Screen):
             self._handle_delete_command(text)
         elif text == "/hooks" or text.startswith("/hooks "):
             self._handle_hooks_command(text)
+        elif text == "/paste" or text == "/image":
+            log = self.query_one("#chat-log", ChatLog)
+            if not self._attach_clipboard_image():
+                log.append_info("[dim]No image on the clipboard — copy or screenshot one first.[/]")
         elif text == "/thinking" or text.startswith("/thinking "):
             self._handle_thinking_command(text)
         elif text == "/status":
@@ -2912,6 +2907,31 @@ class ChatScreen(Screen):
         except Exception:
             png = None
         if not png:
+            # Empty paste, no readable image. If the user was trying to paste an
+            # image they'd otherwise get NO feedback — show a one-time grey hint
+            # on how image pasting works, tailored to the current model. Guarded
+            # so an accidental empty Cmd+V doesn't spam it.
+            if not getattr(self, "_image_paste_hint_shown", False):
+                try:
+                    from ...models_catalog import current as current_choice
+                    log = self.query_one("#chat-log", ChatLog)
+                    choice = current_choice(self.tui.config)
+                    vis_on = bool(getattr(self.tui.config.runtime, "vision_enabled", False))
+                    if choice is not None and getattr(choice, "supports_vision", False):
+                        if not vis_on:
+                            log.append_info(
+                                "[dim]To paste an image, run /vision to enable image "
+                                "support, then paste again.[/]"
+                            )
+                            self._image_paste_hint_shown = True
+                    else:
+                        log.append_info(
+                            "[dim]To paste images, switch to a vision model "
+                            "(Gemma 4 / Qwen 3.6) with /model, then run /vision.[/]"
+                        )
+                        self._image_paste_hint_shown = True
+                except Exception:
+                    pass
             return False
         import base64
         b64 = base64.b64encode(png).decode("ascii")

localcode/tui/screens/model_picker.py

@@ -116,6 +116,13 @@ class ModelPickerScreen(Screen):
         overflow-y: auto;       /* scroll instead of clipping */
         padding: 1 2;
         border: round #5f87ff;
+        /* Grey scrollbar (matches the app); the blue border stays as the brand
+           accent, but the scroller must not be the clashing default blue. */
+        scrollbar-color: #333333;
+        scrollbar-color-hover: #555555;
+        scrollbar-color-active: #666666;
+        scrollbar-background: ansi_default;
+        scrollbar-size-vertical: 1;
     }
     #picker-list {
         background: ansi_default;

localcode/tui/styles/app.tcss

@@ -21,6 +21,20 @@ Screen {
     overflow: hidden;
 }
 
+/* ── Global scrollbar colour ──
+   Every scrollable widget's scrollbar is the app's muted grey, not the
+   textual-ansi theme's blue accent. Applied with the universal selector so
+   NO widget (chat log, input box, model picker, setup, diff panes, or any
+   future one) can reintroduce the "wrong blue" scroller — the per-widget
+   declarations elsewhere are now just belt-and-suspenders. */
+* {
+    scrollbar-color: #333333;
+    scrollbar-color-hover: #555555;
+    scrollbar-color-active: #666666;
+    scrollbar-background: ansi_default;
+    scrollbar-corner-color: ansi_default;
+}
+
 
 
 /* ── Brand bar (bottom, screens without a status row) ──

localcode/tui/widgets/chat_log.py

@@ -415,7 +415,11 @@ class ChatLog(RichLog):
         def _osc52() -> bool:
             try:
                 fd = os.open("/dev/tty", os.O_WRONLY)
-                os.write(fd, f"\033]52;c;{encoded}\a".encode())
+                # Terminate the OSC with ST (ESC \) rather than BEL (\a). Both are
+                # valid OSC terminators, but a terminal that doesn't consume the
+                # OSC 52 clipboard sequence renders a stray BEL as an audible
+                # beep on every copy. ST avoids that.
+                os.write(fd, f"\033]52;c;{encoded}\033\\".encode())
                 os.close(fd)
                 return True
             except OSError:

{localcode-0.3.32.dist-info → localcode-0.3.34.dist-info}/METADATA

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

{localcode-0.3.32.dist-info → localcode-0.3.34.dist-info}/RECORD

@@ -9,13 +9,13 @@ localcode/bootstrap.py,sha256=H12U60LLnVQek8jSgzZPf_aHONxEjNjTljG0s55lGBU,54110
 localcode/cache.py,sha256=iAb5u6nf6Xc_sbwvTpBvTo3HTo1wIzcQMLMnmFEVIY8,7949
 localcode/checkpoint.py,sha256=_XEb1WK0vrDTLj-hKsFM3lczNgEPREfgPCz3Ef6astc,15572
 localcode/compact.py,sha256=IONLoBxrcEbTm0Jv_AWLJIo-hcsHDJKDWMZkzIx6Nvc,2648
-localcode/compaction.py,sha256=oY6Ac7Wd_o9RQnolvjNkNQ-NI3IjnHGaM7zPX9nKpjI,10319
+localcode/compaction.py,sha256=QTskL_xVqjyIYf7oJIg2Q-6knjhfQk8pE4WVaw6XTIE,11421
 localcode/composer.py,sha256=xNL48AcXXiDLWja2LIqRm6NgxwaE8_HmHtvIVmXwk_0,2600
 localcode/config.py,sha256=Z-zt3Df8KSmlUXAQY7bm-OwTS_hw-w5hJ9mtbGg5kvw,24181
 localcode/context.py,sha256=67ir_rfvMzn0KGTrZOQtAnrkGJX6Vx3XyM17J56oBbc,5528
 localcode/display.py,sha256=3U4RHUTwbRRloOtnen-BiRGeRKYgzwd-6eAwtLsyGCg,1591
 localcode/embeddings.py,sha256=Zb9VppcGp3WjJTD4K9WgWwL6B0QfBwzdNANMkpiPDe8,17613
-localcode/entrypoint.py,sha256=JklE0hvKMFe1aOc92reR2N8pjPssJiRJELsSBTTLi9g,20023
+localcode/entrypoint.py,sha256=Qhrj57QkggjbgRkGMltb3PgWqAB2ksFkvZpU7dhwMCs,20578
 localcode/errors.py,sha256=PwvM-Ur2cTeXAuyJ_J-cGeezxkMl8Sq2dMPCh6IORW4,16342
 localcode/events.py,sha256=eSC7fKcGGWXxGUvxlMzZw6GrxPsNkjwC5a8QRv5r_1I,15125
 localcode/evidence.py,sha256=47B4hbfHckmE_UHgZlNW2Z0mC6BTdZMWqMwnIcKJQBw,3489
@@ -33,7 +33,7 @@ localcode/launcher.py,sha256=uDsIy66q-VexbvdIb7iwzYwDmmYhWRP10SNX4GiEWQ4,11462
 localcode/logging_utils.py,sha256=mFn_LO26IkT7OLxKs1ke4mND8BJeDLf-UULCYSSxyz0,920
 localcode/lsp.py,sha256=WTtdbdgforZdWMRqlzCQp2ndkKRbfIE1f5GfGeRH1xU,5939
 localcode/memory_guard.py,sha256=Upi6x6zNceTZeY7m8HrZktiURX-1NbTg89RSvfPl9l8,12315
-localcode/model_config.py,sha256=rTYsnst5mxs1eXRObcz5OVbUTJSRwE9P1IJigseZz7Q,14410
+localcode/model_config.py,sha256=Z6N3TDsSJ3jiX6QXhzjnZ30IrFVKjfqD-kQD004_9vA,16122
 localcode/model_delete.py,sha256=8niDYcXxthHWZmcYREEUGBCqn2z9Z1gcCFXb9zJ67KI,17203
 localcode/model_families.py,sha256=mEBIoEMe-qL93Twxm-4mYv76dWEkKVp5CiQlY43mkWA,11203
 localcode/models.py,sha256=fetDQSmOR3GrMMv_H9ecAZSmHa2TPhsYw8eSYKDl5YA,8243
@@ -49,7 +49,7 @@ localcode/plans.py,sha256=Tih7WzRmkWO0cF4fEDwjI07978mJZ_l9jXTSTidLb9k,7424
 localcode/process_registry.py,sha256=Chmqv5WGMmdQmaAGQ1mZ6ySS5BKt7UDYbb9xS5TDOyk,6125
 localcode/recommendations.py,sha256=HVh8u2L3xbwc2qxH7Syec2cEtlEoFV9n1c33SqWF3ng,3184
 localcode/recovery.py,sha256=QUSsBA9IS5AJ6W4m4nIv2RaktTO9TJeL0RcDeUSWHJk,5237
-localcode/runtime.py,sha256=IMHwpgBOn_AMTRV-PPXwc9-Ful2yCzO06Uh75ddwp8s,122236
+localcode/runtime.py,sha256=YEqevf3d8Yh8Tu-3vMaF5Vl1f2GY7JSm4L61gQCst3o,122975
 localcode/runtime_diffusion.py,sha256=bVopikSdQeaV9mAuzWYoXtoXpUb7U0yMXU5VFTpbsBc,39741
 localcode/server_manager.py,sha256=JHLEdG7FS46K9HIh6utEm-Nqx8W_gHMvicyK29q_GwE,41412
 localcode/session.py,sha256=taEyOOiCcNXEr8oOeszyWvzvn-oAZ7knXQ7BxRew08Q,11970
@@ -60,7 +60,7 @@ localcode/sounds.py,sha256=7AfQYyX7FJ76IDCikP7G8C5KDobdkK75fdeAqotsJXg,1406
 localcode/telemetry.py,sha256=FzChuRetLpvlzMFAwkPLUjJTdicmgec3fJqS_6rjPZ0,9489
 localcode/theme.py,sha256=q88NoDRvcxd71vWgZ95RkZKpzenR8Ov8vFmRUVmBZyc,6172
 localcode/thermal.py,sha256=q2A-HlIs-Uaqpf6bUswE2q9qbvdZCMKe6b9Fg--yHV4,6229
-localcode/thinking.py,sha256=588EujKT3CyA6logo2rTtS1KKEvE5GGJWa7nWzBPYlY,3345
+localcode/thinking.py,sha256=qZCW0Gr9BnR8AzXVz02wxzoOTXRc9Gv0W5YM7qKpl4A,4113
 localcode/tool_router.py,sha256=bmCwTAhFqo8oadJZ-FDSTdEvfwu3fHok8qVOBbxnQG4,9832
 localcode/toolkit.py,sha256=PEToa9AUjp4D1xcdSBk9DT-0bU0zGigKhBR6aiwf4OA,57843
 localcode/turn_diff.py,sha256=ls5soQdYthLaep3eP20Xc5giFAlAx0ObVAzz7egy6Jk,6101
@@ -69,18 +69,19 @@ localcode/verification.py,sha256=UExbGJSB0Ts_PB68yrrqpBAE84rfHfjPAgkELBDGdDs,301
 localcode/voice.py,sha256=ZAh1GmJiQJF4cXQ2YCclJZB77Sa9yflox22MnDMl7t8,39178
 localcode/agent/__init__.py,sha256=-aQIBiYIojvwl9nDf_wcyiT5UQTmcEQbEBwnBEsrjEU,7349
 localcode/agent/app_tasks.py,sha256=8fkC0wErSvP8lc8Hk5GhWSk5IZ4iiEx8pO7H4WEPs0k,5372
-localcode/agent/constants.py,sha256=SGffEjumr-9kn5ZBFl2C6L2J8NLcZ1PgMmkKLf0MNtg,12780
+localcode/agent/constants.py,sha256=Qt6uIgTMld_L0cRtUU5dNZzHJoKfStRZqzm_IuoiOXk,12860
 localcode/agent/context.py,sha256=_zSg3teS-7gIbQcIqQDLamUDowYA7ErEdI2YslytY38,50427
 localcode/agent/goal.py,sha256=Hy2DMXS3dRcNQoNlifUKYHQqkQTl1VRVdoA_VfLX8QQ,8097
 localcode/agent/helpers.py,sha256=Hk5E_MX2XXlogSBYfHy8IsDOJHmQVu7fB4DH90hdDSs,26899
 localcode/agent/hooks.py,sha256=n01uWdt3elOaalURyx3vHg94yCmgL8YMzDohkxT0JAk,16695
-localcode/agent/loop.py,sha256=ilr2ACErrKHXYhAcsPPf3Eo5EGR8hE7HtH0GuGKoXv0,124584
-localcode/agent/prompt_context.py,sha256=WFCJy5OX2cF1kvpniPDPaYo5RroC0al8V4VOgiaog_0,10397
-localcode/agent/prompts.py,sha256=VyFaHYDGvJIZ1a-wMpiUkhthZYu8iwZcQ0SIb4Rffs8,10417
+localcode/agent/loop.py,sha256=ZbYe-Hh0kos6fjaprgwbiSDQPGKvdzOrvfP4IODGvXk,128180
+localcode/agent/prompt_context.py,sha256=FHihqTxTg7djEwV2EArts88AxNxShCja93NYw3w86ww,11046
+localcode/agent/prompts.py,sha256=ru_4gBEwY7TT9QysEFdRYJOFkErRhsZKwJHNciBMxhU,10981
+localcode/agent/reasoning_loop.py,sha256=f71RSAeeoW4gEUCY1cqp2QF2ryJOpaTaJ6g_-KOKx68,3676
 localcode/agent/recovery.py,sha256=Nn5frHkROavHoJ96j2drNrK_VD_kM549AQUr-Hl7t4Q,26445
 localcode/agent/sections.py,sha256=9hnwaNritQHgn7qIGFBZ3ChZgMQXQcqtmpdbR1wafA0,8998
 localcode/agent/state_machine.py,sha256=g99sKobwWN8y7dySlkcYTydWp0dPihOZrnLjJmQ9Ph0,3537
-localcode/agent/streaming.py,sha256=tW3LxUJlUyh3vRzeUsEo8lQcbc3DBvRtWF_2VLLQ9H8,11331
+localcode/agent/streaming.py,sha256=8Uy7Bq-YEcXb8pdSKIAbutUmgKAAKn6aR9fvUmsLnH8,13528
 localcode/agent/tool_execution.py,sha256=W7uleQ1Xf4e04njKOLGH4atth1xBG3bYOtLhwx_gxSA,17570
 localcode/agent/tool_orchestration.py,sha256=LVKNNHg59XLBlakz8J3zCwubXoWDiaXum8AS7HXB0sE,1711
 localcode/agent/turn_finalization.py,sha256=xieXqfpggfAYw2vwgouGXg2vay1ZFzDLCUrcpsZqjKQ,5361
@@ -127,26 +128,26 @@ localcode/tools/web_fetch.py,sha256=UPhMrLipwN5xJx5-zr634gL4p6nIRqYI2_7tbUw_8Go,
 localcode/tools/web_search.py,sha256=ILfBBx50p00OjA939HzdDmdao4QLL8sRuxlBoUDjmC8,1122
 localcode/tools/write_file.py,sha256=Rk1d7P5IyBG2zLwfe97vw2leJE-brdr0axusET7IJDE,12370
 localcode/tui/__init__.py,sha256=Yfy9bvw3l1iY4FDhRX8qZVgnZLuYiq8lc9SDYl4cWwc,61
-localcode/tui/app.py,sha256=c4Ahli1z6XUd_MmpJRKbeQywdwrjrSieX2hwMvfV5NE,18020
+localcode/tui/app.py,sha256=uPqY9H38Swvs7uYz18lsP5OR4EwaYQBUbzUy_HDBVto,18999
 localcode/tui/bridge.py,sha256=urPPCqC_nisAYawWk3juvMI8IaoJfv4g7USpGOZOqQc,2803
 localcode/tui/clipboard_image.py,sha256=xa-Oe7eGYqJ_hH_T3f8a_FJ8YR05IWG00jnh4j8S7h0,4172
 localcode/tui/paste_collapse.py,sha256=b6vWcxNzbrCFp-r209cpB5_hhXJqEmJDK3Sg_F_LLzo,3472
 localcode/tui/screens/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-localcode/tui/screens/chat.py,sha256=sKmj3O8PKttt7aBGBNERjtlLJqrYvYsUYSWLqhbfND4,211733
+localcode/tui/screens/chat.py,sha256=6MXgiP8cjI62ikVd1aqEStocQB1EFeZf9UYUIqYL44s,213002
 localcode/tui/screens/mode_picker.py,sha256=cK_xNo7ytOwJXJwzUevMTcb5dwQKtjMfh60of-ntRz4,2347
-localcode/tui/screens/model_picker.py,sha256=VkhyREIT2W1J8A6tUe0ix5TbWXUa2XSe9qKzcXgjjz4,35991
+localcode/tui/screens/model_picker.py,sha256=xeILKiAK4rmT0DbfoAz5o4uehfbltY7olosk2JsHhLM,36344
 localcode/tui/screens/setup.py,sha256=6sSKU1KagLyf5DtkQWOSBA7inPFZMTF570t-20PIwaE,40844
 localcode/tui/styles/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-localcode/tui/styles/app.tcss,sha256=I1rgltTrBJFRWRVG9zWNtiyYQ3FqOUffu4AlUD0yAuQ,4962
+localcode/tui/styles/app.tcss,sha256=qdXwj8xbHFYK6weF9m9Joc5P_mQAbRQ-huhCO8AwlHw,5557
 localcode/tui/widgets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 localcode/tui/widgets/approval.py,sha256=nFyGEaIW4yIVxE8Pi-TAXlCA-geE0E23RJ5ucWhNhgE,105
-localcode/tui/widgets/chat_log.py,sha256=7OSo_L838CB5-g1M6Kd7_BQ5LN1GwNowbGDqHraOwHg,81630
+localcode/tui/widgets/chat_log.py,sha256=CPXFSZQp4sSFdInTOr6UNYkQkPifzRVwdsJysFO5aUQ,81930
 localcode/tui/widgets/voice_visualizer.py,sha256=zOhrIxaMcg-F2Y8LvHJTddq227phmiTjtEyRbkx1XxU,4709
 localcode/tui/widgets/messages/__init__.py,sha256=952AZ1qVMGUIqPIry7mwxnYbMkgPlcY5FAwZtEa5YPg,967
 localcode/tui/widgets/messages/diff.py,sha256=khDf_MThrQz0S62-t-m7i3OU5cdNolUk1TCeKMRPDQI,10910
-localcode-0.3.32.dist-info/licenses/LICENSE,sha256=Ahg0cteZ-6bIRB7KC15WEtdqWnzy8HY_yzsZBoVRql0,11294
-localcode-0.3.32.dist-info/METADATA,sha256=Hvq3aj9EPziPfRZwVE7vw4YGDsPdgalg8JP54dSdTWY,7897
-localcode-0.3.32.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-localcode-0.3.32.dist-info/entry_points.txt,sha256=rE7elTGUvMsBd-Quy22cuTVJ-zGVOmx0nEuC6ni9Tg4,87
-localcode-0.3.32.dist-info/top_level.txt,sha256=58eL3Rw8v0OGmYNxjx8uS4ERWatrzUbyCL5inlukkTo,10
-localcode-0.3.32.dist-info/RECORD,,
+localcode-0.3.34.dist-info/licenses/LICENSE,sha256=Ahg0cteZ-6bIRB7KC15WEtdqWnzy8HY_yzsZBoVRql0,11294
+localcode-0.3.34.dist-info/METADATA,sha256=bA_mm9xYAqZUZNSLrEDkwkh5AI80ykG19LWI2j_IBpA,7897
+localcode-0.3.34.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+localcode-0.3.34.dist-info/entry_points.txt,sha256=rE7elTGUvMsBd-Quy22cuTVJ-zGVOmx0nEuC6ni9Tg4,87
+localcode-0.3.34.dist-info/top_level.txt,sha256=58eL3Rw8v0OGmYNxjx8uS4ERWatrzUbyCL5inlukkTo,10
+localcode-0.3.34.dist-info/RECORD,,