localcode 0.5.12__tar.gz → 0.5.14__tar.gz

{localcode-0.5.12/src/localcode.egg-info → localcode-0.5.14}/PKG-INFO

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

{localcode-0.5.12 → localcode-0.5.14}/llama-cpp-turboquant/common/speculative.cpp

@@ -1190,6 +1190,44 @@ struct common_speculative_impl_draft_dflash : public common_speculative_impl {
 
         const int32_t n_ubatch = (int32_t) llama_n_ubatch(ctx_dft);
 
+        // mtmd image chunks are decoded into the target context by the mtmd helper
+        // and never pass through this hook, so the draft cache is left with a
+        // positional hole and the next injection fails the consecutive-position
+        // check. The same hole appears when the target reuses a cached prefix the
+        // draft cache never saw. Seed the hole with zero target-layer features:
+        // drafted tokens are still verified by the target, so this degrades
+        // post-image draft acceptance only, never output correctness.
+        for (llama_seq_id seq_id = 0; seq_id < (llama_seq_id) n_seq; ++seq_id) {
+            if (i_batch_beg[seq_id] < 0) {
+                continue;
+            }
+            const llama_pos pos_max = llama_memory_seq_pos_max(llama_get_memory(ctx_dft), seq_id);
+            const llama_pos gap_beg = pos_max + 1;
+            const llama_pos gap_end = batch_in.tokens[i_batch_beg[seq_id]].pos[0]; // exclusive
+            if (gap_end <= gap_beg) {
+                continue;
+            }
+            LOG_WRN("%s: draft cache hole for seq %d: [%d, %d) - seeding with zero features\n",
+                    __func__, (int) seq_id, (int) gap_beg, (int) gap_end);
+            for (llama_pos off = gap_beg; off < gap_end; off += n_ubatch) {
+                const int32_t n_chunk = std::min<int32_t>(n_ubatch, (int32_t) (gap_end - off));
+                features_buf.assign((size_t) n_chunk * n_embd_enc, 0.0f);
+                batch_inject.clear();
+                for (int32_t i = 0; i < n_chunk; ++i) {
+                    const llama_pos p = off + i;
+                    const llama_pos pos_arr[4] = { p, p, p, 0 };
+                    const float * feat = features_buf.data() + (size_t) i * n_embd_enc;
+                    batch_inject.add_embd({ feat, 1, (size_t) n_embd_enc }, pos_arr, seq_id, false);
+                }
+                const int32_t rc = llama_process(ctx_dft, LLAMA_PROCESS_TYPE_DECODE, batch_inject.get());
+                if (rc != 0) {
+                    LOG_ERR("%s: zero-fill llama_process(ctx_dft) failed rc=%d (n_tokens=%d, pos=%d)\n",
+                            __func__, rc, (int) n_chunk, (int) off);
+                    return false;
+                }
+            }
+        }
+
         for (llama_seq_id seq_id = 0; seq_id < (llama_seq_id) n_seq; ++seq_id) {
             if (i_batch_beg[seq_id] < 0) {
                 continue;

{localcode-0.5.12 → localcode-0.5.14}/pyproject.toml

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

{localcode-0.5.12 → localcode-0.5.14}/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.5.12"
+    __version__ = "0.5.14"

{localcode-0.5.12 → localcode-0.5.14}/src/localcode/bin/localcode-ui

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
-name: localcode-0.5.12/src/localcode/bin/localcode-ui
+name: localcode-0.5.14/src/localcode/bin/localcode-ui
 size: 102460976 bytes
 sha256: 44c99212032f56e6453045fef245cbf6eeead1ac5b122fb983727d3980ab3e06

{localcode-0.5.12 → localcode-0.5.14}/src/localcode/models_catalog.py

@@ -578,10 +578,30 @@ CHOICES: list[ModelChoice] = [
 ]
 
 
+def _forced_ram_gb() -> int | None:
+    import os
+    raw = os.environ.get("LOCALCODE_RAM_GB", "").strip()
+    if not raw:
+        return None
+    try:
+        return max(1, int(raw))
+    except ValueError:
+        return None
+
+
 def _system_ram_gb() -> int:
     """Standalone RAM probe — mirrors LocalCodeRuntimeGateway._system_ram_gb so
     the picker doesn't need a runtime instance. Falls back to 16 on any failure
-    (conservative — favors the lightweight model)."""
+    (conservative — favors the lightweight model).
+
+    LOCALCODE_RAM_GB makes the probe report that figure instead, so the evals
+    can run the choices a 16 or 24 GB Mac would make on a larger machine. It
+    is an eval knob, not a setting: every RAM-derived choice (quant fit,
+    context ceiling, slots) follows it, so set it only on a machine that can
+    actually hold what the smaller tier would pick."""
+    forced = _forced_ram_gb()
+    if forced is not None:
+        return forced
     try:
         import platform, subprocess
         if platform.system() == "Darwin":

{localcode-0.5.12 → localcode-0.5.14}/src/localcode/runtime.py

@@ -934,6 +934,11 @@ class LocalCodeRuntimeGateway:
         # each miss shells `sysctl hw.memsize`, a needless per-request TTFT cost.
         if self._cached_ram_gb is not None:
             return self._cached_ram_gb
+        from .models_catalog import _forced_ram_gb
+        forced = _forced_ram_gb()   # LOCALCODE_RAM_GB: eval knob, see models_catalog
+        if forced is not None:
+            self._cached_ram_gb = forced
+            return forced
         try:
             import subprocess
             mem_bytes = int(subprocess.run(

{localcode-0.5.12 → localcode-0.5.14}/src/localcode/ui/plugin/modes.ts

@@ -175,7 +175,7 @@ async function tui(api: TuiPluginApi) {
     try {
       const response = await fetch(control + "/server", { headers, signal: AbortSignal.timeout(3000) });
       if (!response.ok) throw new Error(`Server status: HTTP ${response.status}`);
-      const info = await response.json() as { state: string; base_url: string; model?: string; port: number; preferred_port: number | string | null; server_ready: boolean; server_running?: boolean; detail?: string };
+      const info = await response.json() as { state: string; base_url: string; model?: string; port: number; preferred_port: number | string | null; server_ready: boolean; server_running?: boolean; warmup?: string; detail?: string };
       const copy = async (value: string, secret = false) => {
         const proc = Bun.spawn(["pbcopy"], { stdin: new Blob([value]), stdout: "ignore", stderr: "ignore" });
         if (await proc.exited !== 0) throw new Error("Could not copy to clipboard");
@@ -183,6 +183,7 @@ async function tui(api: TuiPluginApi) {
       };
       api.ui.dialog.replace(() => api.ui.DialogSelect({ title: "Model server · " + info.state, options: [
         { title: "Status", value: "status", description: info.detail || info.state },
+        { title: "Prompt cache", value: "status", description: info.warmup === "warming" ? "Warming up in background · sending a message interrupts warm-up" : info.warmup === "warm" ? "Warm prefix available · changed context still needs processing" : info.warmup === "cold" ? "First use: no saved prefix yet" : info.warmup ?? "Unknown" },
         { title: "Base URL", value: "url", description: info.base_url },
         { title: "Model", value: "model", description: info.model ?? "No model loaded" },
         { title: "Copy API key", value: "key", description: "Private · only for clients you trust" },
@@ -234,9 +235,9 @@ async function tui(api: TuiPluginApi) {
     } catch (e) { error(String(e)); }
   }
   api.keymap.registerLayer({ commands: [
-    { name: "localcode.server", title: "Model server connection and port", category: "LocalCode", slash: { name: "server" }, run: server },
-    { name: "localcode.mode", title: "Choose Chat or Decisions", category: "LocalCode", slash: { name: "mode" }, run: choose },
-    { name: "localcode.decide", title: "Open decision mode", category: "LocalCode", slash: { name: "decide" }, run: open },
+    { name: "localcode.server", title: "Model server connection and port", category: "LocalCode", slashName: "server", run: server },
+    { name: "localcode.mode", title: "Choose Chat or Decisions", category: "LocalCode", slashName: "mode", run: choose },
+    { name: "localcode.decide", title: "Open decision mode", category: "LocalCode", slashName: "decide", run: open },
   ] });
   api.keymap.registerLayer({ enabled: () => api.route.current.name === route && !api.ui.dialog.open, priority: 5, commands: [{ name: "localcode.mode.back", run: back }], bindings: [{ key: "escape", command: "localcode.mode.back" }] });
   const timer = setInterval(() => void poll(), 2000);

{localcode-0.5.12 → localcode-0.5.14}/src/localcode/ui/supervisor.py

@@ -105,6 +105,7 @@ class Supervisor:
         self._budget_info: dict = {}
         self._budget_lock = threading.Lock()
         self._warm_stop = threading.Event()
+        self._warm_status = "idle"
         self._warm_replay = None  # warmup.Replay while the prefix is being pre-read
 
     # ---- llama-server lifecycle -------------------------------------------
@@ -256,7 +257,9 @@ class Supervisor:
     def _start_warmup(self, alias: str) -> None:
         from localcode.ui import warmup
         if not warmup.enabled():
+            self._warm_status = "disabled"
             return
+        self._warm_status = "checking"
         self._warm_stop = threading.Event()
         threading.Thread(target=self._warmup_worker, args=(alias, self._warm_stop), daemon=True).start()
 
@@ -264,14 +267,20 @@ class Supervisor:
         from localcode.ui import warmup
         port = self.port
         baseline: int | None = None
+        model_path = self.models_dir / f"{alias}.gguf"
         try:
-            toks = warmup.load(alias)
+            toks = warmup.load(alias, model_path)
+            if stop.is_set():
+                return
+            self._warm_status = "warming" if toks else "cold"
             if toks:
                 t0 = time.time()
                 rp = warmup.Replay(port)
                 self._warm_replay = rp
                 try:
                     tm = rp.run(toks)
+                    if not stop.is_set():
+                        self._warm_status = "warm"
                     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')})")
                     try:
@@ -282,18 +291,26 @@ class Supervisor:
                         pass
                 except Exception as e:  # noqa: BLE001
                     if rp.cancelled or stop.is_set():
+                        if not stop.is_set():
+                            self._warm_status = "interrupted"
                         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}")
+                        self._warm_status = "failed"
                         warmup.forget(alias)
                 finally:
-                    self._warm_replay = None
+                    if self._warm_replay is rp:
+                        self._warm_replay = None
+                if stop.is_set():
+                    return
                 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
+            if not stop.is_set():
+                self._warm_status = "failed"
             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)
@@ -305,8 +322,8 @@ class Supervisor:
                 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)
+                        merged = warmup.merge_tokens(warmup.load(alias, model_path), new)
+                        warmup.store(alias, merged, model_path)
                         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}")
@@ -405,7 +422,7 @@ class Supervisor:
         ready = running and state["state"] == "ready" and self.healthy()
         if state["state"] == "ready" and not ready:
             state.update(state="error", detail="Model server is unavailable")
-        return dict(state, server_running=running, server_ready=ready)
+        return dict(state, server_running=running, server_ready=ready, warmup=getattr(self, "_warm_status", "idle"))
 
     def server_action(self, action: str) -> dict:
         """Queue an explicit lifecycle action; retain session and selected model."""

{localcode-0.5.12 → localcode-0.5.14}/src/localcode/ui/warmup.py

@@ -152,14 +152,36 @@ class CaptureTracker:
         return None
 
 
+# Saved token IDs are bound to the model file. UI updates do not change the
+# tokenizer; llama-server recomputes the common prefix for each actual request.
 # ---- store -------------------------------------------------------------------
 
-def load(alias: str) -> list[int] | None:
+def model_identity(path: Path) -> dict:
+    """Invalidate token IDs when the model file changes, not when the UI changes."""
+    st = path.stat()
+    return {"path": str(path.resolve()), "size": st.st_size, "mtime_ns": st.st_mtime_ns}
+
+
+def load(alias: str, model_path: Path | None = None) -> list[int] | None:
     try:
         data = json.loads(_warm_file(alias).read_text())
     except (OSError, ValueError):
         return None
-    if data.get("fork") != fork_commit():
+    if not isinstance(data, dict):
+        return None
+    if model_path is not None:
+        try:
+            identity = model_identity(model_path)
+            if "model" in data:
+                if data["model"] != identity:
+                    return None
+            # Legacy captures predate model fingerprints. Only reuse when the
+            # named model has not been modified since the capture was written.
+            elif not isinstance(data.get("saved"), (int, float)) or identity["mtime_ns"] > data["saved"] * 1e9:
+                return None
+        except OSError:
+            return None
+    elif 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:
@@ -167,11 +189,16 @@ def load(alias: str) -> list[int] | None:
     return toks[:MAX_TOKENS]
 
 
-def store(alias: str, tokens: list[int]) -> None:
+def store(alias: str, tokens: list[int], model_path: Path | None = None) -> 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}))
+    data = {"fork": fork_commit(), "saved": time.time(), "tokens": tokens}
+    if model_path is not None:
+        data["model"] = model_identity(model_path)
+    fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC | os.O_NOFOLLOW, 0o600)
+    with os.fdopen(fd, "w") as f:
+        json.dump(data, f)
     os.replace(tmp, path)
 
 

{localcode-0.5.12 → localcode-0.5.14/src/localcode.egg-info}/PKG-INFO

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

{localcode-0.5.12 → localcode-0.5.14}/tests/test_comprehensive_model_gate.py

@@ -62,9 +62,9 @@ def test_shutdown_kills_then_waits_after_timeout(tmp_path):
     assert server.proc.wait.call_count == 2
 
 
-@pytest.mark.parametrize("mutation", ["commit", "binaries", "coverage", "runtime", "decisions", "turbo"])
+@pytest.mark.parametrize("mutation", ["commit", "binaries", "coverage", "runtime", "decisions", "vision", "turbo"])
 def test_invalid_receipts_cannot_publish_a_promotion(mutation):
-    rows = [{"key": key, "turbo4": False, "checks": ["auth", "template", "chat", "tool-loop", "systemone", "decision-control", "runtime"]} for key in gate.REQUIRED_KEYS]
+    rows = [{"key": key, "turbo4": False, "checks": ["auth", "template", "chat", "tool-loop", "systemone", "decision-control", "runtime", "vision"]} for key in gate.REQUIRED_KEYS]
     rows.append({"key": "qwen", "turbo4": True, "checks": ["tool-loop"]})
     receipt = {"commit": "candidate", "dirty": False, "strict": True, "success": True, "binaries": {"server": "hash"}, "models": rows}
     gate.validate_receipt(receipt, "candidate", {"server": "hash"}, gate.REQUIRED_KEYS)
@@ -73,6 +73,7 @@ def test_invalid_receipts_cannot_publish_a_promotion(mutation):
     elif mutation == "coverage": receipt["models"] = rows[1:]
     elif mutation == "runtime": next(r for r in rows if r["key"] == "openjev")["checks"].remove("runtime")
     elif mutation == "decisions": next(r for r in rows if r["key"] == "openjev")["checks"].remove("decision-control")
+    elif mutation == "vision": next(r for r in rows if r["key"] in gate.VISION_KEYS)["checks"].remove("vision")
     else: receipt["models"] = rows[:-1]
     with pytest.raises(AssertionError):
         gate.validate_receipt(receipt, "candidate", {"server": "hash"}, gate.REQUIRED_KEYS)

{localcode-0.5.12 → localcode-0.5.14}/tests/test_models_catalog.py

@@ -383,3 +383,14 @@ def test_saluki_mixed_quant_is_visible_and_keeps_integrity_pin():
     assert browsed.name.endswith("(IQ2-mix)")
     assert (browsed.revision, browsed.sha256, browsed.size_bytes) == (c.revision, c.sha256, c.size_bytes)
     assert _parse_label("model-draft-mtp.gguf") is None
+
+
+def test_ram_probe_honours_the_eval_knob(monkeypatch):
+    from localcode import models_catalog as mc
+
+    monkeypatch.setenv("LOCALCODE_RAM_GB", "16")
+    assert mc._system_ram_gb() == 16
+    monkeypatch.setenv("LOCALCODE_RAM_GB", "junk")
+    assert mc._system_ram_gb() >= 1 and mc._forced_ram_gb() is None   # ignored, real probe used
+    monkeypatch.delenv("LOCALCODE_RAM_GB")
+    assert mc._forced_ram_gb() is None

{localcode-0.5.12 → localcode-0.5.14}/tests/test_ui_warmup.py

@@ -126,3 +126,29 @@ def test_replay_cancel_closes_the_socket_promptly():
     with pytest.raises(Exception):
         rp.run(list(range(600)))
     assert rp.cancelled and time.time() - t0 < 3
+
+
+def test_model_capture_survives_ui_update_but_not_model_replacement(tmp_path, monkeypatch):
+    monkeypatch.setenv("LOCALCODE_AGENT_RUN_DIR", str(tmp_path))
+    model = tmp_path / "model.gguf"
+    model.write_bytes(b"model")
+    tokens = list(range(700))
+    warmup.store("model", tokens, model)
+    monkeypatch.setattr(warmup, "fork_commit", lambda: "new-ui")
+    assert warmup.load("model", model) == tokens
+    model.write_bytes(b"replacement model")
+    assert warmup.load("model", model) is None
+
+
+def test_legacy_capture_migrates_only_if_model_predates_capture(tmp_path, monkeypatch):
+    import os
+    monkeypatch.setenv("LOCALCODE_AGENT_RUN_DIR", str(tmp_path))
+    model = tmp_path / "model.gguf"
+    model.write_bytes(b"model")
+    os.utime(model, (100, 100))
+    tokens = list(range(700))
+    warmup.store("model", tokens)
+    monkeypatch.setattr(warmup, "fork_commit", lambda: "new-ui")
+    assert warmup.load("model", model) == tokens
+    os.utime(model, (9999999999, 9999999999))
+    assert warmup.load("model", model) is None