lcode-cli 0.30.0__py3-none-any.whl → 0.32.0__py3-none-any.whl

lcode/__init__.py

@@ -3,7 +3,7 @@
 From a program: `from lcode import Session` (see lcode.api).
 """
 
-__version__ = "0.30.0"
+__version__ = "0.32.0"
 
 API = ("Session", "Result", "Options", "SetupError")
 

lcode/agent.py

@@ -35,6 +35,7 @@ from lcode import (
     planning,
     repomap,
     residency,
+    review,
     sessions,
     subagents,
     vision,
@@ -112,7 +113,7 @@ SYSTEM_PROMPT = """You are lcode, an autonomous software-engineering agent runni
 - To understand a repository: look at the layout, README/docs, entry points and config, then grep and read the relevant files. Cite code as `path:line`.
 - Read a file before editing it. Use edit_file for targeted changes and write_file for new files or full rewrites. old_string must be copied exactly from the file (without the line-number prefixes).
 - Match the existing code style, naming and structure. Don't add unrequested features.
-- For multi-step tasks, plan with todo_write and keep it updated.
+- For multi-step tasks, plan with todo_write and keep it updated; put decisions and findings you must not lose in its notes.
 - Work autonomously until the task is done. Only stop to ask the user when you are genuinely blocked or the decision is theirs.
 - Don't run destructive or irreversible commands (rm -rf, git reset --hard, git push --force, dropping data) unless the user explicitly asked.
 - If the user denies a tool call, don't retry the same thing; adjust or ask.
@@ -276,6 +277,7 @@ class Settings:
     compact_at: int = 0  # tokens: make room at this size even when the window is larger (0: only at 85%)
     repeat_limit: int = 3  # identical calls with identical results before the model is told (lcode.repeats)
     checks: str = "off"  # the project's checks after a change (lcode.checks): auto, off or a command
+    review: str = "off"  # check a change against the request before the answer (lcode.review): auto or off
 
 
 class Agent:
@@ -334,6 +336,7 @@ class Agent:
         self.autosave = False  # save the session after every step (sessions people resume; not the bench's)
         self._check: tuple[Path, checks.Check | None] | None = None
         self.check_results: list[dict] = []  # the checks of the last request: command, exit code, who ran them
+        self.review_results: list[str] | None = None  # what the last request's review found (None: no review)
         self.sent_chars = 0  # characters of the conversation the model had already read
         self.counted_chars: int | None = None  # characters that ctx_used covers (None: all of them)
         self.turn_status = ""  # how the last request ended: success, max_steps, loop
@@ -613,6 +616,9 @@ class Agent:
             "title": self.session_title,
             "messages": self.messages,
             "checkpoints": self.checkpoints.to_json(),
+            "todos": self.tools.todos,
+            "notes": self.tools.notes,
+            "changed": list(self.tools.changed),
         }
         # Written next to it and then renamed: a crash halfway leaves the previous version, not a broken file.
         partial = f.with_name(f".{f.name}.partial")
@@ -626,6 +632,8 @@ class Agent:
         self.session_name = ""
         self.session_title = ""
         self.checkpoints.reset(self.session_id)
+        self.tools.todos, self.tools.notes, self.tools.changed = [], [], {}
+        self.check_results = []
 
     def rename(self, name: str) -> None:
         self.session_name = " ".join(name.split())
@@ -652,6 +660,9 @@ 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.tools.todos = list(data.get("todos") or [])
+        self.tools.notes = [str(n) for n in data.get("notes") or []]
+        self.tools.changed = dict.fromkeys(str(f) for f in data.get("changed") or [])
         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
         self.counted_chars = None
@@ -823,6 +834,48 @@ class Agent:
             self.last_speed = final.get("eval_count", 0) / seconds if seconds else 0.0
         return message
 
