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

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

@@ -6,6 +6,47 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.36.0] - 2026-10-18
+
+### Changed
+
+- `/models` and `/model` show a numbered list of models, and you switch by typing a number: no
+  second `/model <name>`. `/model 2` switches straight away, and a name still works. The list ends
+  with the other Ollama models you've installed that can call tools, and a model that isn't
+  installed says how to get it.
+- `/context` says why it stops at the model's largest window (256K for qwen3.6-35b): Ollama caps the
+  window at what the model was trained on, whatever the memory, so 512K or 1M would only look larger.
+
+## [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
@@ -769,7 +810,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.35.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.36.0...HEAD
+[0.36.0]: https://github.com/nasser1941/lcode/compare/v0.35.1...v0.36.0
+[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

{lcode_cli-0.35.0 → lcode_cli-0.36.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.35.0
+Version: 0.36.0
 Summary: A local-first terminal coding agent powered by open-weight models on your own GPU or Mac, via Ollama.
 Project-URL: Homepage, https://nasser1941.github.io/lcode/
 Project-URL: Documentation, https://nasser1941.github.io/lcode/

{lcode_cli-0.35.0 → lcode_cli-0.36.0}/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.35.0 → lcode_cli-0.36.0}/docs/configuration.md

@@ -48,7 +48,7 @@ lcode config path                      # print the file location
 | `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 |
+| `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.35.0 → lcode_cli-0.36.0}/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.35.0 → lcode_cli-0.36.0}/docs/models.md

@@ -60,9 +60,18 @@ when they fit entirely in GPU (or Apple unified) memory.
 
     ```text
     ❯ /models
-    ❯ /model qwen3.5-9b
+    Models for this machine: RTX 4080 Laptop (12 GB VRAM), 31 GB RAM
+      #  Key           Size     Max ctx  Fits here  Speed                  Status
+      1  qwen3.6-35b   22.6 GB  256K     256K       good (experts in RAM)  installed, recommended, current
+      2  qwen3.8-27b   …
+      9  my-model:7b                                                       installed, not in catalog
+      Switch to which model? (number or name, Enter to keep lcode-qwen3.6-35b): 9
     ```
 
+    `/model` shows the same list. `/model 9` or `/model qwen3.5-9b` switches straight away. The
+    list ends with the other Ollama models you've installed that can call tools. A model that isn't
+    installed yet says how to get it (`lcode setup <key>` in a shell).
+
 ### Any other Ollama model
 
 ```bash
@@ -107,6 +116,10 @@ Context window for lcode-qwen3.6-35b
   Choose a number, a size like 96k, or press Enter to keep 256K: 2
 ```
 
+The list stops at the largest window the model was trained on, and says so: Ollama caps the window
+there whatever the memory, so a larger setting would only look larger. For qwen3.6-35b that's 256K;
+512K and 1M are offered for models trained on them.
+
 Sizes accept `k` and `m` suffixes (`128k` = 131,072 tokens, `1m` = 1,048,576). When the window is
 85% full, lcode summarizes the conversation automatically so you can keep working; `/compact` does it
 on demand.

{lcode_cli-0.35.0 → lcode_cli-0.36.0}/docs/quickstart.md

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

{lcode_cli-0.35.0 → lcode_cli-0.36.0}/docs/usage.md

@@ -76,7 +76,7 @@ reasoning is on.
 | `/plan [request]` | Work out a [plan](#plan-mode) before changing anything, or show the approved plan |
 | `/compact [focus]` | Summarize the conversation to free context |
 | `/context [size]` | Show how full the context window is, what's using it (by category), and change its size: pick from a list with memory estimates, or give a size like `/context 128k` (`/ctx` is a shortcut) |
-| `/model [name]`, `/models` | Switch model, list models |
+| `/models`, `/model [number or name]` | List the models and how they fit this machine, numbered: type a number to switch, or `/model 2`, `/model qwen3.5-9b` |
 | `/think [on\|off]` | Toggle reasoning |
 | `/verbose` | Toggle showing the reasoning text |
 | `/mode [ask\|plan\|auto-edit\|yolo]` | Set the permission mode |
@@ -101,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)) |
@@ -183,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
@@ -224,8 +231,10 @@ lcode config set escalate_price 3/15                # dollars per million tokens
 ```
 
 **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
+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:

{lcode_cli-0.35.0 → lcode_cli-0.36.0}/src/lcode/__init__.py

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

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

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

{lcode_cli-0.35.0 → lcode_cli-0.36.0}/src/lcode/api.py

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

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

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

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

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

{lcode_cli-0.35.0 → lcode_cli-0.36.0}/src/lcode/checks.py

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