lcode-cli 0.26.0__py3-none-any.whl → 0.28.0__py3-none-any.whl

lcode/__init__.py

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

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)[/]"
         )
@@ -234,6 +263,7 @@ class Settings:
     notify_after: int = 30  # seconds: a request this long notifies when it's done or waits for an answer
     max_parallel_agents: int = 1
     secret_check: bool = True  # scan what git commit and git push would add (lcode.secretscan)
+    compact_at: int = 0  # tokens: make room at this size even when the window is larger (0: only at 85%)
     repeat_limit: int = 3  # identical calls with identical results before the model is told (lcode.repeats)
 
 
@@ -270,6 +300,7 @@ class Agent:
         self.agent_runs: list[subagents.Record] = []  # subagents run in this session, for /agents
         self.plan = ""  # the plan the user approved; kept through compaction
         self.pruned = self.compacted = 0  # how often the context was pruned or summarized automatically
+        self.summarized_size = 0  # tokens right after the last summary (0: none in this conversation)
         self._extensions: tuple[Path, extensions.Extensions] | None = None
         self.skills_loaded: set[str] = set()  # skills whose instructions are in the conversation
         # Set on subagents (see lcode.subagents):
@@ -286,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
@@ -463,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()
@@ -476,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
                 )
@@ -514,6 +570,7 @@ class Agent:
         return WEB_PROMPT.format(tools=tools, date=dt.date.today().isoformat())
 
     def reset(self) -> None:
+        self.summarized_size = 0
         self.messages = [{"role": "system", "content": self.system_prompt()}]
         self._mcp_prompt = ""
         self.tools.read_mtimes.clear()
@@ -621,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
@@ -633,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
 
@@ -656,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
 
@@ -677,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:
@@ -711,6 +777,8 @@ class Agent:
             raise
         finally:
             stop_spinner()
+            if watch is not None:
+                watch.stop()
         if printed_thinking:
             self.console.print()
         md.flush()
@@ -729,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", "")))
@@ -1046,23 +1153,46 @@ class Agent:
         return text + ("\n\n" + "\n\n".join(attached) if attached else "")
 
     # -- context management
+    def compact_limit(self) -> int:
+        """The tokens in use at which lcode makes room: 85% of the window, or `compact_at` when that's lower.
+        Small models lose track in long contexts well before a large window is full."""
+        limit = int(AUTO_COMPACT_RATIO * self.settings.context)
+        if self.settings.compact_at > 0:
+            limit = min(limit, self.settings.compact_at)
+        return limit
+
     def maybe_compact(self) -> None:
-        if self.ctx_used <= AUTO_COMPACT_RATIO * self.settings.context:
+        limit = self.compact_limit()
+        if self.ctx_used <= limit:
             return
+        enough = int(limit * PRUNED_ENOUGH / AUTO_COMPACT_RATIO)  # after pruning, a summary isn't needed below this
         if self.settings.prune:
-            saved = context_tools.prune(self.messages)  # tool output from before the last two requests
-            if self.ctx_used - saved // 3 > PRUNED_ENOUGH * self.settings.context:
-                saved += context_tools.prune(self.messages, keep=1)  # not enough: before the last request
+            removed: list[str] = []  # files and pages whose only copy goes
+            saved = context_tools.prune(self.messages, removed=removed)  # tool output from before the last two requests
+            if self.ctx_used - saved // 3 > enough:
+                saved += context_tools.prune(
+                    self.messages, keep=1, removed=removed
+                )  # 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(
                     f"[dim]Removed old tool output from the conversation (~{format_tokens(saved // 3)} tokens) to "
                     "make room.[/]"
                 )
-                if self.ctx_used <= PRUNED_ENOUGH * self.settings.context:
+                if self.ctx_used <= enough:
                     return
