lcode-cli 0.37.0__tar.gz → 0.39.0__tar.gz

{lcode_cli-0.37.0 → lcode_cli-0.39.0}/CHANGELOG.md

@@ -6,6 +6,59 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.39.0] - 2026-10-23
+
+### Added
+
+- **Modes: code, image and video** (#148). `/mode image`, `/mode video` and `/mode code` switch
+  what lcode makes. `lcode --mode` starts in one, and the `mode` setting is the default. The
+  banner, status bar and prompt show the mode, and sessions keep theirs.
+  - **The GPU goes to one model at a time:** switching to image or video mode unloads the coding
+    model, and switching back asks ComfyUI to free its memory.
+  - **Image and video mode don't generate yet:** they say what's coming (#149–#157) instead of
+    sending your words to the coding model. See [Modes](https://nasser1941.github.io/lcode/modes/).
+
+### Changed
+
+- **Code mode makes code only.** The MCP servers that generated images and videos (`comfyui`,
+  `xai`) are out of the MCP catalog, and lcode doesn't load them in code mode even if they're
+  still in `mcp.json` (it says so once). Image and video generation are moving to their own modes.
+- **`/mode` switches code, image and video.** The permission mode is set with `/permissions` now;
+  `/mode yolo` and the like still work, with a note. Shift+Tab cycles the permission mode as
+  before.
+
+## [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
@@ -823,7 +876,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.37.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.39.0...HEAD
+[0.39.0]: https://github.com/nasser1941/lcode/compare/v0.38.0...v0.39.0
+[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

{lcode_cli-0.37.0 → lcode_cli-0.39.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.37.0
+Version: 0.39.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.37.0 → lcode_cli-0.39.0}/docs/configuration.md

@@ -23,6 +23,8 @@ lcode config path                      # print the file location
 | `backend` | `ollama` | The model server: `ollama`, `lmstudio`, `llama.cpp`, `vllm`, `mlx` or `openai` (any OpenAI-compatible API); see [Other model servers](servers.md) |
 | `base_url` | the backend's | The server's OpenAI-compatible address, e.g. `http://localhost:1234/v1` |
 | `permission_mode` | `ask` | `ask`, `plan`, `auto-edit` or `yolo` |
+| `mode` | `code` | What lcode makes when it starts: `code`, `image` or `video` ([modes](modes.md)) |
+| `comfyui_url` | `http://127.0.0.1:8188` | ComfyUI's address, for image and video mode |
 | `think` | `true` | Let the model reason before answering |
 | `web` | `on` | Web search and page fetching: `on`, `ask` (before each search/website) or `off` |
 | `search_backend` | `auto` | `auto`, `ollama`, `brave`, `tavily` or `searxng`; `auto` uses the first one configured |

{lcode_cli-0.37.0 → lcode_cli-0.39.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.37.0 → lcode_cli-0.39.0}/docs/mcp.md

@@ -28,8 +28,6 @@ and find the code for the top one."*
 | `gcp` | `gcloud` commands on your Google Cloud projects | `npx` and the `gcloud` CLI, signed in |
 | `github` | Repositories, issues, pull requests, Actions | a GitHub token (or the GitHub CLI) |
 | `playwright` | A real (headless) browser: open pages, click, fill forms | `npx` |
-| `comfyui` | Generate and edit images with local models (FLUX, SDXL, SD 1.5, Qwen-Image) | `uvx` and [ComfyUI](#images-with-comfyui) running locally |
-| `xai` | Generate and edit images, and generate videos and speech, with xAI's Grok Imagine (paid, in the cloud) | `uvx`, an xAI API key ([below](#images-videos-and-speech-with-xai)) |
 | `context7` | Up-to-date docs and examples for thousands of libraries | nothing (an API key is optional) |
 | `sentry` | Errors, issues, traces and releases | a Sentry account (browser sign-in) |
 | `postgres` | Schemas, read-only queries, query performance | `uvx`, a connection URL |
@@ -87,86 +85,12 @@ Google Cloud project:
 See [Google's guide](https://developers.google.com/workspace/guides/configure-mcp-servers) for
 details.
 
-### Images with ComfyUI
+### Images and videos
 
-[ComfyUI](https://github.com/comfyanonymous/ComfyUI) runs image generation and editing models
-locally; its official MCP server lets lcode use it, for app icons, illustrations, mockups or
-placeholder art.
-
-```bash
-uv tool install comfy-cli && comfy install                 # ComfyUI, once
-comfy launch --background -- --disable-smart-memory          # start it (http://127.0.0.1:8188)
-lcode mcp add comfyui
-```
-
-Then add models in ComfyUI (its model manager, or ask lcode: *"download FLUX.2 Klein 4B in
-ComfyUI"*), and ask for images: *"make a 512×512 app icon of a paper plane and save it in
-assets/"*. To edit an image, ask lcode to upload it and run an editing workflow (Kontext or
-Qwen-Image-Edit).
-
-| Model | Good for | On a 12 GB GPU |
-|---|---|---|
-| FLUX.2 Klein 4B | Generation and editing, fast | Fits (about 8 GB) |
-| SDXL and its community models | Generation, inpainting | Fits |
-| Stable Diffusion 1.5 and its community models | Light generation, inpainting | Fits easily |
-| FLUX.1 Dev and finetunes | High-quality generation | Needs an fp8 or GGUF version; slower |
-| FLUX.1 Kontext Dev | Editing an image from instructions | Needs an fp8 or GGUF version; slower |
-| Qwen-Image / Qwen-Image-Edit | Generation and editing, good text in images | Heavy: a GGUF version and RAM offloading |
-
-Only ComfyUI's local tools are turned on; Comfy Cloud's partner tools are left out, so prompts and
-images stay on your machine.
-
-**Sharing one GPU.** A GPU rarely holds a coding model and an image model at the same time, so the
-two take turns: before ComfyUI generates, lcode unloads its own model (the `free_gpu` setting), and
-ComfyUI started with `--disable-smart-memory` gives the GPU back after each image. lcode's model
-then reloads for the next step, which adds a few seconds to half a minute per image request. With
-enough GPU memory for both (or on a Mac with plenty of memory), remove `free_gpu` from the server's
-settings in `mcp.json`. lcode can also look at the results ([Images](usage.md#images)).
-
-Measured on an RTX 4080 Laptop GPU (12 GB) with qwen3.6-35b at 64K context and FLUX.2 Klein Base 4B
-(fp8, 512×512, 20 steps):
-
-| | |
-|---|---|
-| Generating while lcode's model is loaded | Fails: ComfyUI runs out of GPU memory |
-| Freeing the GPU (lcode unloads its model) | 0.2 s |
-| Generating one image | about 12 s |
-| Reloading lcode's model afterwards | about 20 s |
-
-The first time, the model has to find the right template and fill in its settings (model file names,
-size, prompt), which can take several minutes of trial and error. Once an image comes out right, ask
-lcode to save that workflow in your project (for example `assets/icon.workflow.json`) and reuse it:
-later images are a single `run_workflow` call.
-
-### Images, videos and speech with xAI
-
-xAI's [Grok Imagine](https://docs.x.ai/developers/model-capabilities/imagine) and
-[text to speech](https://docs.x.ai/developers/models/text-to-speech) APIs make images, videos and
-speech in the cloud: no GPU needed, but each call is billed to your xAI account. lcode ships an MCP
-server for them, `lcode-mcp-xai`.
-
-```bash
-lcode mcp add xai             # asks for your xAI API key (create one at https://console.x.ai)
-```
-
-The key is typed hidden and kept in `~/.config/lcode/mcp.json`, readable only by you. If
-`XAI_API_KEY` is already set in your environment, lcode uses that and doesn't store the key.
-
-| Tool | | Costs |
-|---|---|---|
-| `generate_image` | Images from a description: 1–10 at a time, aspect ratio, 1k or 2k | $0.02–0.05 an image |
-| `edit_image` | Change a local image as described | the same |
-| `generate_video` | A 1–15 second MP4 from a description, optionally starting from a local image, up to 1080p. Waits for it (a minute or more) | $0.02–0.08 a second |
-| `video_status` | Fetch a video that wasn't ready within 10 minutes | |
-| `text_to_speech` | Speech in one of 26 voices and 20 languages, as MP3 or WAV | per character |
-
-Files are saved in `generated/` in the project, or where you ask (*"generate an app icon and save
-it as assets/icon.png"*). xAI has no music generation API.
-
-Your prompts, and the images you edit or animate, go to xAI. lcode asks before each call, since each
-one costs money. To stop asking for some tools, list them under `"allow"` for the server in
-`mcp.json`, for example `"allow": ["generate_image", "text_to_speech"]`. xAI applies its own usage
-policies to what it generates; when it refuses a prompt, lcode passes its message to the model.
+Code mode makes code only, so the servers that generated images and videos in earlier versions
+(`comfyui`, `xai`) aren't in the catalog any more, and lcode doesn't load them in code mode if
+they're still in your `mcp.json`. Image and video generation get their own [modes](modes.md),
+with their own models and controls.
 
 ### Metabase
 

lcode_cli-0.39.0/docs/modes.md

@@ -0,0 +1,58 @@
+# Modes: code, image and video
+
+lcode makes three kinds of things, each in its own mode with its own models:
+
+| Mode | What it makes | The model doing the work |
+|---|---|---|
+| **code** (default) | Code: it reads, writes, runs and checks your project | A coding language model in Ollama (or another server) |
+| **image** | Images from a description and reference images | An image model, run by ComfyUI on your GPU |
+| **video** | Videos from a description, a start image or references | A video model, run by ComfyUI on your GPU |
+
+```text
+❯ /mode image
+Mode: image (local image generation).
+Unloaded qwen3.6-35b to free the GPU for images.
+image ❯
+```
+
+- **Switching:** `/mode code`, `/mode image` and `/mode video` switch in a session. `lcode --mode image`
+  starts in one, and `lcode config set mode video` makes it the default. `/mode` alone shows
+  the current one.
+- **Where it shows:** the banner, the status bar and the prompt (`image ❯`) show the mode.
+- **Sessions:** a session keeps the mode it was made in, and resuming it brings that mode back.
+
+## Code mode makes code only
+
+Code mode is the coding agent, as before, and it no longer generates images or videos. The MCP
+servers that did (`comfyui` and `xai`) are gone from the MCP catalog, and lcode doesn't load them
+in code mode even if they're still in your `mcp.json`. It says so once.
+
+## One model on the GPU at a time
+
+Image and video modes don't need the big coding model: the image or video model does the work. A
+small optional model will help with prompts later. Image and video models need the GPU to
+themselves:
+
+- **Into image or video mode:** lcode unloads its coding model from Ollama.
+- **Back to code mode:** lcode asks ComfyUI to free its memory (at `comfyui_url`, by default
+  `http://127.0.0.1:8188`), then loads the coding model again in the background.
+
+## Coming next
+
+Image and video modes don't generate yet. Until the items below arrive, a request in those modes
+says what's coming instead of going anywhere.
+
+- **#149 Local generation engine:** lcode drives ComfyUI itself: finding or installing it, jobs,
+  progress, cancelling, and saving outputs with their settings.
+- **#150 Media model catalog:** image and video models that fit your machine, installed on
+  demand.
+- **#151, #152 Image mode:** generating, variations, sizes and seeds, a gallery, editing,
+  references, inpainting, upscaling.
+- **#153, #154 Video mode:** from text or a start image, first and last frames, several
+  references, camera moves, longer clips, sound.
+- **#155 Movies:** storyboards with a consistent cast, shots stitched into one film.
+- **#156 Prompt assistant:** a small local model for prompts and follow-ups.
+- **#157 Cloud generation**, with costs shown (Grok Imagine first).
+
+The permission mode (`ask`, `plan`, `auto-edit`, `yolo`) is a different setting: `/permissions`
+sets it, and Shift+Tab cycles it as before.

{lcode_cli-0.37.0 → lcode_cli-0.39.0}/docs/quickstart.md

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

{lcode_cli-0.37.0 → lcode_cli-0.39.0}/docs/usage.md

@@ -79,7 +79,8 @@ reasoning is on.
 | `/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 |
+| `/mode [code\|image\|video]` | Switch what lcode makes: [code, images or videos](modes.md) |
+| `/permissions [ask\|plan\|auto-edit\|yolo]` | Set the permission mode |
 | `/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 |
@@ -170,7 +171,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 +186,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,
@@ -306,7 +316,7 @@ stays loaded:
 | The model was loaded | `◆ Loaded qwen3.6-35b in 15s: 22.3 GB, 45% on the GPU and the rest in system RAM.`, and a warning when less of it is on the GPU than usual, because another program or model is using GPU memory |
 | A dense model doesn't fit on the GPU (at startup and on `/model`) | `⚠ qwen3.8-27b is a dense model: all 27B parameters work on every token. It's capable, but slow here. Only about 61% of it fits in the 12 GB of GPU memory…`, with what to do instead |
 | The model that looks at images needs the memory | `Loading the vision model … to look at bug.png; qwen3.6-35b makes room and reloads afterwards`, then `◆ qwen3.6-35b was unloaded to make room…`, and the next step says `Reloading qwen3.6-35b into memory (it made room for the vision model …)` |
-| A tool needs the GPU to itself, such as image generation | `◆ Unloaded qwen3.6-35b so comfyui can use the GPU; it reloads afterwards.` |
+| A tool needs the GPU to itself (an MCP server with `free_gpu`) | `◆ Unloaded qwen3.6-35b so the server can use the GPU; it reloads afterwards.` |
 | Ollama ran out of memory | `⚠` what ran out (the prompt batch, or the context next to the model), what lcode retries with, and what it remembers for next time |
 
 While the model loads in the background at startup, the status bar says
@@ -427,6 +437,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
@@ -447,7 +471,7 @@ a screen and sees what you would, measured:
 | `auto-edit` | automatic | ask, except read-only commands |
 | `yolo` | automatic | automatic |
 
-++shift+tab++ cycles through them in this order, `/mode` sets one, and `--plan`, `--auto-edit` and
+++shift+tab++ cycles through them in this order, `/permissions` sets one, and `--plan`, `--auto-edit` and
 `--yolo` start in one.
 
 Read-only commands run without asking: `ls`, `cat`, `head`, `tail`, `grep`, `rg`, `find`, `tree`,

{lcode_cli-0.37.0 → lcode_cli-0.39.0}/mkdocs.yml

@@ -92,6 +92,7 @@ nav:
       - Quickstart: quickstart.md
   - Guide:
       - Using lcode: usage.md
+      - Modes (code, image, video): modes.md
       - Memory: memory.md
       - Subagents: agents.md
       - Commands and skills: commands.md

{lcode_cli-0.37.0 → lcode_cli-0.39.0}/src/lcode/__init__.py

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

{lcode_cli-0.37.0 → lcode_cli-0.39.0}/src/lcode/agent.py

@@ -99,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)."
     )
 
 
@@ -302,6 +304,8 @@ class Progress:
 class Settings:
     model: str  # Ollama model name to call
     context: int
+    mode: str = "code"  # what lcode makes: code, image or video (lcode.modes)
+    comfyui_url: str = "http://127.0.0.1:8188"
     num_batch: int | None = None
     keep_alive: str = "30m"
     think: bool = True
@@ -678,6 +682,7 @@ class Agent:
         data = {
             "cwd": str(self.workspace),  # where `lcode -c` there finds it, wherever the shell moved
             "model": self.settings.model,
+            "mode": self.settings.mode,
             "name": self.session_name,
             "title": self.session_title,
             "messages": self.messages,
@@ -724,6 +729,8 @@ class Agent:
         self.session_id = info.id
         self.checkpoints.load(info.id, data.get("checkpoints") or [])
         self.session_name = data.get("name", "")
+        if data.get("mode") in ("code", "image", "video"):
+            self.settings.mode = data["mode"]  # a session belongs to the mode it was made in
         self.session_title = data.get("title") or sessions.title_from(self.messages)
         self.tools.read_mtimes.clear()  # files may have changed since; the model must read them again
         self.tools.todos = list(data.get("todos") or [])
@@ -961,6 +968,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":
@@ -1164,6 +1177,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
@@ -1215,10 +1230,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
@@ -1234,7 +1250,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",
                     )
                 )
@@ -1253,6 +1269,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
@@ -1345,6 +1369,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):
@@ -1412,6 +1437,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.37.0 → lcode_cli-0.39.0}/src/lcode/api.py

@@ -54,6 +54,7 @@ class Options:
     model: str | None = None
     context: int | str | None = None
     permission_mode: str | None = None  # ask, plan, auto-edit or yolo
+    mode: str | None = None  # code, image or video
     allowed_tools: list[str] | None = None  # only these tools (default: all)
     max_steps: int | None = None  # model steps per request
     think: bool | None = None
@@ -179,6 +180,8 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
         think=cfg["think"] if options.think is None else options.think,
         show_thinking=options.show_thinking,
         permission_mode=options.permission_mode or cfg["permission_mode"],
+        mode=options.mode or cfg["mode"],
+        comfyui_url=cfg["comfyui_url"],
         web=switch(options.web, cfg["web"], "on"),
         search_backend=cfg["search_backend"],
         searxng_url=cfg["searxng_url"],