localcode 0.3.45__tar.gz → 0.3.47__tar.gz

{localcode-0.3.45/src/localcode.egg-info → localcode-0.3.47}/PKG-INFO

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

{localcode-0.3.45 → localcode-0.3.47}/pyproject.toml

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

{localcode-0.3.45 → localcode-0.3.47}/src/localcode/__init__.py

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

{localcode-0.3.45 → localcode-0.3.47}/src/localcode/agent/constants.py

@@ -112,7 +112,16 @@ without leaving the reasoning channel unbounded."""
 # runaway and can `esc` — the cap is the backstop for unattended /
 # headless runs where no one is watching.
 
-MAX_THINKING_SECONDS = 600
+# NOTE: the CHAR cap is the real, speed-independent runaway guard (~20k
+# reasoning tokens); the structural loop detector catches periodic loops in
+# ~1s. The TIME cap is only a final backstop, and it must scale to the SLOWEST
+# model we ship: at ~15 tok/s (dense Qwen 3.8 27B Q8 / Muse Glimmer, not the
+# ~50-75 tok/s MoEs this was first tuned for), 80k chars ≈ 20k tokens ≈ 22 min
+# of legitimate reasoning. A 600s cap tripped that at ~5.7k tokens — aborting
+# NORMAL slow reasoning, the exact thing this cap must never do. 1800s (30 min)
+# keeps the char cap + loop detector as the real guards. Either way a trip now
+# recovers via a no-think retry (see loop.py), so the turn is never thrown away.
+MAX_THINKING_SECONDS = 1800
 MAX_THINKING_CHARS = 80000
 
 

{localcode-0.3.45 → localcode-0.3.47}/src/localcode/agent/loop.py

@@ -1089,50 +1089,54 @@ def run_agent_loop(
                 )
             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.
+            _abort_reason = _stream_result.thinking_abort_reason or "unknown"
+            _is_loop = _abort_reason == "loop"
+            if _thinking_loop_recoveries < _MAX_THINKING_LOOP_RECOVERIES:
+                # The model over-reasoned WITHOUT emitting a response — either a
+                # detected periodic loop OR it blew the time/char cap. BOTH are
+                # recoverable and BOTH used to be handled differently (loop
+                # retried, cap hard-failed and threw the whole turn away). Now
+                # they share one path: 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
+                # forces the model to ACT instead of planning forever. This is
+                # DECODE recovery, not an optional nudge — critical for slow
+                # dense models (Qwen 3.8 27B Q8 ~17 tok/s) where legitimate
+                # planning can brush the time cap without any real loop.
                 _thinking_loop_recoveries += 1
-                _next_round_policy = _round_policy.recover_without_thinking("reasoning_loop")
+                _rec_reason = "reasoning_loop" if _is_loop else "reasoning_cap"
+                _next_round_policy = _round_policy.recover_without_thinking(_rec_reason)
                 try:
                     from ..events import emit as _emit_recovery
-                    _emit_recovery("generation_aborted", reason="reasoning_loop", round_idx=round_num)
-                    _emit_recovery("recovery_scheduled", reason="reasoning_loop", mode="no_thinking",
+                    _emit_recovery("generation_aborted", reason=_rec_reason, round_idx=round_num)
+                    _emit_recovery("recovery_scheduled", reason=_rec_reason, mode="no_thinking",
                                    attempt=_thinking_loop_recoveries)
                 except Exception:
                     pass
                 out.notice(
                     "Model reasoning started repeating itself — retrying this "
                     "step without deep reasoning so it acts instead of looping."
+                    if _is_loop else
+                    "Model kept reasoning without acting — retrying this step "
+                    "without deep reasoning so it produces a response."
                 )
                 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
+            # Recovery budget exhausted — the model kept over-reasoning even
+            # without the reasoning channel. End the turn honestly.
             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. Turn off deep reasoning with `/thinking off`, "
-                f"switch to a faster model with `/model`, or rephrase the task in "
-                f"smaller steps."
+                "Model kept repeating itself even without deep reasoning — "
+                "ending the turn. Try `/model` to switch models or split the "
+                "task into smaller steps."
+                if _is_loop else
+                "Model kept reasoning without producing a response even with "
+                "deep reasoning disabled — ending the turn. Try `/model` for a "
+                "faster model, `/thinking off`, or split the task into smaller steps."
             )
+            _loop_exit_reason = "thinking_loop_exhausted"
+            break
 
         # Show thinking summary if present (collapsed, dim)
         # Skip if already emitted when content started streaming

{localcode-0.3.45 → localcode-0.3.47}/src/localcode/tui/widgets/chat_log.py

@@ -788,6 +788,12 @@ class ChatLog(RichLog):
             return
         self._think_stream_buf = ""
         self._think_stream_active = True
+        # Live-partial state: the trailing (not-yet-newline) line is rendered
+        # in place and rewritten as words arrive, so thinking flows word-by-word
+        # like the answer instead of snapping a whole line at a time.
+        self._think_partial_written = 0   # sublines the live partial occupies
+        self._think_partial_start = -1    # log index where the live partial begins
+        self._think_last_flush = 0.0      # monotonic ts of last partial flush
         self._dispatch_gap("thinking")
         self._history.append(("think_header",))
         self._render_think_header()
@@ -798,13 +804,70 @@ class ChatLog(RichLog):
         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.
+        # Finalize every COMPLETE line (text before a newline): draw its final
+        # wrapped form, record it to history, and lock it in so the next partial
+        # starts fresh below it.
         while "\n" in self._think_stream_buf:
             line, self._think_stream_buf = self._think_stream_buf.split("\n", 1)
-            self._commit_thinking_line(line)
+            line = line.rstrip()
+            if line:
+                self._render_think_partial(line)
+                self._history.append(("think_line", line))
+            # Lock in whatever we just drew; the next partial is independent.
+            self._think_partial_written = 0
+            self._think_partial_start = -1
+        # Live-render the trailing partial word-by-word, rate-capped exactly like
+        # the content stream (word boundary + coalesce window). This is the fix
+        # for "jerky thinking": before, thinking only flushed on '\n', so at slow
+        # decode a whole line froze for ~2 s then snapped in.
+        tail = self._think_stream_buf
+        if not tail:
+            return
+        boundary = tail[-1] in self._STREAM_WORD_BOUNDARIES
+        now = time.monotonic()
+        if boundary and (now - self._think_last_flush) >= self._STREAM_COALESCE_SEC:
+            self._render_think_partial(tail)
+            self._think_last_flush = now
+
+    def _render_think_partial(self, text: str) -> None:
+        """Draw `text` as the current live thinking line, rewriting in place.
+
+        Mirrors the content stream's pop-and-rewrite (`_flush_stream`) but scoped
+        to ONE logical line (bounded cost) and guarded by an at-tail check so we
+        never pop lines another writer owns.
+        """
+        import textwrap
+        # Pop this partial's previous render — only if it's still the tail.
+        if self._think_partial_start >= 0 and self._think_partial_written > 0:
+            expected_tail = self._think_partial_start + self._think_partial_written
+            if expected_tail == len(self.lines):
+                for _ in range(self._think_partial_written):
+                    self.lines.pop()
+                self._line_counter = max(0, self._line_counter - self._think_partial_written)
+                self._line_cache.clear()
+            # else: lost the tail (a tool widget/rerender wrote after us) — leave
+            # the stale render; we restart the partial at the new bottom.
+        self._think_partial_start = len(self.lines)
+        self._think_partial_written = 0
+        try:
+            avail = self._content_width()
+        except Exception:
+            avail = 76
+        wrapped = textwrap.fill(
+            text, width=max(avail - 4, 30),
+            initial_indent="    ", subsequent_indent="    ",
+        )
+        follow = self.scroll_offset.y >= self.max_scroll_y - 2
+        for wline in wrapped.split("\n"):
+            self.write(Text(wline, style="dim italic"))
+            self._track_lines()
+            self._think_partial_written += 1
+        if follow:
+            self.scroll_end(animate=False)
 
     def _commit_thinking_line(self, line: str) -> None:
+        # Retained for `append_thinking` / non-streaming callers. The live
+        # streaming path uses `_render_think_partial` for word-by-word flow.
         line = line.rstrip()
         if not line:
             return
@@ -814,9 +877,13 @@ class ChatLog(RichLog):
     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)
+        tail = self._think_stream_buf.strip()
+        if tail:
+            self._render_think_partial(tail)
+            self._history.append(("think_line", tail))
         self._think_stream_buf = ""
+        self._think_partial_written = 0
+        self._think_partial_start = -1
         self._think_stream_active = False
 
     def _render_think_header(self) -> None:

{localcode-0.3.45 → localcode-0.3.47/src/localcode.egg-info}/PKG-INFO

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

{localcode-0.3.45 → localcode-0.3.47}/tests/test_comprehensive_tui.py

@@ -164,13 +164,16 @@ def test_tui_runaway_thinking_loop_recovers_with_no_think_retry(tmp_path, projec
     asyncio.run(scenario())
 
 
-def test_tui_nonperiodic_runaway_hits_length_cap(tmp_path, project):
-    """Non-repeating reasoning that simply runs too long still hits the char/time
-    cap and aborts with the clear 'reasoning exceeded' message. Guards the
-    THINKING_CAPS length backstop for the case the loop detector won't fire on."""
+def test_tui_nonperiodic_runaway_recovers_without_thinking(tmp_path, project):
+    """Non-repeating reasoning that simply runs too long trips the char/time cap.
+    It no longer hard-fails the turn: like a detected loop, it now RECOVERS by
+    re-running the step with thinking off (up to the recovery budget), then ends
+    honestly if the model keeps over-reasoning. Guards that a slow model's cap
+    trip is salvaged instead of throwing the whole turn away."""
     async def scenario():
         # Strictly increasing tokens: long but NOT periodic, so only the length