-        self.console.print("[yellow]Context is nearly full — compacting the conversation…[/]")
+        window_full = self.ctx_used > AUTO_COMPACT_RATIO * self.settings.context
+        if not window_full and self.summarized_size and self.ctx_used - self.summarized_size < limit // 4:
+            return  # summarized not long ago: summarizing again so soon would only lose more
+        if limit < AUTO_COMPACT_RATIO * self.settings.context:
+            self.console.print(
+                f"[yellow]The conversation reached {format_tokens(limit)} tokens (compact_at) — summarizing it…[/]"
+            )
+        else:
+            self.console.print("[yellow]Context is nearly full — compacting the conversation…[/]")
         self.compacted += 1
         self.compact()
 
@@ -1083,9 +1213,13 @@ class Agent:
         with self.console.status("[cyan]Compacting…[/]"):
             for chunk in self.chat([*self.messages, {"role": "user", "content": instructions}], None, False):
                 summary += chunk.get("message", {}).get("content", "")
+        requests = context_tools.user_requests(self.messages)
         self.messages = [
             {"role": "system", "content": self.system_prompt()},
-            {"role": "user", "content": f"[Summary of our conversation so far]\n\n{summary}"},
+            {
+                "role": "user",
+                "content": f"{sessions.SUMMARY_PREFIX}\n\n{summary}" + context_tools.requests_block(requests),
+            },
             {"role": "assistant", "content": "Got it — I have the context from the summary and will continue."},
         ]
         if self.plan:  # the approved plan stays word for word
@@ -1097,6 +1231,8 @@ 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/api.py

@@ -196,8 +196,10 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
         notify_after=cfg["notify_after"],
         secret_check=cfg["secret_check"],
         repeat_limit=cfg["repeat_limit"],
+        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.py

@@ -579,6 +579,7 @@ def cmd_bench(args) -> None:
             web="off",
             checkpoints=False,
             prune=not args.no_prune,
+            compact_at=cfg["compact_at"] if args.compact_at is None else args.compact_at,
             repo_map=args.repo_map,
             embed_model=cfg["embed_model"] if args.code_search else "off",
         )
@@ -678,6 +679,14 @@ def cmd_chat(args) -> None:
         sys.exit(exit_code)
 
 
+def compact_tokens(value: str) -> int:
+    """`--compact-at`: a token count such as 64k, or 0."""
+    try:
+        return config.parse_compact_at(value)
+    except ConfigError as e:
+        raise argparse.ArgumentTypeError(str(e)) from e
+
+
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="lcode",
@@ -765,6 +774,12 @@ def build_subparsers() -> dict[str, argparse.ArgumentParser]:
     p.add_argument("--repo-map", action="store_true", help="give the model the repository map (off by default)")
     p.add_argument("--code-search", action="store_true", help="index each task's folder and offer semantic code search")
     p.add_argument("--no-prune", action="store_true", help="don't remove old tool output (to compare, with --session)")
