localcode 0.3.15__tar.gz → 0.3.16__tar.gz

{localcode-0.3.15/src/localcode.egg-info → localcode-0.3.16}/PKG-INFO

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

{localcode-0.3.15 → localcode-0.3.16}/pyproject.toml

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

{localcode-0.3.15 → localcode-0.3.16}/src/localcode/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.3.15"
+__version__ = "0.3.16"

{localcode-0.3.15 → localcode-0.3.16}/src/localcode/agent/context.py

@@ -76,10 +76,45 @@ def _spill_tool_output(result: str, tool_name: str) -> str | None:
         return None
 
 
-def _truncate_result(result: str, tool_name: str) -> str:
+# How much of the context window (in chars) a single tool result may occupy,
+# per tool. The static RESULT_LIMITS values act as the FLOOR, so small machines
+# (64K window ≈ 224K chars → these fractions fall below the floor) are
+# byte-identical to before, while a big machine (256K ≈ 900K chars) lets the
+# model keep far more of the output it has room for instead of a fixed 20–50K
+# slice. grep matches are dense/repetitive so get the smallest share; read_file
+# is the primary code-ingestion path so gets the most.
+_RESULT_LIMIT_WINDOW_FRACTION: dict[str, float] = {
+    "grep": 0.03,
+    "bash": 0.05,
+    "read_file": 0.08,
+    "default": 0.08,
+}
+
+
+def _dynamic_result_limit(tool_name: str, ctx_tokens: int) -> int:
+    """Per-tool truncation budget (chars), scaled to the real context window.
+
+    Returns the static RESULT_LIMITS value as a floor; on a large window the
+    limit grows to a fraction of the window so the model isn't starved of output
+    it has room for. web_search and any tool without a fraction stay at the
+    fixed floor (web results don't benefit from window-scaling).
+    """
+    floor = RESULT_LIMITS.get(tool_name, RESULT_LIMITS["default"])
+    frac = _RESULT_LIMIT_WINDOW_FRACTION.get(tool_name)
+    if not ctx_tokens or frac is None:
+        return floor
+    # CHARS_PER_TOKEN=4 is the internal estimate; use 3.5 to match loop.py's
+    # tokens→chars conversion and stay conservative.
+    return max(floor, int(ctx_tokens * 3.5 * frac))
+
+
+def _truncate_result(result: str, tool_name: str, ctx_tokens: int = 0) -> str:
     """Truncate a tool result to its per-tool size limit with a
     strategy tuned to what each tool's output actually looks like.
 
+    `ctx_tokens` (the model's real context window) scales the limit up on big
+    machines; 0 falls back to the static floor (small machines unchanged).
+
     Strategies:
       • `read_file` — keep HEAD only. File content is ordered; the
         model can paginate with `offset=` to see more. Middle-dropping
@@ -96,7 +131,7 @@ def _truncate_result(result: str, tool_name: str) -> str:
 
     Returns the result unchanged when it's within the limit.
     """
-    limit = RESULT_LIMITS.get(tool_name, RESULT_LIMITS["default"])
+    limit = _dynamic_result_limit(tool_name, ctx_tokens)
     if len(result) <= limit:
         return result
 

{localcode-0.3.15 → localcode-0.3.16}/src/localcode/agent/helpers.py

@@ -287,6 +287,49 @@ def _render_markdown(text: str, console: Console | None = None) -> None:
     else:
         c.print(Padding(text, (0, 2, 0, 2)))
 
+def _split_exit_code(result: str) -> tuple[int | None, str]:
+    """Split a bash result into (exit_code, body).
+
+    bash.py prepends `[exit code N]\\n` to a failed command's output as a
+    model-facing failure marker. Return the parsed code and the remaining body,
+    or (None, result) when the marker is absent (command succeeded).
+    """
+    s = result.lstrip()
+    if s.startswith("[exit code "):
+        end = s.find("]")
+        if end != -1:
+            try:
+                code = int(s[len("[exit code "):end].strip())
+            except ValueError:
+                return None, result
+            body = s[end + 1:]
+            return code, body[1:] if body.startswith("\n") else body
+    return None, result
+
+
+def _redirect_note(result: str) -> str:
+    """Turn an internal `REJECTED …` string into a short user-facing note.
+
+    The full REJECTED payload (routing hints, "Suggested tool call: …",
+    hard-stop instructions) is for the model's recovery, not the user. Two
+    cases: a routing redirect ("use X instead") → "→ used X instead"; anything
+    else (repeat/hard-stop/unsafe/oversize block) → a neutral "→ skipped …"
+    note. Never show the raw protocol text.
+    """
+    import re
+    m = re.search(r"\buse\s+([a-z_]+)\s+instead", result)
+    if m:
+        return f"→ used {m.group(1)} instead"
+    low = result.lower()
+    if "hard stop" in low or "already failed" in low or "already ran" in low or "rewritten" in low:
+        return "→ skipped (repeating a call that won't help)"
+    if "safety ceiling" in low or "over the" in low:
+        return "→ skipped (too large — splitting instead)"
+    if "defer" in low or "blocked" in low or "live server" in low:
+        return "→ skipped that step"
+    return "→ adjusted approach"
+
+
 def _brief_result(tool_name: str, result: str) -> str:
     """Short summary of a tool result for terminal display."""
     lines = result.strip().splitlines()
@@ -301,6 +344,11 @@ def _brief_result(tool_name: str, result: str) -> str:
         return "already done — using cached result"
     if s.startswith("[FILE UNCHANGED"):
         return "unchanged — see earlier read"
+    # Internal tool-routing/hard-stop correction. This is a signal FOR THE
+    # MODEL, not the user — render a short neutral note, never the raw
+    # "REJECTED: …" / "REJECTED — HARD STOP: …" protocol text (both forms).
+    if s.startswith("REJECTED"):
+        return _redirect_note(s)
     if tool_name == "read_file":
         return f"{len(lines)} lines"
     if tool_name == "write_file":
@@ -308,11 +356,20 @@ def _brief_result(tool_name: str, result: str) -> str:
     if tool_name == "edit_file":
         return result.strip()[:80] if result.strip() else "edited"
     if tool_name == "bash":
-        if not result.strip():
+        # `[exit code N]` is a model-facing marker prepended to the output so the
+        # model knows the command failed. Don't show that raw token to the user:
+        # strip it, and render a clean "failed (exit N)" plus any real output.
+        exit_code, body = _split_exit_code(result)
+        body_lines = body.strip().splitlines()
+        if exit_code is not None:
+            head = body_lines[0][:80] if body_lines and body_lines[0].strip() else ""
+            tail = f"  …({len(body_lines)} lines)" if len(body_lines) > 1 else ""
+            return f"failed (exit {exit_code}){(': ' + head) if head else ''}{tail}"
+        if not body.strip():
             return "done (no output)"
-        if len(lines) <= 3:
-            return "\n".join(lines)[:200]
-        return f"{lines[0][:80]}  …({len(lines)} lines)"
+        if len(body_lines) <= 3:
+            return "\n".join(body_lines)[:200]
+        return f"{body_lines[0][:80]}  …({len(body_lines)} lines)"
     if tool_name == "grep":
         return f"{len(lines)} matches" if lines and lines[0] else "no matches"
     if tool_name in ("glob", "list_files"):

{localcode-0.3.15 → localcode-0.3.16}/src/localcode/agent/loop.py

@@ -52,8 +52,6 @@ from .context import (
     _prepare_model_messages,
     _summarize_args,
     _truncate_result,
-    _estimate_tokens,
-    _compact_messages,
     build_progress_ledger,
 )
 from .helpers import (
@@ -334,14 +332,23 @@ def run_agent_loop(
             messages.append(m)
     elif use_thinking:
         # Thinking mode: keep context shorter but preserve recent assistant responses
-        # Only drop very large blocks (repo structure dumps, huge tool results)
+        # Only drop very large blocks (repo structure dumps, huge tool results).
+        # The "large block" threshold scales with the model's real context window
+        # instead of a fixed 1500 chars — on a 256K window 1500 chars is ~1% of
+        # the budget, so the old fixed value silently stripped tool results the
+        # big machine had ample room to keep (and needs, to track its work).
+        try:
+            _tw = int(app.engine._target_num_ctx())
+        except Exception:
+            _tw = 0
+        _big_block_chars = max(1500, int(_tw * 3.5 * 0.02)) if _tw else 1500
         for m in composed_messages:
             if m.get("role") == "system":
                 continue
             content = str(m.get("content", ""))
             # Skip very large context blocks (repo structure, bulk retrieval results)
             # but keep normal assistant responses so model remembers recent conversation
-            if len(content) > 1500 and m.get("role") not in ("user", "assistant"):
+            if len(content) > _big_block_chars and m.get("role") not in ("user", "assistant"):
                 continue
             messages.append(m)
     else:
@@ -373,8 +380,23 @@ def run_agent_loop(
     )
     hook_before_turn(_hook_state)
     _app_build_request = is_app_build_request(user_text) or _goal_state.goal_type == "build_app"
-    _aggregate_budget = 24_000 if _app_build_request else MAX_AGGREGATE_PER_TURN
-    _compact_token_limit = 12_000 if _app_build_request else 27_000
+    # Per-turn tool-output budget (in chars) scales with the model's REAL
+    # context window instead of a fixed cap: allow tool results to fill up to
+    # ~35% of the window before further output this turn is truncated. Dynamic
+    # per RAM/model — a 256K window keeps far more than a 64K one. The old fixed
+    # values (24K for app builds, 100K otherwise) starved big machines and,
+    # perversely, gave app builds — which read/write the MOST — the LEAST. The
+    # floor keeps small windows usable; within-turn overflow is still caught by
+    # the window-aware compaction pass at the top of each round.
+    try:
+        _ctx_tokens_turn = int(app.engine._target_num_ctx())
+    except Exception:
+        _ctx_tokens_turn = 0
+    _aggregate_budget = (
+        max(MAX_AGGREGATE_PER_TURN, int(_ctx_tokens_turn * 3.5 * 0.35))
+        if _ctx_tokens_turn
+        else MAX_AGGREGATE_PER_TURN
+    )
     _completion_gate_retries = 0
     _MAX_COMPLETION_GATE_RETRIES = 1
     _edit_recovery_nudges = 0
@@ -1805,9 +1827,15 @@ def run_agent_loop(
                 _write_existing_rejections_this_turn += 1
             # Show result to user — send full result for write/edit so TUI can render diff
             is_error = tool_result_is_error(tool_result)
-            is_rejected = tool_result.startswith("REJECTED:")
+            # Match BOTH "REJECTED:" and "REJECTED — HARD STOP:" (em-dash) — the
+            # latter used to slip past this colon-only check and render as a raw
+            # red protocol line to the user.
+            is_rejected = tool_result.startswith("REJECTED")
             if is_rejected:
-                out.tool_result(tool_result, error=True, idx=idx)
+                # Internal tool-routing redirect — the model needs the full
+                # REJECTED payload (kept in `messages` below), but the user sees
+                # only a short neutral note, not a red error block.
+                out.tool_result(_brief_result(tool_name, tool_result), error=False, idx=idx)
             elif tool_name in ("write_file", "append_file", "edit_file") and not is_error:
                 out.tool_result(tool_result, error=False, idx=idx)
             else:
@@ -1817,12 +1845,16 @@ def run_agent_loop(
             _facts_note = facts_suffix(_tool_facts)
             if _facts_note and _facts_note not in tool_result:
                 tool_result = f"{tool_result}{_facts_note}"
-            tool_result = _truncate_result(tool_result, tool_name)
+            tool_result = _truncate_result(tool_result, tool_name, ctx_tokens=_ctx_tokens_turn)
             aggregate_size += len(tool_result)
 
-            # Aggregate budget
+            # Aggregate budget. The post-budget clamp scales with the window too:
+            # once a turn's cumulative tool output crosses the (dynamic) budget,
+            # a big machine still keeps a proportionally larger stub than a 16 GB
+            # one instead of a brutal fixed 500 chars.
             if aggregate_size > _aggregate_budget:
-                tool_result = tool_result[:500] + "\n[Truncated — context budget exceeded this turn]"
+                _stub_chars = max(500, int(_ctx_tokens_turn * 3.5 * 0.01)) if _ctx_tokens_turn else 500
+                tool_result = tool_result[:_stub_chars] + "\n[Truncated — context budget exceeded this turn]"
 
             # Add to history
             messages.append({
@@ -1982,9 +2014,13 @@ def run_agent_loop(
         if loop_detected:
             break
 
-        # Context compaction check (85% of 32K = ~27K tokens)
-        if _estimate_tokens(messages) > _compact_token_limit:
-            messages = _compact_messages(messages, out)
+        # Compaction is handled ONCE per round at the TOP of the loop by the
+        # window-aware `should_compact`/`compact` path (see ~line 612), whose
+        # threshold scales with the model's real context window and the user's
+        # RAM. The old fixed-12K/27K second pass that used to live here fired at
+        # <5% of a 256K window, crushed all but 8 messages into a 5-line note,
+        # and made the model lose provenance of its own writes → the re-read /
+        # "fix systematically" churn loop. Removed: one dynamic system only.
 
     else:
         # `for…else` only fires when the loop exhausted naturally

{localcode-0.3.15 → localcode-0.3.16}/src/localcode/bootstrap.py

@@ -132,6 +132,10 @@ def _runner_panel(label: str, detail: str, tick: int, steps: list[SetupStep], cu
 
 _progress_status: dict[str, str] = {}
 
+# Generic return type for run_with_runner (the TypeVar was imported but never
+# bound — ruff F821, and it broke the E9/F82 lint gate in CI).
+T = TypeVar("T")
+
 
 def run_with_runner(console: Console, step: SetupStep, steps: list[SetupStep], fn: Callable[[], T]) -> T:
     result: dict[str, T] = {}

{localcode-0.3.15 → localcode-0.3.16}/src/localcode/memory_guard.py

@@ -25,6 +25,7 @@ from __future__ import annotations
 
 import ctypes
 import ctypes.util
+import os
 import platform
 import subprocess
 import threading
@@ -192,21 +193,42 @@ def set_jetsam_highwater(pid: int, limit_mb: int) -> bool:
         return False
 
 
-def recommended_jetsam_limit_mb() -> int:
-    """Budget: physical_ram − 3.5 GB reserved for macOS + other apps.
-
-    On a 16 GB Mac that's 16384 − 3500 = 12884 MB. llama-server for our
-    10–11 GB models tops out around 13 GB wired during decode (measured
-    Apr 22 2026), so this leaves ~100 MB margin — kernel will kill
-    llama-server before it can push the system over the edge. On 32 GB+
-    we're more permissive.
-    """
+def _total_ram_mb() -> int:
     try:
         r = subprocess.run(["sysctl", "-n", "hw.memsize"],
                            capture_output=True, text=True, timeout=2)
-        total_mb = int(r.stdout.strip()) // (1024 * 1024)
+        return int(r.stdout.strip()) // (1024 * 1024)
     except Exception:
-        total_mb = 16 * 1024
+        return 16 * 1024
+
+
+def should_set_fatal_jetsam_limit() -> bool:
+    """Whether to install the FATAL per-process jetsam highwater on the server.
+
+    The fatal kernel cap exists to stop a runaway server from freezing a SMALL
+    Mac — on 16 GB, an ~11 GB model that spikes must be killed before it takes
+    the whole machine down. But on a large Mac a big model legitimately needs
+    most of RAM: a 36 GB model at 256K context (weights + a huge KV cache + ctx
+    checkpoints + compute-buffer spikes) can push the server's phys_footprint
+    past total−reserve during a normal decode step, and the FATAL cap then makes
+    the kernel SIGKILL it (-9, no crash report — the mystery crash we chased for
+    hours). On 48 GB+ the graceful userspace pressure monitor (SIGTERM on WARN)
+    is enough, so we DON'T install a fatal cap there. Override with
+    LOCALCODE_FORCE_JETSAM_LIMIT=1 / =0.
+    """
+    force = os.environ.get("LOCALCODE_FORCE_JETSAM_LIMIT")
+    if force in ("0", "1"):
+        return force == "1"
+    return _total_ram_mb() < 48 * 1024
+
+
+def recommended_jetsam_limit_mb() -> int:
+    """Per-process fatal jetsam highwater (MB) for machines that get one.
+
+    Only used when should_set_fatal_jetsam_limit() is True (small Macs). Budget
+    = physical RAM − reserve for macOS + other apps.
+    """
+    total_mb = _total_ram_mb()
     reserve = 3500 if total_mb < 24 * 1024 else 6000
     return max(2048, total_mb - reserve)
 

{localcode-0.3.15 → localcode-0.3.16}/src/localcode/runtime.py

@@ -510,13 +510,28 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
         # subsequent multi-turn requests can restore and skip prefix
         # re-evaluation. Measured 19× speedup on turn 2 vs cold turn 1
         # (5932 ms → 302 ms prompt eval at 2K ctx).
-        # --ctx-checkpoints 32     keep up to 32 rolling state snapshots
+        # --ctx-checkpoints N      keep up to N rolling state snapshots
         # --checkpoint-every-n-tokens 2048  snapshot every 2K tokens during prefill
         # For pure-attention models these are no-ops; cheap to always set.
         # Note: --swa-full would additionally warm the attention SWA cache
         # but causes Metal OOM at our 14336 MiB sysctl on 16 GB Macs. Skip.
+        # Scale the snapshot count DOWN as context grows: a checkpoint stores
+        # the model's recurrent/KV state, and at 256K each one is far larger
+        # than at 8K. 32 snapshots × a 256K state is gigabytes of extra RSS
+        # that pushed the server into the memory killer on long tasks. 32 is
+        # only worth it at small contexts where each snapshot is tiny; at big
+        # windows a handful still gives the multi-turn prefix-reuse speedup.
+        _ckpt_ctx = self._target_num_ctx(model_path=model_path)
+        if _ckpt_ctx >= 131072:
+            _ckpts = "4"
+        elif _ckpt_ctx >= 65536:
+            _ckpts = "8"
+        elif _ckpt_ctx >= 32768:
+            _ckpts = "16"
+        else:
+            _ckpts = "32"
         cmd.extend([
-            "--ctx-checkpoints", "32",
+            "--ctx-checkpoints", _ckpts,
             "--checkpoint-every-n-tokens", "2048",
         ])
         # Single slot, disable fit check (we manage memory via sysctl)

{localcode-0.3.15 → localcode-0.3.16}/src/localcode/server_manager.py

@@ -455,14 +455,26 @@ class ServerManager:
 
             # Layer 1: kernel-enforced memory ceiling via jetsam — the hard
             # backstop (sanctioned Apple API) that kills llama-server before it
-            # can push the system over the edge.
+            # can push the system over the edge. ONLY installed on small Macs
+            # (<48 GB): there a runaway server must be killed before it freezes
+            # the machine. On a large Mac a big model legitimately needs most of
+            # RAM, and a FATAL highwater there just SIGKILLs (-9) the server
+            # mid-decode when its footprint spikes past total−reserve — the
+            # mystery long-task crash. Big machines rely on Layer 2 (graceful).
             try:
                 from .memory_guard import (
                     set_jetsam_highwater, recommended_jetsam_limit_mb,
-                    start_pressure_monitor,
+                    should_set_fatal_jetsam_limit, start_pressure_monitor,
                 )
-                set_jetsam_highwater(self._process.pid,
-                                     recommended_jetsam_limit_mb())
+                if should_set_fatal_jetsam_limit():
+                    _limit = recommended_jetsam_limit_mb()
+                    set_jetsam_highwater(self._process.pid, _limit)
+                    _lifecycle_log("jetsam_highwater_set", pid=self._process.pid,
+                                   limit_mb=_limit)
+                else:
+                    _lifecycle_log("jetsam_highwater_skipped",
+                                   pid=self._process.pid,
+                                   reason="large_ram_uses_pressure_monitor")
             except Exception:
                 pass
 

{localcode-0.3.15 → localcode-0.3.16}/src/localcode/tools/read_file.py

@@ -7,6 +7,26 @@ from .base import ToolContext
 DEFAULT_LIMIT = 240
 MAX_DEFAULT_CHARS = 12_000
 
+
+def _dynamic_read_defaults(ctx: ToolContext) -> tuple[int, int]:
+    """(default_line_limit, max_default_chars), scaled to the model's real
+    context window. read_file is the primary code-ingestion path: on a 256K
+    window the fixed 240-line / 12K-char default forces needless pagination and
+    re-reads where the machine has the MOST room. Scale up to ~6% of the window
+    in chars (and lines proportionally), floored at the static defaults so a
+    16 GB Mac (small window) is byte-identical to before.
+    """
+    try:
+        ctx_tokens = int(ctx.app.engine._target_num_ctx())
+    except Exception:
+        ctx_tokens = 0
+    if not ctx_tokens:
+        return DEFAULT_LIMIT, MAX_DEFAULT_CHARS
+    max_chars = max(MAX_DEFAULT_CHARS, int(ctx_tokens * 3.5 * 0.06))
+    # Keep the historical ~50 chars/line ratio between the two defaults.
+    line_limit = max(DEFAULT_LIMIT, max_chars // 50)
+    return line_limit, max_chars
+
 SCHEMA = {
     "type": "function",
     "function": {
@@ -80,28 +100,29 @@ def execute(ctx: ToolContext, args: dict) -> str:
         return f"File not found: {args['path']}" + (f"\n{hint}" if hint else "")
     content = path.read_text(errors="replace")
     lines = content.splitlines()
+    default_limit, max_default_chars = _dynamic_read_defaults(ctx)
     offset = args.get("offset", 0)
     explicit_limit = "limit" in args
-    limit = args.get("limit", DEFAULT_LIMIT)
+    limit = args.get("limit", default_limit)
     selected = lines[offset:offset + limit]
     numbered = [f"{i + offset + 1}\t{line}" for i, line in enumerate(selected)]
     result = "\n".join(numbered)
     if len(lines) > offset + limit:
         result += f"\n\n[{len(lines) - offset - limit} more lines — use offset={offset + limit} to continue]"
-    if not explicit_limit and len(result) > MAX_DEFAULT_CHARS:
+    if not explicit_limit and len(result) > max_default_chars:
         kept: list[str] = []
         total = 0
         for line in numbered:
             total += len(line) + 1
-            if total > MAX_DEFAULT_CHARS:
+            if total > max_default_chars:
                 break
             kept.append(line)
         result = "\n".join(kept)
         remaining_from_line = offset + len(kept)
         result += (
-            f"\n\n[Large file summarized at {MAX_DEFAULT_CHARS} chars. "
+            f"\n\n[Large file summarized at {max_default_chars} chars. "
             f"File has {len(lines)} lines; continue with "
-            f"offset={remaining_from_line}, limit={DEFAULT_LIMIT}, or request "
+            f"offset={remaining_from_line}, limit={default_limit}, or request "
             "a focused smaller range around the symbol you need.]"
         )
     # Prompt-injection defence: wrap untrusted file content in explicit

{localcode-0.3.15 → localcode-0.3.16}/src/localcode/tui/screens/chat.py

@@ -1093,6 +1093,12 @@ class ChatScreen(Screen):
                 text = (m.get("content") or "").strip()
                 if not text:
                     continue
+                # Defense-in-depth: an ephemeral "SYSTEM:" nudge is a role:user
+                # message that is normally stripped before persistence — but if a
+                # turn was interrupted before stripping ran, it can survive. Never
+                # replay it as "you: SYSTEM: …" (it was never the user's words).
+                if text.startswith("SYSTEM:") or text.startswith("SYSTEM —"):
+                    continue
                 if role == "user":
                     log.append_info(f"[dim]you:[/] {text}")
                 elif role == "assistant":

{localcode-0.3.15 → localcode-0.3.16}/src/localcode/tui/widgets/chat_log.py

@@ -1507,7 +1507,7 @@ class ChatLog(RichLog):
         # so warnings/errors render in a dim-red panel below the main
         # output. Heuristic — only applies if stderr-style markers are
         # detected; otherwise the whole result renders as stdout.
-        from ..formatting import truncate_with_tail, split_stdout_stderr
+        from ...formatting import truncate_with_tail, split_stdout_stderr
         stdout_text, stderr_text = split_stdout_stderr(result)
 
         # If we extracted distinct stderr, render stdout normally and
@@ -1559,7 +1559,7 @@ class ChatLog(RichLog):
         _render_tool_result. Stderr blocks pass label='stderr' + a
         red color to differentiate from normal output.
         """
-        from ..formatting import truncate_with_tail
+        from ...formatting import truncate_with_tail
         lines = text.strip().splitlines()
         if not lines:
             return

{localcode-0.3.15 → localcode-0.3.16/src/localcode.egg-info}/PKG-INFO

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

{localcode-0.3.15 → localcode-0.3.16}/tests/test_comprehensive_install.py

@@ -78,13 +78,6 @@ def test_installed_help_runs(installed_venv, tmp_path):
     assert "LocalCode" in r.stdout
 
 
-def test_installed_models_command_shows_12b(installed_venv, tmp_path):
-    """The freshly-installed package exposes the new Gemma 4 12B profile."""
-    r = _run_installed(installed_venv, "models", home=tmp_path)
-    assert r.returncode == 0, r.stderr
-    assert "12b" in r.stdout
-
-
 def test_installed_package_imports_clean(installed_venv):
     """Import the top-level package from the installed location (NOT the
     source tree) to catch missing modules / packaging gaps."""