+    def reviewing(self) -> bool:
+        return (
+            self.settings.review != "off" and self.allowed_tools is None and not self.planning() and not self.no_changes
+        )
+
+    def self_review(self, answer: str) -> list[str]:
+        """Check the request's change against the request before the answer counts; the problems found."""
+        budget = int(self.settings.context * 3 * 0.25)
+        diff, changed = review.diff_of(self.tools.before, self.current_text, budget)
+        if changed < review.MIN_CHANGED_LINES:
+            return []
+        request = next(
+            (
+                context_tools.request_text(str(m.get("content", "")))
+                for m in reversed(self.messages)
+                if m.get("role") == "user"
+                and not str(m.get("content", "")).startswith(("[lcode]", sessions.SUMMARY_PREFIX))
+            ),
+            "",
+        )
+        try:
+            with self.console.status("Reviewing the change against your request…", spinner="dots"):
+                problems = review.run(self, request, answer, diff)
+        except OllamaError as e:
+            self.say(f"The review didn't run: {e}", warning=True)
+            return []
+        self.review_results = problems
+        if problems:
+            self.say(
+                f"Review: {len(problems)} point(s) sent back to the model. First: {problems[0][:160]}", warning=True
+            )
+        else:
+            self.say("Review: the change does what was asked.")
+        return problems
+
+    def current_text(self, path: str) -> str | None:
+        p = self.tools.resolve(path)
+        try:
+            return self.tools.read_text(p) if p.is_file() else None
+        except OSError:
+            return None
+
     def checks_prompt(self) -> str:
         check = self.project_check()
         if check is None:
@@ -1018,6 +1071,9 @@ class Agent:
         self.messages.append({"role": "user", "content": self.expand_mentions(user_text) + note})
         self.repeats.reset()
         self.check_results = []
+        self.review_results = None
+        self.tools.before = {}
+        reviewed = False
         changed = verified = False  # files changed in this request; the checks passed since
         check_rounds = 0
         malformed = 0
@@ -1079,6 +1135,12 @@ class Agent:
                         changed = False  # run them again only if the model changes something more
                         continue
                     verified = True
+                if not reviewed and self.tools.before and self.reviewing():
+                    reviewed = True
+                    problems = self.self_review(reply.get("content") or "")
+                    if problems:
+                        self.messages.append({"role": "user", "content": review.feedback(problems)})
+                        continue
                 break
             done: dict[int, str] = {}  # results of subagents that ran together
             together = [
@@ -1289,6 +1351,8 @@ class Agent:
                     self.messages, keep=1, removed=removed
                 )  # not enough: before the last request
             context_tools.note_removed(self.messages, removed)
+            if saved:
+                context_tools.pin(self.messages, context_tools.task_sheet(self))
             if saved:
                 self.sent_chars = 0  # the conversation changed: the model reads it again
                 self.pruned += 1
@@ -1333,7 +1397,9 @@ class Agent:
             {"role": "system", "content": self.system_prompt()},
             {
                 "role": "user",
-                "content": f"{sessions.SUMMARY_PREFIX}\n\n{summary}" + context_tools.requests_block(requests),
+                "content": f"{sessions.SUMMARY_PREFIX}\n\n{summary}"
+                + context_tools.requests_block(requests)
+                + (f"\n\n{sheet}" if (sheet := context_tools.task_sheet(self)) else ""),
             },
             {"role": "assistant", "content": "Got it — I have the context from the summary and will continue."},
         ]

lcode/api.py

@@ -77,6 +77,7 @@ class Result:
     files_changed: list[dict] = field(default_factory=list)  # {"status": "A" | "M" | "D", "path"}
     usage: dict = field(default_factory=dict)  # requests, prompt_tokens, output_tokens
     checks: list[dict] = field(default_factory=list)  # {"command", "exit_code", "by": "lcode" | "model"}
+    review: list[str] | None = None  # problems the review sent back ([] when it found none; None: no review)
     seconds: float = 0.0
     error: str = ""
 
@@ -198,6 +199,7 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
         secret_check=cfg["secret_check"],
         repeat_limit=cfg["repeat_limit"],
         checks=cfg["checks"],
+        review=cfg["review"],
         compact_at=cfg["compact_at"],
     )
     agent = Agent(ollama, settings, cwd, console=console)
@@ -306,6 +308,7 @@ def run_request(agent: Agent, prompt: str) -> Result:
         files_changed=files,
         usage=usage,
         checks=list(agent.check_results),
+        review=agent.review_results,
         seconds=round(time.monotonic() - started, 2),
         error=error,
     )

lcode/cli.py

