lcode-cli 0.35.0__py3-none-any.whl → 0.36.0__py3-none-any.whl

lcode/__init__.py

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

lcode/agent.py

@@ -51,7 +51,7 @@ from lcode.mcp import McpManager
 from lcode.ollama import Ollama, OllamaError
 from lcode.permissions import LEADING_CD, Permissions
 from lcode.render import MarkdownStreamer
-from lcode.repeats import Repeats
+from lcode.repeats import Circles, Repeats
 from lcode.sandbox import Sandbox, SandboxError, project_root
 from lcode.steer import NOTE_INTRO, Steering
 from lcode.tools import (
@@ -71,6 +71,7 @@ from lcode.tools import (
     tree,
     truncate,
 )
+from lcode.unreachable import NOTE_AT, Sites
 
 GPU_MEMORY_ERRORS = (
     "out of memory",
@@ -80,6 +81,27 @@ GPU_MEMORY_ERRORS = (
 )
 SAFE_NUM_BATCH = 512  # Ollama's default prompt batch
 MAX_STEPS_PER_TURN = 150
+MAX_STALLS = 2  # replies that go round in circles or say nothing, per request, before lcode stops it
+STALLED = {
+    "circles": "the reply went round in circles, so lcode stopped it",
+    "cut_off": "the reply filled the context before it said anything",
+    "": "the reply was empty",
+}
+
+
+def stall_note(trouble: str) -> str:
+    """What the model is told after a reply that went round in circles or ended without a word."""
+    first = {
+        "circles": "Your last reply went round in circles (the same thoughts over and over), so lcode stopped it.",
+        "cut_off": "Your last reply filled the rest of the context before you said anything.",
+        "": "Your last reply was empty.",
+    }[trouble]
+    return (
+        f"[lcode] {first} Don't deliberate at length now. Either make your next tool call, or, if you're stuck, "
+        "tell the user in a few lines what you did, what fails, and what they could do."
+    )
+
+
 EVENT_OUTPUT = 4000  # characters of a tool's output in an event
 # How a tool result starts when the call failed or wasn't allowed (an "error" in events and results).
 REFUSED = ("Error:", "A deny rule", "The user denied", "This needs the user's permission")
@@ -319,6 +341,9 @@ class Agent:
         self.ollama = ollama
         self.settings = settings
         self.cwd = cwd.resolve()
+        # The folder lcode works in: where it started, or where /cd or a resumed session took it. A shell
+        # command may move the working directory around its project (self.cwd), but not out of it.
+        self.workspace = self.cwd
         self.perms = Permissions(self.console, settings.permission_mode)
         self.tools = Toolbox(self)
         self.session_id = self.new_session_id()
@@ -377,8 +402,10 @@ class Agent:
         self.escalate_approved: bool | None = None  # decided in advance (lcode -p --escalate, the benchmark)
         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
+        self.turn_status = ""  # how the last request ended: success, max_steps, loop, blocked
         self.repeats = Repeats(settings.repeat_limit)  # notices when the model repeats itself
+        self.sites = Sites(NOTE_AT if settings.repeat_limit else 0)  # notices a site this machine can't reach
+        self.reply_trouble = ""  # what went wrong with the last reply: "circles", "cut_off" or ""
         self.response = None  # the streaming response, so another thread can abort it
         self.ctx_used = 0
         self.last_speed = 0.0
@@ -648,7 +675,7 @@ class Agent:
         f = self.session_file()
         f.parent.mkdir(parents=True, exist_ok=True)
         data = {
-            "cwd": str(self.cwd),
+            "cwd": str(self.workspace),  # where `lcode -c` there finds it, wherever the shell moved
             "model": self.settings.model,
             "name": self.session_name,
             "title": self.session_title,
@@ -687,7 +714,7 @@ class Agent:
         saved_cwd = Path(info.cwd) if info.cwd else self.cwd
         if saved_cwd != self.cwd:
             if saved_cwd.is_dir():
-                self.cwd = saved_cwd.resolve()
+                self.cwd = self.workspace = saved_cwd.resolve()
                 note = f"Working directory is now {self.cwd}"
             else:
                 note = f"The session's directory {saved_cwd} no longer exists; staying in {self.cwd}"
@@ -707,7 +734,7 @@ class Agent:
         return note
 
     def load_latest(self) -> bool:
-        latest = sessions.list_sessions(self.cwd, limit=1)
+        latest = sessions.list_sessions(self.workspace, limit=1)
         if latest:
             self.load(latest[0])
         return bool(latest)
@@ -805,8 +832,11 @@ class Agent:
                 status = None
 
         start_spinner()
+        circles = Circles()
+        self.reply_trouble = ""
+        stream = self.chat(self.messages, self.tool_schemas(), self.settings.think)
         try:
-            for chunk in self.chat(self.messages, self.tool_schemas(), self.settings.think):
+            for chunk in stream:
                 if self.cancel is not None and self.cancel.is_set():
                     raise KeyboardInterrupt
                 msg = chunk.get("message", {})
@@ -822,6 +852,9 @@ class Agent:
                         stop_spinner()  # raw text is printed as it streams
                         self.console.print(Text(msg["thinking"], style="dim italic"), end="")
                         printed_thinking = True
+                    if self.settings.repeat_limit and circles.feed(msg["thinking"]):
+                        self.reply_trouble = "circles"
+                        break  # closing the stream below stops the model
                 if msg.get("content"):
                     if printed_thinking:
                         self.console.print("\n")
@@ -846,9 +879,12 @@ class Agent:
             self.messages.append({"role": "assistant", "content": content + "\n[interrupted by user]"})
             raise
         finally:
+            stream.close()
             stop_spinner()
             if watch is not None:
                 watch.stop()
+        if final.get("done_reason") == "length" and not self.reply_trouble:
+            self.reply_trouble = "cut_off"  # it filled the context (or hit the output limit) mid-reply
         if printed_thinking:
             self.console.print()
         md.flush()
@@ -918,6 +954,12 @@ class Agent:
             "is final, and gives you the failures to fix. Run them yourself while you work, too."
         )
 
+    def unrun_scripts(self, commands: list[str]) -> list[str]:
+        """Shell scripts the model wrote in this request and never ran (only where the checks would run)."""
+        if self.allowed_tools is not None or self.planning() or self.no_changes or self.settings.checks == "off":
+            return []
+        return checks.unrun_scripts(project_root_or_cwd(self.cwd), list(self.tools.before), commands)
+
     def project_check(self) -> checks.Check | None:
         """The project's check command, for the main agent outside plan mode and reviews (None otherwise)."""
         if self.allowed_tools is not None or self.planning() or self.no_changes or self.settings.checks == "off":
@@ -1106,6 +1148,7 @@ class Agent:
         self.messages.append({"role": "user", "content": self.expand_mentions(user_text) + note})
         self.turn_requests = [user_text.strip()]
         self.repeats.reset()
+        self.sites.reset()
         self.check_results = []
         self.review_results = None
         self.escalations = []
@@ -1116,6 +1159,10 @@ class Agent:
         check_rounds = 0
         malformed = 0
         looping = ""  # the call the model kept repeating, when lcode stopped the request for it
+        blocked = None  # the site that couldn't be reached, when lcode stopped the request for it
+        stalls = 0  # replies that went round in circles or ended without a word
+        commands: list[str] = []  # shell commands run in this request
+        scripts_noted = False  # the model was told about scripts it wrote and never ran
         for step in range(self.max_steps):
             if self.cancel is not None and self.cancel.is_set():
                 raise KeyboardInterrupt
@@ -1165,9 +1212,46 @@ class Agent:
                     }
                 )
                 continue