-        # cap should stop it.
+        # cap should stop it. The mock re-emits it every round (ignores think),
+        # so recovery is exhausted and the turn ends with the honest message.
         runaway = " ".join(str(i) for i in range(30000))  # ~150k varied chars
         snap = await _drive(
             tmp_path, project,
@@ -178,7 +181,12 @@ def test_tui_nonperiodic_runaway_hits_length_cap(tmp_path, project):
             "build the thing",
         )
         assert snap["model_calls"] >= 1
-        assert "reasoning exceeded" in snap["log_text"].lower()
+        # Collapse wrapping/indent so the multi-line notice matches as one string.
+        low = " ".join(snap["log_text"].lower().split())
+        # New behavior: the cap trip triggers a no-think RETRY (recovery), never
+        # the old "reasoning exceeded" hard-stop that threw the turn away.
+        assert "without deep reasoning" in low
+        assert "reasoning exceeded" not in low
 
     asyncio.run(scenario())
 

{localcode-0.3.45 → localcode-0.3.47}/tests/test_quant_browser_and_thinking.py

@@ -59,19 +59,30 @@ def test_no_catalog_gemma_duplicates():
 # ── Live reasoning stream: buffer partials, flush whole lines ───────────
 
 class _FakeLog:
-    """Minimal stand-in exercising ChatLog's thinking-stream methods."""
+    """Stand-in exercising ChatLog's thinking-stream methods, including the
+    in-place partial rewrite (pop + re-render) the word-by-word path uses.
+    `lines` emulates RichLog.lines (pop-able); `written` is the cumulative
+    record of everything ever rendered."""
     def __init__(self):
