localcode 0.3.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

localcode/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.3.1"
+__version__ = "0.3.2"

localcode/agent/context.py

@@ -45,6 +45,37 @@ if TYPE_CHECKING:
 __all__: list[str] = []
 
 
+def _spill_tool_output(result: str, tool_name: str) -> str | None:
+    """Write an oversized tool result to a file and return its path.
+
+    Truncation alone makes a small model re-run the command "to see the rest".
+    Instead we keep the full output on disk and point the model at it (grep/
+    read the exact part). Best-effort: None on error → caller falls back to
+    plain truncation. Content-hashed filenames; old spills reaped after 7 days.
+    """
+    try:
+        import hashlib
+        import time as _time
+        from ..paths import global_state_dir
+        spill_dir = global_state_dir() / "tool_output"
+        spill_dir.mkdir(parents=True, exist_ok=True)
+        # Reap spills older than 7 days so this never grows unbounded.
+        try:
+            cutoff = _time.time() - 7 * 86400
+            for old in spill_dir.glob("*.txt"):
+                if old.stat().st_mtime < cutoff:
+                    old.unlink(missing_ok=True)
+        except Exception:
+            pass
+        digest = hashlib.sha1(result.encode("utf-8", "replace")).hexdigest()[:12]
+        path = spill_dir / f"{tool_name}_{digest}.txt"
+        if not path.exists():
+            path.write_text(result, encoding="utf-8", errors="replace")
+        return str(path)
+    except Exception:
+        return None
+
+
 def _truncate_result(result: str, tool_name: str) -> str:
     """Truncate a tool result to its per-tool size limit with a
     strategy tuned to what each tool's output actually looks like.
@@ -70,6 +101,15 @@ def _truncate_result(result: str, tool_name: str) -> str:
         return result
 
     dropped = len(result) - limit
+    # Spill the FULL output to disk and point the model at it, so it fetches
+    # the exact part it needs instead of re-running the command to "see the
+    # rest". Appended to every strategy's hint below.
+    _spill = _spill_tool_output(result, tool_name)
+    spill_hint = (
+        f" Full output saved to {_spill} — read_file (with offset) or grep it "
+        f"to see the rest; do NOT re-run the command."
+        if _spill else ""
+    )
 
     if tool_name == "read_file":
         # Keep the HEAD; if we can find line numbers in the content
@@ -85,7 +125,7 @@ def _truncate_result(result: str, tool_name: str) -> str:
                 last_numbered = int(line.split("\t", 1)[0])
         hint = (
             f"\n\n[truncated — {dropped} more chars not shown. "
-            f"{'Call read_file with offset=' + str(last_numbered) + ' to continue reading from there.' if last_numbered else 'Call read_file with a larger offset to continue.'}]"
+            f"{'Call read_file with offset=' + str(last_numbered) + ' to continue reading from there.' if last_numbered else 'Call read_file with a larger offset to continue.'}{spill_hint}]"
         )
         return head + hint
 
@@ -99,7 +139,7 @@ def _truncate_result(result: str, tool_name: str) -> str:
         dropped_lines = result[limit:].count("\n") + 1
         hint = (
             f"\n\n[truncated — {dropped_lines} more match-lines not shown. "
-            "Narrow with a more specific pattern or `include=*.py` to see them.]"
+            f"Narrow with a more specific pattern or `include=*.py` to see them.{spill_hint}]"
         )
         return head + hint
 
@@ -114,7 +154,7 @@ def _truncate_result(result: str, tool_name: str) -> str:
             first_sig = "\n".join(non_empty[:8])
             last_sig = "\n".join(non_empty[-12:]) if len(non_empty) > 12 else ""
             marker = (
-                f"\n\n[... {dropped} chars of bash output compressed ...]\n\n"
+                f"\n\n[... {dropped} chars of bash output compressed.{spill_hint} ...]\n\n"
             )
             if any(token in result for token in ("backend", "frontend", "src/", "node_modules", "package.json", "pyproject.toml")):
                 tree_hint = (
@@ -133,14 +173,14 @@ def _truncate_result(result: str, tool_name: str) -> str:
         tail_size = limit - head_size - 64  # 64 chars for the marker line
         head = result[:head_size]
         tail = result[-tail_size:]
-        marker = f"\n\n[... {dropped} chars of middle output dropped ...]\n\n"
+        marker = f"\n\n[... {dropped} chars of middle output dropped.{spill_hint} ...]\n\n"
         return head + marker + tail
 
     # Default — middle-drop.
     half = limit // 2
     return (
         result[:half]
-        + f"\n\n[...{dropped} chars truncated...]\n\n"
+        + f"\n\n[...{dropped} chars truncated.{spill_hint} ...]\n\n"
         + result[-half:]
     )
 
@@ -205,11 +245,12 @@ def _semantic_tool_summary(content: str) -> str:
         or "Traceback " in content
     )
     if is_error:
-        tail = "\n".join([ln for ln in lines[-12:] if ln.strip()])[:1200]
-        return (
-            f"[older tool error preserved: {len(content)} chars, "
-            f"{len(lines)} lines]\n{first_line}\n{tail}"
-        )
+        # Self-conditioning (arXiv:2509.09677): echoing an OLD error's text
+        # pushes the model to repeat the mistake (scale-independent). Recent
+        # errors stay intact (kept above by keep_recent) so it can fix the
+        # immediate problem; older ones drop to a neutral note. The progress
+        # ledger still records the failure fact, minus the conditioning text.
+        return "[an earlier tool call errored and was handled — details dropped]"
     if facts:
         return (
             f"[older successful tool result summarized: {len(content)} chars, "

localcode/agent/loop.py

@@ -721,6 +721,19 @@ def run_agent_loop(
                     ]
             except Exception:
                 pass
+            # Inject the working-memory checklist (todo_write tool): the model
+            # always sees its own plan (done / in-progress / left) so it
+            # advances instead of repeating. Appended LAST, ephemeral, empty-safe.
+            try:
+                from ..tools.todo_write import render_todo_reminder
+                _todos = list(getattr(app.session, "todos", []) or [])
+                _todo_note = render_todo_reminder(_todos)
+                if _todo_note:
+                    model_messages = list(model_messages) + [
+                        {"role": "user", "content": _todo_note}
+                    ]
+            except Exception:
+                pass
             round_tool_schemas = schemas_for_goal(
                 _goal_state.goal_type,
                 user_text,
@@ -1206,7 +1219,11 @@ def run_agent_loop(
                 break
 
         # ── No tool calls = model is done ──
-        if not tool_calls:
+        # Also require no pending tool call: the runtime promotes pending
+        # tools into `tool_calls`, but if a future path doesn't, we keep
+        # looping instead of ending early (small models often emit a stop
+        # token with a call still pending).
+        if not tool_calls and not _round_pending_tool_count:
             # Match v0.2.12's no-tool-calls path exactly: render content,
             # render any grounded file summary, break. Nothing else.
             #

localcode/agent/prompts.py

@@ -42,11 +42,12 @@ _STACK_MARKERS: tuple[tuple[str, str], ...] = (
 SYSTEM_PROMPT = """\
 You are LocalCode, a coding agent on the user's machine with full filesystem access.
 
-Available tools: read_file, write_file, append_file, edit_file, bash, list_files.
+Available tools: read_file, write_file, append_file, edit_file, bash, list_files, todo_write.
 
 How to work:
 - Match scope to the request. Answer plain questions plainly. Build what was asked when asked. Don't write a script when a one-line bash command will do.
 - Cover every requirement the user named. If your chosen approach can't deliver one, change the approach — don't drop the requirement to fit the approach.
