lcode-cli 0.8.0__py3-none-any.whl → 0.9.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.8.0"
+__version__ = "0.9.0"

lcode/agent.py

@@ -21,7 +21,7 @@ from rich.markup import escape
 from rich.panel import Panel
 from rich.text import Text
 
-from lcode import catalog, limits, sessions, subagents, vision, web
+from lcode import catalog, limits, planning, sessions, subagents, vision, web
 from lcode import memory as memory_notes
 from lcode.checkpoints import Checkpoints
 from lcode.config import format_tokens
@@ -32,6 +32,7 @@ from lcode.render import MarkdownStreamer
 from lcode.sandbox import Sandbox, SandboxError, project_root
 from lcode.tools import (
     MEMORY_SCHEMA,
+    PRESENT_PLAN_SCHEMA,
     SCHEMAS,
     VIEW_IMAGE_SCHEMA,
     WEB_FETCH_SCHEMA,
@@ -198,6 +199,7 @@ class Agent:
         self._memory: memory_notes.Memory | None = None
         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
         # Set on subagents (see lcode.subagents):
         self.allowed_tools: set[str] | None = None  # None: every tool
         self.read_only = False  # only read-only shell commands
@@ -259,6 +261,9 @@ class Agent:
         assert self._agent_types is not None
         return self._agent_types[2]
 
+    def planning(self) -> bool:
+        return self.perms.mode == "plan"
+
     def tool_names(self) -> set[str]:
         return {s["function"]["name"] for s in self.tool_schemas()}
 
@@ -283,6 +288,8 @@ class Agent:
             schemas.append(MEMORY_SCHEMA)
         if self.settings.subagents:
             schemas.append(subagents.schema(self.agent_types(), self.settings.max_parallel_agents))
+        if self.planning():
+            schemas.append(PRESENT_PLAN_SCHEMA)
         if self.mcp:
             schemas += self.mcp.schemas(self.settings.context)
         if self.allowed_tools is not None:
@@ -638,7 +645,8 @@ class Agent:
 
     def _run_turn(self, user_text: str, max_steps: int = MAX_STEPS_PER_TURN) -> None:
         self.prepare_mcp()
-        self.messages.append({"role": "user", "content": self.expand_mentions(user_text)})
+        note = planning.NOTE if self.planning() and self.allowed_tools is None else ""
+        self.messages.append({"role": "user", "content": self.expand_mentions(user_text) + note})
         malformed = 0
         for _ in range(max_steps):
             if self.cancel is not None and self.cancel.is_set():
@@ -777,6 +785,8 @@ class Agent:
             {"role": "user", "content": f"[Summary of our conversation so far]\n\n{summary}"},
             {"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
+            self.messages[1]["content"] += f"\n\n[The plan the user approved; keep following it]\n\n{self.plan}"
         self.ctx_used = sum(len(m["content"]) for m in self.messages) // 3
         self.reflected = len(self.messages)
         self.console.print(Panel(Markdown(summary), title="Compacted summary", border_style="blue"))

lcode/cli.py

@@ -519,7 +519,9 @@ def cmd_chat(args) -> None:
     context, note = choose_context(ollama, model, spec, requested_ctx, hw)
     if note:
         console.print(f"[yellow]Context {format_tokens(context)}: {note}[/]")
-    mode = "yolo" if args.yolo else ("auto-edit" if args.auto_edit else cfg["permission_mode"])
+    mode = (
+        "yolo" if args.yolo else ("auto-edit" if args.auto_edit else ("plan" if args.plan else cfg["permission_mode"]))
+    )
     num_batch = cfg["num_batch"]
     if num_batch is None and spec and spec.num_batch:
         if model == spec.local_name:
@@ -589,6 +591,7 @@ def build_parser() -> argparse.ArgumentParser:
         metavar="SESSION",
         help="resume a saved session: pick from a list, or give its number, name or id",
     )
+    parser.add_argument("--plan", action="store_true", help="start in plan mode: agree on a plan before any change")
     parser.add_argument("--auto-edit", action="store_true", help="apply file edits without asking")
     parser.add_argument("--yolo", action="store_true", help="never ask for permission (edits and commands)")
     parser.add_argument("--no-think", action="store_true", help="disable model reasoning (faster, less accurate)")

lcode/config.py

@@ -21,7 +21,7 @@ else:
     STATE_DIR = Path(os.environ.get("XDG_STATE_HOME") or Path.home() / ".local/state") / "lcode"
 
 DEFAULT_MODEL = "qwen3.6-35b"
-PERMISSION_MODES = ("ask", "auto-edit", "yolo")
+PERMISSION_MODES = ("ask", "plan", "auto-edit", "yolo")  # Shift+Tab cycles in this order
 WEB_MODES = ("on", "ask", "off")
 SEARCH_BACKENDS = ("auto", "ollama", "brave", "tavily", "searxng")
 MCP_TOOL_MODES = ("auto", "direct", "search")
@@ -35,7 +35,7 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "num_batch": (None, int, "prompt batch size; larger reads prompts faster but needs more VRAM"),
     "keep_alive": ("30m", str, "how long Ollama keeps the model loaded after the last request"),
     "ollama_host": ("http://localhost:11434", str, "Ollama server URL"),
-    "permission_mode": ("ask", str, "ask | auto-edit | yolo"),
+    "permission_mode": ("ask", str, "ask | plan | auto-edit | yolo"),
     "think": (True, bool, "let the model reason before answering (slower, better)"),
     "web": ("on", str, "web search and page fetching for the model: on | ask | off"),
     "search_backend": ("auto", str, "auto | ollama | brave | tavily | searxng (keys come from environment variables)"),

lcode/mcp/commands.py

@@ -216,9 +216,9 @@ def _ask(spec: catalog.Input, console: Console) -> str | None:
         source = " ".join(spec.from_command)
         if Confirm.ask(f"  Use the token from `{source}`?", default=True, console=console):
             return suggestion
-    default = f" [{spec.default}]" if spec.default else ""
+    default = f" \\[{escape(spec.default)}]" if spec.default else ""  # escaped, or rich takes it for markup
     while True:
-        value = console.input(f"  {spec.prompt}{default}: ", password=spec.secret).strip()
+        value = console.input(f"  {escape(spec.prompt)}{default}: ", password=spec.secret).strip()
         value = value or spec.default or ""
         if value or spec.optional:
             return value or None

lcode/memory.py

@@ -507,7 +507,7 @@ def reflect(agent: Agent) -> None:
             where = "every repository" if note.scope == "user" else "this repository"
             update = memory.find(note.name, note.scope)
             rows.append(
-                f"[cyan]{i}[/] [{note.type}] {escape(note.description)} [dim]({where}"
+                f"[cyan]{i}[/] \\[{note.type}] {escape(note.description)} [dim]({where}"
                 f"{', updates ' + escape(update.name) if update else ''})[/]"
                 + (f"\n    [dim]{escape(note.details)}[/]" if note.details else "")
             )

lcode/planning.py

@@ -0,0 +1,138 @@
+"""Plan mode: agree on an approach before anything changes.
+
+In the `plan` permission mode the model can read, search, run read-only commands, use the web and
+read-only subagents, but can't change anything. It ends by presenting a plan with the
+present_plan tool. The user approves it (lcode switches to `ask` or `auto-edit`, fills the todo
+list from the plan's steps and keeps the plan through compaction), edits it, saves it to
+`.lcode/plans/`, or sends it back with feedback.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import shlex
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from rich.markdown import Markdown
+from rich.markup import escape
+from rich.panel import Panel
+
+from lcode.checkpoints import work_tree_for
+from lcode.memory import slugify
+
+if TYPE_CHECKING:
+    from lcode.agent import Agent
+
+# Tools that can't change anything (bash is limited to read-only commands, agent to read-only types).
+PLAN_MODE_TOOLS = frozenset(
+    {
+        "read_file", "list_dir", "glob", "grep", "bash", "web_search", "web_fetch", "view_image", "todo_write",
+        "agent", "memory", "present_plan", "mcp_find_tools",
+    }
+)  # fmt: skip
+
+NOTE = """
+
+[lcode] Plan mode is on: you can read, search, run read-only commands, use the web and read-only subagents, but you can't change anything yet. Work out how to do this, then call present_plan with: numbered steps, the files you'll change and how, the risks, and how you'll verify the result. Ask the user only about decisions that are genuinely theirs."""
+
+BLOCKED = (
+    "Plan mode is on, so nothing can be changed yet. Finish working out the plan and present it with "
+    "present_plan; once the user approves it, you can make the changes."
+)
+
+CHOICES = (
+    "  [bold]\\[y][/] run it, asking before changes · [bold]\\[a][/] run it, edits without asking (auto-edit)\n"
+    "  [bold]\\[e][/] edit the plan · [bold]\\[s][/] save it to .lcode/plans/ · [bold]\\[n][/] keep planning (+ what to change)"
+)
+
+
+def steps(plan: str, limit: int = 20) -> list[str]:
+    """The plan's numbered steps (top level only), for the todo list."""
+    found = []
+    for line in plan.splitlines():
+        m = re.match(r"^ {0,3}\d+[.)]\s+(.+)", line)
+        if m:
+            # Plain text for the todo list: no bold, code or emphasis marks (underscores in names stay).
+            text = m.group(1).replace("**", "").replace("__", "").replace("`", "")
+            text = re.sub(r"(?<!\w)[*_]([^*_]+)[*_](?!\w)", r"\1", text).strip().rstrip(":").strip()
+            found.append(text if len(text) <= 120 else text[:119].rstrip() + "…")
+    return found[:limit]
+
+
+def edit_text(text: str) -> str:
+    """Let the user edit `text` in their editor; returns the result."""
+    editor = os.environ.get("VISUAL") or os.environ.get("EDITOR") or ("nano" if shutil.which("nano") else "vi")
+    with tempfile.NamedTemporaryFile("w", suffix=".md", delete=False) as f:
+        f.write(text)
+        path = Path(f.name)
+    try:
+        subprocess.call([*shlex.split(editor), str(path)])
+        return path.read_text()
+    finally:
+        path.unlink(missing_ok=True)
+
+
+def save(agent: Agent, title: str, plan: str) -> Path:
+    folder = work_tree_for(agent.cwd) / ".lcode" / "plans"
+    folder.mkdir(parents=True, exist_ok=True)
+    path = folder / f"{slugify(title) or 'plan'}.md"
+    path.write_text(f"# {title}\n\n{plan.strip()}\n")
+    return path
+
+
+def present(agent: Agent, title: str, plan: str) -> str:
+    """Show the plan and let the user decide. Returns the tool result for the model."""
+    c = agent.console
+    title = " ".join(title.split()) or "Plan"
+    plan = plan.strip()
+    if not plan:
+        return "Error: the plan is empty. Write the steps, the files, the risks and how you'll verify the work."
+    edited = False
+    while True:
+        c.print(Panel(Markdown(plan), title=f"Plan: {escape(title)}", title_align="left", border_style="cyan"))
+        if not agent.interactive:
+            return "The plan was shown to the user, who will review it later. Stop here and don't change anything."
+        c.print(CHOICES)
+        try:
+            answer = input("  > ").strip()
+        except EOFError:
+            return "The plan was shown to the user, who will review it later. Stop here and don't change anything."
+        word = answer.lower()
+        if word in ("", "y", "yes"):
+            return approve(agent, title, plan, "ask", edited)
+        if word in ("a", "auto", "auto-edit"):
+            return approve(agent, title, plan, "auto-edit", edited)
+        if word in ("e", "edit"):
+            new = edit_text(plan).strip()
+            if new and new != plan:
+                plan, edited = new, True
+            continue
+        if word in ("s", "save"):
+            path = save(agent, title, plan)
+            c.print(f"[green]Saved to {escape(agent.tools.rel(path))}[/]")
+            continue
+        feedback = re.sub(r"^(no|n)\b[\s,:-]*", "", answer, flags=re.I).strip()
+        if feedback:
+            return f"The user wants changes to the plan: {feedback}\nStay in plan mode: revise the plan and present it again."
+        return "The user didn't approve the plan. Ask them what they'd like to change."
+
+
+def approve(agent: Agent, title: str, plan: str, mode: str, edited: bool) -> str:
+    agent.perms.mode = mode
+    agent.plan = f"# {title}\n\n{plan}"
+    todo = steps(plan)
+    if todo:
+        agent.tools.todos = [{"content": step, "status": "pending"} for step in todo]
+        agent.tools.show_todos()
+    how = "file edits no longer ask (auto-edit)" if mode == "auto-edit" else "changes ask for approval as usual"
+    agent.console.print(f"[green]Plan approved.[/] Mode: {mode} — {how}.")
+    result = f"The user approved the plan, and plan mode is off ({mode} mode: {how}). Carry it out now, step by step"
+    result += ", keeping the todo list up to date." if todo else "."
+    if edited:
+        result += f"\nThe user edited the plan first. This is the approved version:\n\n{plan}"
+    return result

lcode/repl.py

@@ -18,6 +18,7 @@ from prompt_toolkit.formatted_text import HTML
 from prompt_toolkit.history import FileHistory
 from prompt_toolkit.key_binding import KeyBindings
 from rich.console import Group
+from rich.markdown import Markdown
 from rich.markup import escape
 from rich.panel import Panel
 from rich.rule import Rule
@@ -55,7 +56,8 @@ COMMANDS = {
     "/models": "List models and how they fit this machine",
     "/think": "Toggle model reasoning on/off",
     "/verbose": "Toggle showing the model's reasoning text",
-    "/mode": "Permission mode: ask | auto-edit | yolo (Shift+Tab cycles)",
+    "/plan": "Plan before changing anything: /plan <request>, or /plan to show the approved plan",
+    "/mode": "Permission mode: ask | plan | auto-edit | yolo (Shift+Tab cycles)",
     "/cd": "Change the working directory",
     "/todos": "Show the current todo list",
     "/exit": "Quit",
@@ -118,7 +120,7 @@ def build_session(agent: Agent) -> PromptSession:
     def toolbar():
         s = agent.settings
         pct = 100 * agent.ctx_used / s.context
-        color = {"ask": "ansigreen", "auto-edit": "ansiyellow", "yolo": "ansired"}[agent.perms.mode]
+        color = {"ask": "ansigreen", "plan": "ansicyan", "auto-edit": "ansiyellow", "yolo": "ansired"}[agent.perms.mode]
         return HTML(
             f" <b>{html.escape(s.model)}</b> · ctx {format_tokens(agent.ctx_used)}/{format_tokens(s.context)} "
             f"({pct:.0f}%) · mode <{color}>{agent.perms.mode}</{color}> (shift+tab) · "
@@ -772,6 +774,20 @@ def handle_command(agent: Agent, line: str, hardware: Hardware) -> bool:
     elif cmd == "/verbose":
         s.show_thinking = not s.show_thinking
         c.print(f"Showing reasoning text: {'on' if s.show_thinking else 'off'}.")
+    elif cmd == "/plan":
+        if not arg:
+            if agent.plan:
+                c.print(Panel(Markdown(agent.plan), title="Approved plan", title_align="left", border_style="cyan"))
+            else:
+                c.print(
+                    "No approved plan in this session. [bold]/plan <request>[/] works out a plan first, without "
+                    "changing anything (or Shift+Tab to plan mode)."
+                )
+            return True
+        agent.perms.mode = "plan"
+        c.print("[cyan]Plan mode:[/] the model can look around but not change anything until you approve its plan.")
+        c.print(Rule(style="dim"))
+        run_safely(agent, arg)
     elif cmd == "/mode":
         if arg in PERMISSION_MODES:
             agent.perms.mode = arg

lcode/tools.py

@@ -24,6 +24,7 @@ from rich.text import Text
 
 from lcode import web
 from lcode.permissions import bash_key, is_read_only
+from lcode.planning import BLOCKED, PLAN_MODE_TOOLS
 from lcode.sandbox import SandboxError
 from lcode.vision import is_image
 
@@ -198,8 +199,22 @@ MEMORY_SCHEMA = _fn(
     },
     ["action"],
 )
+PRESENT_PLAN_SCHEMA = _fn(
+    "present_plan",
+    "Plan mode: show the user your plan and ask for approval. Once approved, plan mode ends and you carry it out.",
+    {
+        "title": {"type": "string", "description": "A short name for the plan, e.g. 'Add retries to webhooks'"},
+        "plan": {
+            "type": "string",
+            "description": "Markdown: numbered steps, the files you'll change and how, the risks, and how you'll "
+            "verify the result",
+        },
+    },
+    ["title", "plan"],
+)
 TOOL_NAMES = {
-    s["function"]["name"] for s in [*SCHEMAS, WEB_SEARCH_SCHEMA, WEB_FETCH_SCHEMA, VIEW_IMAGE_SCHEMA, MEMORY_SCHEMA]
+    s["function"]["name"]
+    for s in [*SCHEMAS, WEB_SEARCH_SCHEMA, WEB_FETCH_SCHEMA, VIEW_IMAGE_SCHEMA, MEMORY_SCHEMA, PRESENT_PLAN_SCHEMA]
 }
 
 
@@ -337,6 +352,10 @@ class Toolbox:
         allowed = self.agent.allowed_tools
         if allowed is not None and name not in allowed:
             return f"Error: {name} isn't available to you. Available: {', '.join(sorted(allowed))}"
+        if self.agent.planning() and name not in PLAN_MODE_TOOLS:
+            return f"Error: {BLOCKED}"
+        if name == "present_plan" and not self.agent.planning():
+            return "Error: plan mode is off, so there's nothing to present: carry on with the work."
         if self.agent.mcp and self.agent.mcp.owns(name):
             return self._mcp(name, args)
         fn = getattr(self, f"t_{name}", None)
@@ -376,8 +395,17 @@ class Toolbox:
             raise ToolError("subagents are turned off")
         from lcode import subagents
 
+        kind = self.agent.agent_types().get(type)
+        if self.agent.planning() and kind and not kind.read_only:
+            raise ToolError(f"plan mode is on: only read-only agents can run now ({BLOCKED})")
         return subagents.run_one(self.agent, {"type": type, "task": task, "description": description})
 
+    # -- plan mode
+    def t_present_plan(self, title: str, plan: str) -> str:
+        from lcode.planning import present
+
+        return present(self.agent, title, plan)
+
     # -- memory
     def t_memory(
         self, action: str, name: str = "", type: str = "", description: str = "", details: str = "", scope: str = ""
@@ -605,6 +633,8 @@ class Toolbox:
     # -- shell
     def t_bash(self, command: str, timeout: int = 180) -> str:
         sandbox = self.agent.sandbox
+        if self.agent.planning() and not is_read_only(command):
+            raise ToolError(f"{BLOCKED} Until then, only read-only commands run (ls, cat, grep, git log, …).")
         if self.agent.read_only and not is_read_only(command):
             raise ToolError(
                 "you can only run read-only commands (such as ls, cat, grep, find, git log, git diff), one at a "

{lcode_cli-0.8.0.dist-info → lcode_cli-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.8.0
+Version: 0.9.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/
@@ -80,6 +80,8 @@ through [Ollama](https://ollama.com), and when it needs current information it c
   your approval. `auto-edit` and `yolo` modes when you want speed.
 - **Sandbox (optional).** `lcode --sandbox` runs the model's shell commands in a container (Docker or
   Podman) that only sees your project, without network access unless you allow it.
+- **Plan mode.** `/plan <request>` or Shift+Tab: the model explores read-only and presents a plan;
+  you approve, edit or send it back before anything changes.
 - **Undo.** lcode saves a checkpoint before the model changes files; `/undo` takes back the last
   request's edits, new files and shell-command changes, without touching your git history.
 - **Subagents.** The model hands broad searches, planning and self-contained changes to subagents
@@ -195,7 +197,7 @@ 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:
 
-- [Plan mode](https://github.com/nasser1941/lcode/issues/41) and [custom commands and skills](https://github.com/nasser1941/lcode/issues/42)
+- [Custom commands and skills](https://github.com/nasser1941/lcode/issues/42)
 - [Ready-made MCP for Metabase, Encord and Valohai](https://github.com/nasser1941/lcode/issues/53)
 - Then: [smarter context for small windows](https://github.com/nasser1941/lcode/issues/46), [language servers](https://github.com/nasser1941/lcode/issues/44), [a repository map with local embeddings](https://github.com/nasser1941/lcode/issues/45), [hooks](https://github.com/nasser1941/lcode/issues/43)
 - More models in the catalog, and test reports from your hardware ([report one](https://github.com/nasser1941/lcode/issues/new?template=model_request.yml))

{lcode_cli-0.8.0.dist-info → lcode_cli-0.9.0.dist-info}/RECORD

@@ -1,23 +1,24 @@
-lcode/__init__.py,sha256=1p3bazCEuQ0WZP-SgRA-g8KVP4Avchrem5OtlxRTRHc,117
+lcode/__init__.py,sha256=nFv9AKdtRRoIhmSP_gIiY5ftUlCFh_s-FQeBjbqj6fI,117
 lcode/__main__.py,sha256=s5N5pryX2FAu93GGZ3FxUrIXHWGzxz66lKUoaV_h8Ws,35
-lcode/agent.py,sha256=uNQx8pcTzs4k05100wJedoPCZ7dUFjJz2OD2e__49VM,38597
+lcode/agent.py,sha256=fP52AvWe7WfTXmzbM9BH-_rIUtdEf2Ix1iBspeqcTr4,39130
 lcode/bench.py,sha256=FCn94Gs7L8bpq4hzf6ILoQG8dKrbbd5WC4BRwrTp4LM,37950
 lcode/catalog.py,sha256=pZ1azX9OH2r4JE2c6E5OfwywpgS39-W2oXzoCHJhmtM,4141
 lcode/checkpoints.py,sha256=eqPtmPe44-aweWqc2H21ROogwzIt3NpvcUobsaCHoGY,18354
-lcode/cli.py,sha256=uc9F2HDflhu6cZbb2wARjllmM7KpN0FB9UfnyyFx_9U,29450
-lcode/config.py,sha256=KYgBRO-WN0Sl_YWd-XudqfE5NkV34w9OzQQJ3Apg2bs,7898
+lcode/cli.py,sha256=Bh9wdAe5fZPzfKUdsbebpMObxqKxLZIDsI3OldhddO8,29610
+lcode/config.py,sha256=Wle_Gwv-FWQmD9jBt8jiHNtmdn3O5bOgkrZ6tbD7_9o,7947
 lcode/hardware.py,sha256=2VbknZCxTZJwJUD8YWdQ7ryEQo_LcjtoOBOHOU9Y0fw,3085
 lcode/limits.py,sha256=oJzVQoMyTZ0_Fkpu5t3qxrf9v7Hv9S8U8BRQR5M1aKA,1237
-lcode/memory.py,sha256=ocr_2zDzmH1OCwrVjC-UmzRn4Sr1I_OeazhbIoSdIf0,22359
+lcode/memory.py,sha256=SWB_xt_fdL2hX1mcUqK0drU7laZmg1CqIs0IIAehnCo,22361
 lcode/models.toml,sha256=lt2G64zzo_Ryxv2ISRSNZoVD_JqCqYqsM01n8WoXGs8,4098
 lcode/ollama.py,sha256=0f2rkrm3_5Xcnuyvaxcfx5SeYVyRvHjiROXryHKmRUw,7085
 lcode/permissions.py,sha256=m8YNtCladVAmXB20ca8AwyfEOzHKS557B0SOvx1oHeM,4528
+lcode/planning.py,sha256=C7_JyArIywPygU9DdfaoN2EfgA6JGNnKafuIilkOzGw,6067
 lcode/render.py,sha256=gMvf4W3qkLUJ4Vot3az_hP_zRDAItJC9pP-68dHFkfA,1375
-lcode/repl.py,sha256=0v_b5fFpxdAQU3TreTpDXdAUjWwePMkDW9MGIPiefNU,39521
+lcode/repl.py,sha256=K04EpyIxyrP6I3oPh9tp8xqoIubplqHRXvWbqFdOKks,40356
 lcode/sandbox.py,sha256=u_pkrVRXhCGhh-wFDPwuZ3jGG7UeXxXRAeBNsm37ZvE,8608
 lcode/sessions.py,sha256=wOR-J0EHgJxLSPboKPHnvBcp5VTUYTj3tZWgpsa6-K4,4013
 lcode/subagents.py,sha256=L5U-USz2fnGOx3Z28_sOA6btWmMKSGXVbFKQYcrZSDM,28147
-lcode/tools.py,sha256=179FscWa9zmFGWEpbJekdpuBwheH2Oh_H9XTAP48yxM,33391
+lcode/tools.py,sha256=VNhNkC43x2l20kqv06cbDXmdJHugDncFX0AIUfAr3CE,34820
 lcode/vision.py,sha256=w33QPmdGwP33wM4mvmAH4amFDZ1xzeXhEsSLJ-STSHY,4243
 lcode/web.py,sha256=vyxKbSRJTl1Lj3hj7Yd_NwTgbv0Xi6dup2YfUXjqp-Y,14579
 lcode/mcp/__init__.py,sha256=XujtAmRoXW9S0uq1XPf_CAeCkHh_UvA8FCmoAKP9j1Y,171
@@ -25,14 +26,14 @@ lcode/mcp/auth.py,sha256=vyH3oolgIBNJLYabr2h5Soui99NTY1QxjQEgtczfF6A,16655
 lcode/mcp/catalog.py,sha256=GnIF1fyeHSut9h2y_VJNAHc2FCJT81EIhLFM40V780k,3504
 lcode/mcp/catalog.toml,sha256=_kFzKD2FD78KD2URuE5B-kcQehW9Y3Zi2xf5tu3v4Xc,9230
 lcode/mcp/client.py,sha256=3Gen7zRvWehngXn_dAMOAdKqFkFkQZIQW96hQcW4N4k,7119
-lcode/mcp/commands.py,sha256=Rlnc-LFydRjHTiW-CSxjmQqX0d2MSiEViLF9kczYIi4,16420
+lcode/mcp/commands.py,sha256=mnp0G-GW5ZsARi2tkHuT3hl883sBGFUVRAV3AapA5oU,16478
 lcode/mcp/config.py,sha256=Ej6WX2b_55a84H5WdAwSk9DzERKoq5ifUBQ9uDgSG_o,8780
 lcode/mcp/http.py,sha256=sG9MajwU4_6sqvZhwD4WfyzRKzaR_Lc8C02jwePz18E,7380
 lcode/mcp/manager.py,sha256=79nNWoT5pxgoQD_Pv4ZH0obHIm7rQ-LyB8OmJnQgc6k,15104
 lcode/mcp/protocol.py,sha256=-xwhA2Tz-vzR2zdSdbPx4IjTu29uRrXMaePg0vEz_Vc,5223
 lcode/mcp/stdio.py,sha256=kC6KHwzMMDjBr-yCZLmyVKS7PZXU299WpZdYRoX5eRQ,6292
-lcode_cli-0.8.0.dist-info/METADATA,sha256=R2rlCNEpaoajSJzoThzX77UeTvAV_jv2qwQUlGeOoBI,11282
-lcode_cli-0.8.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.8.0.dist-info/entry_points.txt,sha256=pZ_uDQ98UzVAHUQeXn5HeyQWKGSH3r3T5aPHuSB89eI,41
-lcode_cli-0.8.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.8.0.dist-info/RECORD,,
+lcode_cli-0.9.0.dist-info/METADATA,sha256=DW7hETwyh_0QCwMacZY-ofQbFPMPZTgChvrxjXDTb-8,11379
+lcode_cli-0.9.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.9.0.dist-info/entry_points.txt,sha256=pZ_uDQ98UzVAHUQeXn5HeyQWKGSH3r3T5aPHuSB89eI,41
+lcode_cli-0.9.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.9.0.dist-info/RECORD,,