lcode-cli 0.6.0__py3-none-any.whl → 0.7.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.6.0"
+__version__ = "0.7.0"

lcode/agent.py

@@ -21,6 +21,7 @@ from rich.panel import Panel
 from rich.text import Text
 
 from lcode import catalog, limits, sessions, vision, web
+from lcode import memory as memory_notes
 from lcode.checkpoints import Checkpoints
 from lcode.config import format_tokens
 from lcode.mcp import McpManager
@@ -29,6 +30,7 @@ from lcode.permissions import Permissions
 from lcode.render import MarkdownStreamer
 from lcode.sandbox import Sandbox, SandboxError, project_root
 from lcode.tools import (
+    MEMORY_SCHEMA,
     SCHEMAS,
     VIEW_IMAGE_SCHEMA,
     WEB_FETCH_SCHEMA,
@@ -74,7 +76,7 @@ SYSTEM_PROMPT = """You are lcode, an autonomous software-engineering agent runni
 
 # Top-level layout of the working directory
 {tree}
-{web}{memory}"""
+{web}{project}{notes}"""
 
 WEB_PROMPT = """
 # Web access
@@ -148,6 +150,7 @@ class Settings:
     sandbox_image: str | None = None
     sandbox_network: bool = False
     vision_model: str = "auto"  # auto, off or an Ollama model that can see images
+    memory: str = "off"  # off, ask or auto: notes that carry over to later sessions (lcode.memory)
 
 
 class Agent:
@@ -170,6 +173,9 @@ class Agent:
         self._vision: str | bool | None = False  # the model that looks at images; False = not decided yet
         self.session_name = ""
         self.session_title = ""
+        self.interactive = True  # False for `lcode -p`: no end-of-session questions
+        self.reflected = 0  # messages before this index were already checked for notes to remember
+        self._memory: memory_notes.Memory | None = None
         self.ctx_used = 0
         self.last_speed = 0.0
         self.usage = {"requests": 0, "prompt_tokens": 0, "prompt_ns": 0, "output_tokens": 0, "output_ns": 0}
@@ -182,11 +188,11 @@ class Agent:
         return dt.datetime.now().strftime("%Y%m%d-%H%M%S-") + uuid.uuid4().hex[:6]
 
     def system_prompt(self) -> str:
-        memory = ""
+        project = ""
         for name in PROJECT_FILES:
             f = self.cwd / name
             if f.is_file():
-                memory = f"\n# Project instructions ({name})\n{truncate(f.read_text(errors='replace'), 20_000)}\n"
+                project = f"\n# Project instructions ({name})\n{truncate(f.read_text(errors='replace'), 20_000)}\n"
                 break
         return SYSTEM_PROMPT.format(
             model=self.settings.model,
@@ -196,10 +202,17 @@ class Agent:
             date=dt.date.today().isoformat(),
             git=git_info(self.cwd),
             tree=tree(self.cwd, depth=1, limit=120),
-            memory=memory,
+            project=project,
+            notes=self.memory().prompt(self.settings.context) if self.settings.memory != "off" else "",
             web=self.web_prompt(),
         )
 
+    def memory(self) -> memory_notes.Memory:
+        """The notes for the current folder's repository, plus the user's own."""
+        if self._memory is None or self._memory.cwd != self.cwd:
+            self._memory = memory_notes.Memory(self.cwd)
+        return self._memory
+
     def search_backend(self) -> str | None:
         if self.settings.web == "off":
             return None
@@ -211,6 +224,8 @@ class Agent:
             schemas += [*([WEB_SEARCH_SCHEMA] if self.search_backend() else []), WEB_FETCH_SCHEMA]
         if self.vision_model():
             schemas.append(VIEW_IMAGE_SCHEMA)
+        if self.settings.memory != "off":
+            schemas.append(MEMORY_SCHEMA)
         if self.mcp:
             schemas += self.mcp.schemas(self.settings.context)
         return schemas
@@ -301,6 +316,7 @@ class Agent:
         self.messages = [{"role": "system", "content": self.system_prompt()}]
         self._mcp_prompt = ""
         self.tools.read_mtimes.clear()
+        self.reflected = len(self.messages)
         self.ctx_used = len(self.messages[0]["content"]) // 3
 
     def session_file(self) -> Path:
@@ -357,6 +373,7 @@ class Agent:
         self.session_name = data.get("name", "")
         self.session_title = data.get("title") or sessions.title_from(self.messages)
         self.tools.read_mtimes.clear()  # files may have changed since; the model must read them again
+        self.reflected = len(self.messages)  # checked for notes to remember when that session ended
         self.ctx_used = sum(len(json.dumps(m)) for m in self.messages) // 3
         return note
 
@@ -513,6 +530,8 @@ class Agent:
             return f"glob({args.get('pattern', '')})"
         if name == "list_dir":
             return f"list_dir({args.get('path', '.')})"
+        if name == "memory":
+            return f"memory({' '.join(str(args.get(k) or '') for k in ('action', 'name')).strip()})"
         if self.mcp and self.mcp.owns(name):
             if name == "mcp_find_tools":
                 return f"mcp_find_tools({args.get('query', '')!r})"
@@ -646,6 +665,8 @@ class Agent:
     def compact(self, focus: str = "") -> None:
         if len(self.messages) <= 2:
             return
+        if self.interactive:
+            memory_notes.reflect(self)  # what the summary leaves out is gone for good
         instructions = (
             "Summarize this conversation so the work can continue in a fresh context. Include: the user's goals "
             "and requests, key facts learned about the codebase (files, functions, paths with line numbers), "
@@ -664,6 +685,7 @@ class Agent:
             {"role": "assistant", "content": "Got it — I have the context from the summary and will continue."},
         ]
         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"))
 
     # -- settings changes

lcode/cli.py

@@ -341,6 +341,13 @@ def cmd_doctor(args) -> None:
         network = "network on" if cfg["sandbox_network"] else "no network"
         line("Sandbox", problem or f"{cfg['sandbox']} · {network}", problem is None)
         ok &= problem is None
+    if cfg["memory"] == "off":
+        line("Memory", "off (lcode config set memory ask)", True)
+    else:
+        from lcode.memory import Memory
+
+        project, user = Memory(Path.cwd()).counts()
+        line("Memory", f"{cfg['memory']} · {project} note(s) for this repository, {user} for every repository", True)
     node = shutil.which("npx")
     line("Node.js", "found" if node else "not found (some MCP servers need npx)", True if node else None)
     sys.exit(0 if ok else 1)
@@ -509,8 +516,10 @@ def cmd_chat(args) -> None:
         sandbox_image=cfg["sandbox_image"],
         sandbox_network=cfg["sandbox_network"],
         vision_model=cfg["vision_model"],
+        memory="off" if args.no_memory else cfg["memory"],
     )
     agent = Agent(ollama, settings, cwd, console=console)