+- PLAN MULTI-STEP WORK. For any task with 3+ steps, call `todo_write` FIRST to lay out the steps, then keep it current: mark exactly ONE item in_progress before you start it, and mark it completed the instant it's done. Your task list is shown back to you every round — read it to see what's already finished and what's left, so you advance to the next step instead of redoing one you've already done. If you catch yourself about to re-read a file or re-run a command you ran before, check the list: you've likely already done it.
 - If the request is ambiguous in a way that affects your approach (stack, interface, scope), ask one short question before building, not after.
 - ACT, DON'T NARRATE. Every "let me read", "let me fix", "now I'll write" MUST be followed by the actual tool call IN THE SAME TURN. If you say "let me write the fix" and then end your turn without calling edit_file or write_file, you have failed the user. The user has explicitly complained about this. Never describe a fix without immediately performing it.
 - Forbidden patterns: "Let me read the file:" + end of turn. "I'll rewrite this:" + end of turn. "Now I'll apply the fix:" + end of turn. If the next thing out of your mouth is a verb of intent, the very next action MUST be the tool call that delivers on that intent.
@@ -58,6 +59,8 @@ How to work:
 - For new projects, create a small multi-file structure by default. Keep entrypoints thin; move reusable logic, styles, data/config, templates, and assets into focused files. Use one large file only if requested.
 - Prefer edit_file for existing files. Use write_file when creating a new file or doing a deliberate full rewrite.
 - When a tool returns an error, read it, fix the specific problem, and retry with DIFFERENT input. Never repeat an identical failing call: if the same call fails or returns the same result twice, change the arguments or the approach, or move on — do not loop. Don't give up after one failed call, but don't spin on it either.
+- DON'T RE-READ OR RE-SEARCH what you already have. If you already read a file this turn and it hasn't changed, the content is still above — use it, don't read it again. If a search already gave you a useful result, act on it (open the match, make the edit); don't run the same search again. Repeating a read/search you've already done is the #1 way turns stall.
+- After a tool result, CONTINUE from where you left off — don't restate what you just did or re-summarize the plan. Take the next concrete action.
 - DON'T CONFABULATE. If the user names a person, song, place, term, library, command, or concept you do not recognize, your FIRST move is to say "I don't recognize that" — NOT to invent a plausible-sounding meaning by phonetic association. Phonetic fits ("Alombasi sounds Bantu so it must be a Zambian chant", "Pyfoo sounds like a Python library so it must do X") are exactly the failure mode. If a web search would help, run it BEFORE asserting facts; if results are empty, say so plainly. Never write paragraph-length cultural/etymological/technical descriptions of something you can't actually source — "I'd love to know more, what's it from?" is the correct answer. Doubling down when the user repeats the unknown term is also forbidden; repetition is not evidence.
 
 Runtime facts (true today; rely on these instead of guessing):

localcode/entrypoint.py

@@ -22,21 +22,74 @@ _TERMINAL_RESTORE = (
     "\x1b[?25h\x1b[?1049l\x1b[0m"
 )
 
+# Snapshot of the controlling tty's termios settings, captured BEFORE the
+# TUI puts the terminal into raw mode. The escape sequence above only undoes
+# escape-driven state (alt-screen, mouse tracking, hidden cursor); it does
+# NOT undo the kernel-level raw mode (ECHO/ICANON/ISIG off). If the TUI
+# crashes or hangs and its own teardown is skipped, the terminal is left in
+# raw mode — no echo, and Ctrl+C generates no SIGINT — which looks like a
+# dead terminal. Restoring this snapshot (or `stty sane`) brings it back.
+_ORIG_TERMIOS = None  # tuple[int fd, list attrs] | None
+
+
+def _snapshot_terminal_state() -> None:
+    """Capture the tty's termios attrs before the TUI mutates them."""
+    global _ORIG_TERMIOS
+    if _ORIG_TERMIOS is not None:
+        return
+    try:
+        import termios
+        for stream in (sys.__stdin__, sys.__stdout__):
+            try:
+                if stream is not None and stream.isatty():
+                    fd = stream.fileno()
+                    _ORIG_TERMIOS = (fd, termios.tcgetattr(fd))
+                    return
+            except Exception:
+                continue
+    except Exception:
+        pass
+
 
 def _reset_terminal_state() -> None:
     payload = _TERMINAL_RESTORE.encode()
+    wrote = False
     try:
         with open("/dev/tty", "wb", buffering=0) as tty:
             tty.write(payload)
-        return
+        wrote = True
     except Exception:
         pass
+    if not wrote:
+        try:
+            if sys.__stdout__.isatty():
+                sys.__stdout__.write(_TERMINAL_RESTORE)
+                sys.__stdout__.flush()
+        except Exception:
+            pass
+    # Undo raw mode at the kernel level — escape codes can't do this. Restore
+    # the snapshot if we have one; otherwise fall back to `stty sane`. Without
+    # this, a crashed/hung TUI leaves the shell with no echo and a dead
+    # Ctrl+C until the user blindly types `reset`.
     try:
-        if sys.__stdout__.isatty():
-            sys.__stdout__.write(_TERMINAL_RESTORE)
-            sys.__stdout__.flush()
+        import termios
+        if _ORIG_TERMIOS is not None:
+            fd, attrs = _ORIG_TERMIOS
+            termios.tcsetattr(fd, termios.TCSADRAIN, attrs)
+        else:
+            raise RuntimeError("no snapshot")
     except Exception:
-        pass
+        try:
+            import subprocess
+            subprocess.run(
+                ["stty", "sane"],
+                stdin=open("/dev/tty", "rb"),
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                timeout=2,
+            )
+        except Exception:
+            pass
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -248,6 +301,9 @@ def _run_headless(config, args, console) -> int:
 
 def main(argv: list[str] | None = None) -> None:
     _harden_against_debugger_attach()
+    # Snapshot the terminal while it's still sane — before the TUI enters
+    # raw mode — so any exit path (crash, hang, kill) can restore it.
+    _snapshot_terminal_state()
     import os
     import signal
     import warnings

localcode/runtime.py

@@ -242,6 +242,11 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
         self.config = config
         self._client: httpx.Client | None = None
         self.last_response_meta: dict[str, Any] = {}  # for token tracking
+        # Circuit-breaker state for the stream-recovery loop: consecutive
+        # server deaths since the last successful stream. Persists across
+        # calls/turns (this gateway is one per session) so a deterministic
+        # crash can't restart-loop forever. Reset to 0 on any success.
+        self._consecutive_stream_deaths = 0
         # llama_cpp is the only HTTP runtime (ollama/mlx/hf removed); diffusion
         # models are architecture-routed to the one-shot CLI, not this endpoint.
         base = self.config.base_url.rstrip("/")
@@ -1324,6 +1329,10 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
         # error instead of thrashing.
         _MAX_STREAM_RESTARTS = 1
         _restarts_done = 0
+        # Circuit-breaker ceiling: how many consecutive server deaths (across
+        # calls/turns, reset on any successful stream) we'll keep restarting
+        # through before declaring the server unstable and stopping the loop.
+        _MAX_CONSECUTIVE_STREAM_DEATHS = 3
         # STREAM-LEVEL "have we handed real content to the consumer yet?"
         # flag. The per-attempt `_emitted_real` is reset each try; this one
         # survives across attempts and is the streaming-safety gate for
@@ -1814,6 +1823,10 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
                         "type": "content",
                         "content": _fmt_err(_LCE(_by_code("E3108"))),
                     }