+    p.add_argument(
+        "--compact-at",
+        type=compact_tokens,
+        metavar="TOKENS",
+        help="summarize at this many tokens, e.g. 64k (default: the compact_at setting; 0: only at 85%%)",
+    )
     subs["bench"] = p
     p = argparse.ArgumentParser(
         prog="lcode index",

lcode/config.py

@@ -61,6 +61,7 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "notify_after": (30, int, "seconds a request runs before it notifies (with notify on)"),
     "repeat_limit": (3, int, "identical tool calls with identical results before lcode steps in (0: never)"),
     "secret_check": (True, bool, "before git commit and git push, look for passwords, keys and tokens they'd add"),
+    "compact_at": (65536, int, "summarize at this many tokens even when the window is larger (0: only at 85%)"),
     "max_parallel_agents": (1, int, "subagents that may run at the same time (more needs OLLAMA_NUM_PARALLEL)"),
 }
 ENV_OVERRIDES = {
@@ -81,6 +82,19 @@ class ConfigError(ValueError):
     pass
 
 
+MIN_COMPACT_AT = 16384  # below this, the system prompt and a summary alone come close to the ceiling
+
+
+def parse_compact_at(value: str | int) -> int:
+    """compact_at: a token count like parse_context's, at least 16K, or 0 (off)."""
+    if str(value).strip().lower() in ("0", "off", "false", "none"):
+        return 0
+    tokens = parse_context(value)
+    if tokens < MIN_COMPACT_AT:
+        raise ConfigError(f"compact_at {tokens} is too small: use at least 16k, or 0 to turn it off")
+    return tokens
+
+
 def parse_context(value: str | int) -> int:
     """Parse '131072', '128k', '128K' or '1m' into a token count (k = 1024)."""
     if isinstance(value, int):
@@ -118,6 +132,8 @@ def coerce(key: str, value: object) -> object:
     _, typ, _ = SETTINGS[key]
     if key == "context":
         return parse_context(value)  # type: ignore[arg-type]
+    if key == "compact_at":
+        return parse_compact_at(value)  # type: ignore[arg-type]
     if key in ("ollama_host", "searxng_url"):
         return normalize_host(str(value))
     if key == "base_url":

lcode/context.py

@@ -29,6 +29,10 @@ if TYPE_CHECKING:
 KEEP_RECENT_REQUESTS = 2  # tool results of the last requests stay as they are
 MIN_PRUNE_CHARS = 400  # shorter results aren't worth replacing
 PRUNED = "[lcode: "  # how stubs start, so they're never pruned twice
+GONE = (  # a removed file read: firm, because models answer from the stub instead of reading it again
+    "earlier; its content was removed to save context and isn't in this conversation any more. Read it again "
+    "before answering anything about it.]"
+)
 KEEP_TOOLS = {"agent", "skill", "memory", "todo_write", "present_plan"}  # short, or still guiding the work
 ERROR_LINE = re.compile(
     r"error|exception|traceback|failed|failure|fatal|panic|assert|denied|not found|cannot|can't|undefined", re.I
@@ -37,6 +41,56 @@ MAX_ERROR_LINES = 40
 OUTPUT_DAYS = 7  # saved full outputs are deleted after this
 
 
+# ----------------------------------------------------------------------------- the user's requests
+
+REQUESTS_HEADER = "[The user's requests in this conversation, word for word, oldest first]"
+MAX_REQUESTS = 8  # the most recent ones are kept through a summary
+MAX_REQUEST_CHARS = 1500
+# What lcode appends to the user's words: attached files, images and folders, and its own notes.
+ATTACHED = re.compile(r"\n\n(?:<file path=|<image path=|<directory path=|\[lcode[:\]] |\[The user wants the )")
+
+
+def request_text(content: str) -> str:
+    """The user's own words in a message, without what lcode attached to it."""
+    cut = ATTACHED.search(content)
+    return (content[: cut.start()] if cut else content).strip()
+
+
+def user_requests(messages: list[dict]) -> list[str]:
+    """What the user asked in the conversation, oldest first, including the requests an earlier summary kept."""
+    requests: list[str] = []
+    for message in messages:
+        content = message.get("content") or ""
+        if message.get("role") != "user":
+            continue
+        if content.startswith(SUMMARY_PREFIX):
+            start = content.find(REQUESTS_HEADER)
+            if start >= 0:
+                rest = content[start + len(REQUESTS_HEADER) :]
+                try:
+                    kept, _ = json.JSONDecoder().raw_decode(rest[rest.index("[") :])
+                    requests += [str(r) for r in kept]
+                except ValueError:
+                    pass
+            continue
+        if content.startswith("[lcode]"):
+            continue  # lcode's own nudges
+        text = request_text(content)
+        if text:
+            requests.append(text)
+    return requests
+
+
+def requests_block(requests: list[str]) -> str:
+    """The user's latest requests, word for word, to keep the goal through a summary."""
+    if not requests:
+        return ""
+    kept = [r if len(r) <= MAX_REQUEST_CHARS else f"{r[: MAX_REQUEST_CHARS - 200]} […] {r[-150:]}" for r in requests]
+    older = len(kept) - MAX_REQUESTS
+    note = f" (and {older} earlier, in the summary)" if older > 0 else ""
+    return f"\n\n{REQUESTS_HEADER}{note}\n{json.dumps(kept[-MAX_REQUESTS:], ensure_ascii=False, indent=1)}"
+
+
 # ----------------------------------------------------------------------------- pruning
 
 
@@ -63,7 +117,7 @@ def stub(name: str, args: dict, content: str) -> str:
         if args.get("offset") or args.get("limit"):
             start = int(args.get("offset") or 1)
             span = f" from line {start}"
-        return f"{PRUNED}read {args.get('path', 'a file')}{span} earlier; removed to save context. Read it again if you need it.]"
+        return f"{PRUNED}read {args.get('path', 'a file')}{span} {GONE}"
     if name == "bash":
         command = " ".join(str(args.get("command", "")).split())
         command = command if len(command) <= 80 else command[:79] + "…"
@@ -92,8 +146,9 @@ def boundary(messages: list[dict], keep: int = KEEP_RECENT_REQUESTS) -> int:
     return requests[-keep] if len(requests) >= keep else 0
 
 
-def prune(messages: list[dict], keep: int = KEEP_RECENT_REQUESTS) -> int:
-    """Replace stale tool results with stubs, in place. Returns the number of characters saved."""
+def prune(messages: list[dict], keep: int = KEEP_RECENT_REQUESTS, removed: list[str] | None = None) -> int:
+    """Replace stale tool results with stubs, in place. Returns the number of characters saved; the files and
+    pages whose only copy went are added to `removed`."""
     calls = calls_for_results(messages)
     edge = boundary(messages, keep)
     # A read is superseded by a later read of the whole file, or of the same lines: not by a later
@@ -118,12 +173,34 @@ def prune(messages: list[dict], keep: int = KEEP_RECENT_REQUESTS) -> int:
             continue
         new = stub(name, args, content)
         if reread:
-            new = new.replace("earlier; removed", "earlier (read again later); removed")
+            new = new.replace(
+                GONE, "earlier (read again later); removed to save context. Read it again if you need it.]"
+            )
+        elif removed is not None and name in ("read_file", "web_fetch"):
+            what = str(args.get("path") or args.get("url") or "")
+            if what and what not in removed:
+                removed.append(what)
         messages[i]["content"] = new
         saved += len(content) - len(new)
     return saved
 
 
+def note_removed(messages: list[dict], removed: list[str]) -> None:
+    """Tell the model, next to the request it's working on, which files it no longer has: a stub deep in the
+    conversation is easy to overlook, and models then answer from memory instead of reading again."""
+    if not removed:
+        return
+    for message in reversed(messages):
+        content = str(message.get("content", ""))
+        if message.get("role") == "user" and not content.startswith(("[lcode]", SUMMARY_PREFIX)):
+            names = ", ".join(removed[:10]) + (f" and {len(removed) - 10} more" if len(removed) > 10 else "")
+            message["content"] = (
+                f"{content}\n\n[lcode] To make room, lcode removed what you read earlier from: {names}. It isn't in "
+                "this conversation any more: read it again before answering anything about it, don't answer from memory."
+            )
+            return
+
+
 # ----------------------------------------------------------------------------- long output
 
 

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 "")
         )
 