+    agent.interactive = not args.prompt
     if agent.sandbox:
         # Never run commands unsandboxed when the user asked for a sandbox: stop here instead.
         from lcode.sandbox import SandboxError
@@ -557,6 +566,7 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--no-think", action="store_true", help="disable model reasoning (faster, less accurate)")
     parser.add_argument("--no-web", action="store_true", help="don't let the model search or fetch web pages")
     parser.add_argument("--no-mcp", action="store_true", help="don't start MCP servers in this session")
+    parser.add_argument("--no-memory", action="store_true", help="don't load or save memory notes in this session")
     parser.add_argument("--sandbox", action="store_true", help="run shell commands in a container (Docker or Podman)")
     parser.add_argument("--show-thinking", action="store_true", help="print the model's reasoning as it streams")
     parser.add_argument("-V", "--version", action="version", version=f"lcode {__version__}")

lcode/config.py

@@ -26,6 +26,7 @@ WEB_MODES = ("on", "ask", "off")
 SEARCH_BACKENDS = ("auto", "ollama", "brave", "tavily", "searxng")
 MCP_TOOL_MODES = ("auto", "direct", "search")
 SANDBOX_ENGINES = ("off", "docker", "podman")
+MEMORY_MODES = ("off", "ask", "auto")
 
 # key -> (default, type, help)
 SETTINGS: dict[str, tuple[object, type, str]] = {
@@ -45,6 +46,7 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "sandbox_network": (False, bool, "let commands in the sandbox use the network"),
     "vision_model": ("auto", str, "model that looks at images: auto | off | an Ollama model with vision"),
     "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"),
 }
 ENV_OVERRIDES = {
     "LCODE_MODEL": "model",
@@ -54,6 +56,7 @@ ENV_OVERRIDES = {
     "OLLAMA_HOST": "ollama_host",
     "LCODE_WEB": "web",
     "LCODE_SANDBOX": "sandbox",
+    "LCODE_MEMORY": "memory",
 }
 
 
@@ -110,6 +113,11 @@ def coerce(key: str, value: object) -> object:
         if value not in SANDBOX_ENGINES:
             raise ConfigError(f"sandbox must be one of {', '.join(SANDBOX_ENGINES)}")
         return value
+    if key == "memory":
+        value = {"on": "ask", "true": "ask", "false": "off", "no": "off"}.get(str(value).lower(), str(value).lower())
+        if value not in MEMORY_MODES:
+            raise ConfigError(f"memory must be one of {', '.join(MEMORY_MODES)}")
+        return value
     if key == "mcp_tools" and value not in MCP_TOOL_MODES:
         raise ConfigError(f"mcp_tools must be one of {', '.join(MCP_TOOL_MODES)}")
     if key == "search_backend" and value not in SEARCH_BACKENDS:

lcode/memory.py

@@ -0,0 +1,517 @@
+"""Memory across sessions: short notes about what a future session should know.
+
+Each note is a markdown file holding one fact, with a small frontmatter:
+
+    ---
+    name: test-command
+    type: project
+    description: Run the tests with `uv run pytest -q`; plain pytest misses the dev dependencies
+    modified: 2026-10-05
+    ---
+    Optional details: why, and how to apply it.
+
+Notes live in lcode's state folder: `memory/user/` holds the user's own preferences, for every
+repository, and `memory/projects/<repo>/` holds one repository's notes, shared by all its git
+worktrees. The system prompt gets a one-line index of both, capped so it costs little context;
+the model reads a note's details with the memory tool.
+
+Notes come from three places: the model's memory tool, the user's /remember, and a short
+reflection when a session ends ("what from this session is worth remembering?"), because local
+models rarely save anything on their own.
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+import difflib
+import hashlib
+import json
+import os
+import re
+import subprocess
+import tempfile
+from dataclasses import dataclass, replace
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from rich.markup import escape
+from rich.panel import Panel
+from rich.text import Text
+
+from lcode import config
+
+if TYPE_CHECKING:
+    from lcode.agent import Agent
+
+TYPES = ("feedback", "project", "reference", "user")
+SCOPES = ("project", "user")
+MAX_DESCRIPTION = 200  # characters: a note's description is one line
+MAX_DETAILS = 1000
+MAX_INDEX_CHARS = 6000  # ~2K tokens of the system prompt at most
+SIMILAR = 0.9  # descriptions this alike say the same thing
+MAX_REFLECTION_NOTES = 3
+# A session is worth a reflection when it had a few requests, or one request with real work in it.
+REFLECT_MIN_REQUESTS = 2
+REFLECT_MIN_TOOL_CALLS = 4
+
+# Never saved: text that looks like a credential. The label tells the model what to leave out.
+SECRET_PATTERNS = [
+    ("a private key", re.compile(r"-----BEGIN [A-Z ]*PRIVATE KEY-----")),
+    ("an AWS access key", re.compile(r"\b(?:AKIA|ASIA)[0-9A-Z]{16}\b")),
+    ("a GitHub token", re.compile(r"\b(?:gh[pousr]_[A-Za-z0-9]{30,}|github_pat_[A-Za-z0-9_]{30,})")),
+    ("a GitLab token", re.compile(r"\bglpat-[A-Za-z0-9_\-]{20,}")),
+    ("a Slack token", re.compile(r"\bxox[abprs]-[A-Za-z0-9-]{10,}")),
+    ("an API key", re.compile(r"\bsk-(?:ant-|proj-)?[A-Za-z0-9_\-]{20,}")),
+    ("a Google API key", re.compile(r"\bAIza[0-9A-Za-z_\-]{35}\b")),
+    ("a JSON Web Token", re.compile(r"\beyJ[A-Za-z0-9_\-]{10,}\.eyJ[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{10,}")),
+    ("a password in a URL", re.compile(r"\b[a-z][a-z0-9+.\-]*://[^\s/:@]+:[^\s/@]+@", re.I)),
+    (
+        "a password or key",
+        re.compile(
+            r"\b(?:password|passwd|pwd|secret|token|api[_ -]?key|access[_ -]?key|client[_ -]?secret)\b"
+            r"\s*[:=]\s*['\"]?[^\s'\"]{6,}",
+            re.I,
+        ),
+    ),
+]
+
+PROMPT = """
+# Memory
+Notes saved in earlier sessions. They can be out of date: if one conflicts with what you find, trust what you find and update or delete the note.
+{index}
+- Save a note with the memory tool when you learn something a future session needs that isn't in the code, git history or AGENTS.md: a correction or preference from the user (feedback), a decision or constraint (project), where something lives outside the repository (reference), or who the user is (user). One fact per note; to change a note, save it again under the same name.
+- Never save code structure, file paths, what you changed in this session, temporary state, or secrets.
+"""
+
+REFLECT_PROMPT = """[lcode] The session is ending. Is there anything from this conversation that a future session in this repository should know, and that isn't in the code, the git history or AGENTS.md? Worth saving:
+- feedback: a correction or preference the user gave ("use pnpm, not npm", "don't add docstrings")
+- project: a decision, constraint or ongoing work in this repository ("the staging database needs the VPN")
+- reference: where something lives outside the repository (a dashboard, tracker or document)
+- user: who the user is (role, expertise) and how they like to work in general
+Not worth saving: code structure, file paths, what changed in this session, anything git records, temporary state, secrets. Most sessions have nothing worth saving: then answer with an empty list. At most {limit} notes. To update an existing note, reuse its name.
+
+Existing notes:
+{existing}
+
+Scope: "project" for anything about this repository (almost always); "user" only for something about the user that holds in every repository.
+
+Answer with JSON only: {{"notes": [{{"type": "feedback", "name": "short-kebab-case-name", "description": "the fact, in one line", "details": "optional: why, and how to apply it", "scope": "project"}}]}}"""
+
+REFLECT_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "notes": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "type": {"type": "string", "enum": list(TYPES)},
+                    "name": {"type": "string"},
+                    "description": {"type": "string"},
+                    "details": {"type": "string"},
+                    "scope": {"type": "string", "enum": list(SCOPES)},
+                },
+                "required": ["type", "name", "description"],
+            },
+        }
+    },
+    "required": ["notes"],
+}
+
+
+class NoteError(ValueError):
+    """A note can't be saved; the message is meant for the model or the user."""
+
+
+@dataclass(frozen=True)
+class Note:
+    name: str
+    type: str
+    description: str
+    details: str = ""
+    modified: str = ""  # YYYY-MM-DD
+    scope: str = "project"
+    path: Path | None = None
+
+    def line(self) -> str:
+        more = ", has details" if self.details else ""
+        return f"- [{self.type}] {self.description} ({self.name}, {self.modified}{more})"
+
+    def render(self) -> str:
+        head = (
+            f"---\nname: {self.name}\ntype: {self.type}\ndescription: {self.description}\n"
+            f"modified: {self.modified}\n---\n"
+        )
+        return head + (f"{self.details.strip()}\n" if self.details.strip() else "")
+
+
+# ----------------------------------------------------------------------------- notes on disk
+
+
+def memory_dir() -> Path:
+    return config.STATE_DIR / "memory"
+
+
+def slugify(text: str, limit: int = 50) -> str:
+    slug = re.sub(r"[^a-z0-9]+", "-", text.lower()).strip("-")
+    if len(slug) > limit:
+        slug = slug[:limit].rsplit("-", 1)[0] or slug[:limit]
+    return slug
+
+
+def _git_common_dir(cwd: Path) -> Path | None:
+    """The repository's git directory, the same for every worktree of it (None outside git)."""
+    env = {k: v for k, v in os.environ.items() if not k.startswith("GIT_")}
+    try:
+        r = subprocess.run(
+            ["git", "rev-parse", "--git-common-dir"], cwd=cwd, capture_output=True, text=True, timeout=10, env=env
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    out = r.stdout.strip()
+    if r.returncode != 0 or not out:
+        return None
+    return (cwd / out).resolve()
+
+
+def project_dir(cwd: Path) -> Path:
+    """Where the notes for the repository around `cwd` live: shared by its worktrees."""
+    common = _git_common_dir(cwd)
+    if common:
+        root = common.parent if common.name == ".git" else common
+        name, ident = root.name.removesuffix(".git"), common
+    else:
+        name, ident = cwd.name, cwd.resolve()
+    key = hashlib.sha256(str(ident).encode()).hexdigest()[:8]
+    return memory_dir() / "projects" / f"{slugify(name, 40) or 'folder'}-{key}"
+
+
+def parse(text: str, scope: str, path: Path | None = None) -> Note | None:
+    m = re.match(r"---\n(.*?)\n---\n?(.*)", text, re.S)
+    if not m:
+        return None
+    fields = {}
+    for line in m.group(1).splitlines():
+        key, sep, value = line.partition(":")
+        if sep:
+            fields[key.strip()] = value.strip()
+    name = path.stem if path else fields.get("name", "")  # the file name, in case an edit changed the header
+    if not name or not fields.get("description"):
+        return None
+    kind = fields.get("type", "project")
+    return Note(
+        name=name,
+        type=kind if kind in TYPES else "project",
+        description=fields["description"],
+        details=m.group(2).strip(),
+        modified=fields.get("modified", ""),
+        scope=scope,
+        path=path,
+    )
+
+
+def find_secret(text: str) -> str | None:
+    """What kind of credential the text seems to contain, if any."""
+    for label, pattern in SECRET_PATTERNS:
+        if pattern.search(text):
+            return label
+    return None
+
+
+def make_note(name: str, type: str, description: str, details: str = "", scope: str = "project") -> Note:
+    """A checked note, ready to save. Raises NoteError explaining what's wrong."""
+    description = " ".join(str(description or "").split())
+    details = str(details or "").strip()
+    if type not in TYPES:
+        raise NoteError(f"type must be one of {', '.join(TYPES)}")
+    if scope not in SCOPES:
+        raise NoteError(f"scope must be one of {', '.join(SCOPES)}")
+    if not description:
+        raise NoteError("description is empty: write the fact in one line")
+    if len(description) > MAX_DESCRIPTION:
+        raise NoteError(
+            f"description is {len(description)} characters; keep it to one line under {MAX_DESCRIPTION} and put "
+            "the rest in details"
+        )
+    if len(details) > MAX_DETAILS:
+        raise NoteError(f"details are {len(details)} characters; keep them under {MAX_DETAILS}")
+    secret = find_secret(f"{name}\n{description}\n{details}")
+    if secret:
+        raise NoteError(f"not saved: it seems to contain {secret}. Never save secrets; describe where they live")
+    slug = slugify(name or description)
+    if not slug:
+        raise NoteError("name is empty: use a short kebab-case name such as use-pnpm")
+    return Note(slug, type, description, details, dt.date.today().isoformat(), scope)
+
+
+class Memory:
+    """The notes for one working directory: the user's own, and its repository's."""
+
+    def __init__(self, cwd: Path):
+        self.cwd = cwd
+        self.project = project_dir(cwd)
+        self.user = memory_dir() / "user"
+
+    def folder(self, scope: str) -> Path:
+        return self.user if scope == "user" else self.project
+
+    def notes(self, scope: str | None = None) -> list[Note]:
+        """User notes first, then the repository's; newest first within each."""
+        found = []
+        for s in [scope] if scope else ["user", "project"]:
+            folder = self.folder(s)
+            if not folder.is_dir():
+                continue
+            mine = []
+            for f in folder.glob("*.md"):
+                if f.name == "MEMORY.md":
+                    continue
+                try:
+                    note = parse(f.read_text(errors="replace"), s, f)
+                except OSError:
+                    continue
+                if note:
+                    mine.append(note)
+            found += sorted(mine, key=lambda n: (n.modified, n.name), reverse=True)
+        return found
+
+    def find(self, name: str, scope: str | None = None) -> Note | None:
+        slug = slugify(name)
+        matches = [n for n in self.notes(scope) if n.name == slug]
+        # A repository note wins over a user note with the same name.
+        return next((n for n in matches if n.scope == "project"), matches[0] if matches else None)
+
+    def similar(self, note: Note) -> Note | None:
+        """A note under another name in the same scope that says nearly the same thing."""
+        wanted = note.description.lower()
+        for other in self.notes(note.scope):
+            ratio = difflib.SequenceMatcher(None, wanted, other.description.lower()).ratio()
+            if other.name != note.name and ratio >= SIMILAR:
+                return other
+        return None
+
+    def save(self, note: Note) -> tuple[Note, bool]:
+        """Save a note, replacing the one with the same name. Returns (note, updated)."""
+        existing = self.find(note.name, note.scope)
+        if existing and not note.details and existing.description == note.description:
+            note = replace(note, details=existing.details)
+        folder = self.folder(note.scope)
+        folder.mkdir(parents=True, exist_ok=True)
+        path = folder / f"{note.name}.md"
+        _write_atomic(path, note.render())
+        self.write_index(note.scope)
+        return replace(note, path=path), existing is not None
+
+    def delete(self, note: Note) -> None:
+        if note.path:
+            note.path.unlink(missing_ok=True)
+        self.write_index(note.scope)
+
+    def write_index(self, scope: str) -> None:
+        """MEMORY.md: a readable list of the notes in a folder. lcode reads the notes themselves."""
+        folder = self.folder(scope)
+        notes = self.notes(scope)
+        if not notes:
+            (folder / "MEMORY.md").unlink(missing_ok=True)
+            return
+        lines = ["# lcode memory", "", "Generated by lcode: edit or delete the notes, not this file.", ""]
+        lines += [n.line() for n in notes]
+        _write_atomic(folder / "MEMORY.md", "\n".join(lines) + "\n")
+
+    def prompt(self, context: int) -> str:
+        """The memory section of the system prompt: the index, within its budget."""
+        budget = min(MAX_INDEX_CHARS, context * 3 // 20)  # at most ~5% of the context window
+        notes = self.notes()
+        shown: list[Note] = []
+        used = 0
+        for note in sorted(notes, key=lambda n: n.modified, reverse=True):
+            cost = len(note.line()) + 1
+            if used + cost > budget:
+                continue
+            shown.append(note)
+            used += cost
+        parts = []
+        for scope, title in (("user", "For every repository:"), ("project", "For this repository:")):
+            lines = [n.line() for n in notes if n in shown and n.scope == scope]
+            if lines:
+                parts.append(title + "\n" + "\n".join(lines))
+        hidden = len(notes) - len(shown)
+        if hidden:
+            parts.append(f'({hidden} older note{"" if hidden == 1 else "s"} not shown: memory action "read" lists all)')
+        return PROMPT.format(index="\n".join(parts) if parts else "(none yet)")
+
+    def counts(self) -> tuple[int, int]:
+        return len(self.notes("project")), len(self.notes("user"))
+
+
+def _write_atomic(path: Path, text: str) -> None:
+    fd, tmp = tempfile.mkstemp(dir=path.parent, prefix=".tmp-", suffix=".partial")
+    try:
+        with os.fdopen(fd, "w") as f:
+            f.write(text)
+        os.replace(tmp, path)
+    except BaseException:
+        Path(tmp).unlink(missing_ok=True)
+        raise
+
+
+# ----------------------------------------------------------------------------- the memory tool
+
+
+def run_tool(agent: Agent, action: str, name: str, type: str, description: str, details: str, scope: str) -> str:
+    memory = agent.memory()
+    if action == "read":
+        if not name:
+            notes = memory.notes()
+            return "\n".join(f"{n.line()} [{n.scope}]" for n in notes) if notes else "No notes yet."
+        note = memory.find(name)
+        if not note:
+            return f"Error: no note named {name!r}. Read without a name to list them."
+        return f"{note.line()} [{note.scope}]\n{note.details or '(no details)'}"
+    if action == "delete":
+        note = memory.find(name)
+        if not note:
+            return f"Error: no note named {name!r}."
+        if not approved(agent, f"Forget this {note.scope} note?", note):
+            return "The user kept the note."
+        memory.delete(note)
+        agent.console.print(Text(f"  ⎿ forgot {note.name}", style="dim"))
+        return f"Deleted the note {note.name!r}."
+    if action != "save":
+        return 'Error: action must be "save", "read" or "delete"'
+    if not scope:
+        scope = "user" if type == "user" else "project"
+    try:
+        note = make_note(name, type, description, details, scope)
+    except NoteError as e:
+        return f"Error: {e}"
+    twin = memory.similar(note)
+    if twin:
+        return (
+            f"Error: the note {twin.name!r} already says nearly the same: {twin.description!r}. To change it, save "
+            f"under the name {twin.name!r}; if this is a different fact, make the description say how it differs."
+        )
+    if not approved(
+        agent, f"Remember this {'for every repository' if scope == 'user' else 'for this repository'}?", note
+    ):
+        return "The user didn't want this saved. Don't try to save it again."
+    saved, updated = memory.save(note)
+    agent.console.print(Text(f"  ⎿ {'updated' if updated else 'remembered'} {saved.name}", style="dim"))
+    return f"{'Updated' if updated else 'Saved'} the {saved.scope} note {saved.name!r}."
+
+
+def approved(agent: Agent, title: str, note: Note) -> bool:
+    if agent.settings.memory == "auto":
+        return True
+    body = Text(f"[{note.type}] {note.description}" + (f"\n{note.details}" if note.details else ""))
+    ok, _ = agent.perms.request("memory", "memory", title, body)
+    return ok
+
+
+# ----------------------------------------------------------------------------- end-of-session reflection
+
+
+def worth_reflecting(messages: list[dict], start: int) -> bool:
+    from lcode.sessions import SUMMARY_PREFIX
+
+    new = messages[start:]
+    requests = sum(
+        1
+        for m in new
+        if m.get("role") == "user" and not str(m.get("content", "")).startswith(("[lcode]", SUMMARY_PREFIX))
+    )
+    tool_calls = sum(1 for m in new if m.get("role") == "tool")
+    return requests >= REFLECT_MIN_REQUESTS or (requests >= 1 and tool_calls >= REFLECT_MIN_TOOL_CALLS)
+
+
+def parse_reflection(content: str) -> list[dict]:
+    """The notes in the model's answer: {"notes": [...]}, a bare list, or JSON inside other text."""
+    data = None
+    for candidate in (content, *re.findall(r"\{.*\}|\[.*\]", content, re.S)):
+        try:
+            data = json.loads(candidate)
+            break
+        except (json.JSONDecodeError, TypeError):
+            continue
+    if isinstance(data, dict):
+        data = data.get("notes")
+    return [item for item in data if isinstance(item, dict)] if isinstance(data, list) else []
+
+
+def propose(agent: Agent) -> list[Note]:
+    """Ask the model which facts from this session a future session should know."""
+    memory = agent.memory()
+    existing = "\n".join(f"{n.line()} [{n.scope}]" for n in memory.notes()) or "(none)"
+    payload = {
+        "model": agent.settings.model,
+        # The same messages and tools as the session, so Ollama reuses the cached prompt.
+        "messages": [
+            *agent.messages,
+            {"role": "user", "content": REFLECT_PROMPT.format(limit=MAX_REFLECTION_NOTES, existing=existing)},
+        ],
+        "tools": agent.tool_schemas(),
+        "think": False,
+        "format": REFLECT_SCHEMA,
+        "keep_alive": agent.settings.keep_alive,
+        "options": agent.options(),
+    }
+    reply = agent.ollama.chat(payload)
+    content = (reply.get("message") or {}).get("content") or ""
+    notes = []
+    for item in parse_reflection(content)[:MAX_REFLECTION_NOTES]:
+        kind = str(item.get("type", "project"))
+        scope = str(item.get("scope") or ("user" if kind == "user" else "project"))
+        description = " ".join(str(item.get("description", "")).split())
+        details = str(item.get("details") or "")
+        if len(description) > MAX_DESCRIPTION:
+            description, details = description[: MAX_DESCRIPTION - 1].rstrip() + "…", (details or description)
+        try:
+            notes.append(make_note(str(item.get("name", "")), kind, description, details[:MAX_DETAILS], scope))
+        except NoteError:
+            continue  # secrets and malformed notes are dropped
+    return [n for n in notes if not memory.similar(n)]  # restatements of notes it already has
+
+
+def reflect(agent: Agent) -> None:
+    """At the end of a session (or before compaction): propose notes, then save the ones the user accepts."""
+    if agent.settings.memory == "off" or not worth_reflecting(agent.messages, agent.reflected):
+        return
+    agent.reflected = len(agent.messages)
+    c = agent.console
+    from lcode.ollama import OllamaError
+
+    try:
+        with c.status("[cyan]Looking for anything worth remembering…[/] [dim](Ctrl+C to skip)[/]", spinner="dots"):
+            notes = propose(agent)
+    except KeyboardInterrupt:
+        c.print("[dim]Skipped the memory check.[/]")
+        return
+    except OllamaError as e:
+        c.print(f"[dim]Couldn't check for anything worth remembering: {escape(str(e))}[/]")
+        return
+    if not notes:
+        return
+    memory = agent.memory()
+    if agent.settings.memory == "ask":
+        rows = []
+        for i, note in enumerate(notes, 1):
+            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"{', updates ' + escape(update.name) if update else ''})[/]"
+                + (f"\n    [dim]{escape(note.details)}[/]" if note.details else "")
+            )
+        c.print(Panel("\n".join(rows), title="Worth remembering?", title_align="left", border_style="blue"))
+        try:
+            answer = input("  Save them? [y]es / numbers to keep, e.g. 1,3 / [n]o: ").strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            answer = "n"
+        if answer in ("n", "no", "none"):
+            return
+        if answer not in ("", "y", "yes", "a", "all"):
+            keep = {int(x) for x in re.findall(r"\d+", answer)}
+            notes = [n for i, n in enumerate(notes, 1) if i in keep]
+    for note in notes:
+        saved, updated = memory.save(note)
+        c.print(Text(f"  {'Updated' if updated else 'Remembered'}: {saved.description}", style="dim"))

lcode/permissions.py

@@ -67,11 +67,16 @@ class Permissions:
         self.mode = PERMISSION_MODES[(PERMISSION_MODES.index(self.mode) + 1) % len(PERMISSION_MODES)]
 
     def request(self, key: str, kind: str, title: str, body: RenderableType) -> tuple[bool, str]:
-        """Ask the user. kind is 'edit', 'bash', 'web' or 'mcp'. Returns (allowed, message for the model)."""
-        if self.mode == "yolo" or key in self.always or (kind == "edit" and self.mode == "auto-edit"):
+        """Ask the user. kind is 'edit', 'bash', 'web', 'mcp' or 'memory'. Returns (allowed, message for the model).
+
+        Memory notes follow the memory setting rather than the mode: with `memory = ask`, even yolo asks.
+        """
+        if key in self.always or (self.mode == "yolo" and kind != "memory"):
+            return True, ""
+        if kind == "edit" and self.mode == "auto-edit":
             return True, ""
         self.console.print(Panel(body, title=title, title_align="left", border_style="yellow"))
-        scope = "file edits" if kind == "edit" else key.split(":", 1)[-1]
+        scope = {"edit": "file edits", "memory": "memory notes"}.get(kind) or key.split(":", 1)[-1]
         if kind == "mcp":
             scope = scope.replace(":", " › ", 1)
         try:

lcode/repl.py

@@ -6,6 +6,9 @@ import html
 import json
 import os
 import re
+import shlex
+import shutil
+import subprocess
 import threading
 from pathlib import Path
 
@@ -22,6 +25,7 @@ from rich.table import Table
 from rich.text import Text
 
 from lcode import __version__, catalog, limits, sessions, web
+from lcode import memory as memory_notes
 from lcode.agent import AUTO_COMPACT_RATIO, INIT_PROMPT, Agent
 from lcode.catalog import MIN_USEFUL_CONTEXT
 from lcode.checkpoints import Checkpoint, CheckpointError, Restore
@@ -39,6 +43,8 @@ COMMANDS = {
     "/undo": "Undo the file changes of the last request (lcode saves a checkpoint before changing files)",
     "/rewind": "Go back to before an earlier request: its files, and optionally the conversation",
     "/checkpoints": "List the requests that changed files, and which files",
+    "/remember": "Save a note for later sessions, e.g. /remember use pnpm, not npm (-g: for every repository)",
+    "/memory": "Notes lcode remembers: /memory, /memory show|edit|delete <number or name>, /memory path",
     "/sandbox": "Shell-command sandbox: status, or /sandbox network on|off",
     "/mcp": "MCP servers and their tools: /mcp, /mcp tools NAME, /mcp login NAME, /mcp restart NAME",
     "/compact": "Summarize the conversation to free context (optional: what to focus on)",
@@ -149,6 +155,7 @@ def banner(agent: Agent) -> None:
                         if agent.sandbox
                         else ""
                     )
+                    + (f"[dim]memory[/]   {memory_status(agent)}\n" if s.memory != "off" else "")
                     + "\n"
                     "[dim]/help for commands · @file to attach · Esc+Enter for a newline[/]"
                 ),
@@ -314,6 +321,129 @@ def mcp_command(agent: Agent, arg: str) -> None:
         agent.prepare_mcp()  # the model sees the server's tools from the next request
 
 
+def memory_status(agent: Agent) -> str:
+    project, user = agent.memory().counts()
+    if not (project or user):
+        return f"{agent.settings.memory} · no notes yet [dim](/remember)[/]"
+    parts = [f"{project} for this repository"] if project else []
+    parts += [f"{user} for every repository"] if user else []
+    total = project + user
+    return f"{agent.settings.memory} · {total} note{'' if total == 1 else 's'}: {', '.join(parts)} [dim](/memory)[/]"
+
+
+def memory_off(agent: Agent) -> bool:
+    if agent.settings.memory != "off":
+        return False
+    agent.console.print(
+        "Memory is off in this session. Turn it on with: lcode config set memory ask (or drop --no-memory)"
+    )
+    return True
+
+
+def remember_command(agent: Agent, arg: str) -> None:
+    """/remember [-g] [type:] text — save a note the user writes, without asking the model."""
+    c = agent.console
+    if memory_off(agent):
+        return
+    words = arg.split()
+    scope = "project"
+    if words and words[0] in ("-g", "--global", "--user"):
+        scope, words = "user", words[1:]
+    text = " ".join(words)
+    if not text:
+        c.print(
+            "Usage: /remember <fact>, e.g. /remember the staging database needs the VPN. "
+            "Add -g for a note for every repository, and start with feedback:, reference: or user: to set its type."
+        )
+        return
+    kind = "user" if scope == "user" else "project"
+    m = re.match(r"(feedback|project|reference|user):\s*(.*)", text, re.I | re.S)
+    if m:
+        kind, text = m.group(1).lower(), m.group(2)
+    description, details = text, ""
+    if len(text) > memory_notes.MAX_DESCRIPTION:
+        description, details = text[: memory_notes.MAX_DESCRIPTION - 1].rstrip() + "…", text
+    try:
+        note = memory_notes.make_note(memory_notes.slugify(description), kind, description, details, scope)
+    except memory_notes.NoteError as e:
+        c.print(f"[red]{escape(str(e))}[/]")
+        return
+    saved, updated = agent.memory().save(note)
+    where = "every repository" if scope == "user" else "this repository"
+    c.print(f"[green]{'Updated' if updated else 'Remembered'} for {where}:[/] {escape(saved.description)}")
+    agent.messages.append(
+        {"role": "user", "content": f"[lcode] The user saved a note that later sessions will see: {saved.description}"}
+    )
+    agent.save()
+
+
+def memory_command(agent: Agent, arg: str) -> None:
+    c = agent.console
+    if memory_off(agent):
+        return
+    memory = agent.memory()
+    notes = memory.notes()
+    action, _, target = arg.partition(" ")
+    target = target.strip()
+    if action == "path":
+        c.print(f"For this repository: {memory.project}\nFor every repository: {memory.user}")
+        return
+    if action in ("", "list"):
+        if not notes:
+            c.print(
+                "No notes yet. lcode saves what later sessions should know: the model with its memory tool, you "
+                "with /remember, and a short check when a session ends."
+            )
+            return
+        table = Table(title="Memory", title_justify="left", header_style="bold")
+        table.add_column("#", justify="right", style="cyan")
+        table.add_column("For")
+        table.add_column("Type")
+        table.add_column("Note")
+        table.add_column("Updated", no_wrap=True)
+        for i, note in enumerate(notes, 1):
+            table.add_row(
+                str(i),
+                "every repo" if note.scope == "user" else "this repo",
+                note.type,
+                f"{escape(note.description)} [dim]{escape(note.name)}[/]",
+                note.modified,
+            )
+        c.print(table)
+        c.print("[dim]/memory show|edit|delete <number or name> · the model sees these at the start of a session[/]")
+        return
+    if action not in ("show", "edit", "delete", "forget"):
+        c.print("[yellow]Use /memory, /memory show|edit|delete <number or name> or /memory path.[/]")
+        return
+    note = notes[int(target) - 1] if target.isdigit() and 1 <= int(target) <= len(notes) else None
+    note = note or (memory.find(target) if target else None)
+    if note is None or note.path is None:
+        c.print(f"[yellow]No note {escape(target)!r}. /memory lists them.[/]" if target else "[yellow]Which note?[/]")
+        return
+    if action == "show":
+        where = "every repository" if note.scope == "user" else "this repository"
+        c.print(
+            Panel(
+                escape(note.render()), title=f"{escape(note.name)} · {where}", title_align="left", border_style="blue"
+            )
+        )
+        c.print(f"[dim]{escape(str(note.path))}[/]")
+    elif action == "edit":
+        editor = os.environ.get("VISUAL") or os.environ.get("EDITOR") or ("nano" if shutil.which("nano") else "vi")
+        try:
+            subprocess.call([*shlex.split(editor), str(note.path)])
+        except OSError as e:
+            c.print(f"[red]Can't start the editor {escape(editor)}: {escape(str(e))}[/]")
+            return
+        if memory_notes.parse(note.path.read_text(errors="replace"), note.scope, note.path) is None:
+            c.print(f"[yellow]{escape(str(note.path))} no longer has a name and description, so lcode ignores it.[/]")
+        memory.write_index(note.scope)
+        c.print("[dim]Saved. The model sees the change from the next session.[/]")
+    elif ask_yes(f"Delete the note '{note.description}'?"):
+        memory.delete(note)
+        c.print(f"Deleted {escape(note.name)}. [dim]The model sees the change from the next session.[/]")
+
+
 def ask_yes(question: str) -> bool:
     try:
         return input(f"  {question} [y/N] ").strip().lower() in ("y", "yes")
@@ -450,6 +580,7 @@ def restore_checkpoint(agent: Agent, target: Checkpoint, rewind: bool) -> None:
         c.print(f"[green]Done:[/] {escape(file_summary(plan, limit=8))}.")
     if truncate:
         agent.messages = agent.messages[:index]
+        agent.reflected = min(agent.reflected, index)
         agent.ctx_used = sum(len(json.dumps(m)) for m in agent.messages) // 3
         c.print(f"The conversation is back to before request {target.n} as well.")
     elif plan.restore or plan.remove:
@@ -525,6 +656,7 @@ def handle_command(agent: Agent, line: str, hardware: Hardware) -> bool:
         )
         c.print(Panel(f"{rows}\n\n  [dim]{keys}[/]", title="lcode commands", border_style="cyan"))
     elif cmd == "/clear":
