localcode 0.3.28__tar.gz → 0.3.29__tar.gz

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

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

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

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

{localcode-0.3.28 → 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.
@@ -1552,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.28 → localcode-0.3.29}/src/localcode/server_manager.py

@@ -367,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
@@ -414,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.
@@ -539,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 —
@@ -552,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
@@ -626,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
@@ -634,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
@@ -662,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
 
@@ -674,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:
@@ -699,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:
@@ -761,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}"],
@@ -774,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:
@@ -786,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.28 → 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.28 → 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.28 → 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.28 → 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.28 → 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']}"
 

{localcode-0.3.28 → localcode-0.3.29}/src/localcode/tools/list_files.py

@@ -22,7 +22,7 @@ _SKIP = {".git", "__pycache__", "node_modules", ".venv", "venv", ".tox", "dist",
 
 
 def execute(ctx: ToolContext, args: dict) -> str:
-    target = ctx.repo / args.get("path", ".")
+    target = ctx.resolve_path(args.get("path", "."))
     if not target.exists():
         return f"Directory not found: {args.get('path', '.')}"
     entries = []

{localcode-0.3.28 → localcode-0.3.29}/src/localcode/tools/multi_edit.py

@@ -54,7 +54,7 @@ class _PreparedEdit:
 def execute(ctx: ToolContext, args: dict) -> str:
     if "path" not in args or "edits" not in args:
         return "Error: 'path' and 'edits' (list of {old_string, new_string}) required."
-    path = ctx.repo / args["path"]
+    path = ctx.resolve_path(args["path"])
     if not path.exists():
         return f"File not found: {args['path']}"
     edits = args["edits"]

{localcode-0.3.28 → localcode-0.3.29}/src/localcode/tools/read_file.py

@@ -147,7 +147,7 @@ def execute(ctx: ToolContext, args: dict) -> str:
     if "path" not in args:
         return "Error: 'path' argument is required for read_file."
     requested = args["path"]
-    path = ctx.repo / requested
+    path = ctx.resolve_path(requested)
     note = ""
     source_disp = str(requested)
     if not path.exists():

{localcode-0.3.28 → localcode-0.3.29}/src/localcode/tools/write_file.py

@@ -116,7 +116,7 @@ def _detect_stub_code(content: str, path: str) -> str | None:
 def execute(ctx: ToolContext, args: dict) -> str:
     if "path" not in args:
         return "Error: 'path' argument is required for write_file."
-    path = ctx.repo / args["path"]
+    path = ctx.resolve_path(args["path"])
     # Guard: path must not already be a directory. Without this, the
     # model sometimes invokes write_file to "create a folder", which
     # then crashes with [Errno 21] Is a directory. Redirect it to the

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

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

{localcode-0.3.28 → localcode-0.3.29}/src/localcode.egg-info/SOURCES.txt

@@ -956,6 +956,7 @@ tests/test_models_catalog.py
 tests/test_not_found_recovery.py
 tests/test_output.py
 tests/test_paste_collapse.py
+tests/test_path_healing.py
 tests/test_prompt_language_steering.py
 tests/test_real_models.py
 tests/test_run_json.py

{localcode-0.3.28 → localcode-0.3.29}/tests/test_code_navigation_and_processes.py

@@ -7,10 +7,14 @@ from types import SimpleNamespace
 
 from localcode.process_registry import load_records
 from localcode.tools import background_process, code_navigation
+from localcode.tools.base import ToolContext
 
 
 def _ctx(root: Path):
-    return SimpleNamespace(repo=root)
+    # Real ToolContext (not a bare namespace) so tools get resolve_path —
+    # the corrupted-absolute-path healer every file tool now routes through.
+    app = SimpleNamespace(repo_root=root)
+    return ToolContext(app=app, out=None)  # type: ignore[arg-type]
 
 
 def test_code_navigation_python_symbols_definitions_and_references(tmp_path: Path) -> None:

localcode-0.3.29/tests/test_path_healing.py

@@ -0,0 +1,53 @@
+"""Regression: heal model-corrupted absolute paths back onto repo_root.
+
+Observed live (2026-07-13): the model turned its workdir
+`…/localcode-evals/20260713-024502/tempconv` into
+`…/localcode-evals/2026-0713-0245-02/tempconv` (hyphens hallucinated into the
+timestamp) and wrote the entire project into the phantom tree while the real
+workdir stayed empty. ToolContext.resolve_path must remap near-miss prefixes
+onto the real repo_root, and must NOT touch genuinely different locations.
+"""
+import types
+from pathlib import Path
+
+from localcode.tools.base import ToolContext
+
+
+def _ctx(root: Path) -> ToolContext:
+    app = types.SimpleNamespace(repo_root=root)
+    return ToolContext(app=app, out=None)  # type: ignore[arg-type]
+
+
+def test_heals_hyphen_corrupted_timestamp_dir(tmp_path: Path) -> None:
+    root = tmp_path / "localcode-evals" / "20260713-024502" / "tempconv"
+    root.mkdir(parents=True)
+    ctx = _ctx(root)
+    corrupted = str(tmp_path / "localcode-evals" / "2026-0713-0245-02" / "tempconv" / "pyproject.toml")
+    healed = ctx.resolve_path(corrupted)
+    assert healed == root / "pyproject.toml"
+
+
+def test_heals_deeper_corrupted_paths(tmp_path: Path) -> None:
+    root = tmp_path / "projects" / "my-anki-app"
+    root.mkdir(parents=True)
+    ctx = _ctx(root)
+    corrupted = str(tmp_path / "projects" / "my-anki-ap" / "src" / "db.js")
+    assert ctx.resolve_path(corrupted) == root / "src" / "db.js"
+
+
+def test_relative_and_in_root_paths_untouched(tmp_path: Path) -> None:
+    root = tmp_path / "proj"
+    (root / "src").mkdir(parents=True)
+    ctx = _ctx(root)
+    assert ctx.resolve_path("src/main.py") == root / "src" / "main.py"
+    assert ctx.resolve_path(str(root / "src" / "main.py")) == root / "src" / "main.py"
+
+
+def test_genuinely_different_location_respected(tmp_path: Path) -> None:
+    # LocalCode has full filesystem access by design: a path that is NOT a
+    # near-miss of repo_root must pass through unchanged.
+    root = tmp_path / "proj"
+    root.mkdir(parents=True)
+    ctx = _ctx(root)
+    other = str(tmp_path / "completely" / "elsewhere" / "notes.txt")
+    assert str(ctx.resolve_path(other)) == other

{localcode-0.3.28 → localcode-0.3.29}/tests/test_runtime.py

@@ -501,6 +501,11 @@ def test_restart_server_resets_stale_http_client(monkeypatch) -> None:
         def restart(self, cmd, model):
             return True
 
+        def is_running(self) -> bool:
+            # Dead server → _restart_server must take the kill+relaunch
+            # path (the warmup-wait path is only for a live, loading one).
+            return False
+
     monkeypatch.setattr("localcode.server_manager.ServerManager.get", lambda: _Mgr())
 
     assert gw._restart_server() is True