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

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

@@ -6,6 +6,52 @@ 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
+
+- Long sessions are summarized earlier: once the conversation reaches 64K tokens (`compact_at`),
+  even when the window is larger. Before, a 256K window was summarized only at about 220K, far past
+  where small models work well. lcode still removes old tool output first, and summarizes only if
+  that's not enough. `lcode config set compact_at 0` keeps only the 85% rule, and
+  `lcode bench --compact-at` compares ceilings. Measured with qwen3.6-35b: making room earlier
+  doesn't cost tasks (21 of 24 either way) and saved 17% of the time. See
+  [Context management](https://nasser1941.github.io/lcode/how-it-works/#context-management).
+- Summaries keep your latest requests (up to eight) word for word, so the goal survives the
+  retelling. `/context` shows where the session makes room.
+
+### Fixed
+
+- After lcode removed an earlier file read to make room, the model sometimes answered questions
+  about that file from memory, and got them wrong, instead of reading it again. The files whose
+  only copy went are now named next to the request it's working on, and the note in their place
+  says plainly that the content is gone. A conversation that was just summarized isn't summarized
+  again until it has grown by a quarter of `compact_at`, which must be at least 16K (or 0).
+
 ## [0.26.0] - 2026-10-10
 
 ### Added
@@ -553,7 +599,9 @@ 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.26.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
 [0.24.0]: https://github.com/nasser1941/lcode/compare/v0.23.0...v0.24.0

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

@@ -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 → lcode_cli-0.28.0}/docs/bench.md

@@ -51,7 +51,7 @@ Each task normally starts a new conversation. `--session` runs them all in **one
 instead, as a long working session would, so the context fills up and lcode's
 [context management](how-it-works.md#context-management) has to work: the summary shows how often
 it removed old tool output and how often it summarized the conversation. `--no-prune` turns the
-removal off, to compare.
+removal off, to compare, and `--compact-at` sets the ceiling (`--compact-at 0`: only at 85%).
 
 ```bash
 lcode bench --context 32k --session --rounds 3
@@ -74,6 +74,17 @@ at no measurable cost in tasks solved or time. The bench tasks are independent o
 which is where summaries hurt least; in a real session, where later requests build on earlier
 ones, keeping the conversation intact matters more.
 
+With a large window, `compact_at` decides when lcode makes room. In a 128K window, 24 tasks in one
+conversation reach about 40K tokens, so the default ceiling of 64K never comes into play. Making
+room earlier than needed doesn't cost tasks:
+
+| 128K window, 24 tasks | No room made (peak ~40K) | `--compact-at 32k` |
+|---|---|---|
+| Conversation summarized | 0 times | 1 time (old tool output removed once) |
+| Tasks solved | 21 of 24 | 21 of 24 |
+| Time | 33 min | 27.5 min |
+| Average prompt | 22.9K tokens | 16.6K tokens |
+
 ## The tasks
 
 Every task runs in a new temporary folder, with every permission granted (`yolo` mode) and web

{lcode_cli-0.26.0 → lcode_cli-0.28.0}/docs/configuration.md

@@ -37,6 +37,7 @@ lcode config path                      # print the file location
 | `repo_map` | `true` | Give the model a ranked [map of the repository](search.md) |
 | `embed_model` | `auto` | Embedding model for [semantic code search](search.md#semantic-code-search): `auto`, `off` or a model name |
 | `lsp` | `auto` | Use installed [language servers](lsp.md) for code navigation and errors after edits: `auto` or `off` |
+| `compact_at` | `65536` | Make room (prune, then summarize) once the conversation reaches this many tokens, even in a larger window (at least 16K); `0` leaves only the 85% rule ([why](how-it-works.md#context-management)) |
 | `prune` | `true` | When the context is 85% full, first remove old tool output, and summarize the conversation only if that's not enough ([how](how-it-works.md#context-management)) |
 | `subagents` | `true` | Let the model hand tasks to [subagents](agents.md) with their own context |
 | `max_parallel_agents` | `1` | Subagents that run at the same time; more needs `OLLAMA_NUM_PARALLEL` on the Ollama server ([details](agents.md#several-at-once)) |

{lcode_cli-0.26.0 → lcode_cli-0.28.0}/docs/how-it-works.md

@@ -73,21 +73,32 @@ in a temporary git worktree, and their changes come back as a diff.
 ## Context management
 
 Ollama keeps the processed conversation in its KV cache, so each turn only processes the new tokens.
-lcode tracks how full the window is from Ollama's token counts. Most of a long session's context is
-old tool output, so when the window is 85% full:
+lcode tracks how full the window is from Ollama's token counts. It makes room when the window is
+85% full, or when the conversation reaches 64K tokens (`compact_at`), whichever comes first.
+Small models lose track in long contexts well before a large window is full: in one long session,
+Qwen3.6 35B started repeating itself and overlooking what it had read once the conversation passed
+about 75K tokens. Most of a long session's
+context is old tool output, so:
 
 1. **lcode removes old tool output first.** File contents, command output and search results from
    before your last two requests become one-line notes that say what was there, such as
-   `[lcode: read src/app.py earlier; removed to save context. Read it again if you need it.]`.
+   `[lcode: read src/app.py earlier; its content was removed …. Read it again before answering anything about it.]`.
    An earlier copy of a file that was read again later goes too, even in recent requests. Subagent
-   reports, skill instructions and the approved plan stay.
-2. **If that brings the conversation under 70%,** the work simply continues: nothing is summarized,
+   reports, skill instructions and the approved plan stay. The files whose only copy went are also
+   named next to the request the model is working on, since models tend to overlook a note deep in
+   the conversation and answer from memory instead of reading the file again.
+2. **If that brings the conversation well under the limit** (70% of the window, or about 53K
+   tokens with `compact_at`), the work simply continues: nothing is summarized,
    and the conversation itself stays word for word.
    If it's not, lcode also removes the tool output of your previous request, keeping only the
    latest one's. (`lcode config set prune false` skips this step.)
 3. **Otherwise lcode summarizes.** It asks whether anything is worth [remembering](memory.md), since
    the summary leaves details out, then has the model write a summary of the conversation (goals,
-   findings, files changed, next steps) and continues from it.
+   findings, files changed, next steps) and continues from it. Your latest requests (up to eight)
+   are kept word for word under the summary, so the goal isn't lost in the retelling.
+
+`lcode config set compact_at 128k` moves the ceiling, and `0` turns it off, leaving only the 85%
+rule. `/context` shows where the current session makes room.
 
 Long tool output (over 30,000 characters) keeps its beginning, its end and the lines in between
 that look like errors. The full output is saved under `~/.local/state/lcode/outputs/` (for a week)

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

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

{lcode_cli-0.26.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.26.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.26.0"
+__version__ = "0.28.0"
 
 API = ("Session", "Result", "Options", "SetupError")
 

{lcode_cli-0.26.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)[/]"
         )
@@ -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_cli-0.26.0 → lcode_cli-0.28.0}/src/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-0.26.0 → lcode_cli-0.28.0}/src/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_cli-0.26.0 → lcode_cli-0.28.0}/src/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":