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

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

@@ -6,6 +6,55 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.40.0] - 2026-10-23
+
+### Added
+
+- **Image mode makes images** (#149). In image mode, what you type becomes a picture, made by
+  FLUX.2 klein 4B on your GPU in about 8 seconds, with no language model involved. lcode drives
+  ComfyUI itself. See [Modes](https://nasser1941.github.io/lcode/modes/#image-mode).
+  - **ComfyUI is found or started:** lcode uses a running ComfyUI as it is. Otherwise it starts
+    yours in the background when you enter image mode (`comfyui_path`, the `comfy` CLI's folder or
+    a usual one). It stops that ComfyUI when you quit, go back to code mode or close the terminal.
+    With none, it offers to install ComfyUI with comfy-cli.
+  - **Progress, cancel and type-ahead:** the status line shows the step, the time left and your
+    place in ComfyUI's queue. Esc or Ctrl+C cancels the job in ComfyUI too. What you type
+    meanwhile waits in the next prompt.
+  - **Files with their settings:** images go to `.lcode/media/` (the `media_dir` setting), each
+    with a JSON file of its prompt, model, seed and size, also stored in the PNG itself. Images
+    that finish after a crash are saved the next time.
+  - `lcode --mode image -p "…"` makes an image from a script, and `--output json` gives the paths.
+    `lcode doctor` reports ComfyUI and the image model.
+  - **No Ollama needed for images:** lcode starts in image mode without Ollama or the coding
+    model; `/mode code` says what's missing.
+
+### Fixed
+
+- **lcode cleans up when its terminal closes.** A closed terminal or a `kill` used to end lcode
+  without stopping what it had started. Now it saves the session and stops its background jobs and
+  servers. On Linux, a ComfyUI lcode started also stops if lcode is killed outright.
+
+## [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
@@ -855,7 +904,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.38.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.40.0...HEAD
+[0.40.0]: https://github.com/nasser1941/lcode/compare/v0.39.0...v0.40.0
+[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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.38.0
+Version: 0.40.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/
@@ -107,6 +107,9 @@ through [Ollama](https://ollama.com), and when it needs current information it c
   `lcode --worktree` runs parallel sessions on one repository.
 - **In your editor.** Zed, JetBrains IDEs, Neovim and other editors that speak the Agent Client
   Protocol run lcode with `lcode acp`, with diffs and approvals in the editor.
+- **Image mode.** `/mode image`, describe a picture, and FLUX.2 klein 4B makes it on your GPU in
+  seconds through ComfyUI, which lcode starts, follows and stops itself. Video mode is next
+  ([modes](https://nasser1941.github.io/lcode/modes/)).
 - **Automation.** `lcode -p --output json` for scripts and CI, a Python API (`from lcode import
   Session`), and a GitHub Action that answers `@lcode` in issues and pull requests on your own
   self-hosted runner.

{lcode_cli-0.38.0 → lcode_cli-0.40.0}/README.md

@@ -71,6 +71,9 @@ through [Ollama](https://ollama.com), and when it needs current information it c
   `lcode --worktree` runs parallel sessions on one repository.
 - **In your editor.** Zed, JetBrains IDEs, Neovim and other editors that speak the Agent Client
   Protocol run lcode with `lcode acp`, with diffs and approvals in the editor.
+- **Image mode.** `/mode image`, describe a picture, and FLUX.2 klein 4B makes it on your GPU in
+  seconds through ComfyUI, which lcode starts, follows and stops itself. Video mode is next
+  ([modes](https://nasser1941.github.io/lcode/modes/)).
 - **Automation.** `lcode -p --output json` for scripts and CI, a Python API (`from lcode import
   Session`), and a GitHub Action that answers `@lcode` in issues and pull requests on your own
   self-hosted runner.

{lcode_cli-0.38.0 → lcode_cli-0.40.0}/docs/configuration.md

@@ -23,6 +23,10 @@ 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 |
+| `comfyui_path` | (found) | Your ComfyUI folder, if lcode doesn't find it; lcode starts it when needed ([ComfyUI](modes.md#comfyui)) |
+| `media_dir` | `.lcode/media` | Where images and videos go: a folder in the project, or an absolute path |
 | `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.38.0 → lcode_cli-0.40.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.40.0/docs/modes.md

@@ -0,0 +1,109 @@
+# 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.
+Starting ComfyUI (~/comfy/ComfyUI) in the background.
+Describe an image and press Enter: FLUX.2 klein 4B makes it on your GPU, into .lcode/media.
+image ❯ a red fox sitting in fresh snow at dusk
+◆ .lcode/media/20261023-184531-a-red-fox-sitting-in-fresh-snow-at-dusk-1.png  1024×1024 · FLUX.2 klein 4B · seed 3714779554 · 8.0 s
+```
+
+- **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.
+
+## Image mode
+
+In image mode, what you type is a description, and lcode makes the picture. No language model is
+involved: lcode fills in its own ComfyUI workflow for the image model and follows the job itself.
+For now that's one image per request, 1024×1024, with **FLUX.2 klein 4B** (4 steps, about 8 seconds
+on a 12 GB laptop GPU; a 4B model that fits in 8 GB). Choosing models, sizes, seeds and variations
+comes next (#150, #151).
+
+- **Progress:** the status line says what ComfyUI is doing (loading the model, reading the
+  prompt, drawing, decoding), the step, the time left and the time so far. If other jobs are ahead
+  in ComfyUI's queue, it says how many.
+- **Cancel** with Esc or Ctrl+C: lcode cancels the job in ComfyUI too, so it stops using the GPU.
+- **Type ahead:** what you type while an image is being made waits in the next prompt.
+- **Files:** each image goes to `.lcode/media/` in the project (the `media_dir` setting), named
+  after the time and the prompt, with a `.json` next to it holding the prompt, model, seed, size and
+  steps. PNGs carry the same in their own metadata (an `lcode` text chunk), and ComfyUI's workflow
+  as well. `.lcode/media/` keeps itself out of git; a folder of your own (`lcode config set
+  media_dir assets/generated`) doesn't.
+- **Nothing is lost:** lcode writes each job down while it runs. If lcode crashes or the terminal
+  closes before an image arrives, the next request in image mode saves it.
+- **From scripts:** `lcode --mode image -p "a red fox in the snow"` makes one image and exits;
+  with `--output json` it prints a result with the file paths, model, seed, size and time.
+- **No Ollama needed:** `lcode --mode image` starts even when Ollama isn't running or the coding
+  model isn't installed; `/mode code` then says what's missing.
+
+## ComfyUI
+
+ComfyUI runs the image and video models; lcode drives it through its API.
+
+- **One that's running** at `comfyui_url` (by default `http://127.0.0.1:8188`) is used as it is.
+- **Otherwise lcode starts one** in the background when you switch to image mode, so the first
+  image waits less, and stops it when you quit or go back to code mode, or when the terminal
+  closes. It looks in the `comfyui_path` setting, then the folder the `comfy` CLI uses, then
+  `~/comfy/ComfyUI`, `~/ComfyUI`, `~/comfyui` and `~/Documents/ComfyUI`. It uses that install's
+  own Python (its `.venv` or `venv`), and logs to `comfyui.log` in lcode's state folder.
+- **With none,** your first image request offers to install ComfyUI into lcode's state folder with
+  [comfy-cli](https://github.com/Comfy-Org/comfy-cli) and the PyTorch build for your GPU (NVIDIA,
+  Apple Silicon or CPU). That downloads several GB. To install it yourself:
+
+  ```bash
+  uvx --from comfy-cli comfy install
+  ```
+
+- **The image model** has to be in ComfyUI's model folders for now: for FLUX.2 klein 4B,
+  `diffusion_models/flux-2-klein-4b-fp8.safetensors`, `text_encoders/qwen_3_4b.safetensors` and
+  `vae/flux2-vae.safetensors` (from ComfyUI's FLUX.2 klein template). lcode names any that are
+  missing. Installing models from lcode comes with #150.
+- **`lcode doctor`** shows whether ComfyUI is running or found, and whether the image model is
+  there.
+
+## 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, and checks again
+  before each image.
+- **Back to code mode:** lcode stops the ComfyUI it started, or asks yours to free its memory,
+  then loads the coding model again in the background.
+
+## Coming next
+
+Video mode doesn't generate yet: a request there says what's coming instead of going anywhere.
+
+- **#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.38.0 → lcode_cli-0.40.0}/docs/quickstart.md

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

{lcode_cli-0.38.0 → lcode_cli-0.40.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 |
@@ -315,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
@@ -470,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.38.0 → lcode_cli-0.40.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.38.0 → lcode_cli-0.40.0}/src/lcode/__init__.py

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

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

@@ -304,6 +304,10 @@ 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"
+    comfyui_path: str | None = None  # a ComfyUI install lcode doesn't find by itself (lcode.comfy)
+    media_dir: str = ".lcode/media"  # where image and video mode save their files (lcode.media)
     num_batch: int | None = None
     keep_alive: str = "30m"
     think: bool = True
@@ -368,6 +372,8 @@ class Agent:
         self.session_name = ""
         self.session_title = ""
         self.interactive = True  # False for `lcode -p`: no end-of-session questions
+        self.comfy_process = None  # the ComfyUI lcode started for image and video mode, stopped when it exits
+        self.no_coding_model = ""  # why there's no coding model, when lcode started in image or video mode without
         self.reflected = 0  # messages before this index were already checked for notes to remember
         self._memory: memory_notes.Memory | None = None
         self._agent_types: tuple[Path, dict[str, subagents.AgentType], list[str]] | None = None
@@ -680,6 +686,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,
@@ -726,6 +733,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 [])

{lcode_cli-0.38.0 → lcode_cli-0.40.0}/src/lcode/api.py

@@ -15,6 +15,7 @@ A session is one conversation: each `run` continues it. `stream` yields the same
 
 from __future__ import annotations
 
+import contextlib
 import io
 import queue
 import threading
@@ -54,6 +55,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
@@ -129,6 +131,24 @@ def switch(wanted: bool | None, configured: str, default_on: str) -> str:
     return configured if configured != "off" else default_on
 
 
+def coding_model(ollama, options: Options, cfg: dict, requested: int | None, hw: Hardware, console: Console):
+    """The coding model to use, its catalog entry and the context window; SetupError when there's none."""
+    from lcode import cli
+
+    check_server(ollama, hw)
+    try:
+        model, spec = cli.resolve_model(ollama, options.model or cfg["model"])
+    except cli.NotInstalled as e:
+        first_run = not options.model and cfg["model"] == config.DEFAULT_MODEL and not config.CONFIG_PATH.exists()
+        if first_run and not backends.is_openai(ollama):
+            raise SetupError("lcode isn't set up yet. Run:  lcode setup") from e
+        raise SetupError(str(e)) from e
+    context, note = cli.choose_context(ollama, model, spec, requested, hw)
+    if note:
+        console.print(f"[yellow]Context {config.format_tokens(context)}: {note}[/]")
+    return model, spec, context
+
+
 def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | None = None) -> Agent:
     """An agent set up the way `lcode` sets up a session: model, context, hooks, language servers, MCP."""
     from lcode import catalog, cli, extensions, hooks
@@ -152,17 +172,14 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
     except OllamaError as e:
         raise SetupError(str(e)) from e
     hw = hw or detect()
-    check_server(ollama, hw)
+    no_coding_model = ""  # why, when image or video mode starts without one
     try:
-        model, spec = cli.resolve_model(ollama, options.model or cfg["model"])
-    except cli.NotInstalled as e:
-        first_run = not options.model and cfg["model"] == config.DEFAULT_MODEL and not config.CONFIG_PATH.exists()
-        if first_run and not backends.is_openai(ollama):
-            raise SetupError("lcode isn't set up yet. Run:  lcode setup") from e
-        raise SetupError(str(e)) from e
-    context, note = cli.choose_context(ollama, model, spec, requested, hw)
-    if note:
-        console.print(f"[yellow]Context {config.format_tokens(context)}: {note}[/]")
+        model, spec, context = coding_model(ollama, options, cfg, requested, hw, console)
+    except SetupError as e:
+        if (options.mode or cfg["mode"]) == "code":
+            raise
+        # Image and video mode don't need the coding model: start without it, and say so on /mode code.
+        model, spec, context, no_coding_model = options.model or cfg["model"], None, requested or 32768, str(e)
     num_batch = cfg["num_batch"]
     if num_batch is None and spec and spec.num_batch:
         if model == spec.local_name:
@@ -179,6 +196,10 @@ 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"],
+        comfyui_path=cfg["comfyui_path"],
+        media_dir=cfg["media_dir"],
         web=switch(options.web, cfg["web"], "on"),
         search_backend=cfg["search_backend"],
         searxng_url=cfg["searxng_url"],
@@ -208,6 +229,7 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
     )
     agent = Agent(ollama, settings, cwd, console=console)
     agent.hardware = hw
+    agent.no_coding_model = no_coding_model
     agent.autosave = True
     agent.interactive = options.interactive
     if options.max_steps:
@@ -247,15 +269,25 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
 
 
 def close_agent(agent: Agent) -> None:
+    """Stop what lcode started (background jobs, servers, the sandbox, ComfyUI), then say so: the terminal may be
+    gone already (closed), and saying it then fails."""
+    from lcode import media
+
+    said = []
     stopped = agent.jobs.stop_all()
     if stopped:
-        agent.console.print(f"[dim]Stopped {stopped} background job(s).[/]")
+        said.append(f"Stopped {stopped} background job(s).")
+    if media.stop_engine(agent):
+        said.append("Stopped ComfyUI.")
     if agent.lsp is not None:
         agent.lsp.close()
     if agent.mcp:
         agent.mcp.close()
     if agent.sandbox:
         agent.sandbox.stop()
+    for line in said:
+        with contextlib.suppress(OSError):
+            agent.console.print(f"[dim]{line}[/]")
 
 
 # ----------------------------------------------------------------------------- running