+        import types as _t
         self.written = []
+        self.lines = []
         self._history = []
         self._think_stream_active = False
         self._think_stream_buf = ""
+        self._line_counter = 0
+        self._line_cache = {}
+        self.scroll_offset = _t.SimpleNamespace(y=0)
+        self.max_scroll_y = 0
 
     # Methods copied-by-reference from ChatLog via bind below.
     def write(self, renderable):
-        self.written.append(str(getattr(renderable, "plain", renderable)))
+        s = str(getattr(renderable, "plain", renderable))
+        self.written.append(s)
+        self.lines.append(s)
 
     def _track_lines(self):
-        pass
+        self._line_counter += 1
 
     def _dispatch_gap(self, _kind):
         pass
@@ -79,35 +90,49 @@ class _FakeLog:
     def _content_width(self):
         return 80
 
+    def scroll_end(self, **kwargs):
+        pass
+
 
 def _bind_stream_methods(obj):
     from localcode.tui.widgets.chat_log import ChatLog
     import types
     for name in ("start_thinking_stream", "stream_thinking",
                  "_commit_thinking_line", "_render_think_header",
-                 "_render_think_line", "end_thinking_stream"):
+                 "_render_think_line", "_render_think_partial",
+                 "end_thinking_stream"):
         setattr(obj, name, types.MethodType(getattr(ChatLog, name), obj))
+    # Stream-pacing constants are ChatLog class attrs; the fake isn't a
+    # subclass, so copy them over (kept in sync with the real values).
+    for const in ("_STREAM_WORD_BOUNDARIES", "_STREAM_COALESCE_SEC"):
+        setattr(obj, const, getattr(ChatLog, const))
 
 
-def test_thinking_stream_flushes_whole_lines_only():
+def test_thinking_stream_commits_lines_and_streams_partial_words():
     log = _FakeLog()
     _bind_stream_methods(log)
-    log.stream_thinking("First reasoning line\nSecond li")
-    # Header + first complete line written; partial "Second li" still buffered.
+    # A complete line, then a partial that ENDS on a word boundary (space) —
+    # the fix streams that partial live instead of freezing until the newline.
+    log.stream_thinking("First reasoning line\nSecond word ")
     joined = " ".join(log.written)
     assert "thinking" in joined.lower()
     assert "First reasoning line" in joined
-    assert "Second li" not in joined
-    assert log._think_stream_buf == "Second li"
+    # NEW behavior: the trailing partial renders word-by-word before any newline.
+    assert "Second word" in joined
+    assert log._think_stream_buf == "Second word "
+    # The completed line is locked into history; the live partial is not (yet).
+    assert ("think_line", "First reasoning line") in log._history
 
 
 def test_thinking_stream_end_flushes_partial():
     log = _FakeLog()
     _bind_stream_methods(log)
+    # Ends on 'e' (no word boundary) → stays buffered, not yet rendered.
     log.stream_thinking("partial tail with no newline")
     assert "partial tail" not in " ".join(log.written)  # buffered, not flushed
     log.end_thinking_stream()
     assert "partial tail with no newline" in " ".join(log.written)
+    assert ("think_line", "partial tail with no newline") in log._history
     assert log._think_stream_active is False