localcode 0.3.33__tar.gz → 0.3.35__tar.gz

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

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

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

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

{localcode-0.3.33 → localcode-0.3.35}/src/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-0.3.33 → localcode-0.3.35}/src/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-0.3.33 → localcode-0.3.35}/src/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-0.3.33 → localcode-0.3.35}/src/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-0.3.35/src/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-0.3.33 → localcode-0.3.35}/src/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-0.3.33 → localcode-0.3.35}/src/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-0.3.33 → localcode-0.3.35}/src/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-0.3.33 → localcode-0.3.35}/src/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-0.3.33 → localcode-0.3.35}/src/localcode/runtime.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import os
 import re
 from typing import Any, Iterator
 
@@ -10,6 +11,24 @@ 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,
@@ -2190,6 +2209,25 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
             # few hundred new tokens.
             "cache_prompt": True,
         }
+        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

{localcode-0.3.33 → localcode-0.3.35}/src/localcode/thinking.py

@@ -80,6 +80,14 @@ def should_use_thinking(
     if policy in {"0", "false", "no", "off", "none", ""}:
         return False
     if policy in {"1", "true", "yes", "on"}:
+        # `on` FORCES thinking on every round — it respects the user's explicit
+        # opt-in and never second-guesses it by stage. Stage is inferred from the
+        # last completed action, not what the next round must decide, so a round
+        # after a read/edit during `implement` may genuinely need reasoning;
+        # gating it off here would silently break the contract. Reasoning-loop
+        # prevention lives in the layers that don't lie about intent: the
+        # server-side thinking budget, the periodicity detector, and the
+        # verified no-thinking retry. Use `auto` for stage-aware reasoning.
         return True
     if policy == "legacy":
         return runtime_mode.endswith("-think")

{localcode-0.3.33 → localcode-0.3.35}/src/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