lcode-cli 0.11.1__py3-none-any.whl → 0.12.0__py3-none-any.whl

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/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/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.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/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)"),
 }

lcode/context.py

@@ -0,0 +1,243 @@
+"""Keeping the context window for what matters, which counts most at 32K.
+
+Most of a long session's context is old tool output: files read many turns ago, command output that
+was already acted on. Before lcode summarizes a conversation (which loses detail), it prunes that:
+old tool results become one-line stubs that say what was there and how to get it back, and earlier
+reads of a file that was read again later go too. Recent requests are left alone.
+
+Long tool output is cut smarter: the head, the tail and the lines that look like errors stay, and the
+full output is saved to a file the model can read if it needs more.
+
+`breakdown` shows what uses the context, by category, for /context.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from lcode import config
+from lcode.sessions import SUMMARY_PREFIX
+
+if TYPE_CHECKING:
+    from lcode.agent import Agent
+
+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
+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
+)
+MAX_ERROR_LINES = 40
+OUTPUT_DAYS = 7  # saved full outputs are deleted after this
+
+
+# ----------------------------------------------------------------------------- pruning
+
+
+def calls_for_results(messages: list[dict]) -> dict[int, tuple[str, dict]]:
+    """For each tool message (by index), the name and arguments of the call it answers."""
+    from lcode.agent import call_arguments
+
+    found: dict[int, tuple[str, dict]] = {}
+    pending: list[tuple[str, dict]] = []
+    for i, message in enumerate(messages):
+        if message.get("role") == "assistant":
+            pending = [
+                (c.get("function", {}).get("name", ""), call_arguments(c)) for c in message.get("tool_calls") or []
+            ]
+        elif message.get("role") == "tool":
+            found[i] = pending.pop(0) if pending else (message.get("tool_name", ""), {})
+    return found
+
+
+def stub(name: str, args: dict, content: str) -> str:
+    """A one-line stand-in for an old tool result."""
+    if name == "read_file":
+        span = ""
+        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.]"
+    if name == "bash":
+        command = " ".join(str(args.get("command", "")).split())
+        command = command if len(command) <= 80 else command[:79] + "…"
+        code = re.search(r"\[exit code: (-?\d+)\]\s*$", content)
+        status = f", exit code {code.group(1)}" if code else ""
+        return f"{PRUNED}ran `{command}` earlier{status}; its output was removed to save context.]"
+    if name in ("grep", "glob", "list_dir"):
+        what = args.get("pattern") or args.get("path") or ""
+        return f"{PRUNED}{name}({what}) results removed to save context; run it again if needed.]"
+    if name == "web_fetch":
+        return f"{PRUNED}fetched {args.get('url', 'a page')} earlier; its text was removed to save context.]"
+    if name == "web_search":
+        return f"{PRUNED}search results for {args.get('query', '')!r} removed to save context.]"
+    if name == "view_image":
+        return f"{PRUNED}the description of {args.get('path', 'an image')} was removed to save context.]"
+    return f"{PRUNED}{name} result removed to save context.]"
+
+
+def boundary(messages: list[dict], keep: int = KEEP_RECENT_REQUESTS) -> int:
+    """The index of the oldest of the last `keep` requests from the user (results after it stay)."""
+    requests = [
+        i
+        for i, m in enumerate(messages)
+        if m.get("role") == "user" and not str(m.get("content", "")).startswith(("[lcode]", SUMMARY_PREFIX))
+    ]
+    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."""
+    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
+    # read of other lines, which would leave the model without the part it read first.
+    last_full: dict[str, int] = {}
+    last_same: dict[tuple, int] = {}
+    for i, (name, args) in calls.items():
+        if name == "read_file" and not str(messages[i].get("content", "")).startswith("Error"):
+            path = str(args.get("path", ""))
+            span = (path, int(args.get("offset") or 1), int(args.get("limit") or 0))
+            last_same[span] = i
+            if span[1:] == (1, 0):
+                last_full[path] = i
+    saved = 0
+    for i, (name, args) in calls.items():
+        content = str(messages[i].get("content", ""))
+        if name in KEEP_TOOLS or content.startswith(PRUNED) or len(content) < MIN_PRUNE_CHARS:
+            continue
+        span = (str(args.get("path", "")), int(args.get("offset") or 1), int(args.get("limit") or 0))
+        reread = name == "read_file" and (last_full.get(span[0], i) > i or last_same.get(span, i) > i)
+        if i >= edge and not reread:
+            continue
+        new = stub(name, args, content)
+        if reread:
+            new = new.replace("earlier; removed", "earlier (read again later); removed")
+        messages[i]["content"] = new
+        saved += len(content) - len(new)
+    return saved
+
+
+# ----------------------------------------------------------------------------- long output
+
+
+def outputs_dir() -> Path:
+    return config.STATE_DIR / "outputs"
+
+
+def save_output(text: str, label: str) -> Path | None:
+    """Keep the full text of a long result where the model can read it; old ones are cleaned up."""
+    folder = outputs_dir()
+    try:
+        folder.mkdir(parents=True, exist_ok=True)
+        cutoff = time.time() - OUTPUT_DAYS * 86400
+        for old in folder.glob("*.txt"):
+            if old.stat().st_mtime < cutoff:
+                old.unlink(missing_ok=True)
+        path = folder / f"{time.strftime('%Y%m%d-%H%M%S')}-{re.sub(r'[^a-z0-9]+', '-', label.lower())[:30]}.txt"
+        path.write_text(text)
+        return path
+    except OSError:
+        return None
+
+
+def shorten(text: str, limit: int, label: str = "output") -> str:
+    """Head, tail and the error-looking lines in between; the full text goes to a file."""
+    if len(text) <= limit:
+        return text
+    head, tail = text[: limit * 3 // 5], text[-limit // 4 :]
+    middle = text[len(head) : len(text) - len(tail)]
+    errors, budget = [], limit // 6
+    for line in middle.splitlines():
+        if ERROR_LINE.search(line) and len(errors) < MAX_ERROR_LINES:
+            line = line.strip()[:300]
+            if budget - len(line) < 0:
+                break
+            errors.append(line)
+            budget -= len(line) + 1
+    cut = len(middle) - sum(len(e) + 1 for e in errors)
+    note = f"\n\n... [{cut} characters cut"
+    if errors:
+        note += f"; {len(errors)} line(s) from them that look like errors:]\n" + "\n".join(errors) + "\n[...]\n\n"
+    else:
+        note += "] ...\n\n"
+    saved = save_output(text, label)
+    where = (
+        f"\n[The full {label} ({len(text)} characters) is in {saved}: read parts of it with read_file if you need them.]"
+        if saved
+        else ""
+    )
+    return f"{head}{note}{tail}{where}"
+
+
+# ----------------------------------------------------------------------------- what uses the context
+
+
+@dataclass
+class Part:
+    name: str
+    chars: int
+    detail: str = ""
+
+    @property
+    def tokens(self) -> int:
+        return self.chars // 3
+
+
+def breakdown(agent: Agent) -> list[Part]:
+    """What the next request sends, by category (sizes are estimates: ~3 characters per token)."""
+    from lcode import extensions
+
+    system = agent.messages[0]["content"] if agent.messages else ""
+    pieces = {
+        "AGENTS.md": len(next((system[system.find(h) :] for h in ["\n# Project instructions"] if h in system), "")),
+        "memory notes": len(agent.memory().prompt(agent.settings.context)) if agent.settings.memory != "off" else 0,
+        "skills": len(extensions.skills_prompt(agent.extensions().skills, agent.settings.context)),
+        "MCP servers": len(agent._mcp_prompt),
+    }
+    if pieces["AGENTS.md"]:  # it runs to the end of the prompt, which may include memory and MCP after it
+        pieces["AGENTS.md"] = max(0, pieces["AGENTS.md"] - pieces["memory notes"] - pieces["MCP servers"])
+    parts = [Part("system prompt", len(system) - sum(pieces.values()), "instructions, environment, repository layout")]
+    parts += [Part(name, size) for name, size in pieces.items() if size]
+    schemas = agent.tool_schemas()
+    mcp = [s for s in schemas if agent.mcp and agent.mcp.owns(s["function"]["name"])]
+    parts.append(
+        Part(
+            "tool definitions",
+            len(json.dumps([s for s in schemas if s not in mcp])),
+            f"{len(schemas) - len(mcp)} tools",
+        )
+    )
+    if mcp:
+        parts.append(Part("MCP tool definitions", len(json.dumps(mcp)), f"{len(mcp)} tools"))
+    yours = files = replies = 0
+    results: dict[str, int] = {}
+    calls = calls_for_results(agent.messages)
+    for i, m in enumerate(agent.messages[1:], 1):
+        content = str(m.get("content") or "")
+        if m.get("role") == "user":
+            attached = sum(
+                len(block)
+                for block in re.findall(r"<(?:file|directory|image) path=.*?</(?:file|directory|image)>", content, re.S)
+            )
+            files += attached
+            yours += len(content) - attached
+        elif m.get("role") == "assistant":
+            replies += len(content) + len(json.dumps(m.get("tool_calls") or []))
+        elif m.get("role") == "tool":
+            name = calls.get(i, (m.get("tool_name", "?"), {}))[0]
+            name = "MCP tools" if name.startswith("mcp") else name
+            results[name] = results.get(name, 0) + len(content)
+    parts.append(Part("your messages", yours))
+    if files:
+        parts.append(Part("attached files", files))
+    parts.append(Part("model's replies", replies, "answers and tool calls"))
+    for name, size in sorted(results.items(), key=lambda kv: -kv[1]):
+        parts.append(Part(f"tool results: {name}", size))
+    return parts

lcode/repl.py

@@ -26,6 +26,7 @@ from rich.table import Table
 from rich.text import Text
 
 from lcode import __version__, catalog, extensions, limits, 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
 from lcode.catalog import MIN_USEFUL_CONTEXT
@@ -217,6 +218,8 @@ def context_command(agent: Agent, arg: str, hardware: Hardware) -> None:
     if agent.mcp and agent.mcp.ready():
         how = "found on demand" if agent.mcp.searching(s.context) else "sent with every request"
         c.print(f"MCP tools: ~{format_tokens(agent.mcp.cost())} tokens of definitions, {how}.")
+    if not arg:
+        print_breakdown(agent)
     if arg:
         try:
             apply_context(agent, parse_context(arg), hardware)
@@ -256,6 +259,27 @@ def context_command(agent: Agent, arg: str, hardware: Hardware) -> None:
     apply_context(agent, size, hardware)
 
 
+def print_breakdown(agent: Agent) -> None:
+    """What uses the context, by category."""
+    parts = [p for p in context_tools.breakdown(agent) if p.tokens]
+    total = sum(p.tokens for p in parts) or 1
+    table = Table(title="What uses the context (estimates)", title_justify="left", header_style="bold")
+    table.add_column("Part")
+    table.add_column("Tokens", justify="right")
+    table.add_column("", no_wrap=True)
+    table.add_column("", style="dim")
+    for part in parts:
+        share = part.tokens / total
+        bar = "█" * max(1, round(share * 20)) + f" {share:.0%}"
+        table.add_row(escape(part.name), format_tokens(part.tokens), bar, escape(part.detail))
+    agent.console.print(table)
+    if agent.pruned or agent.compacted:
+        agent.console.print(
+            f"[dim]This session: old tool output removed {agent.pruned} time(s), conversation summarized "
+            f"{agent.compacted} time(s).[/]"
+        )
+
+
 def sandbox_command(agent: Agent, arg: str) -> None:
     c, sandbox = agent.console, agent.sandbox
     if sandbox is None:

lcode/tools.py

@@ -23,6 +23,7 @@ from rich.syntax import Syntax
 from rich.text import Text
 
 from lcode import web
+from lcode.context import shorten
 from lcode.permissions import bash_key, is_read_only
 from lcode.planning import BLOCKED, PLAN_MODE_TOOLS
 from lcode.sandbox import SandboxError
@@ -343,6 +344,11 @@ class Toolbox:
             skills = self.agent.extensions().skills.values()
             if any(p == s.folder or s.folder in p.parents for s in skills):
                 return p
+        if read and root is not None:
+            from lcode.context import outputs_dir
+
+            if outputs_dir().resolve() in p.parents:  # full output that was cut short
+                return p
         if root is not None and p != root and root not in p.parents:
             raise ToolError(f"{path} is outside the project ({root}); with the sandbox on, that's all you can use")
         return p
@@ -469,7 +475,7 @@ class Toolbox:
         if result.startswith("Error:"):
             return result
         self.console.print(Text(f"  ⎿ {result.count(chr(10)) + 1} line(s) from {state.name}", style="dim"))
-        return truncate(result)
+        return shorten(result, MAX_TOOL_OUTPUT, f"{state.name} result")
 
     # -- read-only
     def t_read_file(self, path: str, offset: int = 1, limit: int = 2000) -> str:
@@ -743,7 +749,7 @@ class Toolbox:
                 "with /sandbox network on]"
             )
         self.console.print(Text(f"  exit code {code}", style="green" if code == 0 else "red"))
