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

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

@@ -6,6 +6,53 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.41.0] - 2026-10-23
+
+### Added
+
+- **Image models to choose from, installed by lcode** (#150). lcode's media catalog lists the image
+  models it can run, with their size, license, measured speed and whether they fit your GPU.
+  **Z-Image Turbo** (photorealistic) joins FLUX.2 klein 4B (fast): 17 s and 3.5 s per 1024×1024
+  image on a 12 GB laptop GPU. See
+  [Image models](https://nasser1941.github.io/lcode/modes/#image-models).
+  - **Choose one:** `/models` in image mode (numbered) or `/model z-image-turbo` switches; the
+    `image_model` setting is the default, and sessions keep theirs.
+  - **Installed on demand:** a model that isn't installed downloads with your next image, after you
+    say yes, or ahead with `lcode media install <model>`. lcode downloads only the missing files
+    (models share text encoders and VAEs) into ComfyUI's model folders, checks the disk first,
+    verifies each file's SHA-256, and resumes interrupted downloads. `HF_TOKEN` works for gated
+    models.
+  - **`lcode media`** lists image and video models with what fits and what's installed, and
+    `lcode doctor` says how to install the image model when it's missing.
+
+## [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
@@ -876,7 +923,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.39.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.41.0...HEAD
+[0.41.0]: https://github.com/nasser1941/lcode/compare/v0.40.0...v0.41.0
+[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

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

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

@@ -25,6 +25,9 @@ lcode config path                      # print the file location
 | `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 |
+| `image_model` | `flux2-klein-4b` | The model image mode uses: a key from `lcode media` ([image models](modes.md#image-models)) |
 | `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.41.0/docs/modes.md

@@ -0,0 +1,162 @@
+# 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 the image model you choose (see
+[Image models](#image-models)). Sizes, seeds and variations come next (#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
+  ```
+
+- **`lcode doctor`** shows whether ComfyUI is running or found, and whether the image model is
+  installed.
+
+## Image models
+
+lcode's media catalog lists the image models it can run, with what each needs and whether it fits
+your machine. `/models` in image mode shows them, numbered; pick one with its number, or `/model
+z-image-turbo`. `lcode config set image_model z-image-turbo` makes one the default.
+
+```text
+image ❯ /models
+  1. ● FLUX.2 klein 4B (flux2-klein-4b)  text-to-image · 12.4 GB · installed · fits (~9 GB of 12 GB GPU memory)
+        1024×1024: 3.5 s per image, 14 s for the first with ComfyUI starting (RTX 4080 Laptop, 12 GB)
+  2.   Z-Image Turbo (z-image-turbo)  text-to-image · 14.6 GB · 6.5 GB to download · fits (~9 GB of 12 GB GPU memory)
+        1024×1024: 17 s per image (1.9 s per step), 23 s for the first (RTX 4080 Laptop, 12 GB)
+  Switch to which model? (number or name, Enter to keep FLUX.2 klein 4B): 2
+Image model: Z-Image Turbo.
+Not installed yet: 6.5 GB download with your next image (you're asked first).
+```
+
+| Model | Made by | License | Steps | Good at |
+|---|---|---|---|---|
+| **FLUX.2 klein 4B** (default) | Black Forest Labs | Apache 2.0 | 4 | Speed: a few seconds per image |
+| **Z-Image Turbo** | Tongyi-MAI (Alibaba) | Apache 2.0 | 8 | Photorealism, text in images; slower |
+
+Measured speeds are in the list (`/models`, `lcode media`) and in [Measured](#measured).
+
+- **Installing:** a model that isn't installed downloads with your next image, after you say yes.
+  You can also install it ahead with `lcode media install z-image-turbo`. lcode downloads only
+  the files ComfyUI doesn't have: models share text encoders and VAEs, so Z-Image Turbo needs
+  6.5 GB once FLUX.2 klein is there. Files go into ComfyUI's model folders, and the folders of
+  `extra_model_paths.yaml` count when ComfyUI is running.
+- **Safe downloads:** lcode checks the disk first and keeps 2 GB free. The progress shows the
+  speed and the time left. Each file is checked against Hugging Face's SHA-256 before it's used.
+- **Interrupted?** Ctrl+C pauses a download, and so does a dropped connection. Run the same install
+  again and it continues where it stopped (a `.part` file holds what arrived).
+- **Gated models:** for a model whose license you must accept on Hugging Face, accept it there
+  and set `HF_TOKEN`. lcode sends the token to huggingface.co only.
+- **Will it fit?** On NVIDIA GPUs the list compares an estimate of the GPU memory the model needs
+  with your GPU: the largest of its files plus 1.5 GB. ComfyUI loads the text encoder, the model and
+  the VAE one after another, so the largest file sets the need. A model too big for the GPU still
+  runs, slower, because ComfyUI keeps part of it in RAM. On Apple Silicon, the list compares it
+  with unified memory.
+
+```bash
+lcode media                        # image and video models, what fits, what's installed
+lcode media install z-image-turbo  # download what's missing (asks first; --yes doesn't)
+```
+
+### Measured
+
+On an RTX 4080 Laptop GPU (12 GB) with 32 GB of RAM, ComfyUI 0.38, 1024×1024, four different
+prompts each:
+
+| Model | First image (ComfyUI starting, model loading) | Each next image | Per step |
+|---|---|---|---|
+| FLUX.2 klein 4B (fp8) | 14.3 s | 3.5 s | 0.6 s (4 steps) |
+| Z-Image Turbo (int8) | 22.9 s | 17.4 s | 1.9 s (8 steps) |
+
+ComfyUI uses whatever GPU memory is free to keep models loaded (11.3 to 11.5 GB here), so the
+memory a model *needs* is lower than what `nvidia-smi` shows while it runs.
+
+## 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 models done; video models come with video generation).
+- **#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.39.0 → lcode_cli-0.41.0}/docs/quickstart.md

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

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

@@ -7,6 +7,7 @@ lcode [options]              # interactive session in the current directory
 lcode setup [model]          # pick, download and configure a model
 lcode models                 # the model catalog and what fits this machine
 lcode doctor                 # check the installation (include this in bug reports)
+lcode media [install MODEL]  # image and video models: what fits here, what's installed; install one
 lcode config [set|unset]     # show or change settings
 lcode bench [models]         # score models on small coding tasks on this machine
 lcode mcp [catalog|add|list] # connect MCP servers: Jira, GitHub, AWS, databases… (see MCP servers)

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

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

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

@@ -306,6 +306,9 @@ class Settings:
     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)
+    image_model: str = "flux2-klein-4b"  # the media catalog's model image mode uses (lcode.media_catalog)
     num_batch: int | None = None
     keep_alive: str = "30m"
     think: bool = True
@@ -370,6 +373,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
@@ -683,6 +688,7 @@ class Agent:
             "cwd": str(self.workspace),  # where `lcode -c` there finds it, wherever the shell moved
             "model": self.settings.model,
             "mode": self.settings.mode,
+            "image_model": self.settings.image_model,
             "name": self.session_name,
             "title": self.session_title,
             "messages": self.messages,
@@ -731,6 +737,8 @@ class Agent:
         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
+        if isinstance(data.get("image_model"), str):
+            self.settings.image_model = data["image_model"]
         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.39.0 → lcode_cli-0.41.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
@@ -130,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
@@ -153,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:
@@ -182,6 +198,9 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
         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"],
+        image_model=cfg["image_model"],
         web=switch(options.web, cfg["web"], "on"),
         search_backend=cfg["search_backend"],
         searxng_url=cfg["searxng_url"],
@@ -211,6 +230,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:
@@ -250,15 +270,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

{lcode_cli-0.39.0 → lcode_cli-0.41.0}/src/lcode/cli.py

@@ -3,9 +3,11 @@
 from __future__ import annotations
 
 import argparse
+import contextlib
 import platform
 import re
 import shutil
+import signal
 import sys
 import tempfile
 import time
@@ -466,6 +468,7 @@ def cmd_doctor(args) -> None:
     except ValueError as e:
         line("MCP", str(e), False)
         ok = False
+    line("ComfyUI", *comfyui_status(cfg))
     if cfg["sandbox"] == "off":
         line("Sandbox", "off (lcode config set sandbox docker)", True)
     else:
@@ -733,17 +736,10 @@ def cmd_chat(args) -> None:
             print(json.dumps({"type": "result", "status": "error", "error": str(e)}), flush=True)
             sys.exit(1)
         fail(str(e))
+    exit_on_hangup()
     exit_code = 0
     if args.prompt and agent.settings.mode != "code":
-        from lcode import modes
-
-        message = modes.COMING[agent.settings.mode]
-        if quiet:
-            print(json.dumps({"type": "result", "status": "error", "error": message}), flush=True)
-        else:
-            out.print(f"[yellow]{escape(message)}[/]")
-        api.close_agent(agent)
-        sys.exit(2)
+        media_request(agent, args.prompt, out, quiet)  # makes the image or video, then exits
     if args.escalate and args.prompt:
         agent.escalate_approved = True  # the flag is the user's OK for this run
     try:
@@ -765,6 +761,83 @@ def cmd_chat(args) -> None:
         sys.exit(exit_code)
 
 
+def exit_on_hangup() -> None:
+    """A closed terminal (SIGHUP) or a plain kill (SIGTERM) ends lcode the usual way: it saves the session and stops
+    what it started (ComfyUI, MCP servers, background jobs) instead of leaving them running."""
+
+    def leave(signum, frame):
+        raise SystemExit(128 + signum)
+
+    for name in ("SIGHUP", "SIGTERM"):
+        sig = getattr(signal, name, None)
+        if sig is not None:
+            with contextlib.suppress(ValueError, OSError):  # only the main thread can
+                signal.signal(sig, leave)
+
+
+def comfyui_status(cfg: dict) -> tuple[str, bool | None]:
+    """lcode doctor's ComfyUI line: running or found, and whether the image model is there."""
+    from lcode import comfy
+    from lcode import media_catalog as catalog
+
+    model = catalog.load().find(cfg.get("image_model") or "") or catalog.load().models[catalog.DEFAULT_IMAGE]
+    server = comfy.Server(cfg["comfyui_url"])
+    stats = server.stats()
+    install = None if stats else comfy.find_install(cfg["comfyui_path"])
+    if not stats and install is None:
+        return "not found: image mode offers to install it (or lcode config set comfyui_path <folder>)", None
+    if stats:
+        where = f"{(stats.get('system') or {}).get('comfyui_version', '?')} running at {server.url}"
+    else:
+        where = f"{install.path} (lcode starts it in image mode)"
+    _, missing = catalog.chosen_files(model, catalog.lister(server if stats else None, install))
+    if missing:
+        size = sum(f.gb for f in missing)
+        return f"{where} · {model.name} not installed: lcode media install {model.key} ({size:.1f} GB)", None
+    return f"{where} · image model: {model.name}", True
+
+
+def media_request(agent, prompt: str, out: Console, quiet: bool) -> None:
+    """`lcode --mode image -p "…"`: make the image, say where it went (or, with --output json, a result object)."""
+    import json
+
+    from lcode import api, media, modes
+
+    if agent.settings.mode == "video":
+        message = modes.COMING["video"]
+        if quiet:
+            print(json.dumps({"type": "result", "status": "error", "error": message}), flush=True)
+        else:
+            out.print(f"[yellow]{escape(message)}[/]")
+        api.close_agent(agent)
+        sys.exit(2)
+    try:
+        made = media.generate_image(agent, prompt)
+    except (media.MediaError, KeyboardInterrupt) as e:
+        message = str(e) or "Cancelled."
+        if quiet:
+            print(json.dumps({"type": "result", "status": "error", "error": message}), flush=True)
+        else:
+            out.print(f"[red]{escape(message)}[/]")
+        api.close_agent(agent)
+        sys.exit(1)
+    if quiet:
+        result = {
+            "type": "result",
+            "status": "success",
+            "mode": "image",
+            "files": [str(path) for path in made.files],
+            "model": made.model,
+            "seed": made.seed,
+            "width": made.width,
+            "height": made.height,
+            "seconds": round(made.seconds, 1),
+        }
+        print(json.dumps(result, ensure_ascii=False), flush=True)
+    api.close_agent(agent)
+    sys.exit(0)
+
+
 def compact_tokens(value: str) -> int:
     """`--compact-at`: a token count such as 64k, or 0."""
     try:
@@ -836,6 +909,13 @@ def build_subparsers() -> dict[str, argparse.ArgumentParser]:
     subs["setup"] = p
     subs["models"] = argparse.ArgumentParser(prog="lcode models", description="List models and how they fit here.")
     subs["doctor"] = argparse.ArgumentParser(prog="lcode doctor", description="Check the installation.")
+    p = argparse.ArgumentParser(
+        prog="lcode media", description="Image and video models: list them, with how they fit here, or install one."
+    )
+    p.add_argument("action", nargs="?", choices=["list", "install"], default="list")
+    p.add_argument("model", nargs="?", help="with install: a model key from the list, e.g. z-image-turbo")
+    p.add_argument("-y", "--yes", action="store_true", help="don't ask before downloading")
+    subs["media"] = p
     p = argparse.ArgumentParser(prog="lcode config", description="Show or change settings.")
     p.add_argument("action", nargs="?", choices=["show", "set", "unset", "path"], default="show")
     p.add_argument("key", nargs="?", choices=list(config.SETTINGS))
@@ -992,6 +1072,55 @@ def cmd_index(args) -> None:
     )
 
 
+def cmd_media(args) -> None:
+    """lcode media [list] | install <model>: the media catalog, what's installed in ComfyUI, downloads."""
+    from rich.prompt import Confirm
+
+    from lcode import comfy, media
+    from lcode import media_catalog as catalog
+
+    try:
+        cfg = config.load()
+    except ConfigError as e:
+        fail(str(e))
+    cat, hw = catalog.load(), detect()
+    server = comfy.Server(cfg["comfyui_url"])
+    install = comfy.find_install(cfg["comfyui_path"])
+    running = server.stats() is not None
+    installed = catalog.lister(server if running else None, install) if running or install else None
+    if args.action == "install":
+        model = cat.find(args.model or "")
+        if model is None:
+            fail(f"no media model {args.model!r}: lcode media lists them")
+        if not running and install is None:
+            fail(f"lcode needs ComfyUI to install models into. {comfy.install_hint()}")
+        ask = None if args.yes else (lambda q: Confirm.ask(q, default=True, console=console))
+        try:
+            saved = catalog.install(model, server if running else None, install, console, ask)
+        except catalog.CatalogError as e:
+            fail(str(e))
+        how = f" ({len(saved)} file(s) downloaded)." if saved else "."
+        console.print(f"[green]{model.name} is installed[/]{how}")
+        return
+    where = (
+        f"ComfyUI at {server.url}" if running else (f"{install.path} (not running)" if install else "no ComfyUI found")
+    )
+    console.print(f"[dim]{hw.describe()} · {where} · image model: {cfg['image_model']}[/]\n")
+    for mode in ("image", "video"):
+        models = cat.for_mode(mode)
+        console.print(f"[bold]{mode.capitalize()} models[/]")
+        if not models:
+            console.print(f"  [dim]{media.SOON[mode]}[/]\n")
+            continue
+        for m in models:
+            line = escape(catalog.describe(m, hw, installed))
+            console.print(f"  [bold]{m.key:<16}[/] {escape(m.name)} [dim]· {line}[/]")
+            if m.measured:
+                console.print(f"  {'':<16} [dim]{escape(m.measured)}[/]")
+        console.print()
+    console.print("[dim]Install one: lcode media install <model> · choose in image mode: /model <model>[/]")
+
+
 def cmd_mcp(args) -> None:
     from lcode.mcp.commands import run
 
@@ -1002,6 +1131,7 @@ COMMANDS = {
     "setup": cmd_setup,
     "models": cmd_models,
     "doctor": cmd_doctor,
+    "media": cmd_media,
     "config": cmd_config,
     "bench": cmd_bench,
     "mcp": cmd_mcp,