lcode-cli 0.11.1__tar.gz → 0.12.0__tar.gz

{lcode_cli-0.11.1 → lcode_cli-0.12.0}/CHANGELOG.md

@@ -6,6 +6,28 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.12.0] - 2026-10-05
+
+### Added
+
+- `/context` shows what uses the context window, by category: the system prompt and its parts
+  (`AGENTS.md`, memory notes, skills, MCP servers), tool definitions, your messages, attached files,
+  the model's replies and each tool's results.
+- `lcode bench --session` runs all tasks in one conversation, to test long sessions and context
+  management; `--rounds N` repeats the tasks and `--no-prune` turns the removal of old tool output
+  off, to compare.
+
+### Changed
+
+- Smarter context management, which matters most at 32K. When the window is 85% full, lcode first
+  replaces old tool output (file contents, command output, search results from before your last
+  two requests, and earlier copies of files that were read again) with one-line notes saying what
+  was there, then the output of your previous request if needed; it summarizes the conversation
+  only if that doesn't free enough room. Measured on 24-task sessions at 32K: fewer summaries, with
+  about as many tasks solved. The `prune` setting turns it off.
+- Long command and MCP output keeps its beginning, its end and the lines that look like errors;
+  the full output is saved to a file the model can read.
+
 ## [0.11.1] - 2026-10-05
 
 ### Fixed
@@ -311,7 +333,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.11.1...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.12.0...HEAD
+[0.12.0]: https://github.com/nasser1941/lcode/compare/v0.11.1...v0.12.0
 [0.11.1]: https://github.com/nasser1941/lcode/compare/v0.11.0...v0.11.1
 [0.11.0]: https://github.com/nasser1941/lcode/compare/v0.10.0...v0.11.0
 [0.10.0]: https://github.com/nasser1941/lcode/compare/v0.9.0...v0.10.0

