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

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

@@ -6,6 +6,51 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.38.0] - 2026-10-21
+
+### Added
+
+- The screenshot tool can click first. For a Python Qt program, `actions` run before the picture,
+  the way a user would: `double_click Camera 1` (a widget by its text) or `double_click 300,200`,
+  `click`, `right_click`, `key Escape`, `key ctrl+s`, `type …`, `wait 2`. The result says what each
+  step hit. Bugs that only show after a click were out of reach before.
+- Qt's warnings are listed at the top of a screenshot's report, taken from everything the program
+  printed. In a real run the cause (`setLayout: … which already has a layout`) was there, among 30
+  lines of the program's logs, and the model looked past it.
+
+### Fixed
+
+From a real session that "fixed" a double-click feature four times without once looking at the
+window, while the user saw a blank screen each time:
+
+- **Windows it never looked at** are sent back once before the answer counts. When a request
+  changed a Python file that draws a window (PyQt, PySide, tkinter, Kivy, wx, GTK) and the model
+  never took a screenshot or looked at an image, it's told to look (with clicks first, if that's
+  where the change shows) or to say plainly that it's unchecked. The real cause was in what Qt
+  printed: `setLayout: … which already has a layout`.
+- **A rerun that only took a different time** counts as a repeat: the model ran the same tests four
+  times in a row (`75 passed in 0.14s`, then `0.12s`…) without the repeat check noticing.
+- **A reply lcode drops** for going round in circles is saved, and the message says where, so you
+  can read what the model was thinking instead of taking the stop on trust.
+- **The checks use the project's own Python.** They ran `python -m …` from PATH, which doesn't have
+  the project's dependencies, so a project with a `.venv` "failed" its checks on imports. Now
+  `.venv/bin/python` (or `venv`, `env`) runs them.
+- **Tests written for pytest get pytest** when the project has no pytest configuration: the tests
+  import it, or a requirements file lists it. They used to get `unittest`, which can't run them.
+
+## [0.37.0] - 2026-10-20
+
+### Added
+
+- Ollama's cloud models (tags ending in `cloud`, such as `minimax-m3.1-flash:cloud`) work as the
+  main model or as the stronger model when stuck, and lcode says what they are: what it sends goes
+  to ollama.com and is billed per token. The stronger-model panel said "free, on this machine" for
+  them; it now says ollama.com and shows the cost. A request Ollama refuses because it isn't signed
+  in says to run `ollama signin` (in Docker, with your container's name), and lcode skips the
+  local loading and GPU checks for them. The docs explain the setup and list the cloud models that
+  call tools, with prices and published coding scores: see
+  [Cloud models through Ollama](https://nasser1941.github.io/lcode/models/#cloud-models-through-ollama).
+
 ## [0.36.0] - 2026-10-18
 
 ### Changed
@@ -810,7 +855,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.36.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.38.0...HEAD
+[0.38.0]: https://github.com/nasser1941/lcode/compare/v0.37.0...v0.38.0
+[0.37.0]: https://github.com/nasser1941/lcode/compare/v0.36.0...v0.37.0
 [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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.36.0
+Version: 0.38.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.36.0 → lcode_cli-0.38.0}/docs/configuration.md

@@ -45,7 +45,7 @@ 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_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>` (a local model, or an [Ollama cloud model](models.md#cloud-models-through-ollama) like `ollama/glm-5.3-flash:cloud`), 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) |

{lcode_cli-0.36.0 → lcode_cli-0.38.0}/docs/how-it-works.md

@@ -56,7 +56,8 @@ same tool, the same arguments and the same result.
   `loop`.
 
 A result that changes isn't a repeat, so a test that's run again after a fix, or a background job
-that's checked while it runs, never adds up. A call that may have changed something, like an edit or
+that's checked while it runs, never adds up. Timings don't count as a change: `75 passed in 0.12s`
+and then `in 0.14s` is the same result. 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` (that also turns off the checks for unreachable sites and for thinking in circles, below).
@@ -85,7 +86,8 @@ aren't tracked.
 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
+short one: the next tool call, or what's blocking it. The dropped reply is saved, and the message
+says where, so you can read what went round in circles. 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

{lcode_cli-0.36.0 → lcode_cli-0.38.0}/docs/models.md

@@ -85,6 +85,104 @@ context; set `--context` yourself. If a model prints tool calls as text instead
 lcode tries to recover them, but results are usually worse. To propose a model for the catalog, see
 [Contributing](contributing.md#adding-a-model-to-the-catalog).
 
+## Cloud models through Ollama
+
+Ollama also offers models that run on its own servers, with tags that end in `cloud`, such as
+`minimax-m3.1-flash:cloud`. Your Ollama passes the requests on, so lcode uses them like an installed
+model: as the main model, or as the [stronger model to ask when stuck](usage.md#a-stronger-model-when-stuck).
+What changes:
+
+- **Your code leaves the machine.** What lcode sends (your requests and the files it reads) goes to
+  ollama.com. lcode says so when a session starts, when you switch to one, and in `lcode doctor`.
+- **It's billed per token** to your ollama.com account (some models are free for a while).
+- **It needs an ollama.com account** and a connection to ollama.com.
+
+### Setting one up
+
+1. **Sign your Ollama in** to your ollama.com account, once. It prints a link to open in the
+   browser:
+
+    === "Ollama installed normally"
+
+        ```bash
+        ollama signin
+        ```
+
+    === "Ollama in Docker"
+
+        ```bash
+        docker exec -it <container> ollama signin
+        ```
+
+        `lcode doctor` shows this command with your container's name once a cloud model is set.
+
+2. **Add the model.** This stores a small reference, not the weights:
+
+    ```bash
+    ollama pull minimax-m3.1-flash:cloud      # in Docker: docker exec <container> ollama pull …
+    ```
+
+3. **Use it** as the main model, or as the stronger model when stuck:
+
+    ```bash
+    lcode --model minimax-m3.1-flash:cloud --context 256k    # or pick it by number in /models
+
+    lcode config set escalate_model ollama/minimax-m3.1-flash:cloud
+    lcode config set escalate_price 0.15/0.60                 # its price in/out, for the cost shown
+    ```
+
+    As the main model, give the context yourself: lcode defaults to 32K for models outside its
+    catalog. A larger window costs more, since every step sends the conversation again (the
+    repeated part at the lower *cached* price). As the stronger model, only a short brief goes out,
+    and only when you say yes: the panel shows `Where: … at ollama.com` and the cost.
+
+If a request fails with *this Ollama isn't signed in to an ollama.com account*, run the sign-in
+command the message shows.
+
+### Cheap coding models in Ollama's cloud
+
+The cloud models that call tools, cheapest first. Prices are in dollars per million tokens, from
+[ollama.com](https://ollama.com/search?c=cloud) on 2026-10-20. Check a model's page before you
+rely on a price: they change.
+
+- **TB 2.1** is the Terminal-Bench 2.1 score as published on the model's page. The makers measured
+  it themselves, in different setups, so it's a rough guide, not a ranking. A dash means the page
+  gives none.
+- **One question** is the most a question to the stronger model costs: a 15K-token brief, plus
+  lcode's 4K-token cap on the answer.
+- **DeepSeek** charges less off-peak. Its prices read off-peak / peak.
+
+| Model | Input | Cached | Output | Context | TB 2.1 | One question |
+|---|---|---|---|---|---|---|
+| `glm-5.3-flash:cloud` | $0.15 | $0.03 | $0.50 | 1M | 84.3 | $0.004 |
+| `minimax-m3.1-flash:cloud` | $0.15 | $0.015 | $0.60 | 976K | — | $0.005 |
+| `deepseek-v4.1-flash:cloud` | $0.15 / $0.30 | $0.003 / $0.006 | $0.60 / $1.20 | 1M | 90.6 | $0.005–$0.009 |
+| `minimax-m2.7:cloud` | $0.30 | $0.06 | $1.20 | 200K | — | $0.009 |
+| `nemotron-3-ultra:cloud` | $0.10 | $0.10 | $3.00 | 256K | — | $0.014 |
+| `mistral-large-3:675b-cloud` | $0.50 | — | $1.50 | 256K | — | $0.014 |
+| `minimax-m3:cloud` | $0.60 | $0.12 | $2.40 | 512K | — | $0.019 |
+| `mistral-large-4:cloud` | $0.68 | $0.07 | $2.09 | 1M | — | $0.019 |
+| `deepseek-v4-pro:cloud` | $0.66 / $1.32 | $0.022 / $0.044 | $1.98 / $3.96 | 1M | 87.9 | $0.018–$0.036 |
+| `kimi-k2.6:cloud` | $0.95 | $0.16 | $4.00 | 256K | — | $0.031 |
+| `kimi-k2.7-code:cloud` | $0.95 | $0.19 | $4.00 | 256K | — | $0.031 |
+| `muse-spark-open:cloud` | $1.25 | $0.15 | $4.25 | 1M | — | $0.036 |
+| `glm-5.2:cloud` | $1.40 | $0.26 | $4.40 | 976K | 81.0 | $0.039 |
+| `glm-5.3:cloud` | $1.40 | $0.26 | $4.40 | 1M | 88.2 | $0.039 |
+| `kimi-k3:cloud` | $3.00 | $0.30 | $15.00 | 1M | 88.3 | $0.106 |
+
+- **For the stronger model, the first three cost under a cent a question.**
+  - `deepseek-v4.1-flash` has the highest published score (90.6, DeepSeek's own measurement).
+  - `glm-5.3-flash` is the cheapest.
+  - `minimax-m3.1-flash` is free until 22 October 2026.
+- **GLM-5.3, DeepSeek V4 Pro and Kimi K3** publish similar scores (88.2, 87.9, 88.3) for 4 to 25
+  times the price.
+- **Not in the table:** `beam`, `gemma4:31b-cloud`, `nemotron-3-super`, `nemotron-3-nano` and
+  `clef` have cloud versions too, but list no price on their pages. Clef is an image model, not a
+  coding one.
+
+To set a price for the cost shown, use the input/output pair from the table, e.g.
+`lcode config set escalate_price 0.15/0.50` for `glm-5.3-flash:cloud`.
+
 ## Choosing a context window
 
 The **context window** is how much text the model can see at once: the conversation, files it has

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

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

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

@@ -170,7 +170,9 @@ runs the project's checks itself before the answer is final:
 - **Programs** using `lcode -p --output json` see the runs in the result's `checks`.
 
 **Which checks.** lcode looks at the project: pytest when the configuration mentions it (`uv run
-pytest -q` with a `uv.lock`), otherwise `python -m unittest` for `test_*.py` files. Then
+pytest -q` with a `uv.lock`), when the tests import it, or when a requirements file lists it;
+otherwise `python -m unittest` for `test_*.py` files. Python checks run with the project's own
+environment when it has one (`.venv/bin/python`, `venv`, `env`), where its dependencies are. Then
 `npm test` (or pnpm, yarn, bun) when `package.json` has a test script, `cargo test`, `go test ./...`
 and `make test`. To choose the command yourself, set it for the repository in
 `.lcode/settings.toml`. That file is used once you trust the repository, like its hooks:
@@ -183,6 +185,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.
 
+**Windows it never looked at.** A model that changes a window checks it with an import and the
+project's tests, which don't show what's on the screen, and calls it done: you find a blank
+window. When a request changed a Python file that draws one (it imports PyQt, PySide, tkinter,
+Kivy, wx or GTK) and the model never took a [screenshot](#screenshots) or looked at an image,
+lcode sends it back once: look at it, with clicks first if that's where the change shows, or say
+plainly that it's unchecked. `checks = "off"` turns this 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,
@@ -219,7 +228,8 @@ would have to read the whole conversation again. On a small GPU that's tens of s
 ## 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
+advice: a cloud model with your API key, one of [Ollama's cloud models](models.md#cloud-models-through-ollama)
+(less than a cent a question for some), 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
@@ -227,6 +237,7 @@ lcode config set escalate_model anthropic/<model>   # with ANTHROPIC_API_KEY in
 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_model ollama/glm-5.3-flash:cloud  # Ollama's cloud, after `ollama signin`
 lcode config set escalate_price 3/15                # dollars per million tokens in/out, for the cost
 ```
 
@@ -257,7 +268,8 @@ a stronger model can't reach it either. You can also ask at any time: `/escalate
 - **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.
+  prices change. A local model is free; an Ollama cloud model isn't, and the panel says it goes to
+  ollama.com.
 - **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
@@ -424,6 +436,20 @@ a screen and sees what you would, measured:
 
 - For a web app, the model gives the command that starts the server and the page's URL: lcode
   starts the server, waits for the page to answer, takes the shot and stops the server.
+- **Clicks and keys first.** For something that only shows after a click, a Python Qt program can
+  take `actions` before the picture, the way you would: `double_click 300,200` (a point in the
+  window), `double_click Camera 1` (the widget showing that text), `click Save`, `right_click …`,
+  `key Escape`, `key ctrl+s`, `type some text`, `wait 2`. The result says what each step hit.
+- **Qt's warnings come first.** Qt names many layout mistakes in what the program prints, often
+  among the program's own logs. lcode lists them at the top of the report:
+
+    ```text
+    ● screenshot(python camera_wall.py)  actions: double_click Camera 1
+    Qt printed warnings (they often name the cause):
+    - QWidget::setLayout: Attempting to set QLayout "" on FocusedCamera "", which already has a layout
+    Steps, before the picture:
+    - double_click Camera 1: on QLabel "Camera 1 — Connected" at (207, 317)
+    ```
 - A model that can see describes the picture with the model's question in mind (see
   [Which model looks](#images)). Without one, the measurements still come back.
 - Shots are saved in `.lcode/screenshots/` in the project, which keeps itself out of git, so you

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

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

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

@@ -45,6 +45,7 @@ from lcode import (
 from lcode import context as context_tools
 from lcode import memory as memory_notes
 from lcode.checkpoints import Checkpoints
+from lcode.cloud import is_cloud
 from lcode.config import format_tokens
 from lcode.jobs import Jobs
 from lcode.mcp import McpManager
@@ -98,7 +99,9 @@ def stall_note(trouble: str) -> str:
     }[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."
+        "tell the user in a few lines what you did, what fails, and what they could do. If you were about to check "
+        "something by running it, run it now instead of reasoning about it: for a window, take a screenshot (with "
+        "actions for clicks or keys)."
     )
 
 
@@ -960,6 +963,12 @@ class Agent:
             return []
         return checks.unrun_scripts(project_root_or_cwd(self.cwd), list(self.tools.before), commands)
 
+    def unseen_windows(self, tools_used: set[str]) -> dict[str, str]:
+        """Window code the model changed in this request and never looked at (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.unseen_windows(project_root_or_cwd(self.cwd), list(self.tools.before), tools_used)
+
     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":
@@ -1011,8 +1020,8 @@ class Agent:
     def before_request(self, progress: Progress) -> residency.LoadWatch | None:
         """Set the status line for what comes before the first token: loading the model if it isn't in memory
         (watched until it is), then reading the prompt. Returns the watch while the model loads."""
-        if getattr(self.ollama, "kind", "ollama") != "ollama":
-            return None
+        if getattr(self.ollama, "kind", "ollama") != "ollama" or is_cloud(self.settings.model):
+            return None  # another server loads models itself; an Ollama cloud model isn't loaded here at all
         model, context = self.settings.model, self.settings.context
         fresh = max(0, conversation_chars(self.messages) - self.sent_chars) // 3
         where = residency.placement(self.ollama, model)
@@ -1163,6 +1172,8 @@ class Agent:
         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
+        tools_used: set[str] = set()  # tools called in this request
+        windows_noted = False  # the model was told about windows it changed and never looked at
         for step in range(self.max_steps):
             if self.cancel is not None and self.cancel.is_set():
                 raise KeyboardInterrupt
@@ -1214,10 +1225,11 @@ 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
+                dropped = self.messages.pop()  # no answer, and circles would only fill the context
+                kept = self.keep_dropped(dropped)
                 if stalls < MAX_STALLS:
                     self.console.print(
-                        Text(f"  ⎿ {STALLED[self.reply_trouble]}: asking for a short answer", style="yellow")
+                        Text(f"  ⎿ {STALLED[self.reply_trouble]}: asking for a short answer{kept}", style="yellow")
                     )
                     self.messages.append({"role": "user", "content": stall_note(self.reply_trouble)})
                     continue
@@ -1233,7 +1245,7 @@ class Agent:
                 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.",
+                        f"this request{kept}. Try again with a smaller step, or tell it what to do differently.",
                         style="yellow",
                     )
                 )
@@ -1252,6 +1264,14 @@ class Agent:
                     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
+                unseen = {} if windows_noted else self.unseen_windows(tools_used)
+                if unseen:
+                    windows_noted = True
+                    self.console.print(
+                        Text(f"  ⎿ never looked at {', '.join(unseen)}: asking the model to", style="yellow")
+                    )
+                    self.messages.append({"role": "user", "content": checks.unseen_note(unseen)})
+                    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
@@ -1344,6 +1364,7 @@ class Agent:
                     )
                     if out_of_reach.stop:
                         blocked = out_of_reach
+                tools_used.add(name)
                 if name == "bash":
                     commands.append(str(args.get("command", "")))
                 if name in ("edit_file", "write_file", "apply_patch") and not result.startswith(REFUSED):
@@ -1411,6 +1432,14 @@ class Agent:
         self.turn_status = "success"
         self.print_stats()
 
+    def keep_dropped(self, reply: dict) -> str:
+        """Save a reply lcode dropped (its thinking too), so the user can see what went round in circles."""
+        text = "\n\n".join(part for part in (reply.get("thinking"), reply.get("content")) if part)
+        if not text.strip():
+            return ""
+        path = context_tools.save_output(text, "dropped reply")
+        return f" (the dropped reply is in {path})" if path else ""
+
     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()

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

@@ -50,10 +50,28 @@ def find(root: Path, setting: str, trusted: bool) -> Check | None:
     return detect(root)
 
 
-def python() -> str:
+VENVS = (".venv", "venv", "env")
+PYTEST_USE = re.compile(r"^\s*(?:import pytest\b|from pytest\b)|^\s*@pytest\.", re.M)
+
+
+def python(root: Path | None = None) -> str:
+    """The project's own Python (its .venv, venv or env), where its dependencies are; else the one on PATH."""
+    if root is not None:
+        for env in VENVS:
+            for exe in ("bin/python", "Scripts/python.exe"):
+                if (root / env / exe).is_file():
+                    return f"{env}/{exe}"  # the checks run in the project's root
     return "python" if shutil.which("python") else "python3"
 
 
+def uses_pytest(root: Path) -> bool:
+    """Whether the tests are written for pytest (they import it), or the requirements list it, without a config."""
+    for name in ("requirements.txt", "requirements-dev.txt", "requirements_dev.txt", "dev-requirements.txt"):
+        if re.search(r"^\s*pytest\b", text(root / name), re.M | re.I):
+            return True
+    return any(PYTEST_USE.search(text(path)[:20000]) for path in test_files(root)[:50])
+
+
 def text(path: Path) -> str:
     try:
         return path.read_text(errors="replace") if path.is_file() else ""
@@ -61,38 +79,49 @@ def text(path: Path) -> str:
         return ""
 
 
-def python_tests(root: Path) -> bool:
-    """Whether the project has Python test files (a few levels deep, outside environments and caches)."""
+def test_files(root: Path, limit: int = 200) -> list[Path]:
+    """The project's Python test files, a few levels deep, outside environments and caches."""
     from lcode.tools import IGNORE_DIRS
 
-    def walk(folder: Path, depth: int) -> bool:
+    found: list[Path] = []
+
+    def walk(folder: Path, depth: int) -> None:
         try:
-            entries = list(folder.iterdir())
+            entries = sorted(folder.iterdir())
         except OSError:
-            return False
-        if any(e.is_file() and re.fullmatch(r"test_.*\.py|.*_test\.py", e.name) for e in entries):
-            return True
-        return depth > 0 and any(
-            walk(e, depth - 1)
-            for e in entries
-            if e.is_dir() and e.name not in IGNORE_DIRS and not e.name.startswith(".")
-        )
+            return
+        found.extend(e for e in entries if e.is_file() and re.fullmatch(r"test_.*\.py|.*_test\.py", e.name))
+        if depth > 0:
+            for e in entries:
+                if len(found) >= limit:
+                    return
+                if e.is_dir() and e.name not in IGNORE_DIRS and e.name not in VENVS and not e.name.startswith("."):
+                    walk(e, depth - 1)
 
-    return walk(root, 3)
+    walk(root, 3)
+    return found[:limit]
+
+
+def python_tests(root: Path) -> bool:
+    """Whether the project has Python test files (a few levels deep, outside environments and caches)."""
+    return bool(test_files(root, limit=1))
 
 
 def detect(root: Path) -> Check | None:
     """A check command from what the project looks like. Python checks need test files: pytest configured in a
     project without tests "fails" with nothing to run."""
     if python_tests(root):
+        py = python(root)
         configs = text(root / "pyproject.toml") + text(root / "setup.cfg") + text(root / "tox.ini")
         if "pytest" in configs or any((root / name).is_file() for name in ("pytest.ini", "conftest.py")):
-            runner = "uv run pytest -q" if (root / "uv.lock").is_file() else f"{python()} -m pytest -q"
+            runner = "uv run pytest -q" if (root / "uv.lock").is_file() else f"{py} -m pytest -q"
             return Check(runner, "pytest in the project's configuration")
+        if uses_pytest(root):
+            return Check(f"{py} -m pytest -q", "tests written for pytest")
         if list(root.glob("test_*.py")) or list(root.glob("*_test.py")):
-            return Check(f"{python()} -m unittest", "test files")
+            return Check(f"{py} -m unittest", "test files")
         if (root / "tests").is_dir():
-            return Check(f"{python()} -m unittest discover -s tests -t .", "tests/")
+            return Check(f"{py} -m unittest discover -s tests -t .", "tests/")
     package = text(root / "package.json")
     if package:
         try:
@@ -229,3 +258,52 @@ def unrun_note(scripts: list[str]) -> str:
         f"deploy, delete data) or needs something you don't have, don't: tell the user plainly that {it} is untested "
         "and why."
     )
+
+
+# ----------------------------------------------------------------------------- windows it never looked at
+
+GUI_IMPORT = re.compile(r"^\s*(?:from|import)\s+(PyQt[56]|PySide[26]|tkinter|kivy|wx|gi\.repository)\b", re.M)
+LOOKED = frozenset({"screenshot", "view_image"})
+
+
+def unseen_windows(root: Path, changed: list[str], tools_used: set[str]) -> dict[str, str]:
+    """Python files that draw a window (they import a GUI toolkit), changed in this request when the model never
+    looked at one: file -> toolkit.
+
+    A small model checks a window change by importing the module and running unrelated tests, then calls it done;
+    the user finds a blank window. Tests and imports don't show what's on the screen; a screenshot does.
+    """
+    if tools_used & LOOKED:
+        return {}
+    found = {}
+    for rel in changed:
+        path = root / rel
+        if path.suffix != ".py" or not path.is_file():
+            continue
+        try:
+            text = path.read_text(errors="replace")[:200_000]
+        except OSError:
+            continue
+        match = GUI_IMPORT.search(text)
+        if match:
+            found[rel] = match.group(1)
+    return found
+
+
+def unseen_note(found: dict[str, str]) -> str:
+    names = ", ".join(found)
+    kits = sorted(set(found.values()))
+    qt = any(kit.startswith(("PyQt", "PySide")) for kit in kits)
+    how = (
+        "take a screenshot with the screenshot tool: it runs the program without a screen and shows what it draws, "
+        "and what the program printed (Qt names layout mistakes there). For something that only shows after a click "
+        'or a key, give actions, e.g. actions=["double_click Camera 1"]'
+        if qt
+        else "take a screenshot with the screenshot tool: it runs the program on a virtual display and shows what it "
+        "draws"
+    )
+    return (
+        f"[lcode] You changed {names}, which draws a window ({', '.join(kits)}), but never looked at it: tests and "
+        f"imports don't show what's on the screen. Before you say it works, {how}. Check the picture against what the "
+        "user asked for. If the program can't run here, tell the user plainly that you haven't seen it working."
+    )

{lcode_cli-0.36.0 → lcode_cli-0.38.0}/src/lcode/cli.py

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

lcode_cli-0.38.0/src/lcode/cloud.py

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