lcode-cli 0.34.0__tar.gz → 0.35.1__tar.gz

{lcode_cli-0.34.0 → lcode_cli-0.35.1}/CHANGELOG.md

@@ -6,6 +6,65 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.35.1] - 2026-10-15
+
+### Fixed
+
+Found in a real session that spent an hour on an Android build whose downloads this machine
+couldn't reach, then ended without a word:
+
+- **A site this machine can't reach** now stops the guessing. lcode tracks, per site, the calls that
+  failed to reach it (HTTP errors, names that don't resolve, refused or timed-out connections) and
+  the ones that got an answer. After three different failed calls and none that worked, the model is
+  told to check one address that must exist and, if that fails too, to tell you what fails and what
+  you could do. Two more and lcode stops the request (status `blocked`). Before, every new address
+  looked like a new attempt, so nothing stepped in.
+- **Thinking in circles** is stopped as it streams. A model that repeats the same few paragraphs
+  used to think until the context was full (here 70,000 characters, about ten minutes behind the
+  spinner). Now the reply is dropped once its sentences keep repeating, and the model is asked for
+  its next step or what's blocking it.
+- **A reply with no answer** no longer ends the request as if it were done. An empty reply, or one
+  that filled the context before it said anything, gets a second chance; the second time lcode stops
+  (status `loop`) and offers the stronger model first, when one is set. An answer the context cut off
+  midway now says so. OpenAI-compatible servers report a cut-off reply too.
+- **A `cd` out of the project** no longer moves lcode there. A model that ran `cd /tmp` took the
+  session, the project checks and the memory notes with it, and the session was saved under `/tmp`,
+  so `lcode -c` in the project couldn't find it. Now a `cd` within the project is kept, and one out
+  of it isn't: the next command starts in the project again. Sessions are saved under the folder
+  lcode works in.
+- **Scripts it never ran** are sent back once before the answer counts: a model that wrote
+  `build_android.sh` and called the job done never ran it, and its first line failed. It now runs it
+  and fixes what fails, or says plainly that it's untested and why.
+
+## [0.35.0] - 2026-10-14
+
+### Added
+
+- A stronger model when stuck: with `escalate_model` set (a cloud model with your API key, such as
+  `anthropic/…`, `openai/…` or `xai/…`, or a bigger local one, `ollama/qwen3.8-27b`), lcode
+  offers to ask it for advice when the loop breaker would stop a request or the checks fail twice
+  in a row, and `/escalate` asks at any time. Nothing is sent without asking, in any permission
+  mode: you see why, what goes (your requests, the task sheet, the failure, the last steps and the
+  files in question, never the whole session), where, and the cost (`escalate_price`), and can
+  read it all first. Keys come only from environment variables and go only to their provider.
+  `lcode -p --escalate` allows it for one run, and `lcode bench --retry --escalate MODEL`
+  measures it. Measured on a 12 GB laptop with qwen3.6-35b and the bigger local qwen3.8-27b as
+  the advisor, on `runtime-bug` with a second try: 1 of 3 passed with its advice, as without it
+  (6 of 9 hidden-test problems fixed against 4), at about 9 minutes per question. A local advisor
+  helps a little; a cloud model is the one to try. See
+  [A stronger model when stuck](https://nasser1941.github.io/lcode/usage/#a-stronger-model-when-stuck).
+
+### Fixed
+
+- Long command output can't fill the disk any more. lcode keeps the full text of long outputs so the
+  model can read parts of them, but a command that printed gigabytes was saved whole, and the
+  saved outputs had no total limit, only an age (7 days). Now one is kept to its first 20 MB (the
+  model still gets the end and the error lines), and all of them together to 200 MB, oldest first.
+
+- A screenshot of a web app no longer starts its server a second time when one already answers at
+  the URL (one the model started itself, say), which used to fail on the busy port and put the
+  error in the result. A page that answers also counts when the server command itself exits.
+
 ## [0.34.0] - 2026-10-14
 
 ### Added
@@ -740,7 +799,9 @@ First public release.
 - `AGENTS.md` project instructions and `/init` to generate them.
 - One-line installer for Linux and macOS.
 
-[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.34.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.35.1...HEAD
+[0.35.1]: https://github.com/nasser1941/lcode/compare/v0.35.0...v0.35.1
+[0.35.0]: https://github.com/nasser1941/lcode/compare/v0.34.0...v0.35.0
 [0.34.0]: https://github.com/nasser1941/lcode/compare/v0.33.1...v0.34.0
 [0.33.1]: https://github.com/nasser1941/lcode/compare/v0.33.0...v0.33.1
 [0.33.0]: https://github.com/nasser1941/lcode/compare/v0.32.0...v0.33.0

{lcode_cli-0.34.0 → lcode_cli-0.35.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.34.0
+Version: 0.35.1
 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.34.0 → lcode_cli-0.35.1}/docs/automation.md

@@ -50,7 +50,7 @@ went: `0` success, `1` an error, `3` stopped at `--max-steps`, `4` stopped becau
 
 | Field | |
 |---|---|
-| `status` | `success`, `error`, `max_steps`, `loop` (the model kept repeating the same call) or `interrupted` |
+| `status` | `success`, `error`, `max_steps`, `loop` (the model kept repeating the same call, or its replies went nowhere), `blocked` (a site it needed couldn't be reached) or `interrupted` |
 | `text` | The model's final answer |
 | `tool_calls` | Every tool call, with its arguments and output (the first 4,000 characters). `error` is true when the call failed or wasn't allowed |
 | `files_changed` | Files the request added (`A`), modified (`M`) or deleted (`D`), shell commands included |

{lcode_cli-0.34.0 → lcode_cli-0.35.1}/docs/bench.md

@@ -45,6 +45,22 @@ cause. Neither is in the default set, so results stay comparable with earlier ve
 `--code-search` indexes each task's folder for [semantic search](search.md#semantic-code-search);
 both are off in `lcode bench` by default, for the same reason.
 
+### A second try, and a stronger model
+
+`--retry` gives a failed task one more try, as a user would ask: "That didn't fix it: it still
+doesn't work right. Look again." `--escalate MODEL` sets a [stronger model](usage.md#a-stronger-model-when-stuck)
+that's asked when the model is stuck and, with `--retry`, before the second try, as `/escalate`
+would: no questions asked, since the flag is your OK. Comparing the two shows what the stronger
+model's advice adds to the same second chance:
+
+```bash
+lcode bench --tasks runtime-bug --retry --rounds 3
+lcode bench --tasks runtime-bug --retry --rounds 3 --escalate ollama/qwen3.8-27b
+```
+
+The JSON report has, for each task, `first_passed` (with `--retry`, whether the first try passed)
+and `escalations`.
+
 ### Long sessions
 
 Each task normally starts a new conversation. `--session` runs them all in **one** conversation

{lcode_cli-0.34.0 → lcode_cli-0.35.1}/docs/configuration.md

@@ -45,7 +45,10 @@ lcode config path                      # print the file location
 | `notify_after` | `30` | Seconds a request runs before it notifies |
 | `review` | `off` | Before the answer, [review a change](usage.md#a-review-before-the-answer) against the request and send problems back to the model: `auto` or `off` |
 | `checks` | `auto` | Run the project's [checks](usage.md#checks-before-done) after a request changed files: `auto` (found from the project), `off`, or a command |
-| `repeat_limit` | `3` | Identical tool calls with identical results before lcode [steps in](how-it-works.md#when-the-model-repeats-itself); `0` turns it off |
+| `escalate_model` | — | A [stronger model](usage.md#a-stronger-model-when-stuck) to ask, with your OK, when the model is stuck: `anthropic/…`, `openai/…`, `xai/…` (keys from `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `XAI_API_KEY`), `ollama/<model>`, or `custom/<model>` with `escalate_url` |
+| `escalate_url` | — | Its server, when it isn't the provider's usual one: another Ollama, or any OpenAI-compatible API |
+| `escalate_price` | — | Its price in dollars per million tokens, input/output (e.g. `3/15`), for the cost shown before each use |
+| `repeat_limit` | `3` | Identical tool calls with identical results before lcode [steps in](how-it-works.md#when-the-model-repeats-itself); `0` turns it off, along with the checks for [unreachable sites](how-it-works.md#when-a-site-cant-be-reached) and [thinking in circles](how-it-works.md#when-a-reply-goes-nowhere) |
 | `secret_check` | `true` | Before `git commit` and `git push`, look for passwords, keys and tokens they'd add ([details](usage.md#secrets-in-commits)) |
 | `checkpoints` | `true` | Save a checkpoint before the model changes files, so [`/undo`](usage.md#undo-and-checkpoints) can restore them |
 

{lcode_cli-0.34.0 → lcode_cli-0.35.1}/docs/how-it-works.md

@@ -59,7 +59,37 @@ A result that changes isn't a repeat, so a test that's run again after a fix, or
 that's checked while it runs, never adds up. A call that may have changed something, like an edit or
 a shell command that isn't read-only, starts the count again for the other calls: checking the build
 after each edit is fine. Change the threshold with `lcode config set repeat_limit 5`, or turn it off
-with `0`.
+with `0` (that also turns off the checks for unreachable sites and for thinking in circles, below).
+
+### When a site can't be reached
+
+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. No address the model tries will fix
+that, and every attempt differs, so the repeat count above never fires. 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 got an answer.
+
+- **When three different calls failed for a site and none worked,** the result gets a note: check
+  one address on that site that must exist, and if that fails too, stop and tell you what fails
+  and what you could do (another network or a VPN, a proxy, a mirror, or running that step
+  somewhere else, such as CI).
+- **Two more,** and lcode ends the request with `Stopped: every request to dl.google.com failed (5
+  calls: HTTP 404)…`. The JSON output's status is `blocked`.
+
+A site that answered once in the request is never counted as out of reach, so a wrong address on a
+working site doesn't add up. Local addresses (localhost, private networks, names without a dot)
+aren't tracked.
+
+### When a reply goes nowhere
+
+Small models sometimes think in circles: a few paragraphs, over and over, until the context is full.
+That takes minutes behind the spinner and ends without an answer. lcode watches the thinking as it
+streams, and when its sentences keep repeating, it stops the model, drops that reply and asks for a
+short one: the next tool call, or what's blocking it. An empty reply, or one that filled the context
+before it said anything, gets the same second chance. The second time in a request, lcode stops it
+(status `loop`), offering the [stronger model](usage.md#a-stronger-model-when-stuck) first when one
+is set. An answer the context cut off midway is kept, with a warning to `/compact` or use a larger
+`/context`.
 
 ## Subagents
 

{lcode_cli-0.34.0 → lcode_cli-0.35.1}/docs/quickstart.md

@@ -12,7 +12,7 @@ lcode
 
 ```text
 ╭──────────────────────────────────────────────╮
-│ lcode v0.34.0 — local coding agent           │
+│ lcode v0.35.1 — local coding agent           │
 │                                              │
 │ model    lcode-qwen3.6-35b                   │
 │ context  256K tokens                         │

{lcode_cli-0.34.0 → lcode_cli-0.35.1}/docs/usage.md

@@ -83,6 +83,7 @@ reasoning is on.
 | `/cd DIR` | Change the working directory |
 | `/todos` | Show the model's task list |
 | `/status` | The task sheet: your latest requests, the plan and the model's notes, files changed, the last check |
+| `/escalate` | Ask the [stronger model](#a-stronger-model-when-stuck) for advice on the work, with your OK; `/escalate <what's wrong>` says what to look at |
 | `/jobs [stop ID]` | The [background commands](#background-commands) the model started; stop one |
 | `/commit [notes]` | [Commit](git.md#commit) the changes with a message in the repository's style, once you approve it |
 | `/review [base]` | [Review](git.md#review) the uncommitted changes, or the branch against a base |
@@ -100,7 +101,7 @@ reasoning is on.
 | `list_dir` | Directory tree, skipping `.git`, `node_modules`, virtualenvs and caches |
 | `glob` | Find files by pattern, newest first |
 | `grep` | Regex search with ripgrep (falls back to Python if ripgrep is missing) |
-| `bash` | Run a shell command with live output, a timeout and a persistent working directory; with `background`, keep it running ([details](#background-commands)) |
+| `bash` | Run a shell command with live output, a timeout and a persistent working directory (a `cd` within the project is kept, one out of it isn't); with `background`, keep it running ([details](#background-commands)) |
 | `bash_output`, `bash_stop` | Read what a background command printed since last time; stop it |
 | `todo_write` | Keep a visible task list for multi-step work, with notes (decisions, findings) that survive when old messages are removed; `/status` shows them |
 | `web_search` | Search the web for current information (needs a [search provider](#web-search)) |
@@ -182,6 +183,13 @@ command = "uv run pytest -q && uv run ruff check ."
 Or set it for yourself with `lcode config set checks "make check"`; `lcode config set checks off`
 turns checks off.
 
+**Scripts it never ran.** A model that writes a build or install script tends to call it done
+without running it once, and the first thing you see is its first error. When a request wrote a
+shell script (a `.sh` file, or a file with a shell shebang) and no command in it ran the script,
+lcode sends it back once before the answer counts: run it and fix what fails, or say plainly that
+it's untested and why, when running it would install, deploy or delete things. Making it executable
+or reading it doesn't count as running it. `checks = "off"` turns this off too.
+
 ## A review before the answer
 
 Models claim more than they did: half of a two-part request done, "it works now" without having
@@ -208,6 +216,53 @@ The review is asked on top of the conversation rather than in a fresh one. The m
 the processed conversation cached, and a separate review would push it out, so the next request
 would have to read the whole conversation again. On a small GPU that's tens of seconds.
 
+## A stronger model when stuck
+
+Some problems are beyond a local model. When it's stuck, lcode can ask a stronger one for
+advice: a cloud model with your API key, or a bigger local model. The local model gets the advice
+and carries on with its own tools. It's off until you choose the model:
+
+```bash
+lcode config set escalate_model anthropic/<model>   # with ANTHROPIC_API_KEY in your environment
+lcode config set escalate_model openai/<model>      # OPENAI_API_KEY
+lcode config set escalate_model xai/<model>         # XAI_API_KEY
+lcode config set escalate_model ollama/qwen3.8-27b  # a bigger local model: free, and nothing leaves
+lcode config set escalate_price 3/15                # dollars per million tokens in/out, for the cost
+```
+
+**When.** lcode offers it when the [loop breaker](how-it-works.md#when-the-model-repeats-itself)
+would stop the request, when the model's replies [go nowhere](how-it-works.md#when-a-reply-goes-nowhere)
+twice, and when the project's [checks](#checks-before-done) fail twice in a row after the model's
+fixes, at most once per request. Not for a [site this machine can't reach](how-it-works.md#when-a-site-cant-be-reached):
+a stronger model can't reach it either. You can also ask at any time: `/escalate`, or
+`/escalate the window still grows` to say what's wrong.
+
+**Nothing is sent without asking**, in any permission mode:
+
+```text
+╭─ Ask claude-… for help? ──────────────────────────────────────────────────╮
+│ Why: the project's checks (`pytest -q`) failed 2 times in a row          │
+│ What goes: your requests, the task sheet, the failure, the last steps     │
+│ and these files: wall.py, simulate.py (3.1K tokens)                       │
+│ Where: claude-… (Anthropic), at api.anthropic.com                         │
+│ Cost: about $0.009 to $0.071 (3.1K tokens in at $3/M, up to 4.1K out …)  │
+╰───────────────────────────────────────────────────────────────────────────╯
+  Send it? [y]es / [n]o / [s]how what's sent:
+```
+
+- **What goes:** your last requests, the [task sheet](how-it-works.md#context-management), why
+  it's stuck (the failing check's output, the repeated call), the last few steps, and the files the
+  request changed or read: never the whole session or the rest of the repository. Press `s` to read
+  all of it before you decide.
+- **Keys** come from environment variables, are read when needed, and go only to their own
+  provider. lcode never stores them.
+- **Cost.** The token count is always shown; the price only when you set `escalate_price`, since
+  prices change. A local model is free.
+- **Another server:** `escalate_url` points at another Ollama (`ollama/<model>`) or any OpenAI
+  API (`custom/<model>`, key in `LCODE_ESCALATE_API_KEY`).
+- `lcode -p` can't ask, so it doesn't escalate unless you add `--escalate`, which is your OK for
+  that run. `--output json` lists what was asked in `escalations`.
+
 ## Background commands
 
 Some commands keep running: a dev server, a test watcher, a build in watch mode. The model starts

{lcode_cli-0.34.0 → lcode_cli-0.35.1}/pyproject.toml

@@ -82,6 +82,7 @@ ignore = [
 "src/lcode/subagents.py" = ["E501"]
 "src/lcode/planning.py" = ["E501"]
 "src/lcode/review.py" = ["E501"] # the review prompt is prose
+"src/lcode/escalate.py" = ["E501"] # the advisor prompt is prose
 "src/lcode/extensions.py" = ["E501"]
 "src/lcode/context.py" = ["E501"]
 "src/lcode/lsp.py" = ["E501"]

{lcode_cli-0.34.0 → lcode_cli-0.35.1}/src/lcode/__init__.py

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

{lcode_cli-0.34.0 → lcode_cli-0.35.1}/src/lcode/agent.py

@@ -29,6 +29,7 @@ from lcode import (
     catalog,
     checks,
     codesearch,
+    escalate,
     extensions,
     limits,
     notify,
@@ -50,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 (
@@ -70,6 +71,7 @@ from lcode.tools import (
     tree,
     truncate,
 )
+from lcode.unreachable import NOTE_AT, Sites
 
 GPU_MEMORY_ERRORS = (
     "out of memory",
@@ -79,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")
@@ -307,6 +330,9 @@ class Settings:
     repeat_limit: int = 3  # identical calls with identical results before the model is told (lcode.repeats)
     checks: str = "off"  # the project's checks after a change (lcode.checks): auto, off or a command
     review: str = "off"  # check a change against the request before the answer (lcode.review): auto or off
+    escalate_model: str | None = None  # a stronger model to ask when stuck (lcode.escalate): provider/model
+    escalate_url: str | None = None  # its server, when not the provider's usual one
+    escalate_price: str | None = None  # dollars per million tokens in/out, e.g. "3/15", for the cost estimate
 
 
 class Agent:
@@ -315,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()
@@ -369,10 +398,14 @@ class Agent:
         self._check: tuple[Path, checks.Check | None] | None = None
         self.check_results: list[dict] = []  # the checks of the last request: command, exit code, who ran them
         self.review_results: list[str] | None = None  # what the last request's review found (None: no review)
+        self.escalations: list[dict] = []  # the stronger model asked in the last request (lcode.escalate)
+        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
@@ -642,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,
@@ -681,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}"
@@ -701,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)
@@ -799,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", {})
@@ -816,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")
@@ -840,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()
@@ -912,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":
@@ -952,9 +1000,8 @@ class Agent:
             )
             return None
         if round_ >= checks.MAX_ROUNDS:
-            self.say(
-                f"Checks still fail ({check.command}, exit code {code}): the model will say what's left.", warning=True
-            )
+            then = "" if self.can_escalate() else ": the model will say what's left"
+            self.say(f"Checks still fail ({check.command}, exit code {code}){then}.", warning=True)
         else:
             self.say(
                 f"Checks fail ({check.command}, exit code {code}): the model gets the output to fix it.", warning=True
@@ -1101,14 +1148,21 @@ 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 = []
+        escalated = False  # the stronger model is asked at most once per request
         self.tools.before = {}
         reviewed = False
         changed = verified = False  # files changed in this request; the checks passed since
         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
@@ -1158,14 +1212,60 @@ 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
                     feedback = self.run_check(check, check_rounds)
                     if feedback:
+                        if check_rounds >= checks.MAX_ROUNDS and not escalated and self.can_escalate():
+                            escalated = True
+                            why = f"the project's checks (`{check.command}`) failed {check_rounds} times in a row"
+                            advice = escalate.run(self, why, failure=feedback)
+                            if advice:
+                                self.messages.append({"role": "user", "content": advice})
+                                check_rounds -= 1  # the checks run once more after the advice
+                                changed = False
+                                continue
                         self.messages.append({"role": "user", "content": feedback})
                         changed = False  # run them again only if the model changes something more
                         continue
@@ -1231,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):
@@ -1248,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",
@@ -1259,6 +1374,26 @@ class Agent:
                             skipped["tool_call_id"] = rest["id"]
                         self.messages.append(skipped)
                     break
+            if looping and not escalated and self.can_escalate():
+                escalated = True
+                advice = escalate.run(self, f"it kept making the same call with the same result: {looping}")
+                if advice:
+                    self.messages.append({"role": "user", "content": advice})
+                    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(
@@ -1276,6 +1411,11 @@ class Agent:
         self.turn_status = "success"
         self.print_stats()
 
+    def can_escalate(self) -> bool:
+        """Whether a stronger model may be asked here: one is set, and this isn't a subagent or plan mode."""
+        model = (self.settings.escalate_model or "").strip().lower()
+        return bool(model) and model != "off" and self.allowed_tools is None and not self.planning()
+
     def steer(self) -> None:
         """Between two steps: pause if the user pressed Esc, then hand the model the notes typed meanwhile."""
         steering = self.steering

{lcode_cli-0.34.0 → lcode_cli-0.35.1}/src/lcode/api.py

@@ -78,6 +78,7 @@ class Result:
     usage: dict = field(default_factory=dict)  # requests, prompt_tokens, output_tokens
     checks: list[dict] = field(default_factory=list)  # {"command", "exit_code", "by": "lcode" | "model"}
     review: list[str] | None = None  # problems the review sent back ([] when it found none; None: no review)
+    escalations: list[dict] = field(default_factory=list)  # a stronger model asked: model, why, tokens, seconds
     seconds: float = 0.0
     error: str = ""
 
@@ -200,6 +201,9 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
         repeat_limit=cfg["repeat_limit"],
         checks=cfg["checks"],
         review=cfg["review"],
+        escalate_model=cfg["escalate_model"],
+        escalate_url=cfg["escalate_url"],
+        escalate_price=cfg["escalate_price"],
         compact_at=cfg["compact_at"],
     )
     agent = Agent(ollama, settings, cwd, console=console)
@@ -281,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:
@@ -309,6 +313,7 @@ def run_request(agent: Agent, prompt: str) -> Result:
         usage=usage,
         checks=list(agent.check_results),
         review=agent.review_results,
+        escalations=list(agent.escalations),
         seconds=round(time.monotonic() - started, 2),
         error=error,
     )