@@ -242,7 +243,8 @@ def context_command(agent: Agent, arg: str, hardware: Hardware) -> None:
     c.print(
         f"In use: {format_tokens(agent.ctx_used)} of {format_tokens(s.context)} tokens "
         f"({100 * agent.ctx_used / s.context:.0f}%) in {len(agent.messages)} message"
-        f"{'' if len(agent.messages) == 1 else 's'}; auto-compacts at 85%."
+        f"{'' if len(agent.messages) == 1 else 's'}; makes room at {format_tokens(agent.compact_limit())} "
+        + ("(compact_at)." if agent.compact_limit() < AUTO_COMPACT_RATIO * s.context else "(85%).")
     )
     if agent.mcp and agent.mcp.ready():
         how = "found on demand" if agent.mcp.searching(s.context) else "sent with every request"
@@ -934,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'}.")
@@ -1109,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()
@@ -1134,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/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/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.26.0.dist-info → lcode_cli-0.28.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.26.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.26.0.dist-info → lcode_cli-0.28.0.dist-info}/RECORD

@@ -1,20 +1,20 @@
-lcode/__init__.py,sha256=xjCrbnr5jMJNipwGklkGM9ZGwF83DFfVEQPHFTwk3IY,473
+lcode/__init__.py,sha256=OG44SXHF0F_qxUeC9BH5G84cellTu3wqLwxsfUfYdUU,473
 lcode/__main__.py,sha256=s5N5pryX2FAu93GGZ3FxUrIXHWGzxz66lKUoaV_h8Ws,35
 lcode/acp.py,sha256=Tpc8lsvffZSYbTRI4t7X4E2chahqZIPcKeYIcL5bV3Y,29035
 lcode/action.py,sha256=wuT5F9EJCdEligPeytzmEi8FpahWBhXer528tpuTj_k,16711
