lcode-cli 0.35.1__py3-none-any.whl → 0.37.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.1"
+__version__ = "0.37.0"
 
 API = ("Session", "Result", "Options", "SetupError")
 

lcode/agent.py

@@ -45,6 +45,7 @@ from lcode import (
 from lcode import context as context_tools
 from lcode import memory as memory_notes
 from lcode.checkpoints import Checkpoints
+from lcode.cloud import is_cloud
 from lcode.config import format_tokens
 from lcode.jobs import Jobs
 from lcode.mcp import McpManager
@@ -1011,8 +1012,8 @@ class Agent:
     def before_request(self, progress: Progress) -> residency.LoadWatch | None:
         """Set the status line for what comes before the first token: loading the model if it isn't in memory
         (watched until it is), then reading the prompt. Returns the watch while the model loads."""
-        if getattr(self.ollama, "kind", "ollama") != "ollama":
-            return None
+        if getattr(self.ollama, "kind", "ollama") != "ollama" or is_cloud(self.settings.model):
+            return None  # another server loads models itself; an Ollama cloud model isn't loaded here at all
         model, context = self.settings.model, self.settings.context
         fresh = max(0, conversation_chars(self.messages) - self.sent_chars) // 3
         where = residency.placement(self.ollama, model)

lcode/cli.py

@@ -21,6 +21,7 @@ from rich.table import Table
 from lcode import __version__, backends, catalog, config, limits, web
 from lcode.agent import Settings
 from lcode.catalog import ModelSpec
+from lcode.cloud import is_cloud, signin_command
 from lcode.config import ConfigError, format_tokens, parse_context
 from lcode.hardware import Hardware, detect
 from lcode.ollama import MIN_VERSION, Ollama, OllamaError, redact, version_tuple
@@ -113,44 +114,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 +214,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 +225,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:
@@ -324,6 +385,13 @@ def cmd_doctor(args) -> None:
     try:
         model, spec = resolve_model(ollama, cfg["model"])
         line("Model", f"{cfg['model']} → {model}", True)
+        if is_cloud(model):
+            line(
+                "",
+                "runs in Ollama's cloud: what lcode sends goes to ollama.com, billed per token, and this Ollama "
+                f"must be signed in once: {signin_command(ollama.host)}",
+                None,
+            )
         ctx, note = choose_context(ollama, model, spec, cfg["context"], hw)
         if spec:
             from lcode.subagents import parallel_slots

lcode/cloud.py

@@ -0,0 +1,46 @@
+"""Ollama's cloud models: tags like `minimax-m3.1-flash:cloud` run on ollama.com, through the local Ollama.
+
+They look like any installed model to lcode (Ollama lists them, and they chat and call tools), but nothing about
+them is local: what lcode sends goes to ollama.com, it's billed per token, and it needs the Ollama signed in to an
+ollama.com account (`ollama signin`). So lcode says so where it matters (`lcode doctor`, the start of a session, the
+stronger-model panel), skips what only makes sense for a local model (loading it into memory, GPU fit), and turns
+Ollama's bare `Unauthorized` into the command that fixes it.
+"""
+
+from __future__ import annotations
+
+
+def is_cloud(model: str | None) -> bool:
+    """Whether an Ollama model name is one of Ollama's cloud models: its tag is `cloud` or ends with `-cloud`."""
+    name = (model or "").strip().lower()
+    if ":" not in name:
+        return False
+    tag = name.rsplit(":", 1)[1]
+    return tag == "cloud" or tag.endswith("-cloud")
+
+
+def signin_command(host: str) -> str:
+    """How to sign the Ollama at `host` in to ollama.com: inside its container when it runs in Docker."""
+    try:
+        from lcode import update
+
+        container = update.find_container(host) if update.docker_available() else None
+    except Exception:  # Docker missing, or not answering: the plain command is still right for most installs
+        container = None
+    return f"docker exec -it {container.name} ollama signin" if container else "ollama signin"
+
+
+def unauthorized(model: str, host: str) -> str:
+    """The error for a cloud model that Ollama refused: what it means and the command to run."""
+    return (
+        f"{model} runs in Ollama's cloud (ollama.com), and this Ollama isn't signed in to an ollama.com account. "
+        f"Sign it in with `{signin_command(host)}`, then try again."
+    )
+
+
+def notice(model: str) -> str:
+    """What to know when a cloud model is lcode's main model."""
+    return (
+        f"{model} runs in Ollama's cloud: what lcode sends (your requests and the files it reads) goes to "
+        "ollama.com, and Ollama bills it per token."
+    )

lcode/escalate.py

@@ -23,6 +23,7 @@ from rich.panel import Panel
 from rich.text import Text
 
 from lcode import context as context_tools
+from lcode.cloud import is_cloud
 from lcode.ollama import Ollama, OllamaError, redact
 
 if TYPE_CHECKING:
@@ -76,14 +77,23 @@ class Target:
     @property
     def cloud(self) -> bool:
         """Paid per token: a cloud provider, or an OpenAI-compatible API elsewhere."""
-        return self.provider in ("openai", "anthropic", "xai") or (self.provider == "custom" and not self.local)
+        return (
+            self.provider in ("openai", "anthropic", "xai")
+            or (self.provider == "custom" and not self.local)
+            or (self.provider == "ollama" and is_cloud(self.model))  # an Ollama cloud model runs on ollama.com
+        )
 
     @property
     def where(self) -> str:
+        if self.provider == "ollama" and is_cloud(self.model):
+            return "ollama.com, through " + ("this machine's Ollama" if self.local else self._host())
         if self.url:
-            return re.sub(r"^https?://", "", redact(self.url)).split("/")[0]
+            return self._host()
         return "this machine"
 
+    def _host(self) -> str:
+        return re.sub(r"^https?://", "", redact(self.url)).split("/")[0]
+
 
 def target(setting: str | None, url: str | None = None) -> Target | None:
     """The stronger model from the settings (None: escalation is off). Raises EscalateError for a bad setting."""
@@ -105,6 +115,8 @@ def target(setting: str | None, url: str | None = None) -> Target | None:
         raise EscalateError(f"escalate_model {setting!r} names no model")
     if provider == "custom" and not url:
         raise EscalateError("a custom/… escalate_model needs escalate_url, the server's OpenAI-compatible address")
+    if provider == "ollama" and is_cloud(model):
+        name = "Ollama cloud"
     return Target(provider, model.strip(), (url or base).rstrip("/"), key_env, f"{model.strip()} ({name})")
 
 

lcode/ollama.py

@@ -9,6 +9,8 @@ from urllib.parse import urlsplit, urlunsplit
 
 import requests
 
+from lcode.cloud import is_cloud, unauthorized
+
 MIN_VERSION = (0, 30, 0)  # first release that runs the Qwen3.5/3.6 hybrid-attention architecture
 
 
@@ -49,6 +51,8 @@ class Ollama:
             r = requests.post(self._url(path), json=payload, timeout=timeout)
         except requests.RequestException as e:
             raise OllamaError(f"cannot reach Ollama at {redact(self.host)}: {e}") from e
+        if r.status_code == 401 and is_cloud(payload.get("model")):
+            raise OllamaError(unauthorized(payload["model"], self.host))
         if r.status_code != 200:
             raise OllamaError(f"Ollama {path} failed ({r.status_code}): {r.text[:300]}")
         return r.json()
@@ -164,6 +168,8 @@ class Ollama:
         if on_open:
             on_open(r)
         with r:
+            if r.status_code == 401 and is_cloud(payload.get("model")):
+                raise OllamaError(unauthorized(payload["model"], self.host))
             if r.status_code != 200:
                 raise OllamaError(f"Ollama error {r.status_code}: {r.text[:500]}")
             for line in r.iter_lines():

lcode/repl.py

@@ -45,6 +45,8 @@ from lcode import memory as memory_notes
 from lcode.agent import AUTO_COMPACT_RATIO, INIT_PROMPT, Agent
 from lcode.catalog import MIN_USEFUL_CONTEXT
 from lcode.checkpoints import Checkpoint, CheckpointError, Restore
+from lcode.cloud import is_cloud
+from lcode.cloud import notice as cloud_notice
 from lcode.config import PERMISSION_MODES, STATE_DIR, ConfigError, format_tokens, parse_context
 from lcode.hardware import Hardware
 from lcode.ollama import OllamaError
@@ -68,8 +70,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 +245,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 +325,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 +826,65 @@ 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)}).")
+    if is_cloud(name):
+        agent.say(cloud_notice(name))
+    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 +1032,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 +1080,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'}.")
@@ -1207,6 +1260,8 @@ def repl(agent: Agent, prompt: str | None, hardware: Hardware, cont: bool = Fals
         run_safely(agent, prompt)
         return
     banner(agent)
+    if is_cloud(agent.settings.model):
+        agent.say(cloud_notice(agent.settings.model))
     warning = residency.dense_warning(agent.ollama, agent.settings.model, agent.settings.context, hardware)
     if warning:
         agent.say(warning, warning=True)
@@ -1237,6 +1292,8 @@ def repl(agent: Agent, prompt: str | None, hardware: Hardware, cont: bool = Fals
 
 def preload(agent: Agent, session: PromptSession | None = None) -> None:
     """Start loading the model in the background so the first answer comes sooner; the status bar says so."""
+    if is_cloud(agent.settings.model):
+        return  # it runs on ollama.com: there's nothing to load here
     where = residency.placement(agent.ollama, agent.settings.model)
     if where is not None and (not where.context or where.context == agent.settings.context):
         return  # already in memory

lcode/residency.py

@@ -15,6 +15,7 @@ import time
 from dataclasses import dataclass
 
 from lcode import catalog
+from lcode.cloud import is_cloud
 from lcode.ollama import OllamaError
 
 GB = 1e9
@@ -97,6 +98,8 @@ def expected_share(model: str, context: int, hardware) -> float | None:
 
 def dense_warning(ollama, model: str, context: int, hardware) -> str:
     """For a dense model that won't fit on the GPU: what that means and what to do. Empty otherwise."""
+    if is_cloud(model):
+        return ""  # it runs on ollama.com
     if hardware is None or hardware.unified or is_moe(ollama, model) is not False:
         return ""
     spec = catalog.find(model)

{lcode_cli-0.35.1.dist-info → lcode_cli-0.37.0.dist-info}/METADATA

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

@@ -1,8 +1,8 @@
-lcode/__init__.py,sha256=zUaeUug04u05tZncoC6Kos2DYIKI8_-kGSal29vOt5M,473
+lcode/__init__.py,sha256=lKIIi9DSWXNWEjJvCuOOtYqAkmR0gtWHsaKllXOu7vc,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=m_q7Q-uKWRUru6rUXXEhmUvJeDQQR1EMADigw06MGq4,84599
+lcode/agent.py,sha256=vjWiK79BgUTMAbeC6SPslGaYT86YELwTHIGB21tc4to,84751
 lcode/api.py,sha256=mIfmiN3jDv8jg-HOJtqfr-MQ3cOI8nfFmlYYRZR1r1Y,16164
 lcode/backends.py,sha256=343alwyDZin-bEhb5-Es4f8ek1oBQUzEvV6RFWR1VZo,21160
 lcode/bench.py,sha256=HxeUfy9Kv_0Rug1HAlDLyHYfYd9dw2bMgbXsvUy9nd4,43096
@@ -11,12 +11,13 @@ 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=iPaNaGOGo7zHc_mue41ELEHSNq0VIH_xVYL_bHkYLXU,9373
-lcode/cli.py,sha256=nPvGnL0gZiUkbTniCoTAAyItiPEXZ-f6rHLYYUOKSiU,42151
+lcode/cli.py,sha256=mJBM3Loqs9kOE94IRe00d1A1izW5caAjSR7ITUxC27I,45042
 lcode/clipboard.py,sha256=nTSdJyCXPdtjH947RjvB3QvRqnL5HZsS9KB8EkC42cc,5138
+lcode/cloud.py,sha256=q5Dl5GuqWvKzBCIso-eh6yomvEOsnQ0LW8ZgaAGwBxc,2131
 lcode/codesearch.py,sha256=Io8leN1nb_Y-Dvlm9xaGtwUWYXX-ooswuznJV6dGU1s,10766
 lcode/config.py,sha256=hAjuHg7plRxwFgdD4gOGnDH8-FwyT7NRV0YI5grd0qE,12604
 lcode/context.py,sha256=wgK16ZcNNnq4ngHx0EmtyKHDFTImciGEmtC5NP8tKJQ,20435
-lcode/escalate.py,sha256=6amspekybujPn0BfbVsNDYkB-I_pu6jJB45YJgFv0yc,14638
+lcode/escalate.py,sha256=f-_6_moPaHi2kLuJw2JtkzvTkCl6DoBQgYBOCYLhunM,15120
 lcode/extensions.py,sha256=W0HFDl0BvROzr7i_qtabHdIbacBgP5o5qIJLzoM2oNE,16806
 lcode/frontmatter.py,sha256=Bx0n4vLPhp7ZCWx-g7xqzqNy5VoKBxyeeikh5UFB_gA,2441
 lcode/gitflow.py,sha256=6j_nnCBZXkX1qhTI7K4CyZ5D0NAZLpH96weFEo64AkQ,27913
@@ -29,14 +30,14 @@ lcode/matching.py,sha256=2N3_qwKJ5gd8el2m_y_egKkFM9rsF1eUhYJcRCVIp98,14015
 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/ollama.py,sha256=xFHU2XW47ANJ34-1aeSMQVj28GhqcWiFi6zASH9FiYY,8053
 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=vpXR5pzKX9GsTzQONGS30V-rEU3gunaj_hBzJxg43Q4,5542
-lcode/repl.py,sha256=adq99lxLLr43AQMEHT3qNLNXho4kiQIJUzJTWO9-pmY,54646
+lcode/repl.py,sha256=elnJeSQYt0oEtE14UzW2k-fkDHVFr_Lf2L6XWFo0ne0,56891
 lcode/repomap.py,sha256=1GRJgEUjBl9XHSXsF7tSGXBCEgsY-3CzwMohaTudZ_M,13969
-lcode/residency.py,sha256=bDB2J0SZULDOz6wYuMCnkjacYk7pWi5f75iY83ycAXQ,6912
+lcode/residency.py,sha256=B9pwqG6yx5aQD2M5xyQ-bMnYmhD7fv3wCVw_X6VIeAo,7012
 lcode/review.py,sha256=0QBIS-R1B2b3zqx5TcC1qZptpKBbrDhYvMKSNCaDAUo,4686
 lcode/sandbox.py,sha256=u_pkrVRXhCGhh-wFDPwuZ3jGG7UeXxXRAeBNsm37ZvE,8608
 lcode/screenshots.py,sha256=bcWSXS4xTsBk8HhpjBy5jvu705uH9qV8bXANr--Mf2M,46405
@@ -65,8 +66,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.1.dist-info/METADATA,sha256=QUw9A6Zoi4mnZTYIimLNmID9EjahV_ZlF7ZJmBm5NUw,13141
-lcode_cli-0.35.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.35.1.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
-lcode_cli-0.35.1.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.35.1.dist-info/RECORD,,
+lcode_cli-0.37.0.dist-info/METADATA,sha256=fgaRfrIMEYuJXyDpy8Kj18AL7S2IybZqNmvd09c6IgI,13141
+lcode_cli-0.37.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.37.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
+lcode_cli-0.37.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.37.0.dist-info/RECORD,,