lcode-cli 0.19.0__py3-none-any.whl → 0.20.0__py3-none-any.whl

lcode/__init__.py

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

lcode/acp.py

@@ -46,7 +46,7 @@ KINDS = {
     "read_file": "read", "view_image": "read", "list_dir": "search", "glob": "search", "grep": "search",
     "repo_map": "search", "search_code": "search", "lsp": "search", "edit_file": "edit", "write_file": "edit",
     "bash": "execute", "web_search": "fetch", "web_fetch": "fetch", "agent": "think", "todo_write": "think",
-    "present_plan": "switch_mode",
+    "present_plan": "switch_mode", "bash_output": "read", "bash_stop": "execute",
 }  # fmt: skip
 STOP = {"success": "end_turn", "max_steps": "max_turn_requests", "interrupted": "cancelled"}
 MAX_INLINE = 200_000  # bytes of a file the editor attaches that go into the prompt

lcode/agent.py

@@ -22,11 +22,12 @@ from rich.markup import escape
 from rich.panel import Panel
 from rich.text import Text
 
-from lcode import catalog, codesearch, extensions, limits, planning, repomap, sessions, subagents, vision, web
+from lcode import catalog, codesearch, extensions, limits, notify, planning, repomap, sessions, subagents, vision, web
 from lcode import context as context_tools
 from lcode import memory as memory_notes
 from lcode.checkpoints import Checkpoints
 from lcode.config import format_tokens
+from lcode.jobs import Jobs
 from lcode.mcp import McpManager
 from lcode.ollama import Ollama, OllamaError
 from lcode.permissions import Permissions
@@ -212,6 +213,8 @@ class Settings:
     lsp: str = "off"  # auto: use the installed language servers (lcode.lsp)
     repo_map: bool = False  # the repository map (lcode.repomap)
     embed_model: str = "off"  # semantic code search (lcode.codesearch): auto, off or a model
+    notify: bool = False  # desktop notifications after long requests (lcode.notify)
+    notify_after: int = 30  # seconds: a request this long notifies when it's done or waits for an answer
     max_parallel_agents: int = 1
 
 
@@ -256,6 +259,8 @@ class Agent:
         self.no_changes = ""  # set during a review: why nothing may change (read-only tools only)
         self.cancel: threading.Event | None = None  # set from another thread to stop
         self.on_tool = None  # called with (name, arguments) before each tool runs
+        self.jobs = Jobs()  # background commands (shared with subagents)
+        self.turn_started = 0.0  # when the running request started (time.monotonic)
         self.on_event: Callable[[dict], None] | None = None  # each step and tool result, for --output stream-json
         self.on_delta: Callable[[str, str], None] | None = None  # ("text" or "thinking", piece) as it streams
         self.current_call = ""  # id of the tool call that's running, so a permission request can name it
@@ -746,6 +751,7 @@ class Agent:
         return name
 
     def run_turn(self, user_text: str) -> None:
+        self.turn_started = time.monotonic()
         self.checkpoints.begin_turn(self.session_id, user_text, len(self.messages))
         try:
             self._run_turn(user_text)
@@ -760,6 +766,27 @@ class Agent:
                             Text(f"  ⎿ after_request hook ({outcome.code}): {outcome.output[:500]}", style=style)
                         )
 
+    def waiting(self, title: str) -> None:
+        """lcode waits for the user's answer: tell them, if they've likely walked away (lcode.notify)."""
+        if self.hooks.for_event("notification"):
+            self.hooks.notify(f"lcode needs you: {title}", self.cwd)
+        if (
+            self.settings.notify
+            and self.interactive
+            and time.monotonic() - self.turn_started >= self.settings.notify_after
+        ):
+            notify.desktop("lcode needs you", title)
+
+    def finished(self, request: str, seconds: float) -> None:
+        """A request is done: after a long one, tell the user."""
+        if seconds < self.settings.notify_after:
+            return
+        title = sessions.title_from([{"role": "user", "content": request}])
+        if self.hooks.for_event("notification"):
+            self.hooks.notify(f"lcode finished: {title}", self.cwd)
+        if self.settings.notify and self.interactive:
+            notify.desktop("lcode is done", f"{title} ({seconds:.0f}s)")
+
     def sandbox_root(self) -> Path | None:
         """The folder the model is limited to while the sandbox is on (None when it's off)."""
         if not self.sandbox:

lcode/api.py

@@ -192,6 +192,8 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
         prune=cfg["prune"],
         repo_map=cfg["repo_map"],
         embed_model=cfg["embed_model"],
+        notify=cfg["notify"],
+        notify_after=cfg["notify_after"],
     )
     agent = Agent(ollama, settings, cwd, console=console)
     agent.interactive = options.interactive
@@ -206,8 +208,7 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
     agent.hooks, agent.perms.rules = hooks.load(cwd, trust_project)
     for problem in agent.hooks.problems:
         console.print(f"[yellow]Settings: {problem}[/]")
-    if agent.hooks.for_event("notification"):
-        agent.perms.on_prompt = lambda title: agent.hooks.notify(f"lcode needs you: {title}", agent.cwd)
+    agent.perms.on_prompt = agent.waiting  # notification hooks and desktop notifications
     if cfg["lsp"] == "auto":
         from lcode import lsp
         from lcode.checkpoints import work_tree_for
@@ -233,6 +234,9 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
 
 
 def close_agent(agent: Agent) -> None:
+    stopped = agent.jobs.stop_all()
+    if stopped:
+        agent.console.print(f"[dim]Stopped {stopped} background job(s).[/]")
     if agent.lsp is not None:
         agent.lsp.close()
     if agent.mcp:

lcode/config.py

@@ -57,6 +57,8 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "lsp": ("auto", str, "language servers for code navigation and errors after edits: auto | off"),
     "prune": (True, bool, "before summarizing a full conversation, first remove old tool output from it"),
     "subagents": (True, bool, "let the model hand tasks to subagents that have their own context"),
