localcode 0.4.1__tar.gz → 0.4.4__tar.gz

{localcode-0.4.1/src/localcode.egg-info → localcode-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.4.1
+Version: 0.4.4
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0
@@ -70,7 +70,7 @@ Dynamic: license-file
 </p>
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/mjwsolo/localcode/main/docs/assets/demo/first-change.gif" alt="A localcode turn: two reads, one edit, then pytest reporting 5 passed" width="900">
+  <img src="https://raw.githubusercontent.com/mjwsolo/localcode/main/docs/assets/demo/first-change.gif" alt="A localcode turn: it reads the stub and test, edits the file, then pytest reports 1 passed" width="900">
 </p>
 
 localcode runs an open-weight model on your Mac and uses it to read, edit and test your code. Your prompts and your files stay on your machine. The only thing it downloads is the model weights, once per model.

{localcode-0.4.1 → localcode-0.4.4}/README.md

@@ -19,7 +19,7 @@
 </p>
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/mjwsolo/localcode/main/docs/assets/demo/first-change.gif" alt="A localcode turn: two reads, one edit, then pytest reporting 5 passed" width="900">
+  <img src="https://raw.githubusercontent.com/mjwsolo/localcode/main/docs/assets/demo/first-change.gif" alt="A localcode turn: it reads the stub and test, edits the file, then pytest reports 1 passed" width="900">
 </p>
 
 localcode runs an open-weight model on your Mac and uses it to read, edit and test your code. Your prompts and your files stay on your machine. The only thing it downloads is the model weights, once per model.

{localcode-0.4.1 → localcode-0.4.4}/pyproject.toml

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

{localcode-0.4.1 → localcode-0.4.4}/src/localcode/__init__.py

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

localcode-0.4.4/src/localcode/bin/localcode-ui

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: localcode-0.4.4/src/localcode/bin/localcode-ui
+size: 102794210 bytes
+sha256: e85ce47f3a737cdd4929afa3864bc802c22f510c508ad5949ab65d704319eb35

localcode-0.4.4/src/localcode/ui/FORK_COMMIT

@@ -0,0 +1 @@
+b88aa9395bb0cbc3aa9bf44a04e36ed0dea0f0bc

{localcode-0.4.1 → localcode-0.4.4}/src/localcode/ui/launch.py

@@ -19,7 +19,7 @@ import urllib.request
 from pathlib import Path
 
 from localcode.ui import plugin_path, run_dir, ui_binary_path
-from localcode.ui.ports import choose_ports
+from localcode.ui.ports import choose_ports, find_running
 
 WAIT_S = 240
 
@@ -112,6 +112,35 @@ def write_config(path: Path, *, port: int, ctx: int, alias: str | None) -> None:
     os.replace(tmp, path)
 
 
+def attach(ctrl: int, status: dict, ui_bin: Path, project_dir: Path, alias: str | None) -> int:
+    """Open another UI window on the model server a running session owns."""
+    port = int(status["port"])
+    try:
+        ctx = int(status.get("ctx") or 0) or 32768
+    except (TypeError, ValueError):
+        ctx = 32768
+    current = status.get("current") or None
+    if alias and current and alias != current:
+        print(f"localcode: attaching to the running session's model {current}; use /models there to switch.",
+              file=sys.stderr)
+    rd = run_dir()
+    rd.mkdir(parents=True, exist_ok=True)
+    config_path = rd / f"session-{os.getpid()}.json"
+    write_config(config_path, port=port, ctx=ctx, alias=current)
+    env = dict(os.environ)
+    env["LOCALCODE_CONTROL_URL"] = f"http://127.0.0.1:{ctrl}"
+    env["LOCALCODE_CONFIG"] = str(config_path)
+    env.setdefault("OPENCODE_DISABLE_LSP_DOWNLOAD", "1")
+    argv = [str(ui_bin)] + (["-m", f"localcode/{current}"] if current else [])
+    try:
+        return subprocess.call(argv, cwd=str(project_dir), env=env)
+    finally:
+        try:
+            config_path.unlink()
+        except OSError:
+            pass
+
+
 def main(model: str | None = None, project: str | None = None) -> int:
     ui_bin = ui_binary_path()
     if ui_bin is None:
@@ -132,6 +161,12 @@ def main(model: str | None = None, project: str | None = None) -> int:
         alias = None
     project_dir = Path(project).expanduser().resolve() if project else Path.cwd()
 
+    # A session already open in another terminal: attach to its model server
+    # instead of refusing. One llama-server per machine, any number of windows.
+    running = find_running()
+    if running is not None:
+        return attach(running[0], running[1], ui_bin, project_dir, alias)
+
     try:
         port, ctrl = choose_ports()
     except RuntimeError as error:

{localcode-0.4.1 → localcode-0.4.4}/src/localcode/ui/plugin/localcode.ts

@@ -429,6 +429,21 @@ const LocalcodePlugin: Plugin = async ({ client, directory }) => {
   const log = (msg: string) => emit(`[localcode gate] ${msg}`);
   const plog = (msg: string) => emit(`[localcode plateau] ${msg}`);
 
+  let loadedName: { name: string | undefined; at: number } = { name: undefined, at: 0 };
+  async function loadedModelName(): Promise<string | undefined> {
+    const control = process.env.LOCALCODE_CONTROL_URL;
+    if (!control) return undefined;
+    if (Date.now() - loadedName.at < 3_000) return loadedName.name;
+    try {
+      const r = await fetch(`${control}/status`, { signal: AbortSignal.timeout(1_000) });
+      const j = (await r.json()) as { current?: string; state?: string };
+      loadedName = { name: j.state === "ready" && j.current ? j.current : loadedName.name, at: Date.now() };
+    } catch {
+      loadedName = { ...loadedName, at: Date.now() };
+    }
+    return loadedName.name;
+  }
+
   async function nudge(sessionID: string, text: string) {
     if (interrupted.has(sessionID)) return;
     // synthetic: the TUI hides it from the transcript; the model still sees it.
@@ -484,6 +499,16 @@ const LocalcodePlugin: Plugin = async ({ client, directory }) => {
 
   return {
     "experimental.chat.system.transform": async (input, output) => {
+      // A session opened through the picker keeps the launcher's "__pending__"
+      // placeholder as the wire id, and the runtime quotes that id in its
+      // "You are powered by" line, so the model introduced itself as
+      // __pending__. Put the loaded model's name there instead.
+      const loaded = await loadedModelName();
+      if (loaded) {
+        for (let i = 0; i < output.system.length; i++) {
+          if (output.system[i].includes("__pending__")) output.system[i] = output.system[i].replaceAll("__pending__", loaded);
+        }
+      }
       if (!workspaceActive || (input.agent && input.agent !== "build")) return;
       output.system.push(PLANNING_RULE);
       const open = renderTodos(todos);
@@ -494,6 +519,10 @@ const LocalcodePlugin: Plugin = async ({ client, directory }) => {
       if (input.agent) currentAgent = input.agent;
       const text = output.parts.map((p: any) => (p.type === "text" ? p.text : "")).join(" ");
       if (!text.startsWith(NUDGE_PREFIX)) {
+        // A real turn is about to hit the model: if the supervisor is still
+        // pre-reading the prompt prefix (warm-up), stop it so this request runs next.
+        const control = process.env.LOCALCODE_CONTROL_URL;
+        if (control) fetch(`${control}/warmup/cancel`, { method: "POST", body: "{}" }).catch(() => {});
         workspaceActive = false;
         if (activeSession !== input.sessionID || interrupted.has(input.sessionID)) todos = [];
         activeSession = input.sessionID;

{localcode-0.4.1 → localcode-0.4.4}/src/localcode/ui/ports.py

@@ -15,6 +15,21 @@ def available(port: int) -> bool:
             return False
 
 
+def find_running(control_ports=range(8323, 8400)) -> tuple[int, dict] | None:
+    """The control port and /status of a supervisor already running for this user, if any."""
+    for port in control_ports:
+        if available(port):
+            continue
+        try:
+            with urllib.request.urlopen(f"http://127.0.0.1:{port}/status", timeout=0.3) as response:
+                status = json.load(response)
+                int(status["port"])
+                return port, status
+        except (OSError, ValueError, KeyError, TypeError):
+            continue
+    return None
+
+
 def choose_ports(model_ports=range(8123, 8200), control_ports=range(8323, 8400)) -> tuple[int, int]:
     control = None
     for port in control_ports:
@@ -25,7 +40,7 @@ def choose_ports(model_ports=range(8123, 8200), control_ports=range(8323, 8400))
         try:
             with urllib.request.urlopen(f"http://127.0.0.1:{port}/status", timeout=0.3) as response:
                 int(json.load(response)["port"])
-                raise RuntimeError("localcode is already running. Use its /models menu to switch models, or exit that session before opening another.")
+                raise RuntimeError("localcode is already running in another terminal; a second window attaches to its model server.")
         except (OSError, ValueError, KeyError, TypeError):
             continue
     model = next((port for port in model_ports if available(port)), None)

{localcode-0.4.1 → localcode-0.4.4}/src/localcode/ui/server_cmd.py

@@ -46,6 +46,17 @@ def server_command(gguf: str, port: int, alias: str | None = None) -> list[str]:
     mm = mmproj_for(gguf)
     if mm is not None and "--mmproj" not in cmd:
         cmd += ["--mmproj", str(mm)]
+    # Prompt warm-up (ui/warmup.py) reads the first turn's token ids back out
+    # of a slot save; the flag only enables the endpoint, nothing is written
+    # until the supervisor asks.
+    try:
+        from localcode.ui import warmup
+        if warmup.enabled():
+            d = warmup.slot_save_dir()
+            d.mkdir(parents=True, exist_ok=True)
+            cmd += ["--slot-save-path", str(d)]
+    except Exception:  # noqa: BLE001, S110
+        pass
     return cmd
 
 

{localcode-0.4.1 → localcode-0.4.4}/src/localcode/ui/supervisor.py

@@ -12,6 +12,7 @@ through bootstrap.download_model — the same code the Textual picker uses.
                                         server on the SAME port with that gguf
     GET  /status             {"state": idle|downloading|loading|ready|error, ...}
     POST /cancel             stop the download in progress (the .part is discarded)
+    POST /warmup/cancel      stop the prompt warm-up prefill (the user just sent a turn)
     GET  /models_dir         {"path", "free_gb"}
     GET  /progress           prompt-fill progress of the running request (from llama-server /slots)
     GET  /voice/status       {"ready", "recording", "detail"}   (whisper env + STT model)
@@ -91,6 +92,8 @@ class Supervisor:
         self.ram_gb = _system_ram_gb()
         self.bandwidth = _bandwidth()
         self.log = open(HERE / "server.log", "ab", buffering=0)  # noqa: SIM115 (lives with the server)
+        self._warm_stop = threading.Event()
+        self._warm_replay = None  # warmup.Replay while the prefix is being pre-read
 
     # ---- llama-server lifecycle -------------------------------------------
     def progress(self) -> dict:
@@ -196,11 +199,77 @@ class Supervisor:
                 return False
             if self.healthy():
                 self.current = alias
+                self._start_warmup(alias)
                 return True
             time.sleep(1)
         return False
 
+    # ---- prompt warm-up (see ui/warmup.py) ----------------------------------
+    def _start_warmup(self, alias: str) -> None:
+        from localcode.ui import warmup
+        if not warmup.enabled():
+            return
+        self._warm_stop = threading.Event()
+        threading.Thread(target=self._warmup_worker, args=(alias, self._warm_stop), daemon=True).start()
+
+    def _warmup_worker(self, alias: str, stop: threading.Event) -> None:
+        from localcode.ui import warmup
+        port = self.port
+        baseline: int | None = None
+        try:
+            toks = warmup.load(alias)
+            if toks:
+                t0 = time.time()
+                rp = warmup.Replay(port)
+                self._warm_replay = rp
+                try:
+                    tm = rp.run(toks)
+                    log(f"warmup: replayed {len(toks)} tokens for {alias} in {time.time() - t0:.1f}s "
+                        f"(server prompt_ms={tm.get('prompt_ms')}, cache_n={tm.get('cache_n')})")
+                except Exception as e:  # noqa: BLE001
+                    if rp.cancelled or stop.is_set():
+                        log(f"warmup: replay cancelled after {time.time() - t0:.1f}s (user turn started)")
+                    else:
+                        log(f"warmup: replay failed for {alias}, forgetting it: {e}")
+                        warmup.forget(alias)
+                finally:
+                    self._warm_replay = None
+                for s in warmup.slots(port) or []:
+                    try:
+                        baseline = max(baseline or -1, int(s.get("id_task") if s.get("id_task") is not None else -1))
+                    except (TypeError, ValueError):
+                        pass
+        except Exception as e:  # noqa: BLE001
+            log(f"warmup: skipped: {e}")
+        # Capture this session's first turn so the next load of this model is warm.
+        tracker = warmup.CaptureTracker(baseline_task=baseline)
+        deadline = time.time() + warmup.CAPTURE_WINDOW_S
+        while not stop.is_set() and time.time() < deadline:
+            snap = warmup.slots(port)
+            if snap is not None:
+                slot_id = tracker.observe(snap, time.time())
+                if slot_id is not None:
+                    try:
+                        new = warmup.capture(port, slot_id)
+                        merged = warmup.merge_tokens(warmup.load(alias), new)
+                        warmup.store(alias, merged)
+                        log(f"warmup: captured {len(new)} tokens for {alias}, stored {len(merged)}")
+                    except Exception as e:  # noqa: BLE001
+                        log(f"warmup: capture failed for {alias}: {e}")
+                    return
+            stop.wait(0.5)
+
+    def cancel_warmup(self) -> dict:
+        """The user submitted a turn: stop pre-reading so their request is next."""
+        rp = self._warm_replay
+        if rp is not None:
+            rp.cancel()
+            return {"ok": True, "cancelled": True}
+        return {"ok": True, "cancelled": False}
+
     def stop(self) -> None:
+        self._warm_stop.set()
+        self.cancel_warmup()
         if self.proc and self.proc.poll() is None:
             log(f"supervisor: stopping llama-server pid {self.proc.pid}")
             self.proc.terminate()
@@ -636,6 +705,8 @@ def make_handler(sup: Supervisor):
             if u.path == "/select":
                 res = sup.select(str(body.get("group", "")), str(body.get("filename", "")))
                 return self._json(res, 200 if "error" not in res else 409)
+            if u.path == "/warmup/cancel":
+                return self._json(sup.cancel_warmup())
             if u.path == "/cancel":
                 res = sup.cancel_download()
                 return self._json(res, 200 if "error" not in res else 409)

localcode-0.4.4/src/localcode/ui/warmup.py

@@ -0,0 +1,256 @@
+"""Prompt warm-up: prefill the first request's constant prefix at model load.
+
+The first message of a session pays for the whole system prompt + tool
+schemas (3-9k tokens: ~3 s on an M5, far longer on a 16 GB M1). Later turns
+are free because llama-server keeps the longest common prefix per slot, and
+its host prompt cache (--cache-ram) carries that state across the
+title-generation request the runtime fires alongside the first message.
+
+A fresh process has nothing cached. So, once per session, after the first
+turn settles, the supervisor asks llama-server to save the slot
+(--slot-save-path), reads the TOKEN IDS out of the head of that file, throws
+the multi-hundred-MB state away and keeps the ids (a few KB). On the next
+load of the same model it replays those ids through /completion with
+n_predict=1: the slot (and the host cache) then hold the exact prefix
+before the user has typed anything.
+
+Why tokens and not the saved state: restoring the state file skips the
+prompt-checkpoints that sliding-window models (Gemma) need for prefix reuse,
+so a restored slot re-evaluates everything; replaying tokens rebuilds the
+checkpoints (measured: 5,176-token prompt, 3,900 ms cold -> 540 ms after
+replay + an intervening title request).
+
+Two sessions' captures are merged to their common prefix, so the stored
+tokens converge on the part that never changes (system prompt, tool
+schemas) and drop the user's message. The environment block carries the
+date, so a capture from another day shares only the prompt before it; when
+the common prefix is under half of the new capture the new one replaces it.
+"""
+from __future__ import annotations
+
+import http.client
+import json
+import os
+import socket
+import struct
+import time
+import urllib.request
+from pathlib import Path
+
+from localcode.ui import fork_commit, run_dir
+
+MIN_CAPTURE_TOKENS = 512     # below this it is the title request, not the agent prompt
+MAX_TOKENS = 12288           # never replay more than this (bounds the launch-time prefill)
+SETTLE_S = 3.0               # the slot must stay idle on the same task this long before we capture
+CAPTURE_WINDOW_S = 20 * 60   # give up capturing if no turn happens within this
+SLOT_FILE = "warm.bin"
+
+
+def enabled() -> bool:
+    return os.environ.get("LOCALCODE_PROMPT_WARMUP", "1").strip().lower() not in {"0", "false", "no", "off"}
+
+
+def slot_save_dir() -> Path:
+    return run_dir() / "slots"
+
+
+def warm_dir() -> Path:
+    return run_dir() / "warm"
+
+
+def _warm_file(alias: str) -> Path:
+    safe = "".join(c if c.isalnum() or c in "-_." else "_" for c in alias)
+    return warm_dir() / f"{safe}.json"
+
+
+# ---- pure helpers ----------------------------------------------------------
+
+def parse_slot_tokens(path: Path) -> list[int]:
+    """Token ids from a llama-server slot save file (llama_state_seq_save_file).
+
+    Layout: u32 magic, u32 version, u32 n, then n u32 entries, then the KV
+    state. The entries are server_tokens::serialize's packed form
+    (LLAMA_TOKEN_NULL marker, format version, u32 count, the ids, media
+    keys) or, from older servers, the plain id list.
+    """
+    with path.open("rb") as f:
+        magic, _version, n = struct.unpack("<III", f.read(12))
+        if magic != 0x67677371:  # 'ggsq'
+            raise ValueError("not a llama slot save file")
+        packed = list(struct.unpack(f"<{n}I", f.read(4 * n)))
+    if packed and packed[0] == 0xFFFFFFFF:
+        if len(packed) < 3:
+            raise ValueError("truncated token header")
+        count = packed[2]
+        toks = packed[3:3 + count]
+        if len(toks) != count:
+            raise ValueError("truncated token list")
+        return toks
+    return packed
+
+
+def common_prefix(a: list[int], b: list[int]) -> list[int]:
+    n = 0
+    for x, y in zip(a, b):
+        if x != y:
+            break
+        n += 1
+    return a[:n]
+
+
+def merge_tokens(old: list[int] | None, new: list[int]) -> list[int]:
+    """Keep what two captures share; replace when they share too little."""
+    new = new[:MAX_TOKENS]
+    if not old:
+        return new
+    lcp = common_prefix(old, new)
+    if len(lcp) >= MIN_CAPTURE_TOKENS and len(lcp) * 2 >= len(new):
+        return lcp
+    return new
+
+
+class CaptureTracker:
+    """Decides when the first turn has settled enough to capture the slot.
+
+    Feed it /slots snapshots; it answers with the slot id to save once a slot
+    has been idle on the same task, with a prompt of agent size, for
+    SETTLE_S. Tasks seen before `baseline` (the warm-up replay itself) are
+    ignored.
+    """
+
+    def __init__(self, baseline_task: int | None = None, settle_s: float = SETTLE_S) -> None:
+        self.baseline_task = baseline_task
+        self.settle_s = settle_s
+        self._idle_since: float | None = None
+        self._idle_task: int | None = None
+
+    def observe(self, slots: list[dict], now: float) -> int | None:
+        if any(s.get("is_processing") for s in slots):
+            self._idle_since = None
+            return None
+        best = None
+        for s in slots:
+            try:
+                n = int(s.get("n_prompt_tokens") or 0)
+                task = int(s.get("id_task") if s.get("id_task") is not None else -1)
+            except (TypeError, ValueError):
+                continue
+            if n < MIN_CAPTURE_TOKENS or task < 0:
+                continue
+            if self.baseline_task is not None and task <= self.baseline_task:
+                continue
+            if best is None or n > best[1]:
+                best = (int(s.get("id", 0)), n, task)
+        if best is None:
+            self._idle_since = None
+            return None
+        if self._idle_task != best[2]:
+            self._idle_task, self._idle_since = best[2], now
+            return None
+        if self._idle_since is not None and now - self._idle_since >= self.settle_s:
+            return best[0]
+        return None
+
+
+# ---- store -------------------------------------------------------------------
+
+def load(alias: str) -> list[int] | None:
+    try:
+        data = json.loads(_warm_file(alias).read_text())
+    except (OSError, ValueError):
+        return None
+    if data.get("fork") != fork_commit():
+        return None
+    toks = data.get("tokens")
+    if not isinstance(toks, list) or not all(isinstance(t, int) for t in toks) or len(toks) < MIN_CAPTURE_TOKENS:
+        return None
+    return toks[:MAX_TOKENS]
+
+
+def store(alias: str, tokens: list[int]) -> None:
+    path = _warm_file(alias)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".json.tmp")
+    tmp.write_text(json.dumps({"fork": fork_commit(), "saved": int(time.time()), "tokens": tokens}))
+    os.replace(tmp, path)
+
+
+def forget(alias: str) -> None:
+    try:
+        _warm_file(alias).unlink()
+    except OSError:
+        pass
+
+
+# ---- server I/O --------------------------------------------------------------
+
+def _post(port: int, path: str, body: dict, timeout: float) -> dict:
+    req = urllib.request.Request(f"http://127.0.0.1:{port}{path}", data=json.dumps(body).encode(),
+                                 headers={"Content-Type": "application/json"})
+    with urllib.request.urlopen(req, timeout=timeout) as r:
+        return json.loads(r.read().decode())
+
+
+def slots(port: int) -> list[dict] | None:
+    try:
+        with urllib.request.urlopen(f"http://127.0.0.1:{port}/slots", timeout=2) as r:
+            data = json.loads(r.read().decode())
+        return data if isinstance(data, list) else None
+    except Exception:  # noqa: BLE001
+        return None
+
+
+class Replay:
+    """One in-flight prefill of the stored prefix, cancellable from another thread.
+
+    llama-server drops a task whose client went away (checked between
+    batches), so closing the socket is the cancel: the tokens read so far
+    stay in the slot as a partial prefix. The plugin asks for this the moment
+    the user submits, so a still-running warm-up never delays a real turn by
+    more than one batch.
+    """
+
+    def __init__(self, port: int, timeout: float = 900.0) -> None:
+        self.conn = http.client.HTTPConnection("127.0.0.1", port, timeout=timeout)
+        self.cancelled = False
+
+    def run(self, tokens: list[int]) -> dict:
+        body = json.dumps({"prompt": tokens, "n_predict": 1, "cache_prompt": True, "temperature": 0})
+        self.conn.request("POST", "/completion", body=body, headers={"Content-Type": "application/json"})
+        r = json.loads(self.conn.getresponse().read().decode())
+        return r.get("timings") or {}
+
+    def cancel(self) -> None:
+        self.cancelled = True
+        # shutdown() is what unblocks the reader thread; close() alone is
+        # deferred while http.client's file wrapper holds the socket.
+        sock = getattr(self.conn, "sock", None)
+        try:
+            if sock is not None:
+                sock.shutdown(socket.SHUT_RDWR)
+        except OSError:
+            pass
+        try:
+            self.conn.close()
+        except Exception:  # noqa: BLE001, S110
+            pass
+
+
+def replay(port: int, tokens: list[int], timeout: float = 900.0) -> dict:
+    """Prefill the stored prefix. Returns llama-server's timings."""
+    return Replay(port, timeout).run(tokens)
+
+
+def capture(port: int, slot_id: int) -> list[int]:
+    """Save the slot, keep its token ids, drop the state file."""
+    d = slot_save_dir()
+    d.mkdir(parents=True, exist_ok=True)
+    path = d / SLOT_FILE
+    try:
+        _post(port, f"/slots/{slot_id}?action=save", {"filename": SLOT_FILE}, 120)
+        return parse_slot_tokens(path)
+    finally:
+        try:
+            path.unlink()
+        except OSError:
+            pass

{localcode-0.4.1 → localcode-0.4.4/src/localcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.4.1
+Version: 0.4.4
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0
@@ -70,7 +70,7 @@ Dynamic: license-file
 </p>
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/mjwsolo/localcode/main/docs/assets/demo/first-change.gif" alt="A localcode turn: two reads, one edit, then pytest reporting 5 passed" width="900">
+  <img src="https://raw.githubusercontent.com/mjwsolo/localcode/main/docs/assets/demo/first-change.gif" alt="A localcode turn: it reads the stub and test, edits the file, then pytest reports 1 passed" width="900">
 </p>
 
 localcode runs an open-weight model on your Mac and uses it to read, edit and test your code. Your prompts and your files stay on your machine. The only thing it downloads is the model weights, once per model.

{localcode-0.4.1 → localcode-0.4.4}/src/localcode.egg-info/SOURCES.txt

@@ -1187,6 +1187,7 @@ src/localcode/ui/picker_cli.py
 src/localcode/ui/ports.py
 src/localcode/ui/server_cmd.py
 src/localcode/ui/supervisor.py
+src/localcode/ui/warmup.py
 src/localcode/ui/plugin/localcode.ts
 tests/test_agent_event_regressions.py
 tests/test_agent_state_machine.py
@@ -1280,5 +1281,6 @@ tests/test_tool_arg_validation.py
 tests/test_toolkit.py
 tests/test_tui_input.py
 tests/test_ui_launch.py
+tests/test_ui_warmup.py
 tests/test_web_fetch_host_policy.py
 tests/test_write_containment_and_plan_mode.py

{localcode-0.4.1 → localcode-0.4.4}/tests/test_comprehensive_binary.py

@@ -128,6 +128,8 @@ def test_ui_binary_version_matches_package():
     if not path.is_file():
         pytest.skip("no bundled UI binary")
     from localcode import __version__
-    want = re.match(r"\d+\.\d+\.\d+", __version__).group(0)
+    # Same major.minor: a Python-only patch release must not force a rebuild of
+    # the 98 MB binary; a fork change bumps FORK_COMMIT and rebuilds anyway.
+    want = re.match(r"\d+\.\d+", __version__).group(0)
     out = subprocess.run([str(path), "--version"], capture_output=True, text=True, timeout=60, check=False).stdout.strip()
-    assert out.startswith(want), f"UI binary reports {out!r}, package is {__version__!r}; rebuild with scripts/build_ui_binary.sh"
+    assert out.startswith(want + "."), f"UI binary reports {out!r}, package is {__version__!r}; rebuild with scripts/build_ui_binary.sh"

{localcode-0.4.1 → localcode-0.4.4}/tests/test_ui_launch.py

@@ -117,3 +117,27 @@ def test_supervisor_serves_every_route_the_ui_calls():
     missing = [r for r in CONTROL_ROUTES if f'"{r}"' not in src]
     assert not missing, missing
 
+
+
+def test_second_launch_attaches_to_running_session(monkeypatch, tmp_path):
+    """Another terminal reuses the running session's model server instead of being refused."""
+    import json as _json
+    from localcode.ui import launch
+    calls = {}
+    monkeypatch.setattr(launch, "ui_binary_path", lambda: tmp_path / "ui")
+    (tmp_path / "ui").write_bytes(b"x")
+    monkeypatch.setattr(launch, "_llama_server", lambda: tmp_path / "ui")
+    monkeypatch.setenv("LOCALCODE_AGENT_RUN_DIR", str(tmp_path / "run"))
+    status = {"port": 8123, "ctx": 65536, "current": "gemma-4-12b-it-UD-Q4_K_XL", "state": "ready"}
+    monkeypatch.setattr(launch, "find_running", lambda: (8323, status))
+    def fake_call(argv, cwd, env):
+        calls["argv"] = argv; calls["env"] = env
+        cfg = _json.loads(Path(env["LOCALCODE_CONFIG"]).read_text())
+        calls["cfg"] = cfg
+        return 0
+    monkeypatch.setattr(launch.subprocess, "call", fake_call)
+    assert launch.main(None, str(tmp_path)) == 0
+    assert calls["env"]["LOCALCODE_CONTROL_URL"] == "http://127.0.0.1:8323"
+    assert calls["argv"][1:] == ["-m", "localcode/gemma-4-12b-it-UD-Q4_K_XL"]
+    assert calls["cfg"]["provider"]["localcode"]["options"]["baseURL"] == "http://127.0.0.1:8123/v1"
+    assert calls["cfg"]["model"] == "localcode/gemma-4-12b-it-UD-Q4_K_XL"