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

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

@@ -6,6 +6,35 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [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 +769,8 @@ 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.0...HEAD
+[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.0}/PKG-INFO

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

@@ -45,6 +45,9 @@ 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 |
+| `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 |
 | `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.0}/docs/quickstart.md

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

{lcode_cli-0.34.0 → lcode_cli-0.35.0}/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 |
@@ -208,6 +209,51 @@ 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, and when the project's [checks](#checks-before-done) fail twice in a row
+after the model's fixes, at most once per request. 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.0}/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.0}/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.0"
 
 API = ("Session", "Result", "Options", "SetupError")
 

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

@@ -29,6 +29,7 @@ from lcode import (
     catalog,
     checks,
     codesearch,
+    escalate,
     extensions,
     limits,
     notify,
@@ -307,6 +308,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:
@@ -369,6 +373,8 @@ 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
@@ -952,9 +958,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
@@ -1103,6 +1108,8 @@ class Agent:
         self.repeats.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
@@ -1166,6 +1173,15 @@ class Agent:
                     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
@@ -1259,6 +1275,14 @@ 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 looping:
                 self.turn_status = "loop"
                 self.console.print(
@@ -1276,6 +1300,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.0}/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)
@@ -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,
     )

{lcode_cli-0.34.0 → lcode_cli-0.35.0}/src/lcode/backends.py

@@ -265,11 +265,16 @@ class OpenAICompatible:
             return self.chat({k: v for k, v in payload.items() if k not in ("format", "tools")}, timeout)
         if r.status_code != 200:
             raise self._failed(r.status_code, r.text)
-        choice = (r.json().get("choices") or [{}])[0].get("message") or {}
+        data = r.json()
+        choice = (data.get("choices") or [{}])[0].get("message") or {}
         message: dict = {"role": "assistant", "content": strip_thinking(choice.get("content") or "")}
         if choice.get("tool_calls"):
             message["tool_calls"] = [self._ollama_call(c) for c in choice["tool_calls"]]
-        return {"message": message}
+        reply: dict = {"message": message}
+        usage = data.get("usage") or {}
+        if usage.get("prompt_tokens") is not None:  # as Ollama counts them
+            reply["prompt_eval_count"], reply["eval_count"] = usage["prompt_tokens"], usage.get("completion_tokens")
+        return reply
 
     @staticmethod
     def _ollama_call(call: dict) -> dict:

{lcode_cli-0.34.0 → lcode_cli-0.35.0}/src/lcode/bench.py

@@ -29,7 +29,7 @@ from rich.markup import escape
 from rich.table import Table
 from rich.text import Text
 
-from lcode import __version__
+from lcode import __version__, escalate
 from lcode.agent import Agent, Settings
 from lcode.config import format_tokens
 from lcode.hardware import Hardware
@@ -790,6 +790,8 @@ class TaskResult:
     tool_errors: int = 0  # failed tool calls, including malformed ones
     error: str | None = None  # why the run stopped early: a timeout or an Ollama error
     errors_by_tool: dict[str, int] = field(default_factory=dict)  # which tools failed, "malformed" for unreadable calls
+    first_passed: bool | None = None  # with --retry: whether the first try passed (None: no retry was needed)
+    escalations: int = 0  # times the stronger model was asked (--escalate)
 
 
 @dataclass
@@ -887,8 +889,13 @@ def run_task(
     keep: bool,
     usage: dict,
     agent: Agent | None = None,
+    retry: bool = False,
 ) -> TaskResult:
-    """Run one task in a new folder: in a new conversation, or continuing `agent`'s (--session)."""
+    """Run one task in a new folder: in a new conversation, or continuing `agent`'s (--session).
+
+    With `retry`, a failed task gets one more try, as a user would ask: "That didn't fix it. Look again." With a
+    stronger model set (--escalate), its advice goes along, as with /escalate.
+    """
     folder = Path(tempfile.mkdtemp(prefix=f"lcode-bench-{task.id}-"))
     try:
         for rel, content in task.files.items():