-lcode/agent.py,sha256=kAjvCq2XrXqNVyrwbgLhG0XOtXdY0TVk-ty2Oou6hnk,56297
-lcode/api.py,sha256=i6mxPCkD1ObrVQQeJ7LacEtsjuhQFdV21fM9FTj3hrg,15418
+lcode/agent.py,sha256=HFdmGXK_3oHu57L15z2dmJsQTj_ddjRDq7JnxM1Qq34,63045
+lcode/api.py,sha256=kYq7RghkNyf-A7qsZh6AeMzLoZbc9rTobsFRLtAcvD8,15480
 lcode/backends.py,sha256=dtJHrC6ys73bRDg64z0tQz1PavmeAkiODZu1fOO9ExQ,20635
 lcode/bench.py,sha256=7ICipu_2GXW6vE519XeZucc2GSWA44votT8JvqcNv1k,40964
 lcode/bench_backend.py,sha256=X2fo-zRX92Xp3KMxSsFlWioc2vRupBTtowj5kLME8mw,14287
 lcode/bench_runtime.py,sha256=EjzNgIvUkdbT8cbSy1TpmlyeIk6e-ipjlDFpM7Dnqx0,6835
 lcode/catalog.py,sha256=pZ1azX9OH2r4JE2c6E5OfwywpgS39-W2oXzoCHJhmtM,4141
 lcode/checkpoints.py,sha256=eqPtmPe44-aweWqc2H21ROogwzIt3NpvcUobsaCHoGY,18354
-lcode/cli.py,sha256=cH5mcYi54Aofcv0PDNgFmFFQX8OQjhwTGdbWMUM_FG8,40289
+lcode/cli.py,sha256=M6Mjd5BROSGlZj4J6TrSZMJqI-OVfUEWPoC0TQyOQ28,40831
 lcode/clipboard.py,sha256=nTSdJyCXPdtjH947RjvB3QvRqnL5HZsS9KB8EkC42cc,5138
 lcode/codesearch.py,sha256=Io8leN1nb_Y-Dvlm9xaGtwUWYXX-ooswuznJV6dGU1s,10766
-lcode/config.py,sha256=g7oT5ElKonmbR7_4itgJllTp81wGEYZy1fRZJnAvzOw,10481
-lcode/context.py,sha256=qJymLE3eYeaF6qVOzlUwDURqlky__8cskl_6vXeU3AA,10701
+lcode/config.py,sha256=q1zGzH3p5U23ai6O9Jai3dS-s30CuQ9gc5cWX0_yxWE,11195
+lcode/context.py,sha256=_f0NbXyjA4SyH2RCr49AiWwtAfr_PVDaqyFQ5fZDhkg,14404
 lcode/extensions.py,sha256=W0HFDl0BvROzr7i_qtabHdIbacBgP5o5qIJLzoM2oNE,16806
 lcode/frontmatter.py,sha256=Bx0n4vLPhp7ZCWx-g7xqzqNy5VoKBxyeeikh5UFB_gA,2441
 lcode/gitflow.py,sha256=6j_nnCBZXkX1qhTI7K4CyZ5D0NAZLpH96weFEo64AkQ,27913