+            if not calls and (self.reply_trouble == "circles" or not (reply.get("content") or "").strip()):
+                stalls += 1
+                self.messages.pop()  # nothing to keep: no answer, and circles would only fill the context
+                if stalls < MAX_STALLS:
+                    self.console.print(
+                        Text(f"  ⎿ {STALLED[self.reply_trouble]}: asking for a short answer", style="yellow")
+                    )
+                    self.messages.append({"role": "user", "content": stall_note(self.reply_trouble)})
+                    continue
+                why = "its replies went round in circles or ended without an answer, twice in this request"
+                if not escalated and self.can_escalate():
+                    escalated = True
+                    advice = escalate.run(self, why)
+                    if advice:
+                        self.messages.append({"role": "user", "content": advice})
+                        stalls = 0
+                        continue
+                self.turn_status = "loop"
+                self.console.print(
+                    Text(
+                        "Stopped: the model's replies went round in circles or ended without an answer, twice in "
+                        "this request. Try again with a smaller step, or tell it what to do differently.",
+                        style="yellow",
+                    )
+                )
+                return
             if not calls:
+                if self.reply_trouble == "cut_off":
+                    self.say(
+                        "The answer was cut off: the context window is full. /compact or a larger /context helps.",
+                        warning=True,
+                    )
                 if self.steering is not None and self.steering.waiting():
                     continue  # the user added a note while the model wrote its answer: it reads the note first
+                unrun = [] if scripts_noted else self.unrun_scripts(commands)
+                if unrun:
+                    scripts_noted = True
+                    self.console.print(Text(f"  ⎿ never ran {', '.join(unrun)}: asking the model to", style="yellow"))
+                    self.messages.append({"role": "user", "content": checks.unrun_note(unrun)})
+                    continue
                 check = self.project_check() if changed and not verified else None
                 if check is not None and check_rounds < checks.MAX_ROUNDS:
                     check_rounds += 1
@@ -1247,6 +1331,21 @@ class Agent:
                     )
                     if verdict.stop:
                         looping = self.describe_call(name, args)
+                out_of_reach = self.sites.check(name, args, result)
+                if out_of_reach.note and not looping:
+                    result += out_of_reach.note
+                    what = "stopping the request" if out_of_reach.stop else "told the model"
+                    self.console.print(
+                        Text(
+                            f"  ⎿ {out_of_reach.calls} calls to {out_of_reach.site} failed "
+                            f"({out_of_reach.what}), none worked: {what}",
+                            style="yellow",
+                        )
+                    )
+                    if out_of_reach.stop:
+                        blocked = out_of_reach
+                if name == "bash":
+                    commands.append(str(args.get("command", "")))
                 if name in ("edit_file", "write_file", "apply_patch") and not result.startswith(REFUSED):
                     changed, verified = True, False
                 elif name == "bash" and changed and self.model_ran_checks(str(args.get("command", "")), result):
@@ -1264,7 +1363,7 @@ class Agent:
                         "output": result[:EVENT_OUTPUT] + ("…" if len(result) > EVENT_OUTPUT else ""),
                     }
                 )