-        return truncate("".join(out)) + status + f"\n[exit code: {code}]"
+        return shorten("".join(out), MAX_TOOL_OUTPUT, "output") + status + f"\n[exit code: {code}]"
 
     # -- web
     def _web_allowed(self, key: str, title: str, detail: str) -> tuple[bool, str]:

{lcode_cli-0.11.1.dist-info → lcode_cli-0.12.0.dist-info}/METADATA

@@ -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.dist-info → lcode_cli-0.12.0.dist-info}/RECORD

@@ -1,11 +1,12 @@
-lcode/__init__.py,sha256=UQAtfDKQe1ahZ-_luedI4_SB9hUVZdwvd8BMWoI-GoI,118
+lcode/__init__.py,sha256=h5xnES1ia_uiIlA2RJp7J_HtBimEoooWRfKT0aVp_Kc,118
 lcode/__main__.py,sha256=s5N5pryX2FAu93GGZ3FxUrIXHWGzxz66lKUoaV_h8Ws,35
-lcode/agent.py,sha256=5vSYZYFg-5doSF1yx3YRWI8hKSMCxPnSNzJiIwicY_8,40626
-lcode/bench.py,sha256=FCn94Gs7L8bpq4hzf6ILoQG8dKrbbd5WC4BRwrTp4LM,37950
+lcode/agent.py,sha256=g4QFYvFkuzWSbdIv9bvw7WCUkLy4EZQ0JSDI45Iv0yM,41793
+lcode/bench.py,sha256=wHRDujY2emLiAcpLU7D25yIdG9c6eZt0wxbe0NW5_c4,39493
 lcode/catalog.py,sha256=pZ1azX9OH2r4JE2c6E5OfwywpgS39-W2oXzoCHJhmtM,4141
 lcode/checkpoints.py,sha256=eqPtmPe44-aweWqc2H21ROogwzIt3NpvcUobsaCHoGY,18354