@@ -31,13 +31,14 @@ lcode/permissions.py,sha256=i04YLtqYCxwApgawomPp4d35uk9HAJtpKY__gfw8j9s,6347
 lcode/planning.py,sha256=Q2upaoZPnXDMQT2F-ETxX1lk_wDntTzhSKNVYIQSoQA,6540
 lcode/render.py,sha256=gMvf4W3qkLUJ4Vot3az_hP_zRDAItJC9pP-68dHFkfA,1375
 lcode/repeats.py,sha256=uzyAewX03nJf5dKwYFH4y9ZDnh0Lvy2k0qC2vdntM5Y,4061
-lcode/repl.py,sha256=ZKd4l4wDGKHVaGz8bxjLGc2gRc2W-RpHPQYG9M2A_Zw,49441
+lcode/repl.py,sha256=Et8Tf4COLJ9_FsXtjcOciah_33lLgUS5sl4QAer1m8Y,50652
 lcode/repomap.py,sha256=1GRJgEUjBl9XHSXsF7tSGXBCEgsY-3CzwMohaTudZ_M,13969
+lcode/residency.py,sha256=bDB2J0SZULDOz6wYuMCnkjacYk7pWi5f75iY83ycAXQ,6912
 lcode/sandbox.py,sha256=u_pkrVRXhCGhh-wFDPwuZ3jGG7UeXxXRAeBNsm37ZvE,8608
 lcode/secretscan.py,sha256=6Euvfk2gCtK7lZbuQD84zgWuSECi6OnSw8V5rFu1tfU,13575
 lcode/sessions.py,sha256=wOR-J0EHgJxLSPboKPHnvBcp5VTUYTj3tZWgpsa6-K4,4013
 lcode/subagents.py,sha256=Z2RHp7an16dhOGReucVIEOAnXjxM8jx7sHvWd_Fp2V4,29142
-lcode/tools.py,sha256=jqxMcyvvDZs0rV0AROYxpJ4krxbU6LbkOWnxiLEqq1o,48426
+lcode/tools.py,sha256=OFltvnRZlSUMtzNLEUF84RFoyKQkAFpb7_ZBVhVcVp4,48426
 lcode/update.py,sha256=i92bnW252VneYh0vD6djxmXsDOa5MXP20bjlLZUue_c,25236
 lcode/vision.py,sha256=w33QPmdGwP33wM4mvmAH4amFDZ1xzeXhEsSLJ-STSHY,4243
 lcode/web.py,sha256=vyxKbSRJTl1Lj3hj7Yd_NwTgbv0Xi6dup2YfUXjqp-Y,14579
@@ -57,8 +58,8 @@ lcode/servers/__init__.py,sha256=qrIhxEodEB8cjKEQ4Cicc0GsQhE2OH-9qlVHzr3-tq8,77
 lcode/servers/encord.py,sha256=WSauawL1UKYZCUAG1oalcKL_An3DVof-JM6xIgFyQSE,12769
 lcode/servers/valohai.py,sha256=e5xZGIoa4cja4f5i85q1GpL9c7cglUjV8jN2co1CFMY,14430
 lcode/servers/xai.py,sha256=h2emAvHSnkuB9WmJInlynsDhvxJwNVD2AHFX7vqMXNc,13627
-lcode_cli-0.26.0.dist-info/METADATA,sha256=iHy2mJa4Bk0LVY3hiDAkHxhBs2uqk21--IGY27MaePw,12620
-lcode_cli-0.26.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.26.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
-lcode_cli-0.26.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.26.0.dist-info/RECORD,,
+lcode_cli-0.28.0.dist-info/METADATA,sha256=b-CcZWIZTz_P0M5H9xP1cwtQpICZpHlaGWdBRlSB52U,12620
+lcode_cli-0.28.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.28.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
+lcode_cli-0.28.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.28.0.dist-info/RECORD,,