+    "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)"),
     "max_parallel_agents": (1, int, "subagents that may run at the same time (more needs OLLAMA_NUM_PARALLEL)"),
 }
 ENV_OVERRIDES = {

lcode/jobs.py

@@ -0,0 +1,165 @@
+"""Background commands: dev servers, watchers and other processes that keep running.
+
+The model starts one with `bash(command, background=true)` and gets an id back, reads what it
+printed since last time with `bash_output(id)` and stops it with `bash_stop(id)`. `/jobs` lists
+them. They're all stopped when the session ends.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import signal
+import subprocess
+import threading
+import time
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from pathlib import Path
+
+KEEP = 1_000_000  # characters of a job's output kept in memory
+STARTUP_WAIT = 3.0  # seconds to wait for a new job's first output (and quick failures)
+
+
+class JobError(Exception):
+    pass
+
+
+@dataclass
+class Job:
+    id: str
+    command: str
+    proc: subprocess.Popen
+    kill: Callable[[], None] | None = None  # extra cleanup, e.g. the process in the sandbox
+    started: float = field(default_factory=time.monotonic)
+    output: str = ""
+    read: int = 0  # how much of `output` the model has seen
+    dropped: int = 0  # characters dropped from the front to stay under KEEP
+    stopped: bool = False
+    ended: float = 0.0
+    lock: threading.Lock = field(default_factory=threading.Lock)
+
+    def pump(self) -> None:
+        assert self.proc.stdout is not None
+        for line in self.proc.stdout:
+            with self.lock:
+                self.output += line
+                if len(self.output) > KEEP:
+                    cut = len(self.output) - KEEP
+                    self.output = self.output[cut:]
+                    self.dropped += cut
+                    self.read = max(0, self.read - cut)
+        self.proc.wait()
+        self.ended = time.monotonic()
+
+    @property
+    def running(self) -> bool:
+        return self.proc.poll() is None
+
+    def status(self) -> str:
+        if self.running:
+            return "running"
+        if self.stopped:
+            return "stopped"
+        return f"exited with code {self.proc.returncode}"
+
+    def runtime(self) -> float:
+        return (self.ended or time.monotonic()) - self.started
+
+    def new_output(self, limit: int) -> str:
+        with self.lock:
+            text, self.read = self.output[self.read :], len(self.output)
+        if len(text) > limit:
+            text = f"[… {len(text) - limit:,} earlier characters not shown]\n" + text[-limit:]
+        return text
+
+
+class Jobs:
+    """The session's background commands (shared with its subagents)."""
+
+    def __init__(self) -> None:
+        self.items: dict[str, Job] = {}
+        self.counter = 0
+
+    def start(self, argv: list[str], cwd: Path, command: str, kill: Callable[[], None] | None = None) -> Job:
+        proc = subprocess.Popen(
+            argv,
+            cwd=cwd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            stdin=subprocess.DEVNULL,
+            text=True,
+            errors="replace",
+            start_new_session=True,  # its own process group, so stopping it stops its children too
+            bufsize=1,
+        )
+        self.counter += 1
+        job = Job(str(self.counter), command, proc, kill)
+        self.items[job.id] = job
+        threading.Thread(target=job.pump, daemon=True).start()
+        deadline = time.monotonic() + STARTUP_WAIT
+        while time.monotonic() < deadline and job.running and not job.output:
+            time.sleep(0.05)
+        if job.running:
+            time.sleep(min(0.5, max(0.0, deadline - time.monotonic())))  # a little more of its first output
+        else:
+            time.sleep(0.1)  # let the pump read the rest
+        return job
+
+    def get(self, job_id: str) -> Job:
+        job = self.items.get(str(job_id).strip().lstrip("#"))
+        if job is None:
+            known = ", ".join(self.items) or "none"
+            raise JobError(f"there's no background job {job_id} (jobs: {known})")
+        return job
+
+    def stop(self, job_id: str) -> Job:
+        job = self.get(job_id)
+        if job.running:
+            job.stopped = True
+            terminate(job)
+        return job
+
+    def stop_all(self) -> int:
+        running = [j for j in self.items.values() if j.running]
+        for job in running:
+            job.stopped = True
+            terminate(job)
+        return len(running)
+
+    def running(self) -> list[Job]:
+        return [j for j in self.items.values() if j.running]
+
+
+def stop_leftovers(group: int) -> bool:
+    """Stop what a finished command left running in its process group; whether there was anything."""
+    try:
+        os.killpg(group, 0)  # raises when nothing is left
+    except (ProcessLookupError, PermissionError):
+        return False
+    for sig in (signal.SIGTERM, signal.SIGKILL):
+        with contextlib.suppress(ProcessLookupError, PermissionError):
+            os.killpg(group, sig)
+            time.sleep(0.3)
+    return True
+
+
+def terminate(job: Job, grace: float = 3.0) -> None:
+    """SIGTERM the job's process group, then SIGKILL whatever is left."""
+    if job.kill is not None:
+        with contextlib.suppress(Exception):
+            job.kill()
+    for sig in (signal.SIGTERM, signal.SIGKILL):
+        with contextlib.suppress(ProcessLookupError, PermissionError):
+            os.killpg(job.proc.pid, sig)
+        try:
+            job.proc.wait(timeout=grace)
+            return
+        except subprocess.TimeoutExpired:
+            continue
+
+
+def describe(job: Job) -> str:
+    minutes, seconds = divmod(int(job.runtime()), 60)
+    took = f"{minutes}m {seconds:02d}s" if minutes else f"{seconds}s"
+    return f"job {job.id} ({job.status()}, {took}): {job.command}"

lcode/notify.py

@@ -0,0 +1,43 @@
+"""Desktop notifications: when a long request is done, or lcode waits for an answer during one.
+
+Local models are slow, so people switch to something else while a request runs. lcode shows a
+notification with `notify-send` on Linux and `osascript` on macOS, and rings the terminal bell
+where neither is available.
+"""
+
+from __future__ import annotations
+
+import platform
+import shutil
+import subprocess
+import sys
+import threading
+
+
+def command(title: str, message: str) -> list[str] | None:
+    """The command that shows a notification on this machine, or None."""
+    if platform.system() == "Darwin" and shutil.which("osascript"):
+        quoted = message.replace("\\", "\\\\").replace('"', '\\"')
+        heading = title.replace("\\", "\\\\").replace('"', '\\"')
+        return ["osascript", "-e", f'display notification "{quoted}" with title "{heading}"']
+    if shutil.which("notify-send"):
+        return ["notify-send", "--app-name=lcode", title, message]
+    return None
+
+
+def desktop(title: str, message: str) -> None:
+    """Show the notification without waiting for it; the terminal bell if there's no way to."""
+    argv = command(title, message[:200])
+    if argv is None:
+        sys.stderr.write("\a")
+        sys.stderr.flush()
+        return
+
+    def run() -> None:
+        try:
+            subprocess.run(argv, capture_output=True, timeout=10)
+        except (OSError, subprocess.SubprocessError):
+            sys.stderr.write("\a")
+            sys.stderr.flush()
+
+    threading.Thread(target=run, daemon=True).start()

lcode/planning.py

@@ -32,7 +32,7 @@ if TYPE_CHECKING:
 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", "skill", "lsp", "repo_map", "search_code",
+        "agent", "memory", "present_plan", "mcp_find_tools", "skill", "lsp", "repo_map", "search_code", "bash_output",
     }
 )  # fmt: skip
 