@@ -581,6 +581,7 @@ def cmd_bench(args) -> None:
             prune=not args.no_prune,
             compact_at=cfg["compact_at"] if args.compact_at is None else args.compact_at,
             checks=cfg["checks"] if args.checks is None else args.checks,
+            review=cfg["review"] if args.review is None else args.review,
             repo_map=args.repo_map,
             embed_model=cfg["embed_model"] if args.code_search else "off",
         )
@@ -775,6 +776,9 @@ def build_subparsers() -> dict[str, argparse.ArgumentParser]:
     p.add_argument("--repo-map", action="store_true", help="give the model the repository map (off by default)")
     p.add_argument("--code-search", action="store_true", help="index each task's folder and offer semantic code search")
     p.add_argument("--no-prune", action="store_true", help="don't remove old tool output (to compare, with --session)")
+    p.add_argument(
+        "--review", choices=["auto", "off"], help="review each change before it counts (default: the setting)"
+    )
     p.add_argument(
         "--checks",
         metavar="auto|off|COMMAND",

lcode/config.py

@@ -59,6 +59,7 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "subagents": (True, bool, "let the model hand tasks to subagents that have their own context"),
     "notify": (True, bool, "desktop notification when a long request is done or waits for you"),
     "notify_after": (30, int, "seconds a request runs before it notifies (with notify on)"),
+    "review": ("off", str, "before the answer, check a change against the request and send problems back: auto | off"),
     "checks": ("auto", str, "run the project's checks before calling work done: auto | off | a command"),
     "repeat_limit": (3, int, "identical tool calls with identical results before lcode steps in (0: never)"),
     "secret_check": (True, bool, "before git commit and git push, look for passwords, keys and tokens they'd add"),

lcode/context.py

@@ -49,7 +49,9 @@ REQUESTS_HEADER = "[The user's requests in this conversation, word for word, old
 MAX_REQUESTS = 8  # the most recent ones are kept through a summary
 MAX_REQUEST_CHARS = 1500
 # What lcode appends to the user's words: attached files, images and folders, and its own notes.
-ATTACHED = re.compile(r"\n\n(?:<file path=|<image path=|<directory path=|\[lcode[:\]] |\[The user wants the )")
+ATTACHED = re.compile(
+    r"\n\n(?:<file path=|<image path=|<directory path=|\[lcode[:\]] |\[The user wants the )"
+)  # also the sheet
 
 
 def request_text(content: str) -> str:
@@ -187,6 +189,51 @@ def prune(messages: list[dict], keep: int = KEEP_RECENT_REQUESTS, removed: list[
     return saved
 
 
+SHEET_HEADER = "[lcode] Task sheet: the plan, notes and changes so far, kept when old messages are removed"
+MAX_SHEET = 3000  # characters
+
+
+def task_sheet(agent: Agent) -> str:
+    """The state of the work, from lcode's own records: the todo list and the model's notes (todo_write), the
+    files changed in the session and the last check. Pinned where old messages go: in summaries and next to the
+    request when tool output is removed."""
+    tools = agent.tools
+    parts = []
+    if tools.todos:
+        marks = {"completed": "[x]", "in_progress": "[>]", "pending": "[ ]"}
+        plan = "\n".join(f"{marks.get(t.get('status', ''), '[ ]')} {t.get('content', '')}" for t in tools.todos)
+        parts.append(f"Plan:\n{plan}")
+    if tools.notes:
+        parts.append("Notes:\n" + "\n".join(f"- {note}" for note in tools.notes))
+    if tools.changed:
+        files = list(tools.changed)
+        more = f" and {len(files) - 30} more" if len(files) > 30 else ""
+        parts.append("Files changed in this session: " + ", ".join(files[-30:]) + more)
+    if agent.check_results:
+        last = agent.check_results[-1]
+        code = last.get("exit_code")
+        state = "passed" if code == 0 else "didn't run" if code is None else f"failed (exit code {code})"
+        parts.append(f"Last check: `{last.get('command')}` {state}")
+    if not parts:
+        return ""
+    sheet = "\n\n".join(parts)
+    if len(sheet) > MAX_SHEET:
+        sheet = sheet[: MAX_SHEET - 20] + "\n[…cut]"
+    return f"{SHEET_HEADER}\n{sheet}"
+
+
+def pin(messages: list[dict], text: str) -> None:
+    """Put a note next to the request the model is working on, replacing an earlier sheet there."""
+    if not text:
+        return
+    for message in reversed(messages):
+        content = str(message.get("content", ""))
+        if message.get("role") == "user" and not content.startswith(("[lcode]", SUMMARY_PREFIX)):
+            content = content.split("\n\n" + SHEET_HEADER, 1)[0]
+            message["content"] = f"{content}\n\n{text}"
+            return
+
+
 def note_removed(messages: list[dict], removed: list[str]) -> None:
     """Tell the model, next to the request it's working on, which files it no longer has: a stub deep in the
     conversation is easy to overlook, and models then answer from memory instead of reading again."""

lcode/repl.py

@@ -63,6 +63,7 @@ COMMANDS = {
     "/mode": "Permission mode: ask | plan | auto-edit | yolo (Shift+Tab cycles)",
     "/cd": "Change the working directory",
     "/todos": "Show the current todo list",
+    "/status": "The task sheet: your requests, the plan and notes, files changed, the last check",
     "/jobs": "Background commands the model started: /jobs, /jobs stop <id>",
     "/commit": "Commit the changes with a message in the repository's style, after you approve it",
     "/review": "Review the uncommitted changes, or the branch against a base: /review [base]",
@@ -109,6 +110,31 @@ def mention(path: Path) -> str:
     return f'@"{shown}"' if " " in shown else f"@{shown}"
 
 
+def status_command(agent: Agent) -> None:
+    """What the session is doing, as lcode keeps it for the model (the task sheet)."""
+    c = agent.console
+    requests = context_tools.user_requests(agent.messages)
+    if not requests and not agent.tools.todos and not agent.tools.changed:
+        c.print("Nothing yet: no requests in this session.")
+        return
+    if requests:
+        latest = requests[-3:]
+        lines = [f"[dim]{len(requests) - len(latest) + i + 1}.[/] {escape(r[:300])}" for i, r in enumerate(latest)]
+        c.print(Panel("\n".join(lines), title="Requests (latest)", title_align="left", border_style="cyan"))
+    if agent.tools.todos or agent.tools.notes:
+        agent.tools.show_todos()
+    if agent.tools.changed:
+        c.print(f"[bold]Files changed:[/] {escape(', '.join(agent.tools.changed))}")
+    if agent.check_results:
+        last = agent.check_results[-1]
+        code = last.get("exit_code")
+        state = (
+            "[green]passed[/]" if code == 0 else "didn't run" if code is None else f"[red]failed[/] (exit code {code})"
+        )
+        c.print(f"[bold]Last check:[/] {escape(str(last.get('command')))} {state}")
+    c.print("[dim]The model keeps this too, even when old messages are removed or summarized.[/]")
+
+
 def build_session(agent: Agent) -> PromptSession:
     kb = KeyBindings()
 
@@ -978,6 +1004,8 @@ def handle_command(agent: Agent, line: str, hardware: Hardware) -> bool:
             c.print(f"Working directory: {p}")
         else:
             c.print(f"[red]Not a directory: {p}[/]")
+    elif cmd == "/status":
+        status_command(agent)
     elif cmd == "/todos":
         agent.tools.show_todos()
     elif cmd == "/jobs":

lcode/review.py

@@ -0,0 +1,103 @@
+"""A second look at a change before the answer goes to the user.
+
+Models claim more than they did: "users can now shrink the window" without having checked, half of a
+two-part request done, a debug print left behind. So when a request changed files, lcode asks the model to
+step back and check its change against the request (what was asked, what the diff shows, what the answer
+claims) before the answer counts. Real problems go back to the model once; the user sees a line about it.
+
+The review is asked on top of the conversation, not in a fresh one: the model server keeps the processed
+conversation cached, and a separate review prompt would push it out, so the next step would have to read the
+whole conversation again, tens of seconds on a small GPU. The question tells the model to judge only from the
+request and the diff.
+"""
+
+from __future__ import annotations
+
+import difflib
+from typing import TYPE_CHECKING
+
+from lcode.gitflow import parse_json
+
+if TYPE_CHECKING:
+    from lcode.agent import Agent
+
+MIN_CHANGED_LINES = 1  # even one line: a one-line bug fix is where a wrong fix hides
+MAX_PROBLEMS = 5
+SCHEMA = {
+    "type": "object",
+    "properties": {"problems": {"type": "array", "items": {"type": "string"}}},
+    "required": ["problems"],
+}
+PROMPT = """[lcode] Before your answer goes to the user, review your change as a strict reviewer would: judge it only by what the user asked and what the diff shows, not by what you meant to do.
+
+The user's request:
+<request>
+{request}
+</request>
+
+Your answer to them:
+<answer>
+{answer}
+</answer>
+
+{checks}The change (unified diff of the files changed in this request):
+<diff>
+{diff}
+</diff>
+
+Find real problems only, each one you can point to in the request or the diff:
+1. Something the user asked for that the change doesn't do, or only partly does.
+2. A claim in your answer that the diff doesn't support, or something called tested or working that nothing shows was run.
+3. A mistake in the diff: a bug, a broken edge case the request mentions, leftover debugging (prints, commented-out code), an unfinished TODO.
+No style preferences, no suggestions beyond the request. Answer in JSON: {{"problems": ["…"]}}, with an empty list when the change does what was asked."""
+
+FEEDBACK = """[lcode] A review of your change against the user's request found:
+{problems}
+
+Fix what's real; if a point is wrong, say why in your answer. Then finish."""
+
+
+def diff_of(before: dict[str, str | None], read, budget: int) -> tuple[str, int]:
+    """The unified diff of the files changed in the request, and how many lines it changes."""
+    parts, changed = [], 0
+    for path, old in before.items():
+        new = read(path)
+        if new is None or new == old:
+            continue
+        lines = list(
+            difflib.unified_diff((old or "").splitlines(True), new.splitlines(True), f"a/{path}", f"b/{path}", n=2)
+        )
+        changed += sum(1 for line in lines if line[:1] in "+-" and not line.startswith(("+++", "---")))
+        parts.append("".join(lines))
+    text = "".join(parts)
+    if len(text) > budget:
+        text = text[:budget] + f"\n[… the rest of the diff ({len(text) - budget} characters) is cut]"
+    return text, changed
+
+
+def run(agent: Agent, request: str, answer: str, diff: str) -> list[str]:
+    """Ask for the review; the problems it found (empty when none, or when the answer can't be read)."""
+    checks = ""
+    if agent.check_results:
+        last = agent.check_results[-1]
+        code = last.get("exit_code")
+        state = "passed" if code == 0 else "didn't run" if code is None else f"failed (exit code {code})"
+        checks = f"The project's checks (`{last.get('command')}`) {state} after the change.\n\n"
+    prompt = PROMPT.format(request=request[:4000], answer=answer[:3000] or "(none)", checks=checks, diff=diff)
+    payload = {
+        "model": agent.settings.model,
+        "messages": [*agent.messages, {"role": "user", "content": prompt}],
+        "tools": agent.tool_schemas(),  # as in the session, so the cached conversation is reused
+        "think": agent.settings.think,  # without reasoning it missed every gap it caught with it, and wasn't faster
+        "format": SCHEMA,
+        "keep_alive": agent.settings.keep_alive,
+        "options": agent.options(),
+    }
+    reply = agent.ollama.chat(payload)
+    data = parse_json((reply.get("message") or {}).get("content") or "")
+    problems = data.get("problems") if isinstance(data.get("problems"), list) else []
+    return [str(p).strip()[:500] for p in problems if str(p).strip()][:MAX_PROBLEMS]
+
+
+def feedback(problems: list[str]) -> str:
+    return FEEDBACK.format(problems="\n".join(f"- {p}" for p in problems))

lcode/tools.py

@@ -24,6 +24,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 from rich.console import Group
+from rich.markup import escape
 from rich.panel import Panel
 from rich.syntax import Syntax
 from rich.text import Text
@@ -45,6 +46,7 @@ NO_NETWORK = re.compile(
 )
 MAX_TOOL_OUTPUT = 30_000  # characters returned to the model per tool call
 PENDING_LINES = 5000  # output lines waiting to be read, at most
+MAX_NOTES, MAX_NOTE = 12, 300  # the model's task notes: how many, how long each
 LEFTOVER_GRACE = 0.5  # seconds to wait for output after a command ends, before stopping what it left running
 IGNORE_DIRS = {
     ".git", "node_modules", "__pycache__", ".venv", "venv", "env", ".mypy_cache", ".pytest_cache",
@@ -161,7 +163,8 @@ SCHEMAS = [
     _fn(
         "todo_write",
         "Create or update your task list for multi-step work. Pass the full list every time. Keep exactly one "
-        "item in_progress while working.",
+        "item in_progress while working. In `notes`, keep what you must not forget: decisions and why, findings, "
+        "open questions. The list and the notes stay with you even when old messages are removed.",
         {
             "todos": {
                 "type": "array",
@@ -173,7 +176,12 @@ SCHEMAS = [
                     },
                     "required": ["content", "status"],
                 },
-            }
+            },
+            "notes": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Short notes, the full list each time (omit to keep the current ones)",
+            },
         },
         ["todos"],
     ),
@@ -438,6 +446,9 @@ class Toolbox:
         self.agent = agent
         self.read_mtimes: dict[str, float] = {}
         self.formats: dict[str, TextFormat] = {}  # encoding and line endings of the files read
+        self.notes: list[str] = []  # the model's notes on the task (todo_write): decisions, findings, questions
+        self.changed: dict[str, None] = {}  # files lcode wrote in this session, in order
+        self.before: dict[str, str | None] = {}  # files changed in this request: their text before (None: new)
         self.todos: list[dict] = []
         # An editor's buffers (lcode acp): read unsaved changes and write through the editor.
         self.reader: Callable[[Path], str | None] | None = None
@@ -860,11 +871,14 @@ class Toolbox:
         p.parent.mkdir(parents=True, exist_ok=True)
         fmt = self.formats.get(str(p)) or (decode(p.read_bytes())[1] if p.exists() else TextFormat())
         data = encode(content, fmt)  # before anything is written: it may not be possible
+        if self.rel(p) not in self.before:
+            self.before[self.rel(p)] = decode(p.read_bytes())[0] if p.exists() else None
         if self.writer is not None:
             self.writer(p, content)  # the editor updates its buffer (and the file)
         if not p.exists() or p.read_bytes() != data:
             p.write_bytes(data)  # the file on disk must match, for checkpoints and the tools
         self.read_mtimes[str(p)] = p.stat().st_mtime
+        self.changed[self.rel(p)] = None
 
     def t_write_file(self, path: str, content: str) -> str:
         p = self.path(path)
@@ -1248,12 +1262,29 @@ class Toolbox:
         return f"[{describe(job)}]" + (f"\nIts last output:\n{last}" if last else "")
 
     # -- planning
-    def t_todo_write(self, todos: list | str) -> str:
+    def t_todo_write(self, todos: list | str, notes: list | str | None = None) -> str:
         if isinstance(todos, str):
             todos = json.loads(todos)
         self.todos = list(todos)
+        # Small models often put a note inside an item instead of in `notes`: keep it either way.
+        attached = [
+            str(todo.get(key)).strip()
+            for todo in self.todos
+            if isinstance(todo, dict)
+            for key in ("notes", "note", "details")
+            if str(todo.get(key) or "").strip()
+        ]
+        if attached:
+            notes = [*([] if notes is None else ([notes] if isinstance(notes, str) else list(notes))), *attached]
+        if notes is not None:
+            if isinstance(notes, str):
+                try:
+                    notes = json.loads(notes)
+                except ValueError:
+                    notes = [notes]
+            self.notes = [str(n).strip()[:MAX_NOTE] for n in notes if str(n).strip()][:MAX_NOTES]
         self.show_todos()
-        return "Todo list updated."
+        return "Todo list updated." + (f" {len(self.notes)} note(s) kept." if notes is not None else "")
 
     def show_todos(self) -> None:
         icons = {"completed": "[green]✔[/]", "in_progress": "[yellow]◐[/]", "pending": "[dim]○[/]"}
@@ -1265,4 +1296,6 @@ class Toolbox:
             elif status == "in_progress":
                 text = f"[bold]{text}[/]"
             rows.append(f"{icons.get(status, '○')} {text}")
+        if self.notes:
+            rows += ["", *(f"[dim]•[/] {escape(note)}" for note in self.notes)]
         self.console.print(Panel("\n".join(rows) or "(empty)", title="Todos", title_align="left", border_style="blue"))

{lcode_cli-0.30.0.dist-info → lcode_cli-0.32.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.30.0
+Version: 0.32.0
 Summary: A local-first terminal coding agent powered by open-weight models on your own GPU or Mac, via Ollama.
 Project-URL: Homepage, https://nasser1941.github.io/lcode/
 Project-URL: Documentation, https://nasser1941.github.io/lcode/

{lcode_cli-0.30.0.dist-info → lcode_cli-0.32.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-lcode/__init__.py,sha256=_ncPdkojpmAnL6Af19KuRAd4o_TixpnzWrgz3usKy0A,473
+lcode/__init__.py,sha256=WYtKNLgt5PjAq5IrasutTzXxW9RCwY4T0ZQs0OxnnLs,473
 lcode/__main__.py,sha256=s5N5pryX2FAu93GGZ3FxUrIXHWGzxz66lKUoaV_h8Ws,35
 lcode/acp.py,sha256=d97VV3sbqXdWKhPQQNbYRaDTm8WrUk0mGbDLiOyX7jE,29058
 lcode/action.py,sha256=wuT5F9EJCdEligPeytzmEi8FpahWBhXer528tpuTj_k,16711
-lcode/agent.py,sha256=CVOyaV_KJQor1zlW2zou3iQXzf9UPV-3emTmuqJ5JVE,69562
-lcode/api.py,sha256=PhG8PZReM7DXSxG6wf7mEjAKx_TAsgj3xHApacrXGCM,15684
+lcode/agent.py,sha256=ztjxSzYkvUvwuHVEI9piFnuOV8glHBe9ULNIk7x2HKQ,72682
+lcode/api.py,sha256=YTfXVMSYSp1EC3tNI_fW-JcNBgrdFTN7V57HNIzB7Kc,15861
 lcode/backends.py,sha256=dtJHrC6ys73bRDg64z0tQz1PavmeAkiODZu1fOO9ExQ,20635
 lcode/bench.py,sha256=KDgPnkceZOS3gDDEl5j6-k8Ser2es4-IuV_S8p_46Zo,41517
 lcode/bench_backend.py,sha256=X2fo-zRX92Xp3KMxSsFlWioc2vRupBTtowj5kLME8mw,14287
@@ -11,11 +11,11 @@ lcode/bench_runtime.py,sha256=EjzNgIvUkdbT8cbSy1TpmlyeIk6e-ipjlDFpM7Dnqx0,6835
 lcode/catalog.py,sha256=pZ1azX9OH2r4JE2c6E5OfwywpgS39-W2oXzoCHJhmtM,4141
 lcode/checkpoints.py,sha256=eqPtmPe44-aweWqc2H21ROogwzIt3NpvcUobsaCHoGY,18354
 lcode/checks.py,sha256=FOD8DOxPWXY1RMtrL9ONJsOxsV10BLgzPvzIJMK5NrU,6582
-lcode/cli.py,sha256=svnW6pfLtqiMXbA3wMlYESKGgGe6Xb9wlWkqg6Cz0O0,41081
+lcode/cli.py,sha256=pB8gnPuVkqanm9amuLKWanH3_0onpn8oS8botxl-DSw,41292
 lcode/clipboard.py,sha256=nTSdJyCXPdtjH947RjvB3QvRqnL5HZsS9KB8EkC42cc,5138
 lcode/codesearch.py,sha256=Io8leN1nb_Y-Dvlm9xaGtwUWYXX-ooswuznJV6dGU1s,10766
-lcode/config.py,sha256=KSjSBvxA9nmd4h4QYk3xp8BQ7C04pjTULsSn0jcQwBc,11301
-lcode/context.py,sha256=WSMiitscDh2Juy4Hx0x9EPNWrn804IbOWRZly1-DU38,17022
+lcode/config.py,sha256=CujFZiUPsbZERjPw2j_uTBnZqUfCgYz1hvcvQSSMCu0,11421
+lcode/context.py,sha256=0YYLrC7gI164HqDjW_jrgHSnfrAilrRUoTLhvw54VI8,19082
 lcode/extensions.py,sha256=W0HFDl0BvROzr7i_qtabHdIbacBgP5o5qIJLzoM2oNE,16806
 lcode/frontmatter.py,sha256=Bx0n4vLPhp7ZCWx-g7xqzqNy5VoKBxyeeikh5UFB_gA,2441
 lcode/gitflow.py,sha256=6j_nnCBZXkX1qhTI7K4CyZ5D0NAZLpH96weFEo64AkQ,27913
@@ -33,14 +33,15 @@ lcode/permissions.py,sha256=3OPVVth6uTE5kcAWMZ8X_vUnFRbf6STEHAJimZX0Yu4,12118
 lcode/planning.py,sha256=Q2upaoZPnXDMQT2F-ETxX1lk_wDntTzhSKNVYIQSoQA,6540
 lcode/render.py,sha256=gMvf4W3qkLUJ4Vot3az_hP_zRDAItJC9pP-68dHFkfA,1375
 lcode/repeats.py,sha256=-vcbj363nFcIyso7yFJgsbHz9C6VOu2EOg3Svs4eFyE,4091
-lcode/repl.py,sha256=ayrKySMbbRbax_WMjqYBN4fkcDpzuHniefJC3DZ4-2Y,50687
+lcode/repl.py,sha256=0f3nojURlQE8Pm_JkXvh9y7nEg1CHG3xanZIs0osPxw,52107
 lcode/repomap.py,sha256=1GRJgEUjBl9XHSXsF7tSGXBCEgsY-3CzwMohaTudZ_M,13969
 lcode/residency.py,sha256=bDB2J0SZULDOz6wYuMCnkjacYk7pWi5f75iY83ycAXQ,6912
+lcode/review.py,sha256=0QBIS-R1B2b3zqx5TcC1qZptpKBbrDhYvMKSNCaDAUo,4686
 lcode/sandbox.py,sha256=u_pkrVRXhCGhh-wFDPwuZ3jGG7UeXxXRAeBNsm37ZvE,8608
 lcode/secretscan.py,sha256=6Euvfk2gCtK7lZbuQD84zgWuSECi6OnSw8V5rFu1tfU,13575
 lcode/sessions.py,sha256=wOR-J0EHgJxLSPboKPHnvBcp5VTUYTj3tZWgpsa6-K4,4013
 lcode/subagents.py,sha256=GGn2E7QUwEsShJEHXaMhG53leyGFUZwJku_n33gJguU,29157
-lcode/tools.py,sha256=1zH4hkEyHQz4byV348J4zfe0VzwvjmlH1MOqiobznbA,59446
+lcode/tools.py,sha256=5qaQISmPqkQiM7i1b1_3lDxbokugGRyGNOmSHOBAFDQ,61426
 lcode/update.py,sha256=i92bnW252VneYh0vD6djxmXsDOa5MXP20bjlLZUue_c,25236
 lcode/vision.py,sha256=w33QPmdGwP33wM4mvmAH4amFDZ1xzeXhEsSLJ-STSHY,4243
 lcode/web.py,sha256=vyxKbSRJTl1Lj3hj7Yd_NwTgbv0Xi6dup2YfUXjqp-Y,14579
@@ -60,8 +61,8 @@ 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/servers/xai.py,sha256=h2emAvHSnkuB9WmJInlynsDhvxJwNVD2AHFX7vqMXNc,13627
-lcode_cli-0.30.0.dist-info/METADATA,sha256=s6dAfe3HCeh9LIPNLLoYY3VGXfGT6b8ZW0pZbERa6X0,12620
-lcode_cli-0.30.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.30.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
-lcode_cli-0.30.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.30.0.dist-info/RECORD,,
+lcode_cli-0.32.0.dist-info/METADATA,sha256=QWfst181FXU5mfBDoHdf_9FpIj_SJvVAkbSdvNNv5lo,12620
+lcode_cli-0.32.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.32.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
+lcode_cli-0.32.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.32.0.dist-info/RECORD,,