@@ -906,25 +913,28 @@ def run_task(
             if model:
                 codesearch.Index(folder, model).update(ollama)  # on the CPU: lcode's model stays loaded
             agent._code_index = None
+        agent.escalate_approved = True if settings.escalate_model else None  # the --escalate flag is the OK
         before = dict(agent.usage)
         first = len(agent.messages)
-        error = None
         started = time.monotonic()
-        try:
-            with time_limit(timeout):
-                agent.run_turn(task.prompt)
-        except TaskTimeout:
-            error = f"timed out after {timeout:.0f}s"
-        except OllamaError as e:
-            error = str(e).splitlines()[0][:200]
+        escalations = 0
+        error = attempt(agent, task.prompt, timeout)
+        escalations += len(agent.escalations)
+        check = checked(task, folder, agent)
+        first_passed = None
+        if retry and not (check.passed and error is None):
+            first_passed = False
+            text = RETRY
+            if error is None and agent.can_escalate():
+                advice = escalate.run(agent, "the user says the fix didn't work")
+                escalations += 1 if advice else 0
+                text = f"{RETRY}\n\n{advice}" if advice else RETRY
+            error = attempt(agent, text, timeout)
+            escalations += len(agent.escalations)
+            check = checked(task, folder, agent)
         seconds = time.monotonic() - started
         for key, value in agent.usage.items():
             usage[key] = usage.get(key, 0) + value - before.get(key, 0)
-        answer = next((m.get("content", "") for m in reversed(agent.messages) if m.get("role") == "assistant"), "")
-        try:
-            check = task.check(folder, answer)
-        except Exception as e:  # a check must never crash the benchmark
-            check = Check(False, f"check failed: {type(e).__name__}: {e}")
     finally:  # also when Ctrl+C stops the task
         from lcode.codesearch import index_dir
 
@@ -942,9 +952,34 @@ def run_task(
         tool_errors=count_tool_errors(agent.messages[first:] if len(agent.messages) > first else agent.messages),
         errors_by_tool=errors_by_tool(agent.messages[first:] if len(agent.messages) > first else agent.messages),
         error=error,
+        first_passed=first_passed,
+        escalations=escalations,
     )
 
 
+RETRY = "That didn't fix it: it still doesn't work right. Look again."
+
+
+def attempt(agent: Agent, text: str, timeout: float) -> str | None:
+    """One request of a task; why it stopped early, if it did."""
+    try:
+        with time_limit(timeout):
+            agent.run_turn(text)
+    except TaskTimeout:
+        return f"timed out after {timeout:.0f}s"
+    except OllamaError as e:
+        return str(e).splitlines()[0][:200]
+    return None
+
+
+def checked(task: Task, folder: Path, agent: Agent) -> Check:
+    answer = next((m.get("content", "") for m in reversed(agent.messages) if m.get("role") == "assistant"), "")
+    try:
+        return task.check(folder, answer)
+    except Exception as e:  # a check must never crash the benchmark
+        return Check(False, f"check failed: {type(e).__name__}: {e}")
+
+
 def prompt_speed(ollama: Ollama, settings: Settings, options: dict) -> float | None:
     """Prompt tokens per second for prompts the model hasn't seen: the faster of two readings.
 
@@ -998,6 +1033,7 @@ def run_model(
     keep: bool = False,
     verbose: bool = False,
     session: bool = False,
+    retry: bool = False,
 ) -> ModelRun:
     run = ModelRun(name, settings.model, settings.context, settings.num_batch, settings.think, session=session)
     shared: Agent | None = None  # with --session, one conversation for all tasks
@@ -1038,10 +1074,10 @@ def run_model(
         try:
             if verbose:
                 console.rule(f"{task.id}: {task.title}")
-                result = run_task(ollama, settings, task, timeout, log, keep, run.usage, shared)
+                result = run_task(ollama, settings, task, timeout, log, keep, run.usage, shared, retry)
             else:
                 with console.status(Elapsed(f"  {task.id:<13} {task.title}")):
-                    result = run_task(ollama, settings, task, timeout, log, keep, run.usage, shared)
+                    result = run_task(ollama, settings, task, timeout, log, keep, run.usage, shared, retry)
         except KeyboardInterrupt:
             console.print("  [yellow]Stopped.[/]")
             run.interrupted = True

{lcode_cli-0.34.0 → lcode_cli-0.35.0}/src/lcode/cli.py

@@ -582,11 +582,14 @@ def cmd_bench(args) -> None:
             compact_at=cfg["compact_at"] if args.compact_at is None else args.compact_at,
             checks=cfg["checks"] if args.checks is None else args.checks,
             review=cfg["review"] if args.review is None else args.review,
+            escalate_model=args.escalate_model,
+            escalate_url=cfg["escalate_url"],
+            escalate_price=cfg["escalate_price"],
             repo_map=args.repo_map,
             embed_model=cfg["embed_model"] if args.code_search else "off",
         )
         run = bench.run_model(
-            ollama, name, settings, tasks, console, args.timeout, args.keep, args.verbose, args.session
+            ollama, name, settings, tasks, console, args.timeout, args.keep, args.verbose, args.session, args.retry
         )
         runs.append(run)
         if run.interrupted:
@@ -662,6 +665,8 @@ def cmd_chat(args) -> None:
             sys.exit(1)
         fail(str(e))
     exit_code = 0
+    if args.escalate and args.prompt:
+        agent.escalate_approved = True  # the flag is the user's OK for this run
     try:
         if quiet:
             agent.perms.approve = lambda request: False  # nobody to ask: refuse what needs permission
@@ -727,6 +732,11 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--plan", action="store_true", help="start in plan mode: agree on a plan before any change")
     parser.add_argument("--auto-edit", action="store_true", help="apply file edits without asking")
     parser.add_argument("--yolo", action="store_true", help="never ask for permission (edits and commands)")
+    parser.add_argument(
+        "--escalate",
+        action="store_true",
+        help="with -p: let lcode ask escalate_model for help when stuck, without asking you (it costs money)",
+    )
     parser.add_argument("--no-think", action="store_true", help="disable model reasoning (faster, less accurate)")
     parser.add_argument("--no-web", action="store_true", help="don't let the model search or fetch web pages")
     parser.add_argument("--no-mcp", action="store_true", help="don't start MCP servers in this session")
@@ -779,6 +789,17 @@ def build_subparsers() -> dict[str, argparse.ArgumentParser]:
     p.add_argument(
         "--review", choices=["auto", "off"], help="review each change before it counts (default: the setting)"
     )
+    p.add_argument(
+        "--retry",
+        action="store_true",
+        help='give a failed task one more try, as a user would: "That didn\'t fix it. Look again."',
+    )
+    p.add_argument(
+        "--escalate",
+        dest="escalate_model",
+        metavar="MODEL",
+        help="a stronger model to ask when stuck and on --retry, e.g. ollama/qwen3.8-27b (no questions asked)",
+    )
     p.add_argument(
         "--checks",
         metavar="auto|off|COMMAND",

{lcode_cli-0.34.0 → lcode_cli-0.35.0}/src/lcode/config.py

@@ -61,6 +61,14 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "notify_after": (30, int, "seconds a request runs before it notifies (with notify on)"),
     "review": ("off", str, "before the answer, check a change against the request and send problems back: auto | off"),
     "checks": ("auto", str, "run the project's checks before calling work done: auto | off | a command"),
+    "escalate_model": (
+        None,
+        str,
+        "a stronger model to ask, with your OK, when the model is stuck: anthropic/…, openai/…, xai/… (key from "
+        "ANTHROPIC_API_KEY, OPENAI_API_KEY, XAI_API_KEY) or ollama/<model> (local or at escalate_url)",
+    ),
+    "escalate_url": (None, str, "the stronger model's server, if not its provider's (another Ollama, any OpenAI API)"),
+    "escalate_price": (None, str, "its price in dollars per million tokens in/out, e.g. 3/15, for the cost shown"),
     "repeat_limit": (3, int, "identical tool calls with identical results before lcode steps in (0: never)"),
     "secret_check": (True, bool, "before git commit and git push, look for passwords, keys and tokens they'd add"),
     "compact_at": (65536, int, "summarize at this many tokens even when the window is larger (0: only at 85%)"),
@@ -165,6 +173,22 @@ def coerce(key: str, value: object) -> object:
         if value not in MEMORY_MODES:
             raise ConfigError(f"memory must be one of {', '.join(MEMORY_MODES)}")
         return value
+    if key in ("escalate_model", "escalate_url", "escalate_price"):
+        from lcode import escalate
+
+        text = str(value).strip()
+        if key == "escalate_url":
+            return normalize_host(text)
+        if key == "escalate_model":
+            provider = text.partition("/")[0].lower()
+            if "/" in text and provider not in escalate.PROVIDERS:
+                raise ConfigError(f"escalate_model's provider must be one of {', '.join(escalate.PROVIDERS)}")
+            return text
+        try:
+            escalate.parse_price(text)
+        except escalate.EscalateError as e:
+            raise ConfigError(str(e)) from e
+        return text
     if key == "lsp" and str(value).lower() not in ("auto", "off"):
         raise ConfigError("lsp must be auto or off")
     if key == "lsp":

{lcode_cli-0.34.0 → lcode_cli-0.35.0}/src/lcode/context.py

@@ -41,6 +41,8 @@ ERROR_LINE = re.compile(
 )
 MAX_ERROR_LINES = 40
 OUTPUT_DAYS = 7  # saved full outputs are deleted after this
+MAX_SAVED = 20_000_000  # characters of one saved output: a runaway command doesn't fill the disk
+MAX_SAVED_TOTAL = 200_000_000  # bytes of saved outputs in all, the oldest go first
 
 
 # ----------------------------------------------------------------------------- the user's requests
@@ -262,17 +264,38 @@ def save_output(text: str, label: str) -> Path | None:
     folder = outputs_dir()
     try:
         folder.mkdir(parents=True, exist_ok=True)
-        cutoff = time.time() - OUTPUT_DAYS * 86400
-        for old in folder.glob("*.txt"):
-            if old.stat().st_mtime < cutoff:
-                old.unlink(missing_ok=True)
+        clean_outputs(folder, room=min(len(text), MAX_SAVED))
         path = folder / f"{time.strftime('%Y%m%d-%H%M%S')}-{re.sub(r'[^a-z0-9]+', '-', label.lower())[:30]}.txt"
-        path.write_text(text)
+        path.write_text(text if len(text) <= MAX_SAVED else text[:MAX_SAVED] + CUT_SAVED)
         return path
     except OSError:
         return None
 
 
+CUT_SAVED = "\n[lcode stopped saving here: the output went on, but a saved output is kept to 20 MB]\n"
+
+
+def clean_outputs(folder: Path, room: int = 0) -> None:
+    """Delete saved outputs older than OUTPUT_DAYS, then the oldest until they take MAX_SAVED_TOTAL with `room`."""
+    cutoff = time.time() - OUTPUT_DAYS * 86400
+    files = []
+    for old in folder.glob("*.txt"):
+        try:
+            info = old.stat()
+        except OSError:
+            continue
+        if info.st_mtime < cutoff:
+            old.unlink(missing_ok=True)
+        else:
+            files.append((info.st_mtime, info.st_size, old))
+    total = sum(size for _, size, _ in files) + room
+    for _, size, old in sorted(files):
+        if total <= MAX_SAVED_TOTAL:
+            break
+        old.unlink(missing_ok=True)
+        total -= size
+
+
 def shorten(text: str, limit: int, label: str = "output") -> str:
     """Head, tail and the error-looking lines in between; the full text goes to a file."""
     if len(text) <= limit:
@@ -315,6 +338,7 @@ class OutputSpool:
         self.chars = 0
         self.file = None
         self.path: Path | None = None
+        self.saved = 0  # characters written to the file
 
     def add(self, line: str) -> None:
         self.chars += len(line)
@@ -323,10 +347,12 @@ class OutputSpool:
             if self.chars > self.limit * 2:
                 self._spool()
             return
-        try:
-            self.file.write(line)
-        except OSError:
-            pass
+        if self.saved <= MAX_SAVED:  # past it, only the end and the error lines are kept (in memory)
+            try:
+                self.file.write(line if self.saved + len(line) <= MAX_SAVED else CUT_SAVED)
+            except OSError:
+                pass
+            self.saved += len(line)
         if ERROR_LINE.search(line) and len(self.errors) < MAX_ERROR_LINES:
             self.errors.append(line.strip()[:300])
         self.tail.append(line)
@@ -337,6 +363,7 @@ class OutputSpool:
     def _spool(self) -> None:
         text = "".join(self.head)
         self.path = save_output(text, self.label)
+        self.saved = len(text)
         if self.path is not None:
             try:
                 self.file = self.path.open("a")
@@ -359,12 +386,10 @@ class OutputSpool:
             note += "\n[...]\n\n"
         else:
             note += "] ...\n\n"
-        where = (
-            f"\n[The full {self.label} ({self.chars} characters) is in {self.path}: read parts of it with read_file "
-            "if you need them.]"
-            if self.path
-            else ""
-        )
+        whole = f"The full {self.label} ({self.chars} characters)"
+        if self.saved > MAX_SAVED:
+            whole = f"The first {MAX_SAVED // 1_000_000} MB of the {self.label} ({self.chars} characters in all)"
+        where = f"\n[{whole} is in {self.path}: read parts of it with read_file if you need them.]" if self.path else ""
         return f"{head}{note}{tail}{where}"