localcode 0.3.27__tar.gz → 0.3.29__tar.gz

{localcode-0.3.27/src/localcode.egg-info → localcode-0.3.29}/PKG-INFO

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

{localcode-0.3.27 → localcode-0.3.29}/pyproject.toml

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

{localcode-0.3.27 → localcode-0.3.29}/src/localcode/agent/context.py

@@ -721,12 +721,25 @@ def _microcompact_for_prompt_budget(messages: list[dict], *, target_bytes: int =
         return messages
 
     system_count = 1 if messages and messages[0].get("role") == "system" else 0
+    # NEVER compact away the task statement. The first real user message (not
+    # a synthetic "SYSTEM:" nudge) anchors the entire turn: summarizing it into
+    # a one-line ledger made the model literally ask "what is the actual task?"
+    # mid-build and re-derive the goal from directory names (observed live on a
+    # long agentic build). Keep it VERBATIM at the head, always — the reference
+    # harnesses' compaction likewise carries the original request forward.
+    head_count = system_count
+    for i in range(system_count, len(messages)):
+        m = messages[i]
+        if m.get("role") == "user" and isinstance(m.get("content"), str) \
+                and not m["content"].startswith("SYSTEM:"):
+            head_count = i + 1
+            break
     best = messages
     # Tighten the protocol-safe suffix until the serialized prompt fits. A
     # fixed 12-message tail can itself contain several complete source files.
     for tail_size in (12, 10, 8, 6, 4):
-        boundary = max(system_count, len(messages) - tail_size)
-        while boundary > system_count:
+        boundary = max(head_count, len(messages) - tail_size)
+        while boundary > head_count:
             if messages[boundary].get("role") == "tool":
                 boundary -= 1
                 continue
@@ -735,13 +748,13 @@ def _microcompact_for_prompt_budget(messages: list[dict], *, target_bytes: int =
                 boundary -= 1
                 continue
             break
-        if boundary <= system_count:
+        if boundary <= head_count:
             continue
-        old = messages[system_count:boundary]
+        old = messages[head_count:boundary]
         recent = messages[boundary:]
         summary = _compact_history_summary(old)
         candidate = [
-            *messages[:system_count],
+            *messages[:head_count],
             {"role": "user", "content": summary},
             {"role": "assistant", "content": "Continuing with the summarized prior work."},
             *recent,

{localcode-0.3.27 → localcode-0.3.29}/src/localcode/app.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import replace
 import logging
+import re
 from pathlib import Path
 
 from rich.console import Console
@@ -60,6 +61,19 @@ _FOLLOWUP_CHAT_ONLY = {
 
 _CODING_TASK_KINDS = {"new_app", "existing_app_edit", "run_or_launch"}
 
+# Any slash-joined token that isn't a URL scheme ("://") — "~/x", "./x", "..",
+# "/Users/…", or "some/dir". Used to detect that the user chose a location
+# themselves, in which case the $HOME build anchor must NOT re-pin repo_root.
+_EXPLICIT_PATH_RE = re.compile(r"(?<!:)(?:~|\.{1,2})?/[\w.\-]+|[\w.\-]+/[\w.\-]+(?!//)")
+
+
+def _prompt_names_explicit_path(user_text: str) -> bool:
+    """True when the user's request mentions a concrete filesystem path."""
+    text = (user_text or "")
+    # Strip URLs first so "https://foo.com/bar" doesn't read as a path.
+    text = re.sub(r"\w+://\S+", " ", text)
+    return bool(_EXPLICIT_PATH_RE.search(text))
+
 
 def _canonical_project_dir_has_files(repo_root: Path, slug: str) -> bool:
     """True when a creation task's canonical project directory already exists.
@@ -530,11 +544,20 @@ class LocalCodeApp:
         # BEFORE any tool call, so the model builds in one place and the harness
         # (launcher/verify/context) follows it. Only fires in the degenerate
         # $HOME case; a normal in-project launch is untouched.
+        #
+        # NEVER anchor when the user's prompt names a filesystem path: they've
+        # chosen the location themselves, and re-pinning repo_root to an empty
+        # $HOME/<slug> makes every RELATIVE path resolve against the empty
+        # anchor while the model builds at the user's absolute path — observed
+        # live as "Glob(src/utils/*) → empty → 'the file wasn't persisted'" and
+        # a rebuild-from-scratch spiral. False positives here are safe (we just
+        # fall back to unanchored-at-$HOME, the pre-0.3.26 behavior).
         _anchored_resume = False
         if (
             self.repo_root_is_home
             and goal_state.goal_type == "build_app"
             and goal_state.task_kind == "new_app"
+            and not _prompt_names_explicit_path(user_text)
         ):
             _anchored_resume = self._anchor_home_build_root(goal_state.task_slug)
         if (

{localcode-0.3.27 → localcode-0.3.29}/src/localcode/auto_compact.py

@@ -112,9 +112,27 @@ def auto_compact(messages: list[dict], max_chars: int,
     if len(conversation) <= keep_recent:
         return messages, ""
 
+    # NEVER summarize away the task statement. The most recent real user
+    # message (not a synthetic "SYSTEM:" nudge) is the active task; folding it
+    # into the summary made the model ask "what is the actual task?" mid-build
+    # and re-derive the goal from directory names (observed live). Pin it
+    # verbatim: if it falls in the to-be-summarized region, lift it out and
+    # re-append it just before the recent tail.
+    task_msg = None
+    task_idx = None
+    for i in range(len(conversation) - 1, -1, -1):
+        m = conversation[i]
+        if m.get("role") == "user" and isinstance(m.get("content"), str) \
+                and not m["content"].startswith("SYSTEM:"):
+            task_msg, task_idx = m, i
+            break
+
     # Split into old (to summarize) and recent (to keep)
     old = conversation[:-keep_recent]
     recent = conversation[-keep_recent:]
+    pin_task = task_msg is not None and task_idx < len(conversation) - keep_recent
+    if pin_task:
+        old = [m for i, m in enumerate(conversation[:-keep_recent]) if i != task_idx]
 
     summary_text = _build_summary(old)
 
@@ -136,6 +154,10 @@ def auto_compact(messages: list[dict], max_chars: int,
     if system_msg:
         compacted.append(system_msg)
     compacted.append({"role": "system", "content": memo})
+    if pin_task:
+        # The active task statement, verbatim, right after the memo — the model
+        # must always be able to re-read WHAT it was asked to do.
+        compacted.append(task_msg)
     compacted.extend(recent)
 
     return compacted, summary_text

{localcode-0.3.27 → localcode-0.3.29}/src/localcode/runtime.py

@@ -1255,13 +1255,41 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
             return True
 
         from .bootstrap import get_model_path
-        from .server_manager import ServerManager
+        from .server_manager import ServerManager, HEALTH_TIMEOUT_S
         from pathlib import Path
 
         preferred = Path(self.config.model).name if self.config.model else None
         model = get_model_path(preferred)
         if not model:
             return False
+        mgr = ServerManager.get()
+        # NEVER kill a server that is alive and still LOADING. A 30B+ model
+        # takes ~60 s to come up; a request landing during warmup gets a
+        # 503/conn error, and this recovery path used to treat that as "dead"
+        # and restart — killing the almost-loaded server and starting a fresh
+        # 60 s load on the fallback port. Observed live as 4 restarts in
+        # 3 minutes ping-ponging 8081↔8082, each reloading 35 GB of weights,
+        # while the user just saw "crunching". If the process is alive, WAIT
+        # for its health probe instead; only a genuinely dead or wedged
+        # server gets kill+relaunch.
+        if mgr.is_running():
+            try:
+                from .events import emit as _emit_wait
+                _emit_wait("server_warmup_wait", port=mgr.port)
+            except Exception:
+                pass
+            if mgr._wait_healthy(mgr.port, timeout_s=HEALTH_TIMEOUT_S):
+                # Loaded — the server was never broken. Re-point our client
+                # at the live port and carry on with zero reload cost.
+                try:
+                    actual_port = mgr.port
+                    new_base = f"http://localhost:{actual_port}"
+                    if self.config.base_url != new_base:
+                        self.config.base_url = new_base
+                        self.endpoint = f"{new_base}/v1/chat/completions"
+                except Exception:
+                    pass
+                return True
         try:
             if self._client is not None and not self._client.is_closed:
                 self._client.close()
@@ -1269,7 +1297,6 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
             pass
         self._client = None
         cmd = self.llama_server_command(str(model))
-        mgr = ServerManager.get()
         ok = mgr.restart(cmd, str(model))
         # Propagate the (possibly fallback) port back to our config and
         # endpoint URL so downstream HTTP requests hit the live server.
@@ -1337,6 +1364,50 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
         num_predict: int | None = None,
         recovery_mode: str = "",
         stream_policy: str = "",
+    ) -> Iterator[dict[str, Any]]:
+        """In-flight guard wrapper around the real streaming generator.
+
+        Holds ServerManager's request-in-flight count for the stream's whole
+        lifetime so the idle-suspend watchdog can never shut the server down
+        under an active request. Without this, a long round (10+ min decode —
+        routine for a 30B+ model on local hardware, and prompt-eval of a big
+        context emits no chunks at all) counted as "idle": observed live as
+        `idle_suspend idle_s=612` killing the server mid-build, cascading into
+        back-to-back 35 GB weight reloads and a dead session.
+        """
+        _sm = None
+        try:
+            from .server_manager import ServerManager as _SM
+            _sm = _SM.get()
+            _sm.request_started()
+        except Exception:
+            _sm = None
+        try:
+            yield from self._stream_chat_events_inner(
+                messages,
+                tools=tools,
+                think=think,
+                num_ctx=num_ctx,
+                num_predict=num_predict,
+                recovery_mode=recovery_mode,
+                stream_policy=stream_policy,
+            )
+        finally:
+            if _sm is not None:
+                try:
+                    _sm.request_finished()
+                except Exception:
+                    pass
+
+    def _stream_chat_events_inner(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]] | None = None,
+        think: bool = False,
+        num_ctx: int | None = None,
+        num_predict: int | None = None,
+        recovery_mode: str = "",
+        stream_policy: str = "",
     ) -> Iterator[dict[str, Any]]:
         # Diffusion models (architecture="diffusion_gemma") cannot be
         # served by llama-server — they generate via the one-shot
@@ -1508,7 +1579,62 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
                     _adapter = get_adapter(_family)
                     _open = _adapter.thinking_open
                     _close = _adapter.thinking_close
+                    # ── Stream stall watchdog ──
+                    # Never trust the socket to fail on its own. Observed live
+                    # (2026-07-12): the server logged `done request 200`, the
+                    # client kept blocking in sock_recv for 15+ minutes, and
+                    # the 600 s httpx read-timeout never fired — the whole
+                    # agent hung forever. All reference harnesses bound stream
+                    # idle time and retry. A helper thread closes the response
+                    # if no line arrives within the deadline; the blocked read
+                    # then raises immediately and the existing retry ladder
+                    # takes over (the prefix cache makes the re-prefill cheap).
+                    # Deadlines are DYNAMIC: first chunk must cover worst-case
+                    # prompt prefill (scaled from prompt size at a conservative
+                    # 100 tok/s floor for low-end machines); between chunks a
+                    # local decode should never pause more than ~3 minutes.
+                    import threading as _threading_mod
+                    _stall = {"last": _time_mod_runtime.monotonic(), "seen": False, "fired": False}
+                    _prompt_chars_est = sum(
+                        len(str(m.get("content") or "")) for m in messages
+                    )
+                    _first_deadline_s = max(180.0, 60.0 + (_prompt_chars_est / 3.5) / 100.0)
+                    _inter_deadline_s = 180.0
+
+                    def _stall_watchdog() -> None:
+                        while True:
+                            _time_mod_runtime.sleep(5.0)
+                            try:
+                                if response.is_closed:
+                                    return
+                            except Exception:
+                                return
+                            gap = _time_mod_runtime.monotonic() - _stall["last"]
+                            limit = _inter_deadline_s if _stall["seen"] else _first_deadline_s
+                            if gap > limit:
+                                _stall["fired"] = True
+                                try:
+                                    from .events import emit as _emit_stall
+                                    _emit_stall(
+                                        "stream_stall_abort",
+                                        gap_s=round(gap, 1),
+                                        limit_s=round(limit, 1),
+                                        first_chunk_seen=_stall["seen"],
+                                    )
+                                except Exception:
+                                    pass
+                                try:
+                                    response.close()
+                                except Exception:
+                                    pass
+                                return
+
+                    _threading_mod.Thread(
+                        target=_stall_watchdog, name="lc-stream-stall", daemon=True
+                    ).start()
                     for line in response.iter_lines():
+                        _stall["last"] = _time_mod_runtime.monotonic()
+                        _stall["seen"] = True
                         if not line:
                             continue
                         if self.config.provider == "llama_cpp" and line.startswith("data: "):

{localcode-0.3.27 → localcode-0.3.29}/src/localcode/server_manager.py

@@ -321,6 +321,25 @@ class ServerManager:
         import time as _t
         self._last_activity_ts = _t.time()
 
+    def request_started(self) -> None:
+        """Mark a chat request in flight. The idle watchdog must NEVER
+        suspend the server while a request is live: a single long agentic
+        round (a 10+ minute decode is routine for a 30B+ model on local
+        hardware) used to count as "idle" because activity was only marked at
+        request START — observed live as `idle_suspend idle_s=612` firing
+        mid-build, shutting the server down under an active stream and
+        cascading into back-to-back reloads (35 GB of weights each) and a dead
+        session. Pair with request_finished() in a finally block."""
+        with self._lock:
+            self._inflight = getattr(self, "_inflight", 0) + 1
+        self.mark_activity()
+
+    def request_finished(self) -> None:
+        """Mark a chat request complete (see request_started)."""
+        with self._lock:
+            self._inflight = max(0, getattr(self, "_inflight", 0) - 1)
+        self.mark_activity()
+
     def set_idle_timeout(self, seconds: float) -> None:
         """Update the idle auto-suspend window. 0 disables suspend."""
         self._idle_timeout_s = max(0.0, float(seconds))
@@ -336,6 +355,11 @@ class ServerManager:
                     continue
                 if self._last_activity_ts == 0.0:
                     continue
+                # A live request is never idle, no matter how long its decode
+                # runs. This is the primary guard; the streaming path also
+                # marks activity per chunk as a belt-and-braces backstop.
+                if getattr(self, "_inflight", 0) > 0:
+                    continue
                 idle = _t.time() - self._last_activity_ts
                 if idle >= self._idle_timeout_s:
                     _lifecycle_log(
@@ -343,7 +367,7 @@ class ServerManager:
                         idle_s=round(idle, 1),
                         threshold_s=self._idle_timeout_s,
                     )
-                    self.shutdown()
+                    self.shutdown(reason="idle_suspend")
             except Exception:
                 # Never let the watchdog crash the process.
                 pass
@@ -390,7 +414,7 @@ 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()
+            self._shutdown_locked(reason="start_or_model_swap")
             # Wait for the OLD server's memory to release before spawning the
             # new one (kernel takes 1-3 s to free wired Metal memory; spawning
             # into that window double-commits). Best-effort: ~11 GB target, 8 s.
@@ -515,7 +539,7 @@ class ServerManager:
         """
         return self.start(cmd, model_path, port=port, timeout_s=timeout_s)
 
-    def shutdown(self, force: bool = False) -> None:
+    def shutdown(self, force: bool = False, reason: str = "") -> None:
         """Stop the server. Idempotent; safe to call multiple times.
 
         ``force=False`` (default, used for model swaps): graceful path —
@@ -528,12 +552,16 @@ class ServerManager:
         on process death anyway, and skipping the 5–10 s graceful
         cleanup is the difference between a snappy exit and the user
         wondering if localcode is hung.
+
+        ``reason`` is recorded on the server_stopped lifecycle event so a
+        restart storm is diagnosable from events.jsonl alone.
         """
         with self._lock:
             if force:
+                self._pending_stop_reason = reason or "app_exit_force"
                 self._force_kill_locked()
             else:
-                self._shutdown_locked()
+                self._shutdown_locked(reason=reason)
 
     def _force_kill_locked(self) -> None:
         """SIGKILL-immediately path for app exit. Must be called with
@@ -602,7 +630,7 @@ class ServerManager:
     # Internals
     # ────────────────────────────────────────────────────────────────
 
-    def _shutdown_locked(self) -> None:
+    def _shutdown_locked(self, reason: str = "") -> None:
         """Must be called with self._lock held.
 
         Supervisor pattern: SIGTERM → wait 3s → SIGKILL → wait 2s. If
@@ -610,7 +638,12 @@ class ServerManager:
         kernel sleep — Metal mmap/GPU). We record that in a marker file
         so the next localcode launch's health check can detect it and
         refuse to start, instead of letting the OS OOM-kill the user.
+
+        `reason` lands on the server_stopped lifecycle event. The restart
+        storm of 2026-07-12 (7 stops in 15 min) was invisible precisely
+        because stops carried no reason — never emit a bare stop again.
         """
+        self._pending_stop_reason = reason or getattr(self, "_pending_stop_reason", "") or "unspecified"
         if self._process is not None:
             pid = self._process.pid
             stuck = False
@@ -638,7 +671,9 @@ class ServerManager:
             if stuck:
                 _mark_stuck_server(pid)
             _lifecycle_log("server_stopped", pid=pid, stuck=stuck,
+                           reason=getattr(self, "_pending_stop_reason", "unspecified"),
                            free_mb_at_stop=_system_free_memory_mb())
+            self._pending_stop_reason = ""
             self._process = None
             self._model_path = None
 
@@ -650,24 +685,68 @@ class ServerManager:
         self._kill_port(self._port)
 
     def _reap_stale_pid_file(self) -> None:
-        """If the PID file exists and points to a live process, kill it. This
-        runs on manager construction so that a fresh app launch starts from
-        a clean slate even if the previous run was SIGKILL'd.
+        """Reconcile the PID file on manager construction.
+
+        HARD-LEARNED (2026-07-12, live): this used to killpg(SIGKILL)
+        whatever pid the file named, unverified. Consequences observed the
+        same day: (a) launching a second localcode killed the first
+        session's HEALTHY server mid-build, twice, ending the user's run;
+        (b) under restart churn a recycled pid let the killpg land on the
+        TUI's own process group — the whole app died with `zsh: killed`
+        and 60 GB free. A world-shared pid file must never be treated as
+        a kill list. Now: only a VERIFIED llama-server (see
+        `_pid_is_our_llama_server`) that is NOT serving healthily gets
+        killed; anything else is left alone and only the file is removed.
         """
         self._kill_pid_file()
 
+    @staticmethod
+    def _pid_is_our_llama_server(pid: int) -> bool:
+        """True iff `pid` is alive AND its command line is a llama-server.
+
+        The pgid==pid check exploits our own spawn signature
+        (start_new_session=True makes every server we launch its own
+        process-group leader). A recycled pid belonging to some other
+        program fails the name check; a process in someone else's group
+        (e.g. the TUI's) fails the leader check. Both must pass before we
+        are willing to signal it.
+        """
+        try:
+            if os.getpgid(pid) != pid:
+                return False
+        except Exception:
+            return False
+        try:
+            out = subprocess.run(
+                ["ps", "-p", str(pid), "-o", "command="],
+                capture_output=True, text=True, timeout=3,
+            ).stdout.strip()
+        except Exception:
+            return False
+        return "llama-server" in out or "llama-diffusion" in out
+
     def _kill_pid_file(self) -> None:
         if not PID_FILE.exists():
             return
+        pid, _file_port = 0, 0
         try:
-            raw = PID_FILE.read_text().strip()
-            pid = int(raw) if raw else 0
+            parts = PID_FILE.read_text().strip().split()
+            pid = int(parts[0]) if parts else 0
+            _file_port = int(parts[1]) if len(parts) > 1 else 0
         except Exception:
             pid = 0
-        if pid > 0:
+        if pid > 0 and self._pid_is_our_llama_server(pid):
+            # A healthy, serving llama-server is NOT stale — it belongs to a
+            # live session (possibly this one, possibly another terminal).
+            # Killing it ends that user's in-flight build. Leave it; the
+            # setup screen's reuse/port-fallback logic handles coexistence.
+            _check_port = _file_port or self._port
+            if _probe_health(_check_port, timeout=1.0):
+                _lifecycle_log("pid_reap_skipped_healthy", pid=pid, port=_check_port)
+                return
             try:
-                pgid = os.getpgid(pid)
-                os.killpg(pgid, signal.SIGKILL)
+                os.killpg(os.getpgid(pid), signal.SIGKILL)
+                _lifecycle_log("pid_reap_killed", pid=pid)
             except ProcessLookupError:
                 pass
             except Exception:
@@ -675,6 +754,8 @@ class ServerManager:
                     os.kill(pid, signal.SIGKILL)
                 except Exception:
                     pass
+        elif pid > 0:
+            _lifecycle_log("pid_reap_skipped_not_ours", pid=pid)
         try:
             PID_FILE.unlink()
         except FileNotFoundError:
@@ -737,9 +818,23 @@ class ServerManager:
         return find_free_port(preferred)
 
     def _kill_port(self, port: int) -> None:
-        """Kill anything bound to `port` via lsof. Best-effort; silent on
+        """Kill a WEDGED llama-server bound to `port`. Best-effort; silent on
         failure (lsof not installed, permission denied, etc.).
+
+        Two guards, both learned live (2026-07-12):
+        - Only signal a process whose command line is a llama-server —
+          this sweep must never SIGKILL an arbitrary process that happens
+          to sit on our port (that's the user's dev server, another app…).
+        - Never signal a HEALTHY llama-server: it belongs to a live session
+          (another terminal). Killing it ends that session's build mid-
+          flight; the caller should use port fallback (8082, 8083, …)
+          instead. Only an unresponsive listener — the actual "wedged
+          zombie blocks every launch until reboot" case this sweep exists
+          for — gets killed.
         """
+        if _probe_health(port, timeout=1.0):
+            _lifecycle_log("port_kill_skipped_healthy", port=port)
+            return
         try:
             r = subprocess.run(
                 ["lsof", "-ti", f":{port}"],
@@ -750,6 +845,16 @@ class ServerManager:
                     pid = int(pid_str)
                 except ValueError:
                     continue
+                try:
+                    out = subprocess.run(
+                        ["ps", "-p", str(pid), "-o", "command="],
+                        capture_output=True, text=True, timeout=3,
+                    ).stdout
+                    if "llama-server" not in out and "llama-diffusion" not in out:
+                        _lifecycle_log("port_kill_skipped_not_ours", port=port, pid=pid)
+                        continue
+                except Exception:
+                    continue
                 try:
                     os.kill(pid, signal.SIGKILL)
                 except ProcessLookupError:
@@ -762,7 +867,10 @@ class ServerManager:
     def _write_pid_file(self, pid: int) -> None:
         try:
             PID_FILE.parent.mkdir(parents=True, exist_ok=True)
-            PID_FILE.write_text(str(pid))
+            # "pid port" — the port lets the next launch's reaper health-probe
+            # the RIGHT server before deciding it's stale (a bare pid forced it
+            # to probe the default port and mis-kill fallback-port servers).
+            PID_FILE.write_text(f"{pid} {self._port}")
         except Exception:
             # PID file is a recovery aid, not a correctness requirement.
             pass

{localcode-0.3.27 → localcode-0.3.29}/src/localcode/tools/append_file.py

@@ -36,7 +36,7 @@ def execute(ctx: ToolContext, args: dict) -> str:
         return "Error: 'content' argument is required for append_file."
 
     rel_path = str(args["path"])
-    path = ctx.repo / rel_path
+    path = ctx.resolve_path(rel_path)
     if path.is_dir():
         return f"Error: append_file cannot append to directory: {rel_path}"
     content = str(args.get("content", ""))

{localcode-0.3.27 → localcode-0.3.29}/src/localcode/tools/base.py

@@ -41,6 +41,48 @@ class ToolContext:
     def repo(self) -> Path:
         return self.app.repo_root
 
+    def resolve_path(self, raw: str) -> Path:
+        """Resolve a tool `path` argument, healing corrupted repo prefixes.
+
+        Small quantized models corrupt long absolute paths when they copy
+        them between calls. Observed live (2026-07-13): the model turned the
+        workdir `…/localcode-evals/20260713-024502/tempconv` into
+        `…/localcode-evals/2026-0713-0245-02/tempconv` — hyphens
+        hallucinated into the timestamp — and every subsequent write landed
+        in a phantom tree while the real project stayed empty. Same class of
+        fix as fuzzy old_string matching in edit_file: if an absolute path
+        is NOT under repo_root but its leading components are a near-match
+        of repo_root's (difflib ratio ≥ 0.8 per component), remap that
+        prefix onto the real repo_root. Anything else passes through
+        untouched — LocalCode intentionally has full filesystem access, so
+        this heals corruption without adding containment.
+        """
+        p = self.repo / raw
+        try:
+            root = self.repo.resolve()
+            rp = p.resolve()
+            if root == rp or root in rp.parents:
+                return p  # already inside the project — nothing to heal
+            root_parts = root.parts
+            path_parts = rp.parts
+            if len(path_parts) <= len(root_parts):
+                return p
+            import difflib
+            for a, b in zip(root_parts, path_parts):
+                if a == b:
+                    continue
+                if difflib.SequenceMatcher(None, a, b).ratio() < 0.8:
+                    return p  # genuinely different location — respect it
+            healed = root.joinpath(*path_parts[len(root_parts):])
+            try:
+                from ..events import emit as _emit
+                _emit("path_remap", raw=str(raw)[:200], healed=str(healed)[:200])
+            except Exception:
+                pass
+            return healed
+        except Exception:
+            return p
+
 
 @dataclass
 class ToolResult:

{localcode-0.3.27 → localcode-0.3.29}/src/localcode/tools/code_navigation.py

@@ -56,7 +56,7 @@ def execute(ctx: ToolContext, args: dict) -> str:
     action = str(args.get("action", ""))
     symbol = str(args.get("symbol", "")).strip()
     limit = max(1, min(int(args.get("max_results", 50)), 500))
-    target = (ctx.repo / str(args.get("path", ""))).resolve()
+    target = ctx.resolve_path(str(args.get("path", ""))).resolve()
     try:
         target.relative_to(ctx.repo.resolve())
     except ValueError:

{localcode-0.3.27 → localcode-0.3.29}/src/localcode/tools/edit_diff.py

@@ -33,7 +33,7 @@ SCHEMA = {
 def execute(ctx: ToolContext, args: dict) -> str:
     if "path" not in args or "diff" not in args:
         return "Error: 'path' and 'diff' (unified-diff text) required."
-    path = ctx.repo / args["path"]
+    path = ctx.resolve_path(args["path"])
     if not path.exists():
         return f"File not found: {args['path']}"
 

{localcode-0.3.27 → localcode-0.3.29}/src/localcode/tools/edit_file.py

@@ -310,7 +310,7 @@ def _record_write(ctx: ToolContext, path, content: str) -> None:
 def execute(ctx: ToolContext, args: dict) -> str:
     if "path" not in args:
         return "Error: 'path' argument is required for edit_file."
-    path = ctx.repo / args["path"]
+    path = ctx.resolve_path(args["path"])
     if not path.exists():
         return f"File not found: {args['path']}"