+        memory_notes.reflect(agent)
         agent.new_session()
         c.print("[green]Started a new conversation.[/] The previous one is saved; /resume brings it back.")
     elif cmd == "/rename":
@@ -544,6 +676,10 @@ def handle_command(agent: Agent, line: str, hardware: Hardware) -> bool:
         rewind_command(agent, arg)
     elif cmd == "/checkpoints":
         print_checkpoints(agent)
+    elif cmd == "/remember":
+        remember_command(agent, arg)
+    elif cmd == "/memory":
+        memory_command(agent, arg)
     elif cmd == "/mcp":
         mcp_command(agent, arg)
     elif cmd == "/sandbox":
@@ -727,6 +863,7 @@ def repl(agent: Agent, prompt: str | None, hardware: Hardware, cont: bool = Fals
             continue
         agent.console.print(Rule(style="dim"))
         run_safely(agent, line)
+    memory_notes.reflect(agent)
     agent.console.print("[dim]Bye.[/]")
 
 

lcode/tools.py

@@ -173,7 +173,34 @@ VIEW_IMAGE_SCHEMA = _fn(
     },
     ["path"],
 )
-TOOL_NAMES = {s["function"]["name"] for s in [*SCHEMAS, WEB_SEARCH_SCHEMA, WEB_FETCH_SCHEMA, VIEW_IMAGE_SCHEMA]}
+MEMORY_SCHEMA = _fn(
+    "memory",
+    "Your memory across sessions. save: keep a fact that a future session needs and that isn't in the code, git "
+    "history or AGENTS.md (one fact per note; saving under an existing name updates that note). delete: remove a "
+    "note that turned out wrong. read: a note's details, or the list of all notes when no name is given.",
+    {
+        "action": {"type": "string", "enum": ["save", "read", "delete"]},
+        "name": {"type": "string", "description": "Short kebab-case name, e.g. use-pnpm"},
+        "type": {
+            "type": "string",
+            "enum": ["feedback", "project", "reference", "user"],
+            "description": "save: feedback = the user's corrections and preferences; project = decisions, "
+            "constraints, ongoing work; reference = where things live outside the repository; user = who the "
+            "user is",
+        },
+        "description": {"type": "string", "description": "save: the fact, in one line"},
+        "details": {"type": "string", "description": "save (optional): why, and how to apply it"},
+        "scope": {
+            "type": "string",
+            "enum": ["project", "user"],
+            "description": "save: project (default) = this repository only; user = every repository",
+        },
+    },
+    ["action"],
+)
+TOOL_NAMES = {
+    s["function"]["name"] for s in [*SCHEMAS, WEB_SEARCH_SCHEMA, WEB_FETCH_SCHEMA, VIEW_IMAGE_SCHEMA, MEMORY_SCHEMA]
+}
 
 
 # ----------------------------------------------------------------------------- helpers