{lcode_cli-0.11.1 → lcode_cli-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.11.1
+Version: 0.12.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/
@@ -201,7 +201,6 @@ fills up. Details: [How it works](https://nasser1941.github.io/lcode/how-it-work
 
 See the pinned [Roadmap issue](https://github.com/nasser1941/lcode/issues/10). Next up:
 
-- [Smarter context for small windows](https://github.com/nasser1941/lcode/issues/46)
 - [Code intelligence with language servers](https://github.com/nasser1941/lcode/issues/44)
 - [A repository map and semantic search with local embeddings](https://github.com/nasser1941/lcode/issues/45)
 - [Hooks and permission rules](https://github.com/nasser1941/lcode/issues/43)

{lcode_cli-0.11.1 → lcode_cli-0.12.0}/README.md

@@ -165,7 +165,6 @@ fills up. Details: [How it works](https://nasser1941.github.io/lcode/how-it-work
 
 See the pinned [Roadmap issue](https://github.com/nasser1941/lcode/issues/10). Next up:
 
-- [Smarter context for small windows](https://github.com/nasser1941/lcode/issues/46)
 - [Code intelligence with language servers](https://github.com/nasser1941/lcode/issues/44)
 - [A repository map and semantic search with local embeddings](https://github.com/nasser1941/lcode/issues/45)
 - [Hooks and permission rules](https://github.com/nasser1941/lcode/issues/43)

{lcode_cli-0.11.1 → lcode_cli-0.12.0}/docs/bench.md

@@ -31,6 +31,35 @@ At the end it prints a table comparing the models (see [results](#results-on-a-1
 
 A model usually takes 4 to 12 minutes; each task stops after 5 minutes (`--timeout`).
 
+### Long sessions
+
+Each task normally starts a new conversation. `--session` runs them all in **one** conversation
+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.
+
+```bash
+lcode bench --context 32k --session --rounds 3
+lcode bench --context 32k --session --rounds 3 --no-prune
+```
+
+`--rounds 3` runs the tasks three times, 24 in one conversation, which fills a 32K window several
+times over. With qwen3.6-35b on a 12 GB laptop (two runs each; runs vary a lot from one to the
+next):
+
+| | Removing old tool output first | Summarizing only (`--no-prune`) |
+|---|---|---|
+| Conversation summarized | 1 and 2 times | 1 and 3 times |
+| Old tool output removed | 3 times in each run | — |
+| Tasks solved | 21 and 22 of 24 | 23 and 21 of 24 |
+| Time | 26 and 28 min | 21 and 30 min |
+
+Removing old tool output means fewer summaries, so more of the conversation stays word for word,
+at no measurable cost in tasks solved or time. The bench tasks are independent of each other,
+which is where summaries hurt least; in a real session, where later requests build on earlier
+ones, keeping the conversation intact matters more.
+
 ## The tasks
 
 Every task runs in a new temporary folder, with every permission granted (`yolo` mode) and web

{lcode_cli-0.11.1 → lcode_cli-0.12.0}/docs/configuration.md

@@ -32,6 +32,7 @@ lcode config path                      # print the file location
 | `mcp_tools` | `auto` | How [MCP](mcp.md#context) tool definitions reach the model: `auto`, `direct` or `search` (on demand) |
 | `memory` | `ask` | [Notes that carry over](memory.md) to later sessions: `ask` (confirm each), `auto` or `off` |
 | `skills` | `all` | Which [skills](commands.md#skills) the model is offered: `all` (lcode's folders and the ones other agents share), `lcode` (only `.lcode/skills/` and `~/.config/lcode/skills/`) or `off` |
+| `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)) |
 | `checkpoints` | `true` | Save a checkpoint before the model changes files, so [`/undo`](usage.md#undo-and-checkpoints) can restore them |
@@ -78,6 +79,7 @@ Environment variables override the file, which is useful for one-off runs and CI
 | `~/.config/lcode/commands/`, `~/.config/lcode/skills/` | Your [commands and skills](commands.md) (a repository's go in `.lcode/`) |
 | `~/.local/state/lcode/extensions-approved.json` | Repositories whose commands, skills and agents you approved |
 | `~/.config/lcode/agents/` | Your [custom agents](agents.md#custom-agents) (a repository's go in `.lcode/agents/`) |
+| `~/.local/state/lcode/outputs/` | The full text of long command output that was cut short for the model (kept a week) |
 | `~/.local/state/lcode/limits.json` | Context sizes that ran out of GPU memory on this machine (safe to delete) |
 
 Sessions contain everything the model read, including file contents. Delete the folder to clear them.

{lcode_cli-0.11.1 → lcode_cli-0.12.0}/docs/how-it-works.md

@@ -41,11 +41,27 @@ 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. At 85% it asks the model to write a
-summary of the conversation (goals, findings, files changed, next steps) and continues from that
-summary. Just before that, it asks whether anything from the conversation is worth
-[remembering](memory.md), since the summary leaves details out. Tool outputs are capped at 30,000
-characters (head and tail kept) so one noisy command can't flood the window.
+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:
+
+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.]`.
+   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,
+   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.
+
+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)
+and the model is told where, so it can read the rest if it needs to. `/context` shows what's using
+the window, by category: the system prompt and its parts, tool definitions, your messages, attached
+files, the model's replies and each tool's results.
 
 ## Memory sizing
 

{lcode_cli-0.11.1 → lcode_cli-0.12.0}/docs/quickstart.md

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

{lcode_cli-0.11.1 → lcode_cli-0.12.0}/docs/usage.md

@@ -67,7 +67,7 @@ reasoning is on.
 | `/mcp [tools\|login\|restart NAME]` | [MCP servers](mcp.md), their status and tools |
 | `/plan [request]` | Work out a [plan](#plan-mode) before changing anything, or show the approved plan |
 | `/compact [focus]` | Summarize the conversation to free context |
-| `/context [size]` | Show how full the context window is and change its size: pick from a list with memory estimates, or give a size like `/context 128k` (`/ctx` is a shortcut) |
+| `/context [size]` | Show how full the context window is, what's using it (by category), and change its size: pick from a list with memory estimates, or give a size like `/context 128k` (`/ctx` is a shortcut) |
 | `/model [name]`, `/models` | Switch model, list models |
 | `/think [on\|off]` | Toggle reasoning |
 | `/verbose` | Toggle showing the reasoning text |

{lcode_cli-0.11.1 → lcode_cli-0.12.0}/pyproject.toml

@@ -78,6 +78,7 @@ ignore = [
 "src/lcode/subagents.py" = ["E501"]
 "src/lcode/planning.py" = ["E501"]
 "src/lcode/extensions.py" = ["E501"]
+"src/lcode/context.py" = ["E501"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

{lcode_cli-0.11.1 → lcode_cli-0.12.0}/src/lcode/__init__.py

@@ -1,3 +1,3 @@
 """lcode — a local-first terminal coding agent powered by open-weight models via Ollama."""
 
-__version__ = "0.11.1"
+__version__ = "0.12.0"

{lcode_cli-0.11.1 → lcode_cli-0.12.0}/src/lcode/agent.py

@@ -22,6 +22,7 @@ from rich.panel import Panel
 from rich.text import Text
 
 from lcode import catalog, extensions, limits, planning, sessions, subagents, vision, web
+from lcode import context as context_tools
 from lcode import memory as memory_notes
 from lcode.checkpoints import Checkpoints
 from lcode.config import format_tokens
@@ -50,6 +51,7 @@ SAFE_NUM_BATCH = 512  # Ollama's default prompt batch
 MAX_STEPS_PER_TURN = 150
 MAX_MALFORMED_CALL_RETRIES = 2  # Ollama rejects tool calls whose arguments aren't valid JSON  # safety cap on tool-call iterations for one request
 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
 PROJECT_FILES = ("AGENTS.md", "LCODE.md", "CLAUDE.md")
 
 SYSTEM_PROMPT = """You are lcode, an autonomous software-engineering agent running in the user's terminal on their own machine, powered by the local model {model}. You help the user understand codebases, answer questions about code, write scripts (Python by default), fix bugs, refactor, and run commands.
@@ -173,6 +175,7 @@ class Settings:
     subagents: bool = False  # the agent tool (lcode.subagents)
     trust_project: bool = False  # use the repository's own commands, skills and agents (lcode.extensions)
     skills: str = "off"  # all, lcode (only lcode's own skill folders) or off
+    prune: bool = True  # remove old tool output before summarizing (lcode.context)
     max_parallel_agents: int = 1
 
 
@@ -202,6 +205,7 @@ class Agent:
         self._agent_types: tuple[Path, dict[str, subagents.AgentType], list[str]] | None = None
         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._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):
@@ -775,9 +779,24 @@ class Agent:
 
     # -- context management
     def maybe_compact(self) -> None:
-        if self.ctx_used > AUTO_COMPACT_RATIO * self.settings.context:
-            self.console.print("[yellow]Context is nearly full — compacting the conversation…[/]")
-            self.compact()
+        if self.ctx_used <= AUTO_COMPACT_RATIO * self.settings.context:
+            return
+        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
+            if saved:
+                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:
+                    return
+        self.console.print("[yellow]Context is nearly full — compacting the conversation…[/]")
+        self.compacted += 1
+        self.compact()
 
     def compact(self, focus: str = "") -> None:
         if len(self.messages) <= 2:

{lcode_cli-0.11.1 → lcode_cli-0.12.0}/src/lcode/bench.py

@@ -784,6 +784,9 @@ class ModelRun:
     tasks: list[TaskResult] = field(default_factory=list)
     error: str | None = None  # the model couldn't run at all
     interrupted: bool = False
+    session: bool = False  # all tasks in one conversation (--session)
+    pruned: int = 0  # times old tool output was removed to make room
+    compacted: int = 0  # times the conversation was summarized
 
     @property
     def passed(self) -> int:
@@ -847,14 +850,28 @@ def count_tool_errors(messages: list[dict]) -> int:
 
 
 def run_task(
-    ollama: Ollama, settings: Settings, task: Task, timeout: float, log: Console, keep: bool, usage: dict
+    ollama: Ollama,
+    settings: Settings,
+    task: Task,
+    timeout: float,
+    log: Console,
+    keep: bool,
+    usage: dict,
+    agent: Agent | None = None,
 ) -> TaskResult:
+    """Run one task in a new folder: in a new conversation, or continuing `agent`'s (--session)."""
     folder = Path(tempfile.mkdtemp(prefix=f"lcode-bench-{task.id}-"))
     try:
         for rel, content in task.files.items():
             (folder / rel).parent.mkdir(parents=True, exist_ok=True)
             (folder / rel).write_text(content)
-        agent = Agent(ollama, settings, folder, console=log)
+        if agent is None:
+            agent = Agent(ollama, settings, folder, console=log)
+        else:  # the same conversation moves on to this task's folder, as with /cd
+            agent.cwd = folder.resolve()
+            agent.messages[0]["content"] = agent.system_prompt()
+        before = dict(agent.usage)
+        first = len(agent.messages)
         error = None
         started = time.monotonic()
         try:
@@ -866,7 +883,7 @@ def run_task(
             error = str(e).splitlines()[0][:200]
         seconds = time.monotonic() - started
         for key, value in agent.usage.items():
-            usage[key] = usage.get(key, 0) + value
+            usage[key] = usage.get(key, 0) + value - before.get(key, 0)
         answer = next((m.get("content", "") for m in reversed(agent.messages) if m.get("role") == "assistant"), "")
         try:
             check = task.check(folder, answer)
@@ -882,8 +899,8 @@ def run_task(
         passed=check.passed and error is None,
         seconds=round(seconds, 1),
         detail=error or check.detail,
-        steps=sum(1 for m in agent.messages if m.get("role") == "assistant"),
-        tool_errors=count_tool_errors(agent.messages),
+        steps=agent.usage["requests"] - before.get("requests", 0),
+        tool_errors=count_tool_errors(agent.messages[first:] if len(agent.messages) > first else agent.messages),
         error=error,
     )
 
@@ -940,8 +957,10 @@ def run_model(
     timeout: float = DEFAULT_TIMEOUT,
     keep: bool = False,
     verbose: bool = False,
+    session: bool = False,
 ) -> ModelRun:
-    run = ModelRun(name, settings.model, settings.context, settings.num_batch, settings.think)
+    run = ModelRun(name, settings.model, settings.context, settings.num_batch, settings.think, session=session)
+    shared: Agent | None = None  # with --session, one conversation for all tasks
     console.print(
         f"\n[bold]{escape(settings.model)}[/] · {format_tokens(settings.context)} context · "
         f"reasoning {'on' if settings.think else 'off'} · {len(tasks)} task{'' if len(tasks) == 1 else 's'}"
@@ -969,13 +988,17 @@ def run_model(
     console.print(f"  [dim]Loaded in {run.load_seconds:.0f}s{where}{reads}[/]")
     for task in tasks:
         log = console if verbose else Console(file=io.StringIO(), width=120, force_terminal=False)
+        if session and shared is None:
+            shared = Agent(ollama, settings, Path(tempfile.gettempdir()), console=log)
+        if shared is not None:
+            shared.console = log
         try:
             if verbose:
                 console.rule(f"{task.id}: {task.title}")
-                result = run_task(ollama, settings, task, timeout, log, keep, run.usage)
+                result = run_task(ollama, settings, task, timeout, log, keep, run.usage, shared)
             else:
                 with console.status(Elapsed(f"  {task.id:<13} {task.title}")):
-                    result = run_task(ollama, settings, task, timeout, log, keep, run.usage)
+                    result = run_task(ollama, settings, task, timeout, log, keep, run.usage, shared)
         except KeyboardInterrupt:
             console.print("  [yellow]Stopped.[/]")
             run.interrupted = True
@@ -985,6 +1008,8 @@ def run_model(
         console.print(
             f"  {mark} {task.id:<13} {task.title:<32} {result.seconds:>5.0f}s  [dim]{escape(result.detail)}[/]"
         )
+        if shared is not None:
+            run.pruned, run.compacted = shared.pruned, shared.compacted
     if run.memory_gb is None:
         run.memory_gb, run.gpu_percent = memory_use(ollama, settings.model)
     # lcode lowers the batch size or context if the GPU runs out of memory; report what was used.
@@ -1001,11 +1026,12 @@ def duration(seconds: float) -> str:
 
 def summary_rows(runs: list[ModelRun], tasks: list[Task]) -> list[tuple[str, list[str]]]:
     rows = []
-    for task in tasks:
+    for task in {t.id: t for t in tasks}.values():  # with --rounds a task runs several times: one row, a mark each
         cells = []
         for run in runs:
-            result = next((t for t in run.tasks if t.id == task.id), None)
-            cells.append("" if result is None else f"{'✓' if result.passed else '✗'} {duration(result.seconds)}")
+            results = [t for t in run.tasks if t.id == task.id]
+            marks = "".join("✓" if r.passed else "✗" for r in results)
+            cells.append(f"{marks} {duration(sum(r.seconds for r in results))}" if results else "")
         rows.append((f"{task.id}: {task.title}", cells))
 
     def cell(run: ModelRun, value: str) -> str:
@@ -1023,6 +1049,13 @@ def summary_rows(runs: list[ModelRun], tasks: list[Task]) -> list[tuple[str, lis
         ),
         ("Context", [cell(r, format_tokens(r.context)) for r in runs]),
     ]
+    if any(r.session for r in runs):
+        rows.append(
+            (
+                "One conversation",
+                [cell(r, f"pruned {r.pruned}×, summarized {r.compacted}×" if r.session else "no") for r in runs],
+            )
+        )
     return rows
 
 

{lcode_cli-0.11.1 → lcode_cli-0.12.0}/src/lcode/cli.py

@@ -436,7 +436,7 @@ def cmd_bench(args) -> None:
     try:
         cfg = config.load()
         context = parse_context(args.context) if args.context else bench.DEFAULT_CONTEXT
-        tasks = bench.select_tasks(args.tasks)
+        tasks = bench.select_tasks(args.tasks) * max(1, args.rounds)
     except (ConfigError, ValueError) as e:
         fail(str(e))
     if args.timeout <= 0:
@@ -483,8 +483,11 @@ def cmd_bench(args) -> None:
             permission_mode="yolo",
             web="off",
             checkpoints=False,
+            prune=not args.no_prune,
+        )
+        run = bench.run_model(
+            ollama, name, settings, tasks, console, args.timeout, args.keep, args.verbose, args.session
         )
-        run = bench.run_model(ollama, name, settings, tasks, console, args.timeout, args.keep, args.verbose)
         runs.append(run)
         if run.interrupted:
             break
@@ -566,6 +569,7 @@ def cmd_chat(args) -> None:
         max_parallel_agents=cfg["max_parallel_agents"],
         trust_project=trust_project,
         skills=cfg["skills"],
+        prune=cfg["prune"],
     )
     agent = Agent(ollama, settings, cwd, console=console)
     agent.interactive = not args.prompt
@@ -651,6 +655,15 @@ def build_subparsers() -> dict[str, argparse.ArgumentParser]:
     p.add_argument("--keep", action="store_true", help="keep each task's folder and transcript for inspection")
     p.add_argument("-v", "--verbose", action="store_true", help="show the model working, like a normal session")
     p.add_argument("--list", action="store_true", help="list the tasks and exit")
+    p.add_argument(
+        "--session",
+        action="store_true",
+        help="run all tasks in one conversation, to test a long session and its context management",
+    )
+    p.add_argument(
+        "--rounds", type=int, default=1, help="run the tasks this many times (with --session: a longer session)"
+    )
+    p.add_argument("--no-prune", action="store_true", help="don't remove old tool output (to compare, with --session)")
     subs["bench"] = p
     from lcode.mcp.commands import build_parser as mcp_parser
 

{lcode_cli-0.11.1 → lcode_cli-0.12.0}/src/lcode/config.py

@@ -49,6 +49,7 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "mcp_tools": ("auto", str, "how MCP tools reach the model: auto | direct | search (on demand, saves context)"),
     "memory": ("ask", str, "notes that carry over to later sessions: off | ask (confirm each) | auto"),
     "skills": ("all", str, "skills to offer the model: all (also other agents' folders) | lcode | off"),
+    "prune": (True, bool, "before summarizing a full conversation, first remove old tool output from it"),
     "subagents": (True, bool, "let the model hand tasks to subagents that have their own context"),
     "max_parallel_agents": (1, int, "subagents that may run at the same time (more needs OLLAMA_NUM_PARALLEL)"),
 }