-                if looping:
+                if looping or blocked:
                     for rest in calls[i + 1 :]:
                         skipped = {
                             "role": "tool",
@@ -1283,6 +1382,18 @@ class Agent:
                     self.repeats.reset()
                     looping = ""
                     continue
+            if blocked:
+                self.turn_status = "blocked"
+                self.console.print(
+                    Text(
+                        f"Stopped: every request to {blocked.site} failed ({blocked.calls} calls: {blocked.what}) and "
+                        "none worked, so this machine probably can't reach it: a firewall, a proxy, a regional block "
+                        "or no internet. Check the connection (another network or a VPN, a proxy setting), or tell "
+                        "the model another way to get what it needs.",
+                        style="yellow",
+                    )
+                )
+                return
             if looping:
                 self.turn_status = "loop"
                 self.console.print(

lcode/api.py

@@ -285,7 +285,7 @@ def run_request(agent: Agent, prompt: str) -> Result:
 
     try:
         agent.run_turn(prompt)
-        status = agent.turn_status if agent.turn_status in ("max_steps", "loop") else "success"
+        status = agent.turn_status if agent.turn_status in ("max_steps", "loop", "blocked") else "success"
     except KeyboardInterrupt:
         status, error = "interrupted", "interrupted before the request was done"
     except ModelError as e:

lcode/backends.py

@@ -302,6 +302,7 @@ class OpenAICompatible:
         calls: dict[int, dict] = {}
         usage: dict = {}
         timings: dict = {}  # llama-server measures prompt and generation time itself
+        finished = ""  # why the reply ended, as Ollama's done_reason: "length" when it was cut off
         splitter = ThinkSplitter()
         first_token = None
         with r:
@@ -323,6 +324,7 @@ class OpenAICompatible:
                 usage = chunk.get("usage") or usage
                 timings = chunk.get("timings") or timings
                 for choice in chunk.get("choices") or []:
+                    finished = choice.get("finish_reason") or finished
                     delta = choice.get("delta") or {}
                     thinking = delta.get("reasoning_content") or delta.get("reasoning")
                     if thinking:
@@ -356,6 +358,7 @@ class OpenAICompatible:
             "prompt_eval_duration": first_token - started,
             "eval_count": int(usage.get("completion_tokens") or 0),
             "eval_duration": max(1, ended - first_token),
+            "done_reason": "length" if finished == "length" else "stop",
         }
         if timings.get("prompt_ms") is not None and timings.get("predicted_ms"):
             # The whole prompt counts (it's what fills the context), cached tokens included.

lcode/bench.py

@@ -904,7 +904,7 @@ def run_task(
         if agent is None:
             agent = Agent(ollama, settings, folder, console=log)
         else:  # the same conversation moves on to this task's folder, as with /cd
-            agent.cwd = folder.resolve()
+            agent.cwd = agent.workspace = folder.resolve()
             agent.messages[0]["content"] = agent.system_prompt()
         if settings.embed_model != "off":  # --code-search: index the task's folder first, outside the timer
             from lcode import codesearch

lcode/checks.py

@@ -158,3 +158,74 @@ def missing(check: Check, result: str) -> bool:
         return True
     head = result.splitlines()[:5]  # a missing program says so first; test failures look different
     return code not in (0, None) and any(MISSING.search(line) for line in head)
+
+
+# ----------------------------------------------------------------------------- scripts written, never run
+
+SCRIPT_SUFFIXES = (".sh", ".bash", ".zsh")
+SHELL_SHEBANG = re.compile(r"^#!\S*?(?:/|env\s+)(?:ba|z|da|k)?sh\b")
+RUNNERS = frozenset({"bash", "sh", "zsh", "dash", "ksh", "source", ".", "exec"})
+PREFIXES = frozenset({"sudo", "time", "nohup", "env", "command", "nice"})
+SEGMENTS = re.compile(r"&&|\|\||[;|\n&()]")
+
+
+def unrun_scripts(root: Path, changed: list[str], commands: list[str]) -> list[str]:
+    """Shell scripts written in this request that no command in it ran.
+
+    Small models write a build or install script and call it done without running it once; the first thing
+    the user then sees is its first error. Only shell scripts count (a .sh file, or a shell shebang): a Python
+    file with a shebang is as likely an app or a server that never ends.
+    """
+    unrun = []
+    for rel in changed:
+        path = root / rel
+        if not is_shell_script(path):
+            continue
+        if not any(runs(command, path.name) for command in commands):
+            unrun.append(rel)
+    return unrun
+
+
+def is_shell_script(path: Path) -> bool:
+    if not path.is_file():
+        return False
+    if path.suffix in SCRIPT_SUFFIXES:
+        return True
+    if path.suffix:
+        return False
+    try:
+        with path.open("rb") as f:
+            first = f.readline(200).decode("utf-8", "replace")
+    except OSError:
+        return False
+    return bool(SHELL_SHEBANG.match(first))
+
+
+def runs(command: str, name: str) -> bool:
+    """Whether a shell command runs the script called `name` (not just chmods, cats or commits it)."""
+    for segment in SEGMENTS.split(command):
+        words = segment.split()
+        while words and (("=" in words[0] and not words[0].startswith("=")) or words[0] in PREFIXES):
+            words.pop(0)
+        if words and words[0] == "timeout":
+            words = words[2:] if len(words) > 2 else []
+        if not words:
+            continue
+        program = words[0].strip("'\"")
+        if program in RUNNERS:
+            rest = [w.strip("'\"") for w in words[1:] if not w.startswith("-")]
+            program = rest[0] if rest else ""
+        if Path(program).name == name:
+            return True
+    return False
+
+
+def unrun_note(scripts: list[str]) -> str:
+    names = ", ".join(scripts)
+    it = "it" if len(scripts) == 1 else "them"
+    return (
+        f"[lcode] You wrote {names} in this request but never ran {it}. Run {it} now and fix what fails, so you know "
+        f"{it} works before you say so. If running {it} would change things outside the project (install packages, "
+        f"deploy, delete data) or needs something you don't have, don't: tell the user plainly that {it} is untested "
+        "and why."
+    )

lcode/cli.py

@@ -113,44 +113,96 @@ def choose_context(
 # ----------------------------------------------------------------------------- lcode models
 
 
-def print_served(client: backends.OpenAICompatible, current: str | None) -> None:
+def print_served(
+    client: backends.OpenAICompatible, current: str | None, numbered: bool = False, out: Console | None = None
+) -> list[str]:
+    out = out or console
     try:
         served = client.chat_models()
         current = backends.pick_model(client, current) if current else None
     except OllamaError as e:
         if not isinstance(e, backends.BackendError) or "doesn't serve" not in str(e):
-            console.print(f"[red]{e}[/]")
-            return
-    console.print(f"[bold]Models served by {escape(client.describe())}[/]")
-    for name in served:
-        console.print(f"  {escape(name)}" + ("  [bold]current[/]" if name == current else ""))
+            out.print(f"[red]{e}[/]")
+            return []
+        served = []
+    out.print(f"[bold]Models served by {escape(client.describe())}[/]")
+    for i, name in enumerate(served, 1):
+        number = f"[cyan]{i:>3}[/]  " if numbered else "  "
+        out.print(f"{number}{escape(name)}" + ("  [bold]current[/]" if name == current else ""))
     if not served:
-        console.print("  none listed")
-    console.print(
-        "[dim]Models are downloaded and loaded in the server itself. Choose one with [/]lcode --model <id>[dim] "
-        "or [/]lcode config set model <id>[dim].[/]"
-    )
+        out.print("  none listed")
+    if not numbered:
+        out.print(
+            "[dim]Models are downloaded and loaded in the server itself. Choose one with [/]lcode --model <id>[dim] "
+            "or [/]lcode config set model <id>[dim].[/]"
+        )
+    return served
 
 
-def print_models(ollama: Ollama | None, hw: Hardware, current: str | None = None) -> None:
+def other_installed(ollama: Ollama, installed: set[str]) -> list[str]:
+    """Installed Ollama models outside the catalog that can chat and call tools (so lcode can use them), by name.
+    Embedding models are left out: Ollama may list `tools` for them too, but not `completion`."""
+    known = {name for spec in catalog.load() for name in (spec.tag, spec.local_name)}
+    usable = []
+    for name in sorted({n.removesuffix(":latest") for n in installed} - known):
+        try:
+            capabilities = ollama.show(name).get("capabilities") or []
+            if "completion" in capabilities and "tools" in capabilities:
+                usable.append(name)
+        except OllamaError:
+            continue
+    return usable
+
+
+def model_choices(ollama: Ollama | None) -> list[str]:
+    """What `/models` numbers, in its order: the catalog's keys, then other installed models that call tools.
+    For an OpenAI-compatible server, the models it serves."""
     if ollama is not None and backends.is_openai(ollama):
-        print_served(ollama, current)  # type: ignore[arg-type]
-        return
+        try:
+            return ollama.chat_models()  # type: ignore[union-attr]
+        except OllamaError:
+            return []
+    try:
+        installed = ollama.installed_names() if ollama else set()
+    except OllamaError:
+        installed = set()
+    return [spec.key for spec in catalog.load()] + (other_installed(ollama, installed) if ollama else [])
+
+
+def print_models(
+    ollama: Ollama | None,
+    hw: Hardware,
+    current: str | None = None,
+    numbered: bool = False,
+    out: Console | None = None,
+) -> list[str]:
+    """The models table; with `numbered`, a number on each row to pick it by. Returns the rows' names in order."""
+    out = out or console
+    if ollama is not None and backends.is_openai(ollama):
+        return print_served(ollama, current, numbered, out)  # type: ignore[arg-type]
     try:
         installed = ollama.installed_names() if ollama else set()
     except OllamaError:
         installed = set()
     rec = catalog.recommend(hw)
-    wide = console.width >= 130  # the descriptive columns don't fit an 80-column terminal
+    wide = out.width >= 130  # the descriptive columns don't fit an 80-column terminal
     columns = ["Key", "Model", "Type", "Size", "Max ctx", "Fits here", "Speed", "Status"]
     if not wide:
         columns = [c for c in columns if c not in ("Model", "Type")]
+    if numbered:
+        columns.insert(0, "#")
     table = Table(title=f"Models for this machine: {hw.describe()}", title_justify="left", header_style="bold")
     for col in columns:
         table.add_column(
-            col, no_wrap=col in ("Key", "Size", "Max ctx", "Fits here"), min_width=11 if col == "Status" else None
+            col,
+            no_wrap=col in ("#", "Key", "Size", "Max ctx", "Fits here"),
+            min_width=11 if col == "Status" else None,
+            justify="right" if col == "#" else "left",
+            style="cyan" if col == "#" else None,
         )
+    choices: list[str] = []
     for spec in catalog.load():
+        choices.append(spec.key)
         ctx, speed = spec.fit(hw)
         marks = []
         if spec.local_name in installed or spec.tag in installed:
@@ -161,6 +213,7 @@ def print_models(ollama: Ollama | None, hw: Hardware, current: str | None = None
             marks.append("[bold]current[/]")
         marks.append("tested" if spec.tested else "[dim]untested[/]")
         row = {
+            "#": str(len(choices)),
             "Key": spec.key,
             "Model": spec.name,
             "Type": spec.params,
@@ -171,11 +224,18 @@ def print_models(ollama: Ollama | None, hw: Hardware, current: str | None = None
             "Status": ", ".join(marks) if wide else "\n".join(marks),
         }
         table.add_row(*(row[c] for c in columns))
-    console.print(table)
-    console.print(
-        "[dim]Install one with [/]lcode setup <key>[dim]. 'Fits here' is the largest context that fits in memory; "
-        "choose another with --context. Any other Ollama model with tool calling also works: lcode --model <tag>[/]"
-    )
+    for name in other_installed(ollama, installed) if ollama else []:
+        choices.append(name)
+        marks = ["[green]installed[/]"] + (["[bold]current[/]"] if name == current else []) + ["[dim]not in catalog[/]"]
+        row = {"#": str(len(choices)), "Key": escape(name), "Status": ", ".join(marks) if wide else "\n".join(marks)}
+        table.add_row(*(row.get(c, "") for c in columns))
+    out.print(table)
+    if not numbered:
+        out.print(
+            "[dim]Install one with [/]lcode setup <key>[dim]. 'Fits here' is the largest context that fits in memory; "
+            "choose another with --context. Any other Ollama model with tool calling also works: lcode --model <tag>[/]"
+        )
+    return choices
 
 
 def cmd_models(args) -> None:

lcode/repeats.py

@@ -16,6 +16,8 @@ from __future__ import annotations
 
 import hashlib
 import json
+import re
+from collections import deque
 from dataclasses import dataclass
 
 from lcode.permissions import is_read_only
@@ -102,3 +104,38 @@ def changes_things(name: str, args: dict, result: str) -> bool:
     if name == "bash":
         return not is_read_only(str(args.get("command", "")))
     return True  # other tools (MCP, subagents…) might
+
+
+class Circles:
+    """Notice a reply that goes round in circles while it streams: the same sentences over and over.
+
+    Small models sometimes fall into this while they think: a few paragraphs, repeated until the context is
+    full. It takes minutes behind the spinner and ends without an answer. Sentences shorter than MIN_SENTENCE
+    don't count (they repeat legitimately). The text is going round in circles when, of the last WINDOW
+    sentences, LOOPING or more were each seen REPEATS times or more.
+    """
+
+    MIN_SENTENCE = 20
+    WINDOW = 20
+    REPEATS = 4
+    LOOPING = 16
+    SPLIT = re.compile(r"\n|(?<=[.!?])\s+")
+
+    def __init__(self) -> None:
+        self.partial = ""
+        self.seen: dict[str, int] = {}
+        self.recent: deque[str] = deque(maxlen=self.WINDOW)
+
+    def feed(self, text: str) -> bool:
+        """Add streamed text; whether it's now going round in circles."""
+        parts = self.SPLIT.split(self.partial + text)
+        self.partial = parts.pop()
+        for part in parts:
+            sentence = " ".join(part.split()).lower()
+            if len(sentence) < self.MIN_SENTENCE:
+                continue
+            self.seen[sentence] = self.seen.get(sentence, 0) + 1
+            self.recent.append(sentence)
+        if len(self.recent) < self.WINDOW:
+            return False
+        return sum(self.seen[s] >= self.REPEATS for s in self.recent) >= self.LOOPING

lcode/repl.py

@@ -68,8 +68,8 @@ COMMANDS = {
     "/compact": "Summarize the conversation to free context (optional: what to focus on)",
     "/context": "Show context usage and change the window size: pick from a list, or /context 128k",
     "/ctx": "Shortcut for /context",
-    "/model": "Show or switch model, e.g. /model qwen3.5-9b",
-    "/models": "List models and how they fit this machine",
+    "/model": "Switch model: pick a number from the list, or /model 2, /model qwen3.5-9b",
+    "/models": "List models and how they fit this machine; type a number to switch",
     "/think": "Toggle model reasoning on/off",
     "/verbose": "Toggle showing the model's reasoning text",
     "/plan": "Plan before changing anything: /plan <request>, or /plan to show the approved plan",
@@ -243,14 +243,20 @@ def banner(agent: Agent) -> None:
 CONTEXT_CHOICES = (16384, 32768, 65536, 131072, 262144, 524288, 1048576)
 
 
+def model_limit(agent: Agent) -> int | None:
+    """The largest context the model supports (what Ollama reports, else the catalog's), if known."""
+    spec = catalog.find(agent.settings.model)
+    try:
+        return agent.ollama.max_context(agent.settings.model) or (spec.max_context if spec else None)
+    except OllamaError:
+        return spec.max_context if spec else None
+
+
 def context_options(agent: Agent, hardware: Hardware) -> list[dict]:
     """The context sizes this model supports, with how each one fits this machine."""
     s = agent.settings
     spec = catalog.find(s.model)
-    try:
-        max_ctx = agent.ollama.max_context(s.model) or (spec.max_context if spec else None)
-    except OllamaError:
-        max_ctx = spec.max_context if spec else None
+    max_ctx = model_limit(agent)
     sizes = {c for c in CONTEXT_CHOICES if not max_ctx or c <= max_ctx} | {s.context}
     if max_ctx:
         sizes.add(max_ctx)
@@ -317,6 +323,15 @@ def context_command(agent: Agent, arg: str, hardware: Hardware) -> None:
             marks.append("[cyan]recommended[/]")
         table.add_row(str(i), format_tokens(option["size"]), option["note"], ", ".join(marks))
     c.print(table)
+    limit = model_limit(agent)
+    beyond = [size for size in CONTEXT_CHOICES if limit and size > limit]
+    if beyond:
+        sizes = " and ".join(format_tokens(size) for size in beyond[:2])
+        c.print(
+            f"[dim]Not offered: {sizes}{' and more' if len(beyond) > 2 else ''}. {s.model} was trained on up to "
+            f"{format_tokens(limit)} tokens, and Ollama caps the window there whatever the memory, so a larger "
+            "setting would only look larger.[/]"
+        )
     try:
         answer = input(f"  Choose a number, a size like 96k, or press Enter to keep {format_tokens(s.context)}: ")
     except EOFError:
@@ -809,6 +824,63 @@ def restore_checkpoint(agent: Agent, target: Checkpoint, rewind: bool) -> None:
     agent.save()
 
 
+def model_command(agent: Agent, arg: str, hardware: Hardware) -> None:
+    """/models and /model: the numbered list to pick from, or straight to a number or a name (/model 2)."""
+    from lcode.cli import model_choices, print_models
+
+    c, s = agent.console, agent.settings
+    if arg and not arg.isdigit():
+        switch_model(agent, arg, hardware)
+        return
+    if arg:
+        choices = model_choices(agent.ollama)
+    else:
+        choices = print_models(agent.ollama, hardware, s.model, numbered=True, out=c)
+        if not choices:
+            return
+        try:
+            answer = input(f"  Switch to which model? (number or name, Enter to keep {s.model}): ").strip()
+        except EOFError:
+            return
+        if not answer:
+            c.print(f"Keeping {s.model}.")
+            return
+        arg = answer
+    if arg.isdigit():
+        if not 1 <= int(arg) <= len(choices):
+            c.print(f"[red]There's no model {arg} in the list: choose 1 to {len(choices)}.[/]")
+            return
+        arg = choices[int(arg) - 1]
+    switch_model(agent, arg, hardware)
+
+
+def switch_model(agent: Agent, wanted: str, hardware: Hardware) -> None:
+    """Switch to a catalog key or an installed model, and size the context for it."""
+    from lcode.cli import NotInstalled, resolve_model
+
+    c, s = agent.console, agent.settings
+    try:
+        name, spec = resolve_model(agent.ollama, wanted)
+    except (NotInstalled, OllamaError) as e:
+        c.print(f"[red]{e}[/]")
+        return
+    if name == s.model:
+        c.print(f"Already using {name} (context {format_tokens(s.context)}).")
+        return
+    s.model = name
+    s.num_batch = spec.num_batch if spec and name == spec.local_name else None
+    if spec:  # size the context for the new model: largest window that fits this machine
+        s.context = limits.cap(name, spec.fit(hardware)[0] or MIN_USEFUL_CONTEXT)
+    elif backends.is_openai(agent.ollama):
+        s.context = backends.context_for(agent.ollama, name, None)[0]  # the server's window
+    agent._vision = False  # the model that looks at images goes with the model: decide again
+    agent.messages[0]["content"] = agent.system_prompt()
+    c.print(f"[green]Switched to {name}[/] (context {format_tokens(s.context)}).")
+    warning = residency.dense_warning(agent.ollama, name, s.context, hardware)
+    if warning:
+        agent.say(warning, warning=True)
+
+
 def apply_context(agent: Agent, size: int, hardware: Hardware) -> None:
     c, s = agent.console, agent.settings
     if size == s.context:
@@ -956,8 +1028,6 @@ def session_start(agent: Agent) -> None:
 
 def handle_command(agent: Agent, line: str, hardware: Hardware) -> bool:
     """Run a slash command. Returns False when the REPL should exit."""
-    from lcode.cli import NotInstalled, print_models, resolve_model
-
     cmd, _, arg = line.partition(" ")
     arg = arg.strip()
     c, s = agent.console, agent.settings
@@ -1006,29 +1076,8 @@ def handle_command(agent: Agent, line: str, hardware: Hardware) -> bool:
         agent.compact(arg)
     elif cmd in ("/context", "/ctx"):
         context_command(agent, arg, hardware)
-    elif cmd == "/models":
-        print_models(agent.ollama, hardware, s.model)
-    elif cmd == "/model":
-        if not arg:
-            c.print(f"Model: {s.model}. Switch with /model <name>; list with /models.")
-        else:
-            try:
-                name, spec = resolve_model(agent.ollama, arg)
-            except (NotInstalled, OllamaError) as e:
-                c.print(f"[red]{e}[/]")
-                return True
-            s.model = name
-            s.num_batch = spec.num_batch if spec and name == spec.local_name else None
-            if spec:  # size the context for the new model: largest window that fits this machine
-                s.context = limits.cap(name, spec.fit(hardware)[0] or MIN_USEFUL_CONTEXT)
-            elif backends.is_openai(agent.ollama):
-                s.context = backends.context_for(agent.ollama, name, None)[0]  # the server's window
-            agent._vision = False  # the model that looks at images goes with the model: decide again
-            agent.messages[0]["content"] = agent.system_prompt()
-            c.print(f"[green]Switched to {name}[/] (context {format_tokens(s.context)}).")
-            warning = residency.dense_warning(agent.ollama, name, s.context, hardware)
-            if warning:
-                agent.say(warning, warning=True)
+    elif cmd in ("/models", "/model"):
+        model_command(agent, arg, hardware)
     elif cmd == "/think":
         s.think = (arg == "on") if arg in ("on", "off") else not s.think
         c.print(f"Reasoning {'on' if s.think else 'off'}.")
@@ -1059,7 +1108,7 @@ def handle_command(agent: Agent, line: str, hardware: Hardware) -> bool:
         p = Path(os.path.expanduser(arg or "~"))
         p = (p if p.is_absolute() else agent.cwd / p).resolve()
         if p.is_dir():
-            agent.cwd = p
+            agent.cwd = agent.workspace = p
             agent.messages[0]["content"] = agent.system_prompt()
             c.print(f"Working directory: {p}")
         else:

lcode/subagents.py

@@ -461,6 +461,8 @@ class Run:
             show_thinking=False,
         )
         child = Agent(parent.ollama, settings, cwd, console=Console(file=io.StringIO(), width=120))
+        if not self.worktree:
+            child.workspace = parent.workspace  # it may cd around the same project, not out of it
         child.perms = self.relay  # type: ignore[assignment]
         child.sandbox = parent.sandbox
         child.jobs = parent.jobs  # its background commands belong to the session
@@ -487,11 +489,10 @@ class Run:
             last = child.messages[-1]
             if last.get("role") != "assistant" or last.get("tool_calls") or not last.get("content", "").strip():
                 # It ran out of steps, or went round in circles: ask for what it has so far, without tools.
-                why = (
-                    "You kept making the same call, so lcode stopped you."
-                    if child.turn_status == "loop"
-                    else "You've used all your steps."
-                )
+                why = {
+                    "loop": "You went round in circles, so lcode stopped you.",
+                    "blocked": "A site you needed can't be reached from this machine, so lcode stopped you.",
+                }.get(child.turn_status, "You've used all your steps.")
                 child.messages.append(
                     {
                         "role": "user",

lcode/tools.py

@@ -1283,10 +1283,18 @@ class Toolbox:
             out.add(last)
             recent.append(last)
         if recorded and Path(recorded).is_dir() and Path(recorded).resolve() != self.agent.cwd:
-            if sandbox and not sandbox.contains(Path(recorded).resolve()):
+            from lcode.checkpoints import work_tree_for
+
+            moved = Path(recorded).resolve()
+            if sandbox and not sandbox.contains(moved):
                 status += "\n[That directory is outside the project; the working directory stays the same]"
+            elif not sandbox and not moved.is_relative_to(work_tree_for(self.agent.workspace)):
+                status += (
+                    f"\n[{moved} is outside the project, so the working directory stays {self.agent.cwd}: the next "
+                    "command starts there. To run something elsewhere, cd in the same command]"
+                )
             else:
-                self.agent.cwd = Path(recorded).resolve()
+                self.agent.cwd = moved
                 status += f"\n[Working directory is now {self.agent.cwd}]"
         if sandbox and code != 0 and not sandbox.network and NO_NETWORK.search("".join(recent)):
             status += (

lcode/unreachable.py

@@ -0,0 +1,186 @@
+"""Notice when the network, not the model, is in the way.
+
+A download that fails however its address is written usually means this machine can't reach the site: a
+firewall, a proxy, a regional block, or no internet. Nothing the model writes fixes that, yet a small model
+will try address after address for an hour (and lcode's repeat check never fires: every address differs).
+So within one request lcode keeps track, per site, of the calls that failed to reach it (an HTTP error, a
+name that doesn't resolve, a refused or timed-out connection…) and of the ones that worked. When `NOTE_AT`
+different calls failed for a site and none worked, the result gets a note: check one address that must
+exist, and if that fails too, tell the user. If `STOP_AFTER_NOTE` more fail, lcode ends the request.
+
+Which site a failure belongs to is read from the output: the address on the failing line, else the last
+address printed before it, else the command's address when the command names only one site. A call that
+names several sites and prints a bare status line counts for none of them. A site counts as reached when a
+call got an answer from it: a success status, a page from web_fetch, or a call naming only that site that
+printed plenty without an error. Local addresses (localhost, private networks, names without a dot) aren't
+tracked: they aren't "the internet".
+"""
+
+from __future__ import annotations
+
+import hashlib
+import ipaddress
+import json
+import re
+from dataclasses import dataclass
+from urllib.parse import urlsplit
+
+NOTE_AT = 3  # different calls that failed for a site, and none worked: the note
+STOP_AFTER_NOTE = 2  # more such calls after the note: the request ends
+PLENTY = 400  # characters of error-free output from a call naming one site: it was reached
+URL = re.compile(r"\b(?:https?|ftp)://[^\s'\"<>`|]+", re.I)
+OK_STATUS = re.compile(
+    r"\bHTTP/\d(?:\.\d)?\s+[23]\d\d\b|awaiting response\.\.\. [23]\d\d\b"
+    r"|\b(?:status(?:[ _]code)?|http_code)[:= ]+[23]\d\d\b",
+    re.I,
+)
+FAILED_STATUS = re.compile(
+    r"\bHTTP/\d(?:\.\d)?\s+([45]\d\d)\b"  # curl -I / -v, wget -S
+    r"|\bHTTP Error ([45]\d\d)\b"  # Python's urllib
+    r"|\breturned HTTP ([45]\d\d)\b"  # lcode's web_fetch
+    r"|\breturned error: ([45]\d\d)\b"  # curl --fail
+    r"|\bERROR ([45]\d\d):"  # wget
+    r"|\b([45]\d\d) (?:Client|Server) Error\b"  # requests
+    r"|\b(?:status(?:[ _]code)?|http_code)[:= ]+([45]\d\d)\b"  # what a model's own loop prints
+    r"|\b([45]\d\d):? \(?(?:Not Found|Forbidden|Unauthorized|Bad Gateway|Service Unavailable|Gateway Time-?out|"
+    r"Too Many Requests)\b",  # npm, wget, error pages
+    re.I,
+)
+NETWORK_ERRORS = (
+    (
+        "the name doesn't resolve",
+        re.compile(
+            r"Could not resolve host|Temporary failure in name resolution|Name or service not known|"
+            r"nodename nor servname|getaddrinfo|ENOTFOUND|EAI_AGAIN|NameResolutionError|Failed to resolve",
+            re.I,
+        ),
+    ),
+    ("connection refused", re.compile(r"Connection refused|ECONNREFUSED", re.I)),
+    ("timed out", re.compile(r"Connection timed out|ETIMEDOUT|Operation timed out|Read timed out", re.I)),
+    ("connection reset", re.compile(r"Connection reset|ECONNRESET", re.I)),
+    ("no route to it", re.compile(r"Network is unreachable|No route to host|ENETUNREACH", re.I)),
+    ("a TLS/SSL error", re.compile(r"SSL certificate problem|certificate verify failed|SSLError", re.I)),
+    ("couldn't connect", re.compile(r"Failed to connect to|Max retries exceeded", re.I)),
+)
+LOCAL_SUFFIXES = (".local", ".lan", ".home", ".internal", ".localhost", ".test", ".example", ".invalid")
+
+
+@dataclass
+class Verdict:
+    site: str = ""
+    calls: int = 0  # different calls that failed for the site
+    what: str = ""  # how they failed, e.g. "HTTP 404"
+    note: str = ""  # to add to the tool result
+    stop: bool = False  # end the request
+
+
+class Sites:
+    def __init__(self, note_at: int = NOTE_AT) -> None:
+        self.note_at = note_at  # 0: off
+        self.failed: dict[str, dict[str, str]] = {}  # site -> {call key: how it failed}
+        self.reached: set[str] = set()
+
+    def reset(self) -> None:
+        """A new request."""
+        self.failed.clear()
+        self.reached.clear()
+
+    def check(self, name: str, args: dict, result: str) -> Verdict:
+        """Count what this call reached and failed to reach; a note when a site looks out of reach."""
+        if self.note_at <= 0:
+            return Verdict()
+        failed, reached = outcomes(name, args, result)
+        self.reached |= reached
+        key = hashlib.sha256(json.dumps([name, args], sort_keys=True, default=str).encode()).hexdigest()
+        verdict = Verdict()
+        for site, how in failed.items():
+            if site in self.reached:
+                continue
+            calls = self.failed.setdefault(site, {})
+            calls[key] = how
+            n = len(calls)
+            if n < self.note_at or n < verdict.calls:
+                continue
+            what = ", ".join(sorted(set(calls.values())))
+            if n >= self.note_at + STOP_AFTER_NOTE:
+                note = (
+                    f"\n\n[lcode] {n} different calls to {site} failed ({what}) and none worked, so lcode stopped "
+                    "the request here: this machine can't reach that site."
+                )
+                verdict = Verdict(site, n, what, note, stop=True)
+            elif not verdict.stop:
+                verdict = Verdict(site, n, what, advice(site, n, what))
+        return verdict
+
+
+def advice(site: str, n: int, what: str) -> str:
+    return (
+        f"\n\n[lcode] Every request to {site} in this request has failed ({n} different calls: {what}) and none "
+        "worked. When a site fails however the address is written, the usual cause is the network, not the "
+        "address: a firewall, a proxy, a regional block, or no internet on this machine. Check that once: request "
+        f"an address on {site} that must exist (one the site's own pages link to). If that fails too, stop trying "
+        "addresses and tell the user what fails and what they could do: use another network or a VPN, set a "
+        f"proxy (HTTPS_PROXY), use a mirror, or run this step on a machine that can reach {site}, such as CI."
+    )
+
+
+def site_of(url: str) -> str:
+    """The host to track for a URL, or "" for local and private addresses (and anything unparseable)."""
+    try:
+        host = (urlsplit(url).hostname or "").lower().rstrip(".")
+    except ValueError:
+        return ""
+    if not host or "$" in host or "{" in host or host == "localhost" or host.endswith(LOCAL_SUFFIXES):
+        return ""
+    try:
+        ip = ipaddress.ip_address(host.strip("[]"))
+    except ValueError:
+        return host if "." in host else ""
+    return "" if ip.is_private or ip.is_loopback or ip.is_link_local or ip.is_unspecified else host
+
+
+def failure(line: str) -> str:
+    """How a line of output says a request failed ("HTTP 404", "the name doesn't resolve"…), or ""."""
+    m = FAILED_STATUS.search(line)
+    if m:
+        return f"HTTP {next(g for g in m.groups() if g)}"
+    for what, pattern in NETWORK_ERRORS:
+        if pattern.search(line):
+            return what
+    return ""
+
+
+def outcomes(name: str, args: dict, result: str) -> tuple[dict[str, str], set[str]]:
+    """The sites a call failed to reach (with how) and the ones it reached."""
+    if name == "web_fetch":
+        site = site_of(str(args.get("url", "")))
+        if not site:
+            return {}, set()
+        if result.startswith("Error:"):
+            how = failure(result)
+            return ({site: how} if how else {}), set()
+        return {}, {site}
+    if name != "bash":
+        return {}, set()
+    named = {site_of(url) for url in URL.findall(str(args.get("command", "")))}
+    current = next(iter(named)) if len(named) == 1 else ""
+    failed: dict[str, str] = {}
+    reached: set[str] = set()
+    for line in result.splitlines():
+        if line.startswith("[lcode") or line.startswith("[exit code"):
+            continue
+        urls = URL.findall(line)
+        if urls:
+            current = site_of(urls[-1])
+        if not current:
+            continue
+        how = failure(line)
+        if how:
+            failed.setdefault(current, how)
+        elif OK_STATUS.search(line):
+            reached.add(current)
+    if len(named) == 1 and (site := next(iter(named))) and not failed and site not in reached:
+        printed = "".join(line for line in result.splitlines() if not line.startswith(("[lcode", "[exit code")))
+        if result.rstrip().endswith("[exit code: 0]") and len(printed) >= PLENTY:
+            reached.add(site)
+    return failed, reached

{lcode_cli-0.35.0.dist-info → lcode_cli-0.36.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.35.0
+Version: 0.36.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.35.0.dist-info → lcode_cli-0.36.0.dist-info}/RECORD

@@ -1,17 +1,17 @@
-lcode/__init__.py,sha256=gk-TBYXXl_EmM4X0Si03ubfRw1OFZ-QjmkNP_Rj4jfc,473
+lcode/__init__.py,sha256=yGzk6CSXaFMumjYybvLVXP6ECcm-RN4YJ77pJlK1FWw,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=hLnVWTzXjqgXMn5JgkR-VXPZj4GDri1lIU7xYB5YBBs,78221
-lcode/api.py,sha256=FahtmNRjdgrVbImGFZhnKjMyeHHXGAMHv6-7NR9vm9I,16153
-lcode/backends.py,sha256=Tq8B1XzZflb56N-j7qtzgIws4lodWXIyWJkIqB1wSO4,20916
-lcode/bench.py,sha256=cBchBoDIqq5iA8Otevbf9BKF6mi6BzTEmmdxdG6MpCI,43078
+lcode/agent.py,sha256=m_q7Q-uKWRUru6rUXXEhmUvJeDQQR1EMADigw06MGq4,84599
+lcode/api.py,sha256=mIfmiN3jDv8jg-HOJtqfr-MQ3cOI8nfFmlYYRZR1r1Y,16164
+lcode/backends.py,sha256=343alwyDZin-bEhb5-Es4f8ek1oBQUzEvV6RFWR1VZo,21160
+lcode/bench.py,sha256=HxeUfy9Kv_0Rug1HAlDLyHYfYd9dw2bMgbXsvUy9nd4,43096
 lcode/bench_backend.py,sha256=X2fo-zRX92Xp3KMxSsFlWioc2vRupBTtowj5kLME8mw,14287
 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=nPvGnL0gZiUkbTniCoTAAyItiPEXZ-f6rHLYYUOKSiU,42151
+lcode/checks.py,sha256=iPaNaGOGo7zHc_mue41ELEHSNq0VIH_xVYL_bHkYLXU,9373
+lcode/cli.py,sha256=vtrGb1A_Jnxulu-L0nac01ARdQ8dyxZI4fapb-0G2N4,44703
 lcode/clipboard.py,sha256=nTSdJyCXPdtjH947RjvB3QvRqnL5HZsS9KB8EkC42cc,5138
 lcode/codesearch.py,sha256=Io8leN1nb_Y-Dvlm9xaGtwUWYXX-ooswuznJV6dGU1s,10766
 lcode/config.py,sha256=hAjuHg7plRxwFgdD4gOGnDH8-FwyT7NRV0YI5grd0qE,12604
@@ -33,8 +33,8 @@ lcode/ollama.py,sha256=u5tnvL28cfaFS4GhmiEsHhTQe6w3Ng_Tej05UUzLQTQ,7715
 lcode/permissions.py,sha256=q7CjDsc_Xrblw7t3_BbxA5LUjxFSswGs1RiJmtMi0po,12288
 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=zEXyfmIW-V8NqvfXmoqqeiMiM8Il4jb8bUFAA1SnF94,54628
+lcode/repeats.py,sha256=vpXR5pzKX9GsTzQONGS30V-rEU3gunaj_hBzJxg43Q4,5542
+lcode/repl.py,sha256=2i_EDAsXxQ9OxXyWiuPGtIY4pLO3lQW4_SulITcThkM,56548
 lcode/repomap.py,sha256=1GRJgEUjBl9XHSXsF7tSGXBCEgsY-3CzwMohaTudZ_M,13969
 lcode/residency.py,sha256=bDB2J0SZULDOz6wYuMCnkjacYk7pWi5f75iY83ycAXQ,6912
 lcode/review.py,sha256=0QBIS-R1B2b3zqx5TcC1qZptpKBbrDhYvMKSNCaDAUo,4686
@@ -43,8 +43,9 @@ lcode/screenshots.py,sha256=bcWSXS4xTsBk8HhpjBy5jvu705uH9qV8bXANr--Mf2M,46405
 lcode/secretscan.py,sha256=6Euvfk2gCtK7lZbuQD84zgWuSECi6OnSw8V5rFu1tfU,13575
 lcode/sessions.py,sha256=ojkpP453JyIll8_iFeJgW4BG4Zz2FKMRsLiij6spiTo,4185
 lcode/steer.py,sha256=0vaqLxgRKgC0yGp8xoQfV1f9VEOzH3U4rCIb74eFnZ8,12127
-lcode/subagents.py,sha256=GGn2E7QUwEsShJEHXaMhG53leyGFUZwJku_n33gJguU,29157
-lcode/tools.py,sha256=2aZtQ1dot9p6Y6pcympP8nyiCdlba8gMbCqREwPMtPI,67586
+lcode/subagents.py,sha256=thR2ZzFZ1DeoAf0Ctr_oeKjYajhvd3uRs2kGdw6LlJM,29349
+lcode/tools.py,sha256=glp18sbnxaK5iugDxrCFlDaT0SEbO-GTOL_-O3Afp44,68005
+lcode/unreachable.py,sha256=TXrv41ljwX_amxdcf4CY6qGF2YkWetORvPUSvwceJXI,8685
 lcode/update.py,sha256=i92bnW252VneYh0vD6djxmXsDOa5MXP20bjlLZUue_c,25236
 lcode/vision.py,sha256=w33QPmdGwP33wM4mvmAH4amFDZ1xzeXhEsSLJ-STSHY,4243
 lcode/web.py,sha256=vyxKbSRJTl1Lj3hj7Yd_NwTgbv0Xi6dup2YfUXjqp-Y,14579
@@ -64,8 +65,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.35.0.dist-info/METADATA,sha256=FanOqu5FsF_g3lvnsVZ9ciVjq11BOHYFeBYTFkqm4G4,13141
-lcode_cli-0.35.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.35.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
-lcode_cli-0.35.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.35.0.dist-info/RECORD,,
+lcode_cli-0.36.0.dist-info/METADATA,sha256=kp6gDSBL_DtXIWYn7FRO6CpzOf8t-dQPMOwpCQ_4trU,13141
+lcode_cli-0.36.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.36.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
+lcode_cli-0.36.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.36.0.dist-info/RECORD,,