+                # Reached the end of a stream without an exception — the server
+                # answered. Clear the circuit breaker so a later transient death
+                # gets a fresh recovery budget (only CONSECUTIVE deaths count).
+                self._consecutive_stream_deaths = 0
                 yield {
                     "type": "stream_done",
                     "finish_reason": last_finish_reason,
@@ -1858,7 +1871,29 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
                 # With recovery: detect the pattern, wait for memory to
                 # settle, restart the server, retry the stream once.
                 err_str = _error_message(exc).lower()
-                is_conn_err = "connect" in err_str or "refused" in err_str
+                # Classify by EXCEPTION TYPE (with a text fallback), not a bare
+                # `"connect" in err_str` — that substring also matched httpx's
+                # RemoteProtocolError ("peer closed CONNECTION … incomplete
+                # chunked read"), but that's fine on its own; both a dead socket
+                # AND a mid-body drop are recoverable by restart. The real
+                # defect was the ABSENCE of a stop condition: a deterministic
+                # failure (an oversized request that kills the server every
+                # time) restarted + re-POSTed forever. The circuit breaker
+                # below (_consecutive_stream_deaths) bounds that.
+                try:
+                    import httpx as _httpx
+                    _is_protocol_drop = isinstance(exc, _httpx.RemoteProtocolError)
+                    _is_connect_err = isinstance(
+                        exc, (_httpx.ConnectError, _httpx.ConnectTimeout)
+                    )
+                except Exception:
+                    _is_protocol_drop = "incomplete chunked read" in err_str or "peer closed" in err_str
+                    _is_connect_err = False
+                if not _is_connect_err and not _is_protocol_drop:
+                    _is_connect_err = "connect" in err_str or "refused" in err_str
+                # Both a connect failure and a mid-stream protocol drop are
+                # "server went away" — recoverable by restart + retry.
+                is_conn_err = _is_connect_err or _is_protocol_drop
                 # Auto-recovery on connection-refused: try ONE server
                 # restart before surfacing the error to the user. Any
                 # time the server is dead (pressure-kill, OOM, crash,
@@ -1876,27 +1911,44 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
                 # e2e run 2026-04-23T23:54, long_coding_session failed
                 # 25/25 turns at 0.5 s each on a dead server).
                 _pressure_related = _pressure_kill_recent()
-                # STREAMING-SAFETY RULE: a connection drop AFTER we've already
-                # yielded real content cannot be recovered by restart+retry —
-                # re-running the stream would re-emit content the consumer
-                # already saw (double answer / corrupted turn). Restart+retry
-                # is only safe when nothing has been handed downstream yet
-                # (drop before first token). Mid-stream → surface E3102 with
-                # diagnostic context instead of silently replaying.
+                # STREAMING-SAFETY: a mid-stream drop that already yielded
+                # content may replay a partial duplicate on retry — acceptable
+                # (the recovery stage explains it) and far better than killing a
+                # turn that would otherwise self-heal (a hard E3102 here used to
+                # kill builds on a transient memory-pressure pause).
                 if is_conn_err:
-                    # Capture the disconnect class for diagnostics.
+                    # Capture the disconnect class for diagnostics (both a dead
+                    # socket and a mid-body protocol drop land here).
                     _log_disconnect_context(
-                        "stream_chat_events", exc, mid_stream=_emitted_real_stream
+                        "stream_chat_events", exc,
+                        mid_stream=_emitted_real_stream or _is_protocol_drop,
                     )
-                    # RECOVER even when content was already streamed: restart +
-                    # retry (below). The server gets paused/killed under memory
-                    # pressure mid-build and used to silently restart+continue;
-                    # hard-failing with E3102 here was a REGRESSION (turns that
-                    # used to self-heal started dying). A mid-response restart
-                    # may replay a partial duplicate of the reply — far better
-                    # than killing the whole turn. The retry path emits a clear
-                    # "restarting" stage so the duplicate is explained.
-                if is_conn_err and attempt < self.config.max_retries and _restarts_done < _MAX_STREAM_RESTARTS:
+                    # CIRCUIT BREAKER — the fix for the restart loop. Count
+                    # consecutive server deaths across calls (reset on any
+                    # successful stream, see below). A transient death recovers
+                    # on the first restart; a DETERMINISTIC one — a request too
+                    # large for the server, killing it every time — would
+                    # otherwise restart + re-POST forever. Once the deaths pile
+                    # up we stop restarting and surface actionable guidance.
+                    self._consecutive_stream_deaths = (
+                        getattr(self, "_consecutive_stream_deaths", 0) + 1
+                    )
+                    if self._consecutive_stream_deaths > _MAX_CONSECUTIVE_STREAM_DEATHS:
+                        yield {
+                            "type": "stage", "name": "server_unstable",
+                            "message": (
+                                "The model server keeps crashing on this request — "
+                                "it's likely too large for the current settings. "
+                                "Try /clear to shrink the context, or /model to "
+                                "switch to a lighter model."
+                            ),
+                        }
+                        break  # stop the restart loop; fall through to E3102
+                if (
+                    is_conn_err
+                    and attempt < self.config.max_retries
+                    and _restarts_done < _MAX_STREAM_RESTARTS
+                ):
                     _restarts_done += 1
                     recovery_label = (
                         "memory_pressure_recovery"

localcode/server_manager.py

@@ -398,23 +398,20 @@ class ServerManager:
         """
         with self._lock:
             had_prior = self._process is not None
+            _prev_model = self._model_path  # capture before shutdown clears it
             self._shutdown_locked()
-            # Wait for the OLD server's memory to actually release
-            # before spawning the new one. `process.wait()` returns
-            # when the child reaps, but the kernel may take 1-3 s to
-            # release wired Metal memory. Spawning the new ~10 GB
-            # server in that window double-commits memory and reliably
-            # triggers the pressure monitor on a 16 GB Mac (the bug
-            # behind the user's "two servers running" hypothesis).
-            #
-            # Target: enough free memory to fit a typical model + 1 GB
-            # margin (~11 GB for our standard quant). Best-effort —
-            # times out at 8 s if the target isn't met, logs the
-            # outcome, and proceeds anyway (the user wanted to switch
-            # models; refusing entirely would be worse than retry).
+            # Wait for the OLD server's memory to actually release before
+            # spawning the new one: the kernel may take 1-3 s to free wired
+            # Metal memory after the child reaps, and spawning the new ~10 GB
+            # server in that window double-commits and trips the pressure
+            # monitor on a 16 GB Mac. Best-effort — targets ~11 GB free, times
+            # out at 8 s, and proceeds anyway (refusing would be worse).
             if had_prior:
-                _lifecycle_log("memory_wait_start",
-                               reason="model_switch", target_mb=11000)
+                # Only a genuine model change is "model_switch"; a same-model
+                # relaunch (crash/disconnect recovery) is "server_restart".
+                _reason = ("model_switch" if (model_path and model_path != _prev_model)
+                           else "server_restart")
+                _lifecycle_log("memory_wait_start", reason=_reason, target_mb=11000)
                 _wait_for_memory_release(min_free_mb=11000, timeout_s=8.0)
 
             # Find a port we can actually bind to. If the default is

localcode/session.py

@@ -49,6 +49,10 @@ class SessionState:
     events: list[dict[str, str]] = field(default_factory=list)
     current_task: TaskState | None = None
     recent_tasks: list[TaskState] = field(default_factory=list)
+    # Working-memory checklist written by the todo_write tool: a list of
+    # {content, status, activeForm} dicts. Persisted so a resumed session
+    # keeps its plan; injected into context each round by the agent loop.
+    todos: list[dict] = field(default_factory=list)
 
 
 class SessionStore:
@@ -170,6 +174,7 @@ class SessionStore:
             events=list(data.get("events", [])),
             current_task=_load_task(current_task),
             recent_tasks=[task for task in (_load_task(t) for t in recent_tasks) if task is not None],
+            todos=list(data.get("todos", [])),
         )
 
     def save(self, session: SessionState) -> Path:
@@ -184,6 +189,7 @@ class SessionStore:
             "pinned_files": session.pinned_files,
             "last_assistant_text": session.last_assistant_text,
             "events": session.events,
+            "todos": session.todos,
             "current_task": None if session.current_task is None else {
                 "task_id": session.current_task.task_id,
                 "user_request": session.current_task.user_request,

localcode/tools/__init__.py

@@ -36,6 +36,7 @@ from . import (
     plan_mode,
     read_file,
     skill_tool,
+    todo_write,
     web_fetch,
     web_search,
     write_file,
@@ -60,6 +61,7 @@ _TOOLS: dict[str, tuple[dict, Callable[[ToolContext, dict], str]]] = {
     "web_search":     (web_search.SCHEMA,     web_search.execute),
     "web_fetch":      (web_fetch.SCHEMA,      web_fetch.execute),
     "skill":          (skill_tool.SCHEMA,     skill_tool.execute),
+    "todo_write":     (todo_write.SCHEMA,     todo_write.execute),
     "agent":          (agent.SCHEMA,          agent.execute),
     "enter_plan_mode": (plan_mode.ENTER_SCHEMA, plan_mode.execute_enter),
     "exit_plan_mode":  (plan_mode.EXIT_SCHEMA,  plan_mode.execute_exit),
@@ -80,6 +82,7 @@ _PUBLIC_TOOL_NAMES = [
     "web_search",
     "web_fetch",
     "skill",
+    "todo_write",
     "agent",
 ]
 
@@ -126,6 +129,9 @@ def schemas_for_goal(
         # Sub-agent — lets the model spawn focused sub-tasks (explore/plan/verify
         # /general-purpose) so it doesn't burn its own context on long searches.
         "agent",
+        # Working-memory checklist — lets the model record a plan and track
+        # done/in-progress/remaining across rounds so it stops repeating work.
+        "todo_write",
     }
     schemas = schemas_for_names(selected)
     # MCP tools — any tools exposed by user-configured MCP servers in
@@ -154,6 +160,7 @@ _MODULES = {
     "web_search": web_search,
     "web_fetch": web_fetch,
     "skill": skill_tool,
+    "todo_write": todo_write,
 }
 
 

localcode/tools/todo_write.py

@@ -0,0 +1,140 @@
+"""todo_write — the agent's working-memory checklist.
+
+Small quantized models lose track of what they've already done across
+rounds: they re-read the same file, re-run the same `find`, and restart from
+scratch. The reactive dedup guards reject those repeats but don't tell the
+model where it is in the job. This tool gives the model an explicit,
+persistent task list — what's done, what's in progress, what's left — that
+the agent loop feeds back into context every round (see
+`agent/loop.py`), so the model can progress sequentially instead of looping.
+
+Modelled on the TodoWrite pattern: the model sends the FULL updated list
+each call (it replaces the stored one), keeps exactly ONE item in_progress,
+and marks items completed the moment they're done.
+"""
+from __future__ import annotations
+
+from .base import ToolContext
+
+_STATUSES = ("pending", "in_progress", "completed")
+
+SCHEMA = {
+    "type": "function",
+    "function": {
+        "name": "todo_write",
+        "description": (
+            "Record and update your task list for a multi-step job. Call this "
+            "at the START of any task with 3+ steps to lay out the plan, then "
+            "again every time you finish a step or discover a new one. Send the "
+            "FULL list each time — it replaces the previous one. Keep exactly "
+            "ONE item 'in_progress'; mark an item 'completed' the moment it's "
+            "done (don't batch). This is how you remember what you've already "
+            "done and what's left, so you don't repeat work."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "todos": {
+                    "type": "array",
+                    "description": "The full, updated task list (replaces the previous one).",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "content": {
+                                "type": "string",
+                                "description": "The task in imperative form, e.g. 'Add /login endpoint'.",
+                            },
+                            "status": {
+                                "type": "string",
+                                "enum": list(_STATUSES),
+                                "description": "pending | in_progress | completed.",
+                            },
+                            "activeForm": {
+                                "type": "string",
+                                "description": "Optional present-continuous form shown while active, e.g. 'Adding /login endpoint'.",
+                            },
+                        },
+                        "required": ["content", "status"],
+                    },
+                },
+            },
+            "required": ["todos"],
+        },
+    },
+}
+
+
+def _normalize(todos) -> list[dict]:
+    """Coerce the model's list into clean {content, status, activeForm} dicts."""
+    cleaned: list[dict] = []
+    for item in todos:
+        if not isinstance(item, dict):
+            continue
+        content = str(item.get("content", "") or "").strip()
+        if not content:
+            continue
+        status = str(item.get("status", "pending") or "pending").strip().lower()
+        if status not in _STATUSES:
+            status = "pending"
+        active = str(item.get("activeForm", "") or "").strip() or content
+        cleaned.append({"content": content, "status": status, "activeForm": active})
+    return cleaned
+
+
+def render_todo_reminder(todos: list[dict]) -> str:
+    """Render the current list as a compact reminder for the model context.
+
+    Used both by this tool's result and by the agent loop's per-round
+    injection. Returns "" for an empty list so the first round's prompt
+    prefix stays stable (cache-friendly).
+    """
+    if not todos:
+        return ""
+    lines = ["Your task list (keep exactly one in_progress; update it as you go):"]
+    marks = {"completed": "[x]", "in_progress": "[~]", "pending": "[ ]"}
+    for i, t in enumerate(todos, 1):
+        status = t.get("status", "pending")
+        mark = marks.get(status, "[ ]")
+        label = t.get("content", "")
+        if status == "in_progress" and t.get("activeForm"):
+            label = t["activeForm"]
+        lines.append(f"{i}. {mark} {label}")
+    return "\n".join(lines)
+
+
+def execute(ctx: ToolContext, args: dict) -> str:
+    todos = args.get("todos")
+    if not isinstance(todos, list):
+        return (
+            "Error: todo_write expects a 'todos' array of "
+            "{content, status} objects. Retry with the full task list."
+        )
+    cleaned = _normalize(todos)
+    session = getattr(ctx.app, "session", None)
+
+    # Auto-clear once everything is done — an all-completed list means the
+    # job is finished, so persist it as empty rather than a wall of [x].
+    all_done = bool(cleaned) and all(t["status"] == "completed" for t in cleaned)
+    if session is not None:
+        session.todos = [] if all_done else cleaned
+
+    if all_done:
+        return "All tasks completed. Task list cleared."
+    if not cleaned:
+        if session is not None:
+            session.todos = []
+        return "Task list cleared."
+
+    in_progress = [t for t in cleaned if t["status"] == "in_progress"]
+    body = render_todo_reminder(cleaned)
+    note = ""
+    if len(in_progress) == 0:
+        note = "\nNote: nothing is in_progress — mark the next task in_progress before you start it."
+    elif len(in_progress) > 1:
+        note = "\nNote: more than one task is in_progress — keep it to exactly one at a time."
+    return f"Task list updated.\n{body}{note}"
+
+
+def is_concurrency_safe(args: dict) -> bool:
+    # Mutates session state; never run it alongside other tools in a batch.
+    return False

localcode/tools/write_file.py

@@ -174,7 +174,28 @@ def execute(ctx: ToolContext, args: dict) -> str:
     # write_file" disaster, which was the one case where rejecting
     # was load-bearing.
     existed = path.is_file()
+    # Capture the prior content so an in-place rewrite renders as a diff card
+    # (like edit_file/multi_edit), not a bare "Rewrote (N lines)" one-liner.
+    old_content = ""
+    if existed:
+        try:
+            old_content = path.read_text(errors="replace")
+        except Exception:
+            old_content = ""
     path.write_text(content)
     lines = content.count("\n") + 1
     verb = "Rewrote" if existed else "Created"
+
+    # Emit a unified diff for rewrites of existing files so the TUI draws the
+    # diff card. New files (or unchanged rewrites) keep the concise summary —
+    # a full new-file dump as "+" lines is noise, and the summary reads fine.
+    if existed and old_content != content:
+        import difflib
+        diff = list(difflib.unified_diff(
+            old_content.splitlines(keepends=True),
+            content.splitlines(keepends=True),
+            fromfile=args["path"], tofile=args["path"], lineterm="",
+        ))
+        if diff:
+            return "\n".join(diff[:120])
     return f"{verb} {args['path']} ({lines} lines)"

localcode/tui/app.py

@@ -45,20 +45,36 @@ _TERMINAL_RESTORE = (
 def _restore_terminal_state() -> None:
     """Best-effort reset for shutdown paths that bypass Textual teardown."""
     payload = _TERMINAL_RESTORE.encode()
+    wrote = False
     try:
         with open("/dev/tty", "wb", buffering=0) as tty:
             tty.write(payload)
-        return
+        wrote = True
     except Exception:
         pass
-    try:
-        os.write(1, payload)
-    except Exception:
+    if not wrote:
         try:
-            sys.__stdout__.write(_TERMINAL_RESTORE)
-            sys.__stdout__.flush()
+            os.write(1, payload)
         except Exception:
-            pass
+            try:
+                sys.__stdout__.write(_TERMINAL_RESTORE)
+                sys.__stdout__.flush()
+            except Exception:
+                pass
+    # Escape codes don't undo kernel raw mode (no echo, dead Ctrl+C). On the
+    # signal path this runs instead of the launcher's termios restore, so
+    # bring the line discipline back to sane here too.
+    try:
+        import subprocess
+        subprocess.run(
+            ["stty", "sane"],
+            stdin=open("/dev/tty", "rb"),
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            timeout=2,
+        )
+    except Exception:
+        pass
 
 
 class LocalCodeTUI(App):

localcode/tui/screens/chat.py

@@ -399,16 +399,24 @@ class _ChatTextArea(TextArea):
     DEFAULT_CSS = """
     _ChatTextArea {
         background: ansi_default;
+        /* Scrollbar shows once the input grows past its cap. Force the brand
+           blue + a thin bar — otherwise it inherits the textual-ansi theme's
+           `scrollbar: ansi_blue`, which renders as the terminal's dark navy
+           (the "wrong blue"). */
+        scrollbar-color: #5f87ff;
+        scrollbar-color-hover: #5f87ff;
+        scrollbar-color-active: #7aa2ff;
+        scrollbar-background: ansi_default;
+        scrollbar-size-vertical: 1;
         & .text-area--cursor-line {
             background: ansi_default;
         }
-        /* The caret. Without an explicit style it inherits the ansi_default
-           theme where $foreground == $background, rendering an INVISIBLE
-           cursor. Give it concrete high-contrast colors so it shows (and
-           blinks) on every terminal, light or dark. */
+        /* The caret. `reverse` swaps the cell's fg/bg using the terminal's
+           OWN colors, so the cursor is a light block on a dark terminal and
+           a dark block on a light one — no hardcoded hex that fights the
+           ansi_default palette (which rendered as a near-black block). */
         & .text-area--cursor {
-            color: #1e1e1e;
-            background: #d0d0d0;
+            text-style: reverse;
         }
         &:focus {
             background-tint: transparent 0%;
@@ -484,6 +492,14 @@ class _ChatTextArea(TextArea):
         # being cut off (the CSS `max-height` was a static 10).
         self.styles.max_height = cap
 
+    def on_text_area_changed(self, event: "TextArea.Changed") -> None:
+        # Re-measure on EVERY content change — typing, backspace, cut — not
+        # just paste/history. A long typed line soft-wraps in the document;
+        # without this the widget stayed one row tall and only the last
+        # wrapped row (the "end") was visible, so mid-line edits looked
+        # impossible. Growing the box exposes the whole wrapped input.
+        self.autosize_height()
+
     # ── input history (per-session, in-memory) ──
     # Same shell-style behaviour as the old Input: ↑ recalls older
     # submissions, ↓ walks newer / clears the draft. For a multi-line
@@ -667,6 +683,23 @@ _SLASH_COMMANDS = [
 # command handler still treats it as a no-op alias to avoid surprising
 # anyone who typed it before.
 
+# Every recognized slash command (palette names + aliases the handler
+# accepts). Input starting with "/" is only treated as a command when its
+# first token is one of these; anything else — e.g. a filesystem path like
+# /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",
+}
+
+
+def _is_known_command(text: str) -> bool:
+    """True only when `text`'s leading token is a recognized slash command."""
+    if not text.startswith("/"):
+        return False
+    head = text.split(None, 1)[0].lower()
+    return head in _KNOWN_COMMANDS
+
 if TYPE_CHECKING:
     from ..app import LocalCodeTUI
     from ...telemetry import TurnTrace
@@ -684,6 +717,14 @@ _SPINNER_GERUNDS = [
 ]
 
 
+# How long (seconds) each spinner word stays before rotating. Deliberately
+# slow: the word is a mood indicator, not a data readout. Rotating it per
+# token (at 50-100 tok/s) makes it strobe unreadably — the reference CLI
+# agents keep the word steady for a couple seconds and let only the little
+# frame glyph + timer animate quickly. ~2.4 s reads as "alive but calm".
+_SPINNER_WORD_PERIOD = 2.4
+
+
 def _spinner_label(tick: int = 0) -> str:
     """Return a generic playful gerund for the streaming spinner.
 
@@ -693,6 +734,16 @@ def _spinner_label(tick: int = 0) -> str:
     """
     return _SPINNER_GERUNDS[tick % len(_SPINNER_GERUNDS)]
 
+
+def _spinner_label_for_elapsed(elapsed: float) -> str:
+    """Pick the gerund by WALL-CLOCK time, not token/tick count.
+
+    The word advances once every `_SPINNER_WORD_PERIOD` seconds regardless of
+    how fast tokens stream, so a fast decode no longer flickers the label.
+    """
+    idx = int(max(0.0, elapsed) / _SPINNER_WORD_PERIOD)
+    return _SPINNER_GERUNDS[idx % len(_SPINNER_GERUNDS)]
+
 _TOOL_CALL_RE = re.compile(
     r'<\|?tool_call\|?>.*?<\|?/?tool_call\|?>', re.DOTALL
 )
@@ -1311,6 +1362,14 @@ class ChatScreen(Screen):
         if not text:
             return
 
+        # While the model is REASONING, rotate the playful gerund on a slow
+        # wall-clock cadence here — never per streamed chunk. This is the one
+        # place the word is chosen, so token speed can't strobe it. Fixed
+        # phases ("generating") keep their word.
+        if self._active_mode == "thinking" and getattr(self, "_thinking_phase", "") == "thinking":
+            elapsed = time.time() - (self._turn_start or time.time())
+            text = _spinner_label_for_elapsed(elapsed)
+
         timer = self._elapsed_str()
 
         # ● for tools (blue ball), ◆ for thinking
@@ -1820,9 +1879,9 @@ class ChatScreen(Screen):
         if not text:
             return
         # Record into per-input history so ↑/↓ can recall it next time.
-        # Skipped for slash commands because users normally don't want
-        # `/clear` and `/quit` in their navigable history.
-        if not text.startswith("/"):
+        # Skipped only for real slash commands (users don't want `/clear`
+        # and `/quit` in navigable history) — a `/path` message IS recorded.
+        if not _is_known_command(text):
             inp.history_push(text)
         inp.clear()
         # Belt + suspenders for the "submitted text reappears in the
@@ -1860,7 +1919,10 @@ class ChatScreen(Screen):
         self.set_timer(0.5, _double_clear)
         self.set_timer(1.5, _double_clear)
 
-        if text.startswith("/"):
+        # A leading "/" is a command ONLY when it matches a known one —
+        # otherwise (e.g. a pasted path like /Users/you/repo) it's a normal
+        # message for the model, not an "Unknown command".
+        if _is_known_command(text):
             self._handle_command(text)
             return
 
@@ -3958,24 +4020,18 @@ class ChatScreen(Screen):
             self._thinking_text += chunk
             self._turn_tokens += max(1, len(chunk) // 4) if chunk else 0
             self._thinking_phase = "thinking"
-            # Keep the spinner on a generic placeholder — never surface the
-            # model's real reasoning text here (it goes to the expandable
-            # thinking section on thinking_done). Token count + elapsed time
-            # next to the label keep updating via _tick_active.
+            # Do NOT touch the spinner word here — the word rotates on the
+            # 50 ms wall-clock timer in _tick_active, so a fast decode can't
+            # strobe it (and the shimmer stays smooth instead of jumping on
+            # every irregular chunk). Just make sure the animation is running.
             if self._active_mode != "thinking":
-                self._show_active_thinking(_spinner_label(self._tick_count))
-            else:
-                self._active_step_text = _spinner_label(self._tick_count)
-                self._tick_active()
+                self._show_active_thinking("thinking")
         elif t == "thinking_peek":
             self._thinking_phase = "thinking"
             # thinking_peek carries model text in p["text"]; deliberately
-            # ignore it for the spinner label and show a placeholder instead.
+            # ignore it — the timer picks the placeholder word (see above).
             if self._active_mode != "thinking":
-                self._show_active_thinking(_spinner_label(self._tick_count))
-            else:
-                self._active_step_text = _spinner_label(self._tick_count)
-                self._tick_active()
+                self._show_active_thinking("thinking")
         elif t == "thinking_done":
             text = p.get("text", "")
             self._thinking_text = text

localcode/tui/screens/setup.py

@@ -120,8 +120,8 @@ class SetupScreen(Screen):
                     id="setup-onetime-note",
                 )
                 yield Static(
-                    "[dim]q / Esc / Ctrl+C to quit — the download resumes "
-                    "where it left off next launch.[/]",
+                    "[dim]Esc to quit — the download resumes where it "
+                    "left off next launch.[/]",
                     id="setup-quit-hint",
                 )
 
@@ -838,7 +838,7 @@ class SetupScreen(Screen):
             f"[bold]/model[/].\n\n"
             f"[bold]c[/] chat now with {fallback.name}   ·   "
             f"[bold]w[/] wait here for {target.name}\n"
-            f"[dim]q / Esc / Ctrl+C to quit — the download resumes next launch.[/]"
+            f"[dim]Esc to quit — the download resumes next launch.[/]"
         )
         # Stored as the live status text; `_tick` renders it verbatim while
         # `_awaiting_choice` is set (no [dim] wrap, no clobber).

localcode/tui/styles/app.tcss

@@ -66,8 +66,10 @@ Screen {
     background-tint: transparent 0%;
 }
 
+/* height: auto so the row grows with the multi-line input instead of
+   clipping it to a single line. The `›` prompt (height 1) top-aligns. */
 #input-row {
-    height: 1;
+    height: auto;
     border: none;
     background: ansi_default;
     background-tint: transparent 0%;
@@ -87,7 +89,7 @@ Screen {
     border: none;
     padding: 0;
     margin: 0;
-    height: 1;
+    height: auto;
     width: 1fr;
     background: ansi_default;
     background-tint: transparent 0%;

localcode/tui/widgets/chat_log.py

@@ -143,7 +143,21 @@ class ChatLog(RichLog):
         self._prompt_gap_pending: bool = False
 
     def write(self, content, *args, **kwargs) -> "ChatLog":
-        """Override to always constrain width to the visible area."""
+        """Override to constrain width AND to only follow the tail when the
+        user is already at the bottom.
+
+        RichLog's `auto_scroll=True` snaps to the bottom on EVERY write, so
+        new output (streaming prose, tool lines, info) yanked a user who had
+        scrolled up to read back down to the end. Gate it: stick to the
+        bottom only when already (near) there; otherwise leave the scroll
+        position alone. Skipped during `_rerender`, which manages
+        `auto_scroll` itself and restores the exact prior position.
+        """
+        if not getattr(self, "_rerendering", False):
+            try:
+                self.auto_scroll = self._at_bottom()
+            except Exception:
+                pass
         try:
             w = self._content_width()
             if w > 10 and "width" not in kwargs:
@@ -152,6 +166,14 @@ class ChatLog(RichLog):
             pass
         return super().write(content, *args, **kwargs)
 
+    def _at_bottom(self) -> bool:
+        """True when the viewport is at (or within ~2 lines of) the bottom —
+        i.e. the user is following the tail rather than reading history."""
+        try:
+            return self.scroll_offset.y >= self.max_scroll_y - 2
+        except Exception:
+            return True
+
     def _content_width(self, *, fallback: int = 76) -> int:
         """Actual visible width for chat content.
 

localcode/tui/widgets/messages/diff.py

@@ -46,6 +46,7 @@ def _emit_wrapped_line(
     build_cont_prefix,       # callable() → Text for every wrap-continuation row
     content_style: str,
     content_width: int,
+    highlighted=None,        # optional pre-syntax-highlighted Text for `content`
 ) -> None:
     """Write a styled diff line to `log`, wrapping long content cleanly.
 
@@ -56,7 +57,20 @@ def _emit_wrapped_line(
     width, write the first piece with the real line-number + marker
     prefix, and write each continuation piece with a blank prefix of
     the same width so everything lines up under the `+`/`-` column.
+
+    When `highlighted` (a syntax-colored Text of `content`) is given AND the
+    line fits on one row, we render it directly to preserve token colors;
+    long lines fall back to plain-style wrapping so layout never breaks.
     """
+    # Syntax-highlighted fast path: only when the whole line fits one row
+    # (avoids re-implementing style-preserving wrap). Otherwise fall through.
+    if highlighted is not None and content_width > 0 and len(content) <= content_width:
+        dl = build_first_prefix()
+        dl.append_text(highlighted)
+        log.write(dl)
+        log._track_lines()
+        return
+
     if content_width <= 0:
         # Degenerate terminal size — fall back to one write and let
         # Rich wrap as best it can.
@@ -94,6 +108,45 @@ def _emit_wrapped_line(
 _HUNK_HEADER_RE = re.compile(r'\+(\d+)(?:,(\d+))?')
 _HUNK_OLD_RE = re.compile(r'-(\d+)')
 
+# Extension → Pygments lexer name for syntax-highlighting diff content.
+_LEXER_BY_EXT = {
+    ".py": "python", ".pyi": "python", ".ts": "typescript", ".tsx": "tsx",
+    ".js": "javascript", ".jsx": "jsx", ".mjs": "javascript", ".go": "go",
+    ".rs": "rust", ".java": "java", ".kt": "kotlin", ".swift": "swift",
+    ".c": "c", ".h": "c", ".cpp": "cpp", ".cc": "cpp", ".hpp": "cpp",
+    ".cs": "csharp", ".rb": "ruby", ".php": "php", ".css": "css",
+    ".scss": "scss", ".html": "html", ".xml": "xml", ".json": "json",
+    ".yaml": "yaml", ".yml": "yaml", ".toml": "toml", ".sh": "bash",
+    ".bash": "bash", ".zsh": "bash", ".sql": "sql", ".md": "markdown",
+}
+
+
+def _lexer_for(file_path: str) -> str | None:
+    import os
+    return _LEXER_BY_EXT.get(os.path.splitext(file_path or "")[1].lower())
+
+
+def _highlight(content: str, lexer: str | None):
+    """Syntax-highlight one code line into a Rich Text, or None on failure.
+
+    Bounded to the few preview lines a diff card shows, so the Pygments cost
+    is negligible. Uses `background_color="default"` so it stays transparent
+    over the terminal palette (ansi_default theme). Any failure → None, and
+    the caller falls back to the flat green/red/dim styling.
+    """
+    if not lexer or not content.strip():
+        return None
+    try:
+        from rich.syntax import Syntax
+        txt = Syntax(
+            content, lexer, theme="ansi_dark",
+            background_color="default", word_wrap=False,
+        ).highlight(content)
+        txt.rstrip()  # drop the trailing newline Syntax appends
+        return txt
+    except Exception:
+        return None
+
 
 def render_diff(log: "ChatLog", diff_text: str, max_body_lines: int = 8) -> None:
     """Write a unified-diff blob to `log` with the structured layout.
@@ -118,6 +171,7 @@ def render_diff(log: "ChatLog", diff_text: str, max_body_lines: int = 8) -> None
                 span = int(m.group(2) or 0)
                 max_line_no = max(max_line_no, start + span)
     gutter_w = max(2, len(str(max_line_no)) + 1)
+    lexer = _lexer_for(file_path)
 
     # Header row
     header = Text()
@@ -199,6 +253,7 @@ def render_diff(log: "ChatLog", diff_text: str, max_body_lines: int = 8) -> None
             _emit_wrapped_line(
                 log, line_text[1:], _first_plus, _cont_plus,
                 content_style=f"{C.success}", content_width=width_changed,
+                highlighted=_highlight(line_text[1:], lexer),
             )
             new_line += 1
         else:
@@ -217,6 +272,7 @@ def render_diff(log: "ChatLog", diff_text: str, max_body_lines: int = 8) -> None
             _emit_wrapped_line(
                 log, content, _first_ctx, _cont_ctx,
                 content_style="dim", content_width=width_context,
+                highlighted=_highlight(content, lexer),
             )
             old_line += 1
             new_line += 1

{localcode-0.3.1.dist-info → localcode-0.3.2.dist-info}/METADATA

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

{localcode-0.3.1.dist-info → localcode-0.3.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-localcode/__init__.py,sha256=PcC5VXE54DKaV56uIqe24mQFZ_lu_yD-3qkZtHFJ1jc,49
+localcode/__init__.py,sha256=7CJ7c6EVsH8bTBDIvPtzt8awFwxSSTwMCdNZ31RVGFc,49
 localcode/__main__.py,sha256=_4Tblte9F1KOpB-oGBQuTlaSN-IncLmhihqhBkpH3pU,69
 localcode/_subproc_env.py,sha256=eltq_kKvqGj22pIFivB5BZft9-s5fziBW0lsV9FhEV4,2383
 localcode/app.py,sha256=FSwpce6Jfn7zJmhL1ipaqTq0xKh0MxCMnEnMQuFV8L8,67820
@@ -15,7 +15,7 @@ localcode/config.py,sha256=hiro3Xij6dYWMsRH2UAZSQo4PHQfz11qqmgg_iMOt6M,23590
 localcode/context.py,sha256=eNcTSn5h0FThSYU3l70pMvt4wBXMGwSXe-dUZ0ZTxCs,2968
 localcode/display.py,sha256=3U4RHUTwbRRloOtnen-BiRGeRKYgzwd-6eAwtLsyGCg,1591
 localcode/embeddings.py,sha256=rjhK6o-byPVEz3__EuMerM69upKz8yidgECDsRhki3c,17187
-localcode/entrypoint.py,sha256=aPuPajrjmdvjleuxJFzTINCsjkBkntnWXCGqntgllDw,17769
+localcode/entrypoint.py,sha256=JklE0hvKMFe1aOc92reR2N8pjPssJiRJELsSBTTLi9g,20023
 localcode/errors.py,sha256=PwvM-Ur2cTeXAuyJ_J-cGeezxkMl8Sq2dMPCh6IORW4,16342
 localcode/events.py,sha256=eSC7fKcGGWXxGUvxlMzZw6GrxPsNkjwC5a8QRv5r_1I,15125
 localcode/features.py,sha256=eE_k6SAdo_drGNOfU4cXjH_dVf5kMn2GVmWUyJ59Hxo,12217
@@ -46,10 +46,10 @@ localcode/plans.py,sha256=Tih7WzRmkWO0cF4fEDwjI07978mJZ_l9jXTSTidLb9k,7424
 localcode/process_registry.py,sha256=KBd5ndChtbmIEIFSkGTmAtaLEIIAzc8DhuYX692q73Y,5165
 localcode/recommendations.py,sha256=HVh8u2L3xbwc2qxH7Syec2cEtlEoFV9n1c33SqWF3ng,3184
 localcode/recovery.py,sha256=QUSsBA9IS5AJ6W4m4nIv2RaktTO9TJeL0RcDeUSWHJk,5237
-localcode/runtime.py,sha256=CsiItf-6TviGxeiexK-fD4W0GGYTJZ6TuaT6UTBOWGw,110330
+localcode/runtime.py,sha256=7BWAf-PaUvP0SUBFzxLB4edb6FcLOZay_sBafAPLDIk,113508
 localcode/runtime_diffusion.py,sha256=bVopikSdQeaV9mAuzWYoXtoXpUb7U0yMXU5VFTpbsBc,39741
-localcode/server_manager.py,sha256=LakxnLebZvB7b2hKNd7BeEgChzGNM7mwBmlhCMEceNM,34383
-localcode/session.py,sha256=eYQpJbjdVX9NCo7Ugg_eyJAEE22pt-3PUR0DIFA3Jkg,11614
+localcode/server_manager.py,sha256=DLXnijvGfWbW3tGNaj0sEWIQVJ0N7Jadl_YIWc4W1RE,34339
+localcode/session.py,sha256=taEyOOiCcNXEr8oOeszyWvzvn-oAZ7knXQ7BxRew08Q,11970
 localcode/shell.py,sha256=2QcXk0NB6d8t2gpbbKOB5nGZ_xBJ7VVsLtF4hnUknVM,2300
 localcode/skills.py,sha256=TGdy63dQTlfa6U2l7wjg3zSatKyLAYdu_wVO-J2BrHY,25800
 localcode/snapshots.py,sha256=RYvvC7r1YVaWZNoM7n70X7gjQ_T5MJS6yGro1bmyaeg,6995
@@ -67,13 +67,13 @@ localcode/voice.py,sha256=ZAh1GmJiQJF4cXQ2YCclJZB77Sa9yflox22MnDMl7t8,39178
 localcode/agent/__init__.py,sha256=-aQIBiYIojvwl9nDf_wcyiT5UQTmcEQbEBwnBEsrjEU,7349
 localcode/agent/app_tasks.py,sha256=e5tcxBZczgQyq5irGePfe5fPmNAK6AUJ_N2i11iXb5Q,5725
 localcode/agent/constants.py,sha256=0zlgyqZYJs0MOoh70rOgrXfl_ZuU5kR29Sjzrrz7TlI,12350
-localcode/agent/context.py,sha256=CKF0rE6ho5b04e9h5aBPZfmlruvebxt0TB2zKdgM3Yc,35507
+localcode/agent/context.py,sha256=nXwOhBN5phQ8yxVPrIaju8VDngf2BmdejpvtBP8e88c,37559
 localcode/agent/goal.py,sha256=X87Q3rsdp70wOfkpbh35M4qFWSNyklX3RuRWjv-pCXs,6264
 localcode/agent/helpers.py,sha256=vutFyCtnca0UnF0wgk7LdsqVWdiqyYm4YnFOxtnCJ_A,15004
 localcode/agent/hooks.py,sha256=XadEbSM7gHtKlLrqSKnvcQFcoWoNUXdlMdIPS-EwBGA,15841
-localcode/agent/loop.py,sha256=rI36_dosJLCA9Vp4Xd5QOWYnkWrR0Wf4V-EfSNgZqCc,98891
+localcode/agent/loop.py,sha256=ZX3VS_7jCcRLX3VCSOsl8uMF51AnPICt18awXGk928s,99869
 localcode/agent/prompt_context.py,sha256=abJPLMhTzuVcsW4AfMBIW-SEqmrU69DhI-0vGZllZVU,13707
-localcode/agent/prompts.py,sha256=FjBG_XmM1svqhjfmQxmanAvm8Su0JSXqHbHqY7OS-SA,13580
+localcode/agent/prompts.py,sha256=1VFrtzumZ2A7BaZ1gStpre-mZBs721FZi9hiB4qenZw,14639
 localcode/agent/recovery.py,sha256=8wwPeESsIHtdsSb_eU95JJvlVJrHxeoTVAofxmm3UIs,16639
 localcode/agent/sections.py,sha256=9hnwaNritQHgn7qIGFBZ3ChZgMQXQcqtmpdbR1wafA0,8998
 localcode/agent/streaming.py,sha256=TEcKbmKfDGV1razrV-ceVrvIIxvS-GmLWGNDnF0gSTA,12872
@@ -95,7 +95,7 @@ localcode/skills/locate.md,sha256=sOcEWfzOTueqwhtjMq0lrvBjL4K-4MCAg5dOvmP9kNA,15
 localcode/skills/plan-task.md,sha256=thaz9KdZd6KcErvdduuQEmMSdEtLEyg4b1H_-qsxVkU,2002
 localcode/skills/review.md,sha256=dcR5Qk9ZWUG2wvvJ_JrbbCRgp-k3OUd6ZC5wszVWLcQ,1216
 localcode/skills/run-tests.md,sha256=X9nhFAWtNh7HJwu6CawWgy-8KrDXUVQhWO3V3xCE7zM,1340
-localcode/tools/__init__.py,sha256=BDHMPiL--jHtD5hHWbO4Dp9kor1X9pTKJcfeUwak67k,13550
+localcode/tools/__init__.py,sha256=6FknaKvS-0mo4dYFTegcJcyihcJpH42NzQnM-FkKCPk,13860
 localcode/tools/agent.py,sha256=aIcoGc3JiiSN4MSumwNc9TiKPZciyNXWKTYjFNir79s,8786
 localcode/tools/append_file.py,sha256=GNjPBnnV7hpD32u0Jx6YxRmsOSr4uwvJgIcInH1qhSc,2015
 localcode/tools/base.py,sha256=2QV-q1DzXWM4KL9mFKNPzlBiLOS2uKLXhlgGyeWEKCI,2064
@@ -111,28 +111,29 @@ localcode/tools/multi_edit.py,sha256=bT9OROgwTAZ1gKHE6DnpOU6_EBzLcDiisxXDnkwlyEg
 localcode/tools/plan_mode.py,sha256=2RU6QH1IJoOTKuoAr7Ga7uTaebAS8v7OFt5v1zLEXFw,2886
 localcode/tools/read_file.py,sha256=u8ZySkvSj-ZzPVSdi1ybZ6yTgZ-yXiqAW54ZVdZWf-g,3017
 localcode/tools/skill_tool.py,sha256=vTVPyRWxICtDCVYWMiAMInGnc-wGAk2L1EZn-6e79nE,1478
+localcode/tools/todo_write.py,sha256=8A4k9MzoqOtzJ6y2Gd3lEGkINcpV3JVCd2lYBmdd6qI,5801
 localcode/tools/web_fetch.py,sha256=UPhMrLipwN5xJx5-zr634gL4p6nIRqYI2_7tbUw_8Go,2770
 localcode/tools/web_search.py,sha256=ILfBBx50p00OjA939HzdDmdao4QLL8sRuxlBoUDjmC8,1122
-localcode/tools/write_file.py,sha256=N_cAWtl5V0JekwVIMtEaYdu3tvy87mzD6kUsi0flYsA,8229
+localcode/tools/write_file.py,sha256=zsG2QDkofjjqaUte1mio9_0BvdXpr-LIrNBD1U-pp9Y,9129
 localcode/tui/__init__.py,sha256=Yfy9bvw3l1iY4FDhRX8qZVgnZLuYiq8lc9SDYl4cWwc,61
-localcode/tui/app.py,sha256=I8SBm89yBHqiMqTbI9kI_mKsRT-XyMz1lkneJaC3FkE,17143
+localcode/tui/app.py,sha256=KjQzpGKnxkgh-0kVc3zcb63Q6a5LBuGreBqTUrasiqM,17700
 localcode/tui/bridge.py,sha256=urPPCqC_nisAYawWk3juvMI8IaoJfv4g7USpGOZOqQc,2803
 localcode/tui/screens/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-localcode/tui/screens/chat.py,sha256=DEMeWKHq-i-lV72P3-mZT-_WG29OyWfzwMr_l8CaQHs,190479
+localcode/tui/screens/chat.py,sha256=aTYu03GTAlbXFuZDZaZBIvGNE4we--nRHZw5OYRgvAw,193390
 localcode/tui/screens/mode_picker.py,sha256=cK_xNo7ytOwJXJwzUevMTcb5dwQKtjMfh60of-ntRz4,2347
 localcode/tui/screens/model_picker.py,sha256=VkhyREIT2W1J8A6tUe0ix5TbWXUa2XSe9qKzcXgjjz4,35991
-localcode/tui/screens/setup.py,sha256=JvmV0VRb7uq-uyPrvoPC2arxbTpeBOJO6ry1E5PU-v0,40870
+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=_M_1rlyu1fTAj1MNVtStyvLfc6kAIc6nkbLeKP_Tsl0,4746
+localcode/tui/styles/app.tcss,sha256=9ajThb1pLvI7Ram1ksvtrNGJg1-UqkDY-WerZSJPKlA,4898
 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=J2QZGL-jd2XDD_LwJ2v_SygrdE4_CqxJcLEGrmjmGmY,74695
+localcode/tui/widgets/chat_log.py,sha256=D5DUkrQXL_ilxyC8N1xIPLw4Pqeh0jSWt1mPgho0M-4,75678
 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=fF7GMDSrJtVEzw1FfqlNMlg51MzOi4DwWIe9Oz6Bu6Y,8457
-localcode-0.3.1.dist-info/licenses/LICENSE,sha256=Ahg0cteZ-6bIRB7KC15WEtdqWnzy8HY_yzsZBoVRql0,11294
-localcode-0.3.1.dist-info/METADATA,sha256=7Ytl4F6kiXVDqdKE5pA6ZkV-QC-yRHmizF8eeibTcJM,7813
-localcode-0.3.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-localcode-0.3.1.dist-info/entry_points.txt,sha256=rE7elTGUvMsBd-Quy22cuTVJ-zGVOmx0nEuC6ni9Tg4,87
-localcode-0.3.1.dist-info/top_level.txt,sha256=58eL3Rw8v0OGmYNxjx8uS4ERWatrzUbyCL5inlukkTo,10
-localcode-0.3.1.dist-info/RECORD,,
+localcode/tui/widgets/messages/diff.py,sha256=khDf_MThrQz0S62-t-m7i3OU5cdNolUk1TCeKMRPDQI,10910
+localcode-0.3.2.dist-info/licenses/LICENSE,sha256=Ahg0cteZ-6bIRB7KC15WEtdqWnzy8HY_yzsZBoVRql0,11294
+localcode-0.3.2.dist-info/METADATA,sha256=NfiKTcmNdZeRHzlMdJd6Qm5lTlLT9W2ZPWEnMYsZBKU,7813
+localcode-0.3.2.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+localcode-0.3.2.dist-info/entry_points.txt,sha256=rE7elTGUvMsBd-Quy22cuTVJ-zGVOmx0nEuC6ni9Tg4,87
+localcode-0.3.2.dist-info/top_level.txt,sha256=58eL3Rw8v0OGmYNxjx8uS4ERWatrzUbyCL5inlukkTo,10
+localcode-0.3.2.dist-info/RECORD,,