@@ -340,6 +367,16 @@ class Toolbox:
         valid = ", ".join(p if params[p].default is inspect.Parameter.empty else f"{p} (optional)" for p in params)
         return f"{'; '.join(parts)}. Valid arguments: {valid}."
 
+    # -- memory
+    def t_memory(
+        self, action: str, name: str = "", type: str = "", description: str = "", details: str = "", scope: str = ""
+    ) -> str:
+        if self.agent.settings.memory == "off":
+            raise ToolError("memory is turned off")
+        from lcode.memory import run_tool
+
+        return run_tool(self.agent, action, name, type, description, details, scope)
+
     # -- images
     def t_view_image(self, path: str, question: str = "") -> str:
         p = self.path(path)
@@ -365,6 +402,11 @@ class Toolbox:
             if not ok:
                 return feedback
         if mcp.needs_gpu(state, tool):
+            # The tool must finish before lcode's model comes back: a job left running in the
+            # background would compete with it for the GPU.
+            properties = (tool.get("inputSchema") or {}).get("properties") or {}
+            if (properties.get("wait") or {}).get("type") == "boolean" and arguments.get("wait") is not True:
+                arguments = {**arguments, "wait": True}
             freed = self.agent.free_gpu()
             if freed:
                 self.console.print(

{lcode_cli-0.6.0.dist-info → lcode_cli-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.6.0
+Version: 0.7.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/
@@ -82,6 +82,9 @@ through [Ollama](https://ollama.com), and when it needs current information it c
   Podman) that only sees your project, without network access unless you allow it.
 - **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.
+- **Remembers what matters.** Corrections, decisions and where things live carry over to the next
+  session as short notes, saved by the model, by you (`/remember`) or by a quick check at the end
+  of a session. Not whole conversations, and never secrets.
 - **Bring your own model.** Eight curated open-weight models, all tested end to end, or any Ollama model
   with tool calling.
 - **MCP servers, ready to go.** Connect Jira and Confluence, GitHub, AWS, Google Drive, Grafana,
@@ -189,6 +192,10 @@ 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:
 
+- [Parallel subagents](https://github.com/nasser1941/lcode/issues/40) with their own context
+- [Plan mode](https://github.com/nasser1941/lcode/issues/41) and [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))
 
 ## Contributing

{lcode_cli-0.6.0.dist-info → lcode_cli-0.7.0.dist-info}/RECORD

@@ -1,21 +1,22 @@
-lcode/__init__.py,sha256=FWZV2PnebwvlC4fL-VRqLfpH2njKjqCUWaGd0s-R-5c,117
+lcode/__init__.py,sha256=AYDtOJESsR1DlJ0ZwkCOtt-VYOGMMNpCJq6WX274Lz8,117
 lcode/__main__.py,sha256=s5N5pryX2FAu93GGZ3FxUrIXHWGzxz66lKUoaV_h8Ws,35
-lcode/agent.py,sha256=AhUf1l0OEjpizU74HI7yfdRz0q_UAnqFddbyQwdmFx0,32256
+lcode/agent.py,sha256=oqG_t5SgtaZu_rvceNB_E15okpTpC1a4_HN30OYaLwY,33570
 lcode/bench.py,sha256=FCn94Gs7L8bpq4hzf6ILoQG8dKrbbd5WC4BRwrTp4LM,37950
 lcode/catalog.py,sha256=pZ1azX9OH2r4JE2c6E5OfwywpgS39-W2oXzoCHJhmtM,4141
 lcode/checkpoints.py,sha256=eqPtmPe44-aweWqc2H21ROogwzIt3NpvcUobsaCHoGY,18354
-lcode/cli.py,sha256=53MucKCHe9NreYXwDaMEwfHtPS-26kxj7Xg3Bl4yoR8,27506
-lcode/config.py,sha256=VyRHq3ElCGmTQqTdtcGRHGuselm2U8-04ZC3tnEQ6L8,7063
+lcode/cli.py,sha256=Au73avRLxEkq0gnvJ2FjVGhwRw7EkPGkAdOaqpu9Ozw,28040
+lcode/config.py,sha256=E326xMjcoHCP88MfnG_dxmNRlUYHm4A1OwQQoPtgg7g,7518
 lcode/hardware.py,sha256=2VbknZCxTZJwJUD8YWdQ7ryEQo_LcjtoOBOHOU9Y0fw,3085
 lcode/limits.py,sha256=oJzVQoMyTZ0_Fkpu5t3qxrf9v7Hv9S8U8BRQR5M1aKA,1237
+lcode/memory.py,sha256=-gHSbJ4kradOzhlHf38pHzZkb-qe6HQTN1lr2CJ2GJQ,22066
 lcode/models.toml,sha256=lt2G64zzo_Ryxv2ISRSNZoVD_JqCqYqsM01n8WoXGs8,4098
 lcode/ollama.py,sha256=8zxJcMhcxKF3L0vdgrzcoXAj_4MvbybVDSRPbLek0QE,6892
-lcode/permissions.py,sha256=OcWUDLrSoohUWHDUQ3UuBE3zI2JnBnOPizLE3bIgqyU,3982
+lcode/permissions.py,sha256=WhbgvhS6GTpuBbvbpQPHd3F65MtdNlKYjio58lPIyFY,4192
 lcode/render.py,sha256=gMvf4W3qkLUJ4Vot3az_hP_zRDAItJC9pP-68dHFkfA,1375
-lcode/repl.py,sha256=2p6UG1xCmn85YEYcWUtgfoLJc3rHLaGLb_VV-RvzYvw,30332
+lcode/repl.py,sha256=Xke23adGRnGNbqwsjCQ-7rVM2rICoy-UxG38wi9-YxM,36536
 lcode/sandbox.py,sha256=u_pkrVRXhCGhh-wFDPwuZ3jGG7UeXxXRAeBNsm37ZvE,8608
 lcode/sessions.py,sha256=wOR-J0EHgJxLSPboKPHnvBcp5VTUYTj3tZWgpsa6-K4,4013
-lcode/tools.py,sha256=iwt7UINg7xkwz1k_BAXFM-siA6KxC6LHuAjaomBHoRU,30287
+lcode/tools.py,sha256=PVKmnFtXL0mvx7HV0nPLgNuUb4sUjbiGPNpXp37gVOs,32428
 lcode/vision.py,sha256=w33QPmdGwP33wM4mvmAH4amFDZ1xzeXhEsSLJ-STSHY,4243
 lcode/web.py,sha256=vyxKbSRJTl1Lj3hj7Yd_NwTgbv0Xi6dup2YfUXjqp-Y,14579
 lcode/mcp/__init__.py,sha256=XujtAmRoXW9S0uq1XPf_CAeCkHh_UvA8FCmoAKP9j1Y,171
@@ -29,8 +30,8 @@ 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.6.0.dist-info/METADATA,sha256=oMYnPQJlwjwLZls7GP4mxJkTRLmWM0LaVzAsyQdcqiM,10251
-lcode_cli-0.6.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.6.0.dist-info/entry_points.txt,sha256=pZ_uDQ98UzVAHUQeXn5HeyQWKGSH3r3T5aPHuSB89eI,41
-lcode_cli-0.6.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.6.0.dist-info/RECORD,,
+lcode_cli-0.7.0.dist-info/METADATA,sha256=1tegGLTvWCWivTaFxFp0kjftvUML1iK0hEy3lgzIVPw,11143
+lcode_cli-0.7.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.7.0.dist-info/entry_points.txt,sha256=pZ_uDQ98UzVAHUQeXn5HeyQWKGSH3r3T5aPHuSB89eI,41
+lcode_cli-0.7.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.7.0.dist-info/RECORD,,