-lcode/cli.py,sha256=2xSELCKgYyqvJUAwG6P6qimZq6wmZGxwYAxCYfeZ7rk,30509
-lcode/config.py,sha256=HwOAz-9LFkH9hOlQwPPG26oIGtOfd0b2Wq2I09WxIAE,8297
+lcode/cli.py,sha256=jD4VOOS--SnnHp5CmQ-zfMukfGxMeuAsRfgNHOcSn84,31068
+lcode/config.py,sha256=2pSPR84e_VWqW6Ec5mYGnjGMdy_azcwpJz173_ENUzQ,8404
+lcode/context.py,sha256=qJymLE3eYeaF6qVOzlUwDURqlky__8cskl_6vXeU3AA,10701
 lcode/extensions.py,sha256=1MkCmfvQvcJt1XaqIEOYUruCTsrfQVI5TXOTWBkkJtI,15882
 lcode/frontmatter.py,sha256=Bx0n4vLPhp7ZCWx-g7xqzqNy5VoKBxyeeikh5UFB_gA,2441
 lcode/hardware.py,sha256=2VbknZCxTZJwJUD8YWdQ7ryEQo_LcjtoOBOHOU9Y0fw,3085
@@ -16,11 +17,11 @@ lcode/ollama.py,sha256=0f2rkrm3_5Xcnuyvaxcfx5SeYVyRvHjiROXryHKmRUw,7085
 lcode/permissions.py,sha256=m8YNtCladVAmXB20ca8AwyfEOzHKS557B0SOvx1oHeM,4528
 lcode/planning.py,sha256=Z30K2tbqoy2XimKwth1lYYz7OVaQUXGdDvBgops7pGE,6076
 lcode/render.py,sha256=gMvf4W3qkLUJ4Vot3az_hP_zRDAItJC9pP-68dHFkfA,1375