@@ -103,6 +103,8 @@ def present(agent: Agent, title: str, plan: str) -> str:
         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)
+        if agent.perms.on_prompt:
+            agent.perms.on_prompt(f"Plan: {title}")
         try:
             answer = input("  > ").strip()
         except EOFError:

lcode/repl.py

@@ -62,6 +62,7 @@ COMMANDS = {
     "/mode": "Permission mode: ask | plan | auto-edit | yolo (Shift+Tab cycles)",
     "/cd": "Change the working directory",
     "/todos": "Show the current todo list",
+    "/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]",
     "/pr": "Push the branch and open a GitHub pull request, after you approve it: /pr [base] [notes]",
@@ -776,7 +777,28 @@ def web_status(agent: Agent) -> str:
     return f"{agent.settings.web} · {search}"
 
 
-LONG_REQUEST = 30  # seconds: a request this long sends a notification when it's done (notification hooks)
+def jobs_command(agent: Agent, arg: str) -> None:
+    """List the background commands, or stop one: /jobs stop <id>."""
+    from lcode.jobs import JobError, describe
+
+    c = agent.console
+    word, _, job_id = arg.partition(" ")
+    if word == "stop":
+        try:
+            job = agent.jobs.stop(job_id or "?")
+        except JobError as e:
+            c.print(f"[red]{escape(str(e))}[/]")
+            return
+        c.print(f"Stopped {escape(describe(job))}")
+        return
+    if not agent.jobs.items:
+        c.print("No background commands. The model starts them with bash(background=true), e.g. a dev server.")
+        return
+    for job in agent.jobs.items.values():
+        style = "green" if job.running else "dim"
+        c.print(f"[{style}]{escape(describe(job))}[/]")
+    if agent.jobs.running():
+        c.print("[dim]/jobs stop <id> stops one; they all stop when the session ends.[/]")
 
 
 def git_command(agent: Agent, cmd: str, arg: str) -> None:
@@ -810,8 +832,7 @@ def run_safely(agent: Agent, text: str) -> None:
         agent.console.print(f"[red]{e}[/]")
     finally:
         agent.save()
-        if time.monotonic() - started > LONG_REQUEST:
-            agent.hooks.notify(f"lcode finished: {sessions.title_from([{'role': 'user', 'content': text}])}", agent.cwd)
+        agent.finished(text, time.monotonic() - started)
 
 
 def session_start(agent: Agent) -> None:
@@ -931,6 +952,8 @@ def handle_command(agent: Agent, line: str, hardware: Hardware) -> bool:
             c.print(f"[red]Not a directory: {p}[/]")
     elif cmd == "/todos":
         agent.tools.show_todos()
+    elif cmd == "/jobs":
+        jobs_command(agent, arg)
     elif cmd == "/init":
         run_safely(agent, INIT_PROMPT)
     elif cmd in REPLACEABLE and cmd[1:] not in agent.extensions().commands:

lcode/subagents.py

@@ -463,6 +463,7 @@ class Run:
         child = Agent(parent.ollama, settings, cwd, console=Console(file=io.StringIO(), width=120))
         child.perms = self.relay  # type: ignore[assignment]
         child.sandbox = parent.sandbox
+        child.jobs = parent.jobs  # its background commands belong to the session
         if not self.worktree:
             child.checkpoints = parent.checkpoints  # changes in the shared tree are part of the running request
         child.mcp = None

lcode/tools.py

@@ -25,6 +25,7 @@ from rich.text import Text
 
 from lcode import web
 from lcode.context import shorten
+from lcode.jobs import JobError, describe, stop_leftovers
 from lcode.permissions import bash_key, is_read_only
 from lcode.planning import BLOCKED, PLAN_MODE_TOOLS
 from lcode.sandbox import SandboxError
@@ -38,6 +39,7 @@ NO_NETWORK = re.compile(
     r"EAI_AGAIN|Name or service not known|network is unreachable|No route to host"
 )
 MAX_TOOL_OUTPUT = 30_000  # characters returned to the model per tool call
+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",
     ".ruff_cache", ".tox", ".idea", ".vscode", "dist", "build", ".next", "target", ".cache", ".gradle",
@@ -119,13 +121,28 @@ SCHEMAS = [
         "bash",
         "Run a shell command with bash in the working directory and return its output and exit code. The "
         "working directory persists between calls (cd works). Use it to run scripts and tests, use git, install "
-        "packages, etc. Avoid interactive commands.",
+        "packages, etc. Avoid interactive commands. For a process that keeps running (a dev server, a watcher), "
+        "set background=true and give the plain command, without & or redirecting its output: lcode keeps it "
+        "running and keeps its output, you get a job id back and can carry on.",
         {
             "command": {"type": "string"},
             "timeout": {"type": "integer", "description": "Seconds before the command is killed (default 180)"},
+            "background": {
+                "type": "boolean",
+                "description": "Keep it running in the background; read its output with bash_output and stop it "
+                "with bash_stop (not with kill)",
+            },
         },
         ["command"],
     ),
+    _fn(
+        "bash_output",
+        "Read what a background command (bash with background=true) printed since you last read it, and whether "
+        "it's still running.",
+        {"id": {"type": "string", "description": "The job id bash returned"}},
+        ["id"],
+    ),
+    _fn("bash_stop", "Stop a background command.", {"id": {"type": "string"}}, ["id"]),
     _fn(
         "todo_write",
         "Create or update your task list for multi-step work. Pass the full list every time. Keep exactly one "
@@ -792,7 +809,7 @@ class Toolbox:
         return f"Edited {self.rel(p)} ({count} replacement(s)). Result:\n{snippet}" + problems
 
     # -- shell
-    def t_bash(self, command: str, timeout: int = 180) -> str:
+    def t_bash(self, command: str, timeout: int = 180, background: bool = False) -> 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, …).")
@@ -814,7 +831,9 @@ class Toolbox:
                 return feedback
         if not is_read_only(command):
             self.agent.checkpoint()
-        self.console.print(Text(f"  $ {command}", style="bold cyan"))
+        self.console.print(Text(f"  $ {command}" + ("  (in the background)" if background else ""), style="bold cyan"))
+        if background is True or str(background).lower() == "true":
+            return self._background(command)
         marker = f"__lcode_cwd_{secrets.token_hex(8)}__"
         script = f"{command}\n__lcode_ec=$?\nprintf '\\n{marker}%s\\n' \"$(pwd -P)\"\nexit $__lcode_ec\n"
         token = ""
@@ -855,6 +874,8 @@ class Toolbox:
         out: list[str] = []
         shown, status, recorded = 0, "", ""
         deadline = time.time() + int(timeout or 180)
+        finished = 0.0  # when the command itself ended (its marker arrived)
+        held_open = False  # something it started still holds the output open
         try:
             while True:
                 if self.agent.cancel is not None and self.agent.cancel.is_set():
@@ -862,6 +883,9 @@ class Toolbox:
                 try:
                     line = lines.get(timeout=0.2)
                 except queue.Empty:
+                    if finished and time.time() - finished > LEFTOVER_GRACE:
+                        held_open = True
+                        break
                     if time.time() > deadline:
                         stop()
                         status = f"\n[Command timed out after {timeout}s and was killed]"
@@ -871,6 +895,7 @@ class Toolbox:
                     break
                 if line.startswith(marker):
                     recorded = line[len(marker) :].strip()
+                    finished = time.time()
                     continue
                 out.append(line)
                 if shown <= 40:
@@ -881,6 +906,13 @@ class Toolbox:
             stop()
             raise
         code = proc.wait()
+        if held_open and sandbox and token:
+            sandbox.kill(token)  # what it left running in the container
+        if (not sandbox and stop_leftovers(proc.pid)) or held_open:
+            status += (
+                "\n[lcode stopped what this command left running (started with &). To keep a process running, "
+                "start it with background=true: then bash_output reads its output and bash_stop stops it]"
+            )
         if out and out[-1] == "\n":
             out.pop()  # the blank line printed before the marker
         if recorded and Path(recorded).is_dir() and Path(recorded).resolve() != self.agent.cwd:
@@ -933,6 +965,51 @@ class Toolbox:
             raise ToolError(str(e)) from e
         return web.format_page(url, title, text, max(1000, min(int(max_chars or 20000), MAX_TOOL_OUTPUT)))
 
+    def _background(self, command: str) -> str:
+        sandbox, kill = self.agent.sandbox, None
+        if sandbox:
+            try:
+                with self.console.status("Starting the sandbox…"):
+                    sandbox.ensure(self.agent.cwd)
+            except SandboxError as e:
+                return f"Error: the sandbox can't start, so the command didn't run: {e}"
+            argv, token = sandbox.exec_argv(self.agent.cwd, command)
+            kill = lambda: sandbox.kill(token)  # noqa: E731
+        else:
+            argv = ["bash", "-c", command]
+        job = self.agent.jobs.start(argv, self.agent.cwd, command, kill)
+        first = job.new_output(MAX_TOOL_OUTPUT // 3).rstrip()
+        for line in first.splitlines()[:10]:
+            self.console.print(Text("    " + line[:300], style="dim"))
+        if not job.running:
+            return (
+                f"The command ended right away ({job.status()}), so it isn't running in the background:\n"
+                f"{first or '(no output)'}"
+            )
+        self.console.print(Text(f"  ⎿ background job {job.id}, /jobs to see it", style="dim"))
+        return (
+            f"Started background job {job.id}: it keeps running while you work. Read its new output with "
+            f'bash_output(id="{job.id}") and stop it with bash_stop(id="{job.id}") when it\'s no longer needed.\n'
+            f"Output so far:\n{first or '(none yet)'}"
+        )
+
+    def t_bash_output(self, id: str) -> str:
+        try:
+            job = self.agent.jobs.get(id)
+        except JobError as e:
+            raise ToolError(str(e)) from e
+        text = job.new_output(MAX_TOOL_OUTPUT).rstrip()
+        return f"[{describe(job)}]\n{text or '(no new output)'}"
+
+    def t_bash_stop(self, id: str) -> str:
+        try:
+            job = self.agent.jobs.stop(id)
+        except JobError as e:
+            raise ToolError(str(e)) from e
+        self.console.print(Text(f"  ⎿ {describe(job)}", style="dim"))
+        last = job.new_output(4000).rstrip()
+        return f"[{describe(job)}]" + (f"\nIts last output:\n{last}" if last else "")
+
     # -- planning
     def t_todo_write(self, todos: list | str) -> str:
         if isinstance(todos, str):

{lcode_cli-0.19.0.dist-info → lcode_cli-0.20.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.19.0
+Version: 0.20.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/
@@ -216,7 +216,6 @@ fills up. Details: [How it works](https://nasser1941.github.io/lcode/how-it-work
 
 See the pinned [Roadmap issue](https://github.com/nasser1941/lcode/issues/10). Next up:
 
-- [Long-running work: finish notifications and background commands](https://github.com/nasser1941/lcode/issues/51)
 - 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.19.0.dist-info → lcode_cli-0.20.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-lcode/__init__.py,sha256=7yjbvkgWF_Vh6y72kETMa3SVkh4RP81rLJzvo11gIV8,473
+lcode/__init__.py,sha256=4WFGTgYgTZwsc2yTfp-j5FUCi0s6YN2WTQKRYUO9oeU,473
 lcode/__main__.py,sha256=s5N5pryX2FAu93GGZ3FxUrIXHWGzxz66lKUoaV_h8Ws,35
-lcode/acp.py,sha256=M_CdTVqRSmLn33QD56Le4238Vz1ZxffnHCfjmajSv34,28940
+lcode/acp.py,sha256=kRD_uuDDdGXt7xwvXZ8OqePK1HprEV76wWAWkV_gcak,28987
 lcode/action.py,sha256=1r3abjheYFYQ-EUArvotls8pLmE3YjNMGHAy_iF0Z70,16198
-lcode/agent.py,sha256=pB7rDZIbWiRrc8Ye4rA_LzHVqJ36yoTUN6nFsUeg428,49664
-lcode/api.py,sha256=kXlzXhGwkNdW9sWpxgOvL9h5pPzhzKRLXKrL1-eN3XY,15110
+lcode/agent.py,sha256=FgZJpGD1a46qaa1nixZYXS3rPaFaJgnGpfoUi7ikhGY,51106
+lcode/api.py,sha256=rOpcA2-axzUj_DppH3EelanVnwd-2O4MgN91OXGJePY,15250
 lcode/backends.py,sha256=dtJHrC6ys73bRDg64z0tQz1PavmeAkiODZu1fOO9ExQ,20635
 lcode/bench.py,sha256=XVdk0hDxmRcjgROOCgwwOsExcUhIxgh0B2vnxtGnA3o,40742
 lcode/bench_backend.py,sha256=X2fo-zRX92Xp3KMxSsFlWioc2vRupBTtowj5kLME8mw,14287
@@ -11,27 +11,29 @@ lcode/catalog.py,sha256=pZ1azX9OH2r4JE2c6E5OfwywpgS39-W2oXzoCHJhmtM,4141
 lcode/checkpoints.py,sha256=eqPtmPe44-aweWqc2H21ROogwzIt3NpvcUobsaCHoGY,18354
 lcode/cli.py,sha256=zo2QTHrdxVaJwIjCEOsfR99byPqeCkKHE5p_Xh8kfb8,39471
 lcode/codesearch.py,sha256=Io8leN1nb_Y-Dvlm9xaGtwUWYXX-ooswuznJV6dGU1s,10766
-lcode/config.py,sha256=nFljzjHTFaCTTbagycagbh2X_PpLtsUs-yRODiy4QcU,10065
+lcode/config.py,sha256=eDEvOAA1plsSjvihzHEwGjNVgvcz3Pb-AR5DY5JmXnM,10255
 lcode/context.py,sha256=qJymLE3eYeaF6qVOzlUwDURqlky__8cskl_6vXeU3AA,10701
 lcode/extensions.py,sha256=W0HFDl0BvROzr7i_qtabHdIbacBgP5o5qIJLzoM2oNE,16806
 lcode/frontmatter.py,sha256=Bx0n4vLPhp7ZCWx-g7xqzqNy5VoKBxyeeikh5UFB_gA,2441
 lcode/gitflow.py,sha256=y78dqqh80is-MiDTnSHnK9vjx0vFovor_SZ8hW1NJaU,27167
 lcode/hardware.py,sha256=2VbknZCxTZJwJUD8YWdQ7ryEQo_LcjtoOBOHOU9Y0fw,3085
 lcode/hooks.py,sha256=K0itOiAuH4rxndJ9gne_uCrqby6oWAzFPRrfB3tCq-E,9324
+lcode/jobs.py,sha256=P1P3FqI6EqL4LgdMX9YGZwCW0Bh5BRXFA_FnQxpHNjE,5618
 lcode/limits.py,sha256=oJzVQoMyTZ0_Fkpu5t3qxrf9v7Hv9S8U8BRQR5M1aKA,1237
 lcode/lsp.py,sha256=NtSW7xapv7fg2HAQLuYK1nwIqT7nG0LK1hiTpOmla_4,26086
 lcode/memory.py,sha256=WZEHTp-lVxAwS-yyLQR2xB3TMZ9sejmX2Ivg7T-tl3w,21949
 lcode/models.toml,sha256=lt2G64zzo_Ryxv2ISRSNZoVD_JqCqYqsM01n8WoXGs8,4098
+lcode/notify.py,sha256=uieDeXe7XwuVHjOk4tqVyZEW_85XWkoWQmFOWEf77oc,1538
 lcode/ollama.py,sha256=u5tnvL28cfaFS4GhmiEsHhTQe6w3Ng_Tej05UUzLQTQ,7715
 lcode/permissions.py,sha256=i04YLtqYCxwApgawomPp4d35uk9HAJtpKY__gfw8j9s,6347
-lcode/planning.py,sha256=mGXMU-khHyGHE8IHxxrsQc-FFOzbdRa4MWHMU19UR7o,6439
+lcode/planning.py,sha256=Q2upaoZPnXDMQT2F-ETxX1lk_wDntTzhSKNVYIQSoQA,6540
 lcode/render.py,sha256=gMvf4W3qkLUJ4Vot3az_hP_zRDAItJC9pP-68dHFkfA,1375
-lcode/repl.py,sha256=zJ2hj1c-tx35Sms8V-1W4XsyfFZ9omu9bZgGpEgBYi8,47655
+lcode/repl.py,sha256=pQAPePNsBxJfcuif2Cvyxr0FSeO_DVGv_T5cL9BrWu4,48470
 lcode/repomap.py,sha256=1GRJgEUjBl9XHSXsF7tSGXBCEgsY-3CzwMohaTudZ_M,13969
 lcode/sandbox.py,sha256=u_pkrVRXhCGhh-wFDPwuZ3jGG7UeXxXRAeBNsm37ZvE,8608
 lcode/sessions.py,sha256=wOR-J0EHgJxLSPboKPHnvBcp5VTUYTj3tZWgpsa6-K4,4013
-lcode/subagents.py,sha256=S_ZBpqnKFxRKhe-lE-I8SHc3yMOhe0zW-SD2K-Gwn28,28832
-lcode/tools.py,sha256=Y4XmQsoLIA32S255DnCwOwebGPgQay1k7H_A9R5DINA,43145
+lcode/subagents.py,sha256=rD7lnIioodirh8eVnXvRWdZx79J_rscPLssD2Gt7KIo,28914
+lcode/tools.py,sha256=pOdA4ihQHSs8yWUzfxhiLw3GajF5Dr1edxVX0Akr6CU,47257
 lcode/vision.py,sha256=w33QPmdGwP33wM4mvmAH4amFDZ1xzeXhEsSLJ-STSHY,4243
 lcode/web.py,sha256=vyxKbSRJTl1Lj3hj7Yd_NwTgbv0Xi6dup2YfUXjqp-Y,14579
 lcode/mcp/__init__.py,sha256=XujtAmRoXW9S0uq1XPf_CAeCkHh_UvA8FCmoAKP9j1Y,171
@@ -49,8 +51,8 @@ lcode/mcp/stdio.py,sha256=kC6KHwzMMDjBr-yCZLmyVKS7PZXU299WpZdYRoX5eRQ,6292
 lcode/servers/__init__.py,sha256=qrIhxEodEB8cjKEQ4Cicc0GsQhE2OH-9qlVHzr3-tq8,77
 lcode/servers/encord.py,sha256=WSauawL1UKYZCUAG1oalcKL_An3DVof-JM6xIgFyQSE,12769
 lcode/servers/valohai.py,sha256=e5xZGIoa4cja4f5i85q1GpL9c7cglUjV8jN2co1CFMY,14430
-lcode_cli-0.19.0.dist-info/METADATA,sha256=cUJGqerCzNU65yzxUbn48STtIOP3fjvVbItArdo1vJ4,12642
-lcode_cli-0.19.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.19.0.dist-info/entry_points.txt,sha256=pMz2Byj2QRyt-ZZQYZvmWUtmKPCeE7f8iCvu-sjZPIo,133
-lcode_cli-0.19.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.19.0.dist-info/RECORD,,
+lcode_cli-0.20.0.dist-info/METADATA,sha256=x59SrZvhlqu_9PZpirJgYDSKny6D_yubs_cE9yFzDuo,12527
+lcode_cli-0.20.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.20.0.dist-info/entry_points.txt,sha256=pMz2Byj2QRyt-ZZQYZvmWUtmKPCeE7f8iCvu-sjZPIo,133
+lcode_cli-0.20.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.20.0.dist-info/RECORD,,