lcode-cli 0.27.0__tar.gz → 0.28.0__tar.gz

{lcode_cli-0.27.0 → lcode_cli-0.28.0}/CHANGELOG.md

@@ -6,6 +6,30 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.28.0] - 2026-10-13
+
+### Added
+
+- lcode says what's happening under the hood, in a line, only when it happens:
+  - loading the model and then reading the conversation are named in the status line instead of
+    "Thinking";
+  - after a load, how long it took and how much of the model is on the GPU, with a warning when less
+    is than usual;
+  - at startup and on `/model`, a warning when a dense model won't fit on the GPU and will be slow,
+    with what to use instead;
+  - the vision model making the main model step aside, and the reload after it;
+  - an image tool taking the GPU;
+  - clearer explanations when Ollama runs out of memory.
+
+  The status bar shows when the model is still loading at startup. See
+  [What's happening under the hood](https://nasser1941.github.io/lcode/usage/#whats-happening-under-the-hood).
+
+### Fixed
+
+- After `/model`, images were still described by the vision model chosen for the previous model.
+- The tests no longer write into your lcode state folder; one of them had left about a hundred
+  entries in `extensions-approved.json`.
+
 ## [0.27.0] - 2026-10-10
 
 ### Changed
@@ -575,7 +599,8 @@ First public release.
 - `AGENTS.md` project instructions and `/init` to generate them.
 - One-line installer for Linux and macOS.
 
-[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.27.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.28.0...HEAD
+[0.28.0]: https://github.com/nasser1941/lcode/compare/v0.27.0...v0.28.0
 [0.27.0]: https://github.com/nasser1941/lcode/compare/v0.26.0...v0.27.0
 [0.26.0]: https://github.com/nasser1941/lcode/compare/v0.25.0...v0.26.0
 [0.25.0]: https://github.com/nasser1941/lcode/compare/v0.24.0...v0.25.0

{lcode_cli-0.27.0 → lcode_cli-0.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.27.0
+Version: 0.28.0
 Summary: A local-first terminal coding agent powered by open-weight models on your own GPU or Mac, via Ollama.
 Project-URL: Homepage, https://nasser1941.github.io/lcode/
 Project-URL: Documentation, https://nasser1941.github.io/lcode/

{lcode_cli-0.27.0 → lcode_cli-0.28.0}/docs/quickstart.md

@@ -12,7 +12,7 @@ lcode
 
 ```text
 ╭──────────────────────────────────────────────╮
-│ lcode v0.27.0 — local coding agent           │
+│ lcode v0.28.0 — local coding agent           │
 │                                              │
 │ model    lcode-qwen3.6-35b                   │
 │ context  256K tokens                         │

{lcode_cli-0.27.0 → lcode_cli-0.28.0}/docs/usage.md

@@ -133,6 +133,33 @@ since last time with `bash_output`, and stops it with `bash_stop`.
 - Background commands ask for permission like any other command, and run in the
   [sandbox](sandbox.md) when it's on.
 
+## What's happening under the hood
+
+Much of the waiting with a local model isn't the model thinking: it's loading the model, or reading
+a long conversation before the first word. lcode says which, in the status line under a request:
+
+```text
+⠋ Loading qwen3.6-35b into memory… (0 tokens, 9s · Ctrl+C to stop)
+⠋ Reading the conversation (18K tokens)… (0 tokens, 21s · Ctrl+C to stop)
+⠋ Thinking… (312 tokens, 27s · Ctrl+C to stop)
+```
+
+It prints a line only when something worth knowing happens, and nothing while the model simply
+stays loaded:
+
+| When | What it says |
+|---|---|
+| The model was loaded | `◆ Loaded qwen3.6-35b in 15s: 22.3 GB, 45% on the GPU and the rest in system RAM.`, and a warning when less of it is on the GPU than usual, because another program or model is using GPU memory |
+| A dense model doesn't fit on the GPU (at startup and on `/model`) | `⚠ qwen3.8-27b is a dense model: all 27B parameters work on every token. It's capable, but slow here. Only about 61% of it fits in the 12 GB of GPU memory…`, with what to do instead |
+| The model that looks at images needs the memory | `Loading the vision model … to look at bug.png; qwen3.6-35b makes room and reloads afterwards`, then `◆ qwen3.6-35b was unloaded to make room…`, and the next step says `Reloading qwen3.6-35b into memory (it made room for the vision model …)` |
+| A tool needs the GPU to itself, such as image generation | `◆ Unloaded qwen3.6-35b so comfyui can use the GPU; it reloads afterwards.` |
+| Ollama ran out of memory | `⚠` what ran out (the prompt batch, or the context next to the model), what lcode retries with, and what it remembers for next time |
+
+While the model loads in the background at startup, the status bar says
+`loading the model into memory…`. Mixture-of-Experts models, such as qwen3.6-35b, run well with
+part of them in system RAM. Dense ones slow down a lot, to a few tokens a second, which is why they
+get the warning.
+
 ## Notifications
 
 Local models take a while, so you'll often switch to something else during a request. lcode shows

{lcode_cli-0.27.0 → lcode_cli-0.28.0}/src/lcode/__init__.py

@@ -3,7 +3,7 @@
 From a program: `from lcode import Session` (see lcode.api).
 """
 
-__version__ = "0.27.0"
+__version__ = "0.28.0"
 
 API = ("Session", "Result", "Options", "SetupError")
 

{lcode_cli-0.27.0 → lcode_cli-0.28.0}/src/lcode/agent.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import base64
+import contextlib
 import datetime as dt
 import json
 import platform
@@ -23,7 +24,20 @@ from rich.markup import escape
 from rich.panel import Panel
 from rich.text import Text
 
-from lcode import catalog, codesearch, extensions, limits, notify, planning, repomap, sessions, subagents, vision, web
+from lcode import (
+    catalog,
+    codesearch,
+    extensions,
+    limits,
+    notify,
+    planning,
+    repomap,
+    residency,
+    sessions,
+    subagents,
+    vision,
+    web,
+)
 from lcode import context as context_tools
 from lcode import memory as memory_notes
 from lcode.checkpoints import Checkpoints
@@ -53,7 +67,12 @@ from lcode.tools import (
     truncate,
 )
 
-GPU_MEMORY_ERRORS = ("out of memory", "illegal memory access", "cudamalloc failed")
+GPU_MEMORY_ERRORS = (
+    "out of memory",
+    "illegal memory access",
+    "cudamalloc failed",
+    "requires more system memory",  # Ollama: the model and its context don't fit in RAM either
+)
 SAFE_NUM_BATCH = 512  # Ollama's default prompt batch
 MAX_STEPS_PER_TURN = 150
 EVENT_OUTPUT = 4000  # characters of a tool's output in an event
@@ -62,6 +81,7 @@ REFUSED = ("Error:", "A deny rule", "The user denied", "This needs the user's pe
 MAX_MALFORMED_CALL_RETRIES = 2  # Ollama rejects tool calls whose arguments aren't valid JSON
 # How Ollama reports a tool call it couldn't parse (Qwen3.6's calls are XML)
 MALFORMED_CALL = ("error parsing tool call", "XML syntax error")
+READING_NOTE_TOKENS = 4000  # new input this large gets "Reading … new tokens" in the status line
 AUTO_COMPACT_RATIO = 0.85  # summarize the history when the context is this full
 PRUNED_ENOUGH = 0.6  # after pruning old tool output, summarize only if the context is still this full
 # @path, @"path with spaces" or @'path'
@@ -171,6 +191,10 @@ def project_root_or_cwd(cwd: Path) -> Path:
     return work_tree_for(cwd)
 
 
+def conversation_chars(messages: list[dict]) -> int:
+    return sum(len(str(m.get("content") or "")) + len(str(m.get("thinking") or "")) for m in messages)
+
+
 def call_arguments(call: dict) -> dict:
     """A tool call's arguments as a dict (some models send them as a JSON string)."""
     args = call.get("function", {}).get("arguments") or {}
@@ -189,17 +213,22 @@ class Progress:
     arrives, for example while the model writes a long file into a tool call.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, phase: str = "Thinking") -> None:
         self.started = self.last_chunk = time.time()
-        self.phase = "Thinking"
+        self.phase = phase
         self.chars = 0
 
     def update(self, phase: str, text: str) -> None:
         self.phase, self.chars, self.last_chunk = phase, self.chars + len(text), time.time()
 
+    def set_phase(self, phase: str) -> None:
+        """What happens before the first token: loading the model, reading the prompt."""
+        self.phase, self.last_chunk = phase, time.time()
+
     def __rich__(self) -> Text:
         now = time.time()
-        phase = self.phase if now - self.last_chunk < 3 else "Working"
+        streaming = self.phase in ("Thinking", "Writing")  # loading and reading say what they are throughout
+        phase = self.phase if now - self.last_chunk < 3 or not streaming else "Working"
         return Text.from_markup(
             f"[cyan]{phase}…[/] [dim]({self.chars // 4} tokens, {now - self.started:.0f}s · Ctrl+C to stop)[/]"
         )
@@ -288,6 +317,10 @@ class Agent:
         # Decides on a presented plan instead of asking in the terminal: "ask", "auto-edit", or why not.
         self.plan_review: Callable[[str, str], str] | None = None
         self.max_steps = MAX_STEPS_PER_TURN
+        self.hardware = None  # an lcode.hardware.Hardware, set by the CLI: for what fits on the GPU
+        self.made_room_for = ""  # why the model was unloaded (the vision model, an MCP tool), for the reload line
+        self.load_state = ""  # "loading" while the model loads in the background at startup (lcode.repl)
+        self.sent_chars = 0  # characters of the conversation the model had already read
         self.turn_status = ""  # how the last request ended: success, max_steps, loop
         self.repeats = Repeats(settings.repeat_limit)  # notices when the model repeats itself
         self.response = None  # the streaming response, so another thread can abort it
@@ -465,12 +498,33 @@ class Agent:
             image = vision.read_image(path)
             # The session's own model keeps its settings, so Ollama doesn't reload it.
             options = self.options() if model == self.settings.model else None
-            loading = "" if model == self.settings.model else " (loads it; the next request reloads the main model)"
-            with self.console.status(f"Looking at {path.name} with {model}{loading}…", spinner="dots"):
+            with self.vision_swap(model, path.name):
                 return vision.describe(self.ollama, model, image, question, options, self.settings.keep_alive)
         except vision.VisionError as e:
             raise ToolError(str(e)) from e
 
+    @contextlib.contextmanager
+    def vision_swap(self, model: str, what: str):
+        """Look at an image with `model`, saying when it has to load and when the main model made room for it."""
+        main = self.settings.model
+        own = model == main
+        main_was_loaded = not own and residency.placement(self.ollama, main) is not None
+        if own or residency.placement(self.ollama, model) is not None:
+            text = f"Looking at {what} with {model}…"
+        else:
+            text = f"Loading the vision model {model} to look at {what}" + (
+                f"; {main} makes room and reloads afterwards…" if main_was_loaded else "…"
+            )
+        with self.console.status(text, spinner="dots"):
+            yield
+        if main_was_loaded and residency.placement(self.ollama, main) is None:
+            self.made_room_for = f"the vision model {model}"
+            self.say(f"{main} was unloaded to make room for {model}; it reloads for the next step.")
+
+    def say(self, text: str, warning: bool = False) -> None:
+        """One line about what happens under the hood (loading, memory), not about the work itself."""
+        self.console.print(Text(f"{'⚠' if warning else '◆'} {text}", style="yellow" if warning else "dim cyan"))
+
     def describe_image_data(self, data: str, mime: str) -> str:
         """For images that tools return (e.g. an MCP browser's screenshots): a description, or a note."""
         model = self.vision_model()
@@ -478,7 +532,7 @@ class Agent:
             return f"[{mime} image not shown: {vision.INSTALL_HINT}]"
         options = self.options() if model == self.settings.model else None
         try:
-            with self.console.status(f"Looking at the {mime} image with {model}…", spinner="dots"):
+            with self.vision_swap(model, f"the {mime} image"):
                 text = vision.describe(
                     self.ollama, model, base64.b64decode(data), "", options, self.settings.keep_alive
                 )
@@ -624,9 +678,11 @@ class Agent:
                 if not started and batch and batch > SAFE_NUM_BATCH:
                     # Larger batches read prompts faster but need extra VRAM that isn't always free.
                     self.settings.num_batch = SAFE_NUM_BATCH
-                    self.console.print(
-                        f"[yellow]The GPU ran out of memory with a prompt batch of {batch}; retrying with "
-                        f"{SAFE_NUM_BATCH}.[/] [dim]To skip this retry: lcode config set num_batch {SAFE_NUM_BATCH}[/]"
+                    self.say(
+                        f"The GPU ran out of memory reading the prompt in batches of {batch} tokens. Retrying with "
+                        f"batches of {SAFE_NUM_BATCH}: a little slower to read, but it needs less memory. To start "
+                        f"there next time: lcode config set num_batch {SAFE_NUM_BATCH}",
+                        warning=True,
                     )
                     yield from self.chat(messages, tools, think)
                     return
@@ -636,16 +692,19 @@ class Agent:
                     smaller = max(catalog.MIN_USEFUL_CONTEXT, context // 2)
                     self.settings.context = smaller
                     limits.record(self.settings.model, smaller)
-                    self.console.print(
-                        f"[yellow]{self.settings.model} didn't fit in GPU memory with a {format_tokens(context)} "
-                        f"context; retrying with {format_tokens(smaller)}.[/] [dim]lcode will start there next "
-                        "time on this machine.[/]"
+                    self.say(
+                        f"{self.settings.model} didn't fit in memory with a {format_tokens(context)} context: the "
+                        "context needs its own memory next to the model. Reloading it with "
+                        f"{format_tokens(smaller)}; lcode will start there next time on this machine.",
+                        warning=True,
                     )
                     yield from self.chat(messages, tools, think)
                     return
                 raise OllamaError(
-                    f"{e}\nThe model ran out of GPU memory. Try a smaller context (/ctx 128k), close other programs "
-                    "using the GPU, or pick a smaller model (/models)."
+                    f"{e}\n{self.settings.model} ran out of memory. Close other programs that use the GPU (another "
+                    "model, a game, an image generator), use a smaller context (/ctx "
+                    f"{format_tokens(max(catalog.MIN_USEFUL_CONTEXT // 2, context // 2)).lower()}), or pick a smaller "
+                    "model (/models)."
                 ) from e
             raise
 
@@ -659,6 +718,7 @@ class Agent:
         content, thinking, tool_calls, final = "", "", [], {}
         md = MarkdownStreamer(self.console)
         progress = Progress()
+        watch = self.before_request(progress)
         status = None
         printed_thinking = False
 
@@ -680,6 +740,9 @@ class Agent:
                 if self.cancel is not None and self.cancel.is_set():
                     raise KeyboardInterrupt
                 msg = chunk.get("message", {})
+                if watch is not None:
+                    self.after_load(watch)
+                    watch = None
                 if msg.get("thinking"):
                     thinking += msg["thinking"]
                     if self.on_delta:
@@ -714,6 +777,8 @@ class Agent:
             raise
         finally:
             stop_spinner()
+            if watch is not None:
+                watch.stop()
         if printed_thinking:
             self.console.print()
         md.flush()
@@ -732,10 +797,49 @@ class Agent:
             self.usage["output_tokens"] += final.get("eval_count", 0)
             self.usage["output_ns"] += final.get("eval_duration", 0)
             self.ctx_used = final.get("prompt_eval_count", 0) + final.get("eval_count", 0)
+            self.sent_chars = conversation_chars(self.messages)
             seconds = final.get("eval_duration", 0) / 1e9
             self.last_speed = final.get("eval_count", 0) / seconds if seconds else 0.0
         return message
 
+    def before_request(self, progress: Progress) -> residency.LoadWatch | None:
+        """Set the status line for what comes before the first token: loading the model if it isn't in memory
+        (watched until it is), then reading the prompt. Returns the watch while the model loads."""
+        if getattr(self.ollama, "kind", "ollama") != "ollama":
+            return None
+        model, context = self.settings.model, self.settings.context
+        fresh = max(0, conversation_chars(self.messages) - self.sent_chars) // 3
+        where = residency.placement(self.ollama, model)
+        if where is not None and (not where.context or where.context == context):
+            if fresh >= READING_NOTE_TOKENS:
+                progress.set_phase(f"Reading {format_tokens(fresh)} new tokens")
+            return None
+        total = conversation_chars(self.messages) // 3
+        if where is not None:
+            phase = f"Reloading {model} with a {format_tokens(context)} context"
+        elif self.made_room_for:
+            phase = f"Reloading {model} into memory (it made room for {self.made_room_for})"
+        else:
+            phase = f"Loading {model} into memory"
+        progress.set_phase(phase)
+        watch = residency.LoadWatch(
+            self.ollama, model, context, progress, f"Reading the conversation ({format_tokens(total)} tokens)"
+        )
+        watch.reload = where is not None or bool(self.made_room_for)
+        return watch
+
+    def after_load(self, watch: residency.LoadWatch) -> None:
+        """The first token after a load: one line on how long it took and how the model fits."""
+        seconds = watch.stop()
+        self.made_room_for = ""
+        self.load_state = ""
+        where = residency.placement(self.ollama, self.settings.model)
+        dense = residency.is_moe(self.ollama, self.settings.model) is False
+        report = residency.load_report(
+            self.settings.model, seconds, where, self.settings.context, self.hardware, dense, watch.reload
+        )
+        self.say(report, warning=report.endswith(("closed.", "slow.")))
+
     def describe_call(self, name: str, args: dict) -> str:
         if name in ("read_file", "write_file", "edit_file"):
             path = self.tools.rel(self.tools.resolve(args.get("path", "")))
@@ -1071,6 +1175,7 @@ class Agent:
                 )  # not enough: before the last request
             context_tools.note_removed(self.messages, removed)
             if saved:
+                self.sent_chars = 0  # the conversation changed: the model reads it again
                 self.pruned += 1
                 self.ctx_used = max(len(self.messages[0]["content"]) // 3, self.ctx_used - saved // 3)
                 self.console.print(
@@ -1127,6 +1232,7 @@ class Agent:
             self.skills_loaded.clear()
         self.ctx_used = sum(len(m["content"]) for m in self.messages) // 3
         self.summarized_size = self.ctx_used
+        self.sent_chars = 0
         self.reflected = len(self.messages)
         self.console.print(Panel(Markdown(summary), title="Compacted summary", border_style="blue"))
 

{lcode_cli-0.27.0 → lcode_cli-0.28.0}/src/lcode/api.py

@@ -199,6 +199,7 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
         compact_at=cfg["compact_at"],
     )
     agent = Agent(ollama, settings, cwd, console=console)
+    agent.hardware = hw
     agent.interactive = options.interactive
     if options.max_steps:
         agent.max_steps = options.max_steps

{lcode_cli-0.27.0 → lcode_cli-0.28.0}/src/lcode/repl.py

@@ -27,7 +27,7 @@ from rich.rule import Rule
 from rich.table import Table
 from rich.text import Text
 
-from lcode import __version__, backends, catalog, clipboard, extensions, gitflow, limits, sessions, web
+from lcode import __version__, backends, catalog, clipboard, extensions, gitflow, limits, residency, sessions, web
 from lcode import context as context_tools
 from lcode import memory as memory_notes
 from lcode.agent import AUTO_COMPACT_RATIO, INIT_PROMPT, Agent
@@ -153,6 +153,7 @@ def build_session(agent: Agent) -> PromptSession:
             f" <b>{html.escape(s.model)}</b> · ctx {format_tokens(agent.ctx_used)}/{format_tokens(s.context)} "
             f"({pct:.0f}%) · mode <{color}>{agent.perms.mode}</{color}> (shift+tab) · "
             f"think {'on' if s.think else 'off'} · {html.escape(agent.cwd.name)}/"
+            + (" · <ansiyellow>loading the model into memory…</ansiyellow>" if agent.load_state == "loading" else "")
             + (f" · <b>{html.escape(agent.session_name)}</b>" if agent.session_name else "")
         )
 
@@ -935,8 +936,12 @@ def handle_command(agent: Agent, line: str, hardware: Hardware) -> bool:
                 s.context = limits.cap(name, spec.fit(hardware)[0] or MIN_USEFUL_CONTEXT)
             elif backends.is_openai(agent.ollama):
                 s.context = backends.context_for(agent.ollama, name, None)[0]  # the server's window
+            agent._vision = False  # the model that looks at images goes with the model: decide again
             agent.messages[0]["content"] = agent.system_prompt()
             c.print(f"[green]Switched to {name}[/] (context {format_tokens(s.context)}).")
+            warning = residency.dense_warning(agent.ollama, name, s.context, hardware)
+            if warning:
+                agent.say(warning, warning=True)
     elif cmd == "/think":
         s.think = (arg == "on") if arg in ("on", "off") else not s.think
         c.print(f"Reasoning {'on' if s.think else 'off'}.")
@@ -1110,9 +1115,12 @@ def repl(agent: Agent, prompt: str | None, hardware: Hardware, cont: bool = Fals
     if prompt:
         run_safely(agent, prompt)
         return
-    preload(agent)
     banner(agent)
+    warning = residency.dense_warning(agent.ollama, agent.settings.model, agent.settings.context, hardware)
+    if warning:
+        agent.say(warning, warning=True)
     session = build_session(agent)
+    preload(agent, session)
     while True:
         try:
             agent.console.print()
@@ -1135,13 +1143,25 @@ def repl(agent: Agent, prompt: str | None, hardware: Hardware, cont: bool = Fals
     agent.console.print("[dim]Bye.[/]")
 
 
-def preload(agent: Agent) -> None:
-    """Start loading the model in the background so the first answer comes sooner."""
+def preload(agent: Agent, session: PromptSession | None = None) -> None:
+    """Start loading the model in the background so the first answer comes sooner; the status bar says so."""
+    where = residency.placement(agent.ollama, agent.settings.model)
+    if where is not None and (not where.context or where.context == agent.settings.context):
+        return  # already in memory
 
     def load() -> None:
+        agent.load_state = "loading"
+        refresh()
         try:
             agent.ollama.load(agent.settings.model, agent.options(), agent.settings.keep_alive)
         except OllamaError:
             pass
+        finally:
+            agent.load_state = ""
+            refresh()
+
+    def refresh() -> None:
+        if session is not None and session.app.is_running:
+            session.app.invalidate()
 
     threading.Thread(target=load, daemon=True).start()

lcode_cli-0.28.0/src/lcode/residency.py

@@ -0,0 +1,167 @@
+"""Where the model is, in words: loading it, how it fits, making room for another one.
+
+A local model has to be in memory before it answers. On a small GPU loading takes a while, how much of
+the model fits on the GPU decides how fast it runs, and a second model (the one that looks at images)
+can push the first one out. lcode says so, in a line, when it happens: nothing is printed while the
+model simply stays loaded.
+
+Only Ollama is asked: other servers load and place their models themselves.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from dataclasses import dataclass
+
+from lcode import catalog
+from lcode.ollama import OllamaError
+
+GB = 1e9
+SPLIT_WARNING = 0.95  # a dense model with less than this on the GPU runs much slower
+SHORTFALL = 0.25  # this much less on the GPU than expected: something else is using GPU memory
+
+
+@dataclass
+class Placement:
+    """A loaded model, from Ollama's /api/ps."""
+
+    name: str
+    size: float  # bytes in memory
+    vram: float  # bytes of it on the GPU
+    context: int = 0  # the context window it was loaded with
+
+    @property
+    def gpu_share(self) -> float:
+        return self.vram / self.size if self.size else 0.0
+
+    def describe(self) -> str:
+        """'22.3 GB, 44% on the GPU and the rest in system RAM'"""
+        size = f"{self.size / GB:.1f} GB"
+        share = self.gpu_share
+        if share >= 0.995:
+            return f"{size}, all on the GPU"
+        if share <= 0.005:
+            return f"{size}, all in system RAM (on the CPU)"
+        return f"{size}, {share:.0%} on the GPU and the rest in system RAM"
+
+
+def same_model(a: str, b: str) -> bool:
+    return a.removesuffix(":latest") == b.removesuffix(":latest")
+
+
+def loaded(ollama, model: str | None = None) -> list[Placement]:
+    """The models Ollama has in memory (only `model`, if given). Empty when it can't be asked."""
+    if getattr(ollama, "kind", "ollama") != "ollama":
+        return []
+    try:
+        entries = ollama.running()
+    except (OllamaError, OSError):
+        return []
+    found = []
+    for entry in entries or []:
+        name = entry.get("name") or entry.get("model") or ""
+        if model is None or same_model(name, model):
+            size = float(entry.get("size") or 0)
+            vram = float(entry.get("size_vram") if entry.get("size_vram") is not None else size)
+            found.append(Placement(name.removesuffix(":latest"), size, vram, int(entry.get("context_length") or 0)))
+    return found
+
+
+def placement(ollama, model: str) -> Placement | None:
+    found = loaded(ollama, model)
+    return found[0] if found else None
+
+
+def is_moe(ollama, model: str) -> bool | None:
+    """Whether the model is a Mixture-of-Experts (None: unknown)."""
+    spec = catalog.find(model)
+    if spec:
+        return spec.moe
+    try:
+        info = (ollama.show(model) or {}).get("model_info") or {}
+    except (OllamaError, OSError):
+        return None
+    if not info:
+        return None
+    return any(key.endswith(".expert_count") and value for key, value in info.items())
+
+
+def expected_share(model: str, context: int, hardware) -> float | None:
+    """How much of the model should fit on the GPU, from the catalog's estimate."""
+    spec = catalog.find(model)
+    if not spec or hardware is None or not hardware.gpu or hardware.unified:
+        return None
+    return min(1.0, hardware.vram_gib / spec.memory_gib(context))
+
+
+def dense_warning(ollama, model: str, context: int, hardware) -> str:
+    """For a dense model that won't fit on the GPU: what that means and what to do. Empty otherwise."""
+    if hardware is None or hardware.unified or is_moe(ollama, model) is not False:
+        return ""
+    spec = catalog.find(model)
+    params = f" {spec.params.split(' ')[0]}" if spec and spec.params else ""
+    if not hardware.gpu:
+        where = "There's no GPU here, so it runs on the CPU"
+    else:
+        share = expected_share(model, context, hardware)
+        if share is None or share >= SPLIT_WARNING:
+            return ""
+        where = (
+            f"Only about {share:.0%} of it fits in the {hardware.vram_gib:.0f} GB of GPU memory and the rest runs "
+            "on the CPU"
+        )
+    return (
+        f"{model} is a dense model: all{params} parameters work on every token. It's capable, but slow here. "
+        f"{where}, so expect a few tokens a second. For speed, pick a Mixture-of-Experts model such as "
+        "qwen3.6-35b (/model qwen3.6-35b), or a smaller context (/ctx 16k) to keep more of it on the GPU."
+    )
+
+
+def load_report(
+    model: str, seconds: float, where: Placement | None, context: int, hardware, dense: bool, reload: bool = False
+) -> str:
+    """The line after a load: how long it took, how it fits, and a warning if it fits worse than it should."""
+    took = f" in {seconds:.0f}s" if seconds >= 1 else ""
+    line = f"{'Reloaded' if reload else 'Loaded'} {model}{took}" + (f": {where.describe()}." if where else ".")
+    if where is None:
+        return line
+    expected = expected_share(model, context, hardware)
+    if expected is not None and where.gpu_share < expected - SHORTFALL:
+        line += (
+            f" Less of it is on the GPU than usual ({expected:.0%}): another program or model is using GPU "
+            "memory, so it runs slower until that's closed."
+        )
+    elif dense and where.gpu_share < SPLIT_WARNING:
+        line += " It's a dense model split between GPU and CPU, so expect it to be slow."
+    return line
+
+
+class LoadWatch:
+    """While a model loads: asks Ollama once a second, and once the model is in memory moves the status line
+    on to reading the prompt, which comes next and can take a while too."""
+
+    POLL = 1.0
+
+    def __init__(self, ollama, model: str, context: int, progress, reading: str) -> None:
+        self.ollama, self.model, self.context = ollama, model, context
+        self.progress, self.reading = progress, reading
+        self.started = time.monotonic()
+        self.loaded_after: float | None = None
+        self.reload = False  # it was in memory before: unloaded for another model, or loaded with another context
+        self.stopped = threading.Event()
+        threading.Thread(target=self.run, daemon=True).start()
+
+    def run(self) -> None:
+        while not self.stopped.wait(self.POLL):
+            where = placement(self.ollama, self.model)
+            if where and (not where.context or not self.context or where.context == self.context):
+                self.loaded_after = time.monotonic() - self.started
+                if not self.stopped.is_set():
+                    self.progress.set_phase(self.reading)
+                return
+
+    def stop(self) -> float:
+        """Seconds the load took (until the first token, when the end of the load went unseen)."""
+        self.stopped.set()
+        return self.loaded_after if self.loaded_after is not None else time.monotonic() - self.started

{lcode_cli-0.27.0 → lcode_cli-0.28.0}/src/lcode/tools.py

@@ -614,9 +614,8 @@ class Toolbox:
                 arguments = {**arguments, "wait": True}
             freed = self.agent.free_gpu()
             if freed:
-                self.console.print(
-                    Text(f"  ⎿ freed the GPU for {state.name} ({', '.join(freed)} reloads afterwards)", style="dim")
-                )
+                self.agent.made_room_for = state.name
+                self.agent.say(f"Unloaded {', '.join(freed)} so {state.name} can use the GPU; it reloads afterwards.")
         result = mcp.call(state, tool, arguments, image_text=self.agent.describe_image_data)
         if result.startswith("Error:"):
             return result

{lcode_cli-0.27.0 → lcode_cli-0.28.0}/tests/conftest.py

@@ -70,6 +70,12 @@ def call(name: str, **arguments) -> dict:
     return {"function": {"name": name, "arguments": arguments}}
 
 
+@pytest.fixture(autouse=True)
+def isolated_state(tmp_path_factory, monkeypatch):
+    """Every test gets its own state folder, so none writes into the user's (approvals, sessions…)."""
+    monkeypatch.setattr("lcode.config.STATE_DIR", tmp_path_factory.mktemp("lcode-state"))
+
+
 @pytest.fixture
 def repo(tmp_path: Path) -> Path:
     (tmp_path / "src" / "pkg").mkdir(parents=True)