-lcode/repl.py,sha256=FnyYpRuvpqmIVWQbMSvagrFBvFcLjIAedFeF32u5Vp4,43612
+lcode/repl.py,sha256=Dnm4H0FGbD-LbXUYhF13tL4WTTVf_rzDIuj-Gse9vdU,44647
 lcode/sandbox.py,sha256=u_pkrVRXhCGhh-wFDPwuZ3jGG7UeXxXRAeBNsm37ZvE,8608
 lcode/sessions.py,sha256=wOR-J0EHgJxLSPboKPHnvBcp5VTUYTj3tZWgpsa6-K4,4013
 lcode/subagents.py,sha256=ILGFwdFWfwKqExl2D5h_AArqlOris2N0aqh3Ccj895Q,28295
-lcode/tools.py,sha256=Af2pbx8KIR4uLaWk2opbzMY8ZFQ22mGcu8FnRbX9DsM,35486
+lcode/tools.py,sha256=42rho60PWJuQeqjEna459nwqOW_2VndiCIKPwgmpTvo,35787
 lcode/vision.py,sha256=w33QPmdGwP33wM4mvmAH4amFDZ1xzeXhEsSLJ-STSHY,4243
 lcode/web.py,sha256=vyxKbSRJTl1Lj3hj7Yd_NwTgbv0Xi6dup2YfUXjqp-Y,14579
 lcode/mcp/__init__.py,sha256=XujtAmRoXW9S0uq1XPf_CAeCkHh_UvA8FCmoAKP9j1Y,171
@@ -38,8 +39,8 @@ lcode/mcp/stdio.py,sha256=kC6KHwzMMDjBr-yCZLmyVKS7PZXU299WpZdYRoX5eRQ,6292
 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_cli-0.11.1.dist-info/METADATA,sha256=xcrLvH_QYkYUWKgRMrVoBjOTQP_CPDSlp8ttCu6e9O8,11549
-lcode_cli-0.11.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.11.1.dist-info/entry_points.txt,sha256=pMz2Byj2QRyt-ZZQYZvmWUtmKPCeE7f8iCvu-sjZPIo,133
-lcode_cli-0.11.1.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.11.1.dist-info/RECORD,,
+lcode_cli-0.12.0.dist-info/METADATA,sha256=rjhKfHrINzf0qVIeQ7PL8fP3cMeGJkgNTY-63zEhB8Q,11464
+lcode_cli-0.12.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.12.0.dist-info/entry_points.txt,sha256=pMz2Byj2QRyt-ZZQYZvmWUtmKPCeE7f8iCvu-sjZPIo,133
+lcode_cli-0.12.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.12.0.dist-info/RECORD,,