diff --git a/docs/superpowers/handoffs/2026-06-16-comfyui-followups.md b/docs/superpowers/handoffs/2026-06-16-comfyui-followups.md
new file mode 100644
index 00000000..c4a58265
--- /dev/null
+++ b/docs/superpowers/handoffs/2026-06-16-comfyui-followups.md
@@ -0,0 +1,287 @@
+# ComfyUI integration — follow-up handoffs (for a Codex agent new to hal0)
+
+Context: the ComfyUI platform-integration work shipped as **PR #878** (branch `feat/comfyui-platform`),
+merged "partial" with known gaps filed as issues **#872–#877**. #872 is already fixed on the branch.
+These handoffs cover the rest. **Read "0. Shared onboarding" first — every task depends on it.**
+
+---
+
+## 0. Shared onboarding (READ FIRST)
+
+### 0.1 Where things are
+- **Main checkout** (other sessions use it; do NOT edit here): `/home/halo/dev/hal0` (branch varies).
+- **Your worktree** (do your work here): `/home/halo/dev/wt/comfyui-integration`, on branch `feat/comfyui-platform`.
+  A git *worktree* is a second working dir sharing one `.git`. Edits here are isolated from the main checkout.
+- **The Python venv lives in the main checkout**, not the worktree: use `/home/halo/dev/hal0/.venv/bin/python`
+  (and `/home/halo/dev/hal0/.venv/bin/ruff`). There is no venv inside the worktree.
+- ComfyUI code: `src/hal0/comfyui/` (capabilities.py, fetch.py, selection.py).
+- ComfyUI API routes: `src/hal0/api/routes/comfyui.py`.
+- Installer assets: `installer/comfyui/` (scripts/, extra_model_paths.yaml, custom_nodes/).
+- Plan + this doc: `docs/superpowers/plans/2026-06-16-comfyui-platform-integration.md`, `docs/superpowers/handoffs/`.
+
+### 0.2 Running tests + lint (IMPORTANT)
+- **Never run the whole suite** (`pytest tests/`) — it hangs (a health probe blocks). Always target files:
+  ```bash
+  cd /home/halo/dev/wt/comfyui-integration
+  PYTHONPATH=src /home/halo/dev/hal0/.venv/bin/python -m pytest tests/comfyui -q
+  ```
+- Lint is **ruff, not black**:
+  ```bash
+  /home/halo/dev/hal0/.venv/bin/ruff check <files>      # must report "All checks passed!"
+  /home/halo/dev/hal0/.venv/bin/ruff format <files>     # auto-format before committing
+  ```
+  Project selects rules `E,F,I,B,UP,SIM,RUF` (so `RUF006` unstored-task, `RUF012` mutable-classvar,
+  `B905` zip-strict all fail CI — handle them).
+- Frontend (only for UI tasks): `cd ui && npm run build` (tsc+vite) and
+  `cd ui && npx playwright test <spec-substring>`.
+
+### 0.3 Git flow — pick ONE of these two situations
+**A) PR #878 is still OPEN (check: `gh pr view 878 -R Hal0ai/hal0 --json state -q .state`).**
+Do the fix directly on `feat/comfyui-platform` so it joins that PR:
+```bash
+cd /home/halo/dev/wt/comfyui-integration
+git pull --rebase origin feat/comfyui-platform   # pick up anything pushed since
+# ... make changes, TDD ...
+git add -A
+git commit -m "fix(comfyui): <what> (#<issue>)"
+git push                                          # updates PR #878
+```
+
+**B) PR #878 is already MERGED.** Branch fresh from `main`, one branch + PR per issue:
+```bash
+cd /home/halo/dev/hal0
+git fetch origin
+git worktree add -B fix/comfyui-<issue> /home/halo/dev/wt/comfyui-<issue> origin/main
+cd /home/halo/dev/wt/comfyui-<issue>
+# ... TDD, commit ...
+git push -u origin fix/comfyui-<issue>
+gh pr create -R Hal0ai/hal0 --base main --head fix/comfyui-<issue> --title "..." --body "...Fixes #<issue>..."
+```
+
+**Commit/PR conventions** (required):
+- Conventional-commit prefix: `fix(comfyui): ...`, `feat(comfyui): ...`, `style(comfyui): ...`.
+- End commit messages with:
+  `Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>`
+- End PR bodies with: `🤖 Generated with [Claude Code](https://claude.com/claude-code)`
+- Put `Fixes #<n>` in the PR body so the issue auto-closes on merge.
+- The repo remote is `origin` = `https://github.com/Hal0ai/hal0.git`. `gh` is authed (account `thinmintdev`).
+
+**Before merging PR #878 specifically:** it is BEHIND `main`. Update it first:
+`gh pr update-branch 878 -R Hal0ai/hal0` (or `git merge origin/main` in the worktree, resolve, push).
+Only merge when all CI checks are green (`gh pr checks 878 -R Hal0ai/hal0`).
+
+### 0.4 CT105 deploy flow (ONLY tasks #874, Phase 1, 6.3 need this — the rest are code-only)
+CT105 (a.k.a. `hal0`, `10.0.1.142`) is the **GPU runtime box** and a **SHARED host** — other sessions use it.
+- SSH: `ssh hal0` (alias for `root@10.0.1.142`).
+- **Coordinate before touching `/opt/hal0`:**
+  ```bash
+  ssh hal0 'cd /opt/hal0 && git branch --show-current && git status --porcelain'
+  ```
+  If branch ≠ `main` OR there are uncommitted tracked edits → **another session is working there. Stop and
+  coordinate; do not `git checkout`/`reset`/deploy over it.**
+- **Deploy a branch (preview):** `deploy.sh` rebuilds `ui/dist` (gitignored — a bare `git reset` leaves the
+  dashboard stale, so always use the script) + restarts + healthchecks:
+  ```bash
+  ssh hal0 'cd /opt/hal0 && sudo bash scripts/deploy.sh --ref origin/feat/comfyui-platform'
+  ```
+- **After PR merges, reconcile CT105 back to main:**
+  ```bash
+  ssh hal0 'cd /opt/hal0 && sudo bash scripts/deploy.sh --ref origin/main'
+  ```
+- Model store on CT105: `/mnt/ai-models/comfyui/` (writable ZFS bind). ComfyUI container = `comfyui`, port `8188`,
+  brought up by `/opt/comfyui/comfy-up.sh`. iGPU is gfx1151; only one renderer can hold it at a time.
+
+### 0.5 Record your work (project rule)
+After creating/merging a PR or finishing a task, record a one-line memory via the hal0 memory engine
+(skill `hal0-memory` → `memory_add`, dataset `shared`, `document_id` like `pr-<n>` / `issue-<n>`, with the *why*).
+
+---
+
+## 1. #876 — remove stale Lemonade inference scripts  *(easiest; code-only)*
+
+**Goal:** `installer/comfyui/scripts/start-inference.sh` and `stop-inference.sh` call the **removed**
+`hal0-lemonade.service` (Lemonade was deleted from hal0 months ago) and bypass the GPU arbiter. They are a
+footgun shipped to `/opt/comfyui`. Remove them.
+
+**Why they exist:** they were copied verbatim from CT105 (pre-Lemonade-removal era) during PR #878.
+
+**Steps:**
+1. Confirm the dead refs: `grep -n lemonade installer/comfyui/scripts/start-inference.sh installer/comfyui/scripts/stop-inference.sh`
+   (you'll see `systemctl start/stop hal0-lemonade.service`).
+2. `git rm installer/comfyui/scripts/start-inference.sh installer/comfyui/scripts/stop-inference.sh`
+3. Grep for anything that referenced them so you don't leave a dangling caller:
+   `grep -rn "start-inference\|stop-inference" src/ installer/ tests/ packaging/`
+   - `installer/install.sh` copies `installer/comfyui/scripts/*.sh` with a glob, so removing the files is enough
+     (no edit needed) — but **verify** the install.sh block uses `*.sh` and not an explicit list; if explicit, drop them there too.
+   - If `tests/install/test_comfyui_scripts_shipped.py` asserts these two exist, update it to not expect them.
+4. Run: `PYTHONPATH=src /home/halo/dev/hal0/.venv/bin/python -m pytest tests/install -q` → green.
+5. Commit `fix(comfyui): drop stale Lemonade start/stop-inference scripts (#876)`.
+
+**Done when:** the two scripts are gone, no caller references them, `tests/install` green.
+
+---
+
+## 2. #877 — review follow-ups (do the two real ones; rest are optional polish)
+
+### 2a. I4 — exception leak + unguarded workflow lookup *(code-only, do this)*
+**Files:** `src/hal0/api/routes/comfyui.py` — the workflow-launch route (~line 590–625) and `_find_workflow` (~line 625).
+**Problem:** the launch route catches `KeyError as exc` and returns `{"message": str(exc)}` (~line 599–605),
+echoing internal exception text to the client; `_find_workflow(name)` builds a path from `name` without validating it.
+**Note:** FastAPI's `{name}` path param won't match a `/`, so classic path traversal is already blocked — but
+harden anyway and stop leaking exception strings.
+**Steps (TDD):**
+1. Add tests in `tests/api/test_comfyui_phase4.py`: launching an unknown workflow returns 404 with a generic
+   message (no raw exception text); a `name` containing `..` or `/` is rejected (422/404), never reads outside the
+   workflows dir.
+2. In `_find_workflow`, validate `name` matches `^[A-Za-z0-9._-]+$` (reject otherwise → return None); in the route,
+   replace `str(exc)` with a generic message and log the detail server-side.
+3. `PYTHONPATH=src /home/halo/dev/hal0/.venv/bin/python -m pytest tests/api/test_comfyui_phase4.py -q` → green; ruff clean.
+4. Commit `fix(comfyui): validate workflow name + stop leaking exception text (#877)`.
+
+### 2b. I5 — image identity divergence *(small; mostly documentation)*
+**Problem:** the ComfyUI image is referenced inconsistently:
+- `manifest.json:34` → `docker.io/kyuz0/amd-strix-halo-comfyui:latest` (mutable **tag**)
+- `src/hal0/config/schema.py:769` (SEED_PROFILES) → same `:latest` tag
+- `installer/etc-hal0/profiles.toml:76` → same `:latest` tag
+- but `installer/comfyui/scripts/comfy-up.sh` pins a **digest** `@sha256:0066678a…`
+**Decision already made:** we keep consuming kyuz0's image this week (Phase 1 build deferred). So the fix is to make
+all four agree on the **same digest** (reproducible), not the mutable `:latest`.
+**Steps:**
+1. Get the digest comfy-up.sh uses (it's in the file): `grep sha256 installer/comfyui/scripts/comfy-up.sh`.
+2. Replace the `:latest` tag with `@sha256:<that digest>` in `manifest.json`, `schema.py:769`, `profiles.toml:76`.
+3. If `tests/config/` asserts the comfyui profile image, update the expectation.
+4. Run `tests/config` + `tests/comfyui` targeted → green; ruff clean.
+5. Commit `fix(comfyui): pin comfyui image to one digest across manifest/profile/seed (#877)`.
+
+### 2c. Optional polish (only if time; otherwise leave in #877)
+- `Selections.comfyui_defaults` sidecar → a dedicated `ComfyUISelection` type (refactor).
+- installer repair `if unit == "comfyui"` → a `_REPAIR_HANDLERS` dispatch table.
+- UI: replace `alert()` log display with a drawer; preview staleness during render.
+Skip unless asked; they aren't correctness bugs.
+
+---
+
+## 3. #873 — wire real GPU telemetry into `/status` *(code-only; you'll feel this in the UI)*
+
+**Goal:** the V2 pane's device grid (util / temp / clock) renders **0** because `/api/comfyui/status` only returns
+memory (gtt/ram) + queue + inventory. Add `util`, `temp`, `clock` from hal0's existing GPU telemetry.
+`it_s`/`eta`/`step` need a ComfyUI websocket subscription — leave those as a documented follow-up (emit the keys as
+`null`, don't fake them).
+
+**Where hal0 reads the iGPU** (reuse, don't reinvent): `src/hal0/hardware/gpu_view.py`, `src/hal0/hardware/stats.py`,
+`src/hal0/providers/_gpu.py`, `src/hal0/api/routes/power.py`, `src/hal0/api/routes/slots.py`. Find the function that
+returns temperature / clock (sclk) / utilization and call it from comfyui.py's status builder.
+
+**Critical gotcha (from prior incident):** raw `gpu_busy_percent` is a **forced-high artifact** on this box — the
+GPU is pinned to perf-level "high" for inference, so it reads ~100% even when idle. **Do not report
+`gpu_busy_percent` as `util` unconditionally.** Gate it: report util only when a render is actually active
+(there's a running job in the ComfyUI queue); otherwise `util = 0` (or null). Temp/clock are real — report them directly.
+
+**Steps (TDD):**
+1. In `src/hal0/api/routes/comfyui.py` find the `/status` handler (`comfyui_status`, ~line 321) and the helper that
+   assembles the payload. Add a `telemetry`/device block: `{util, temp, clock}` (keep existing `memory` gtt/ram).
+2. Add tests to `tests/api/test_comfyui_phase4.py` (or a new `tests/api/test_comfyui_telemetry.py`): mock the
+   hardware helper; assert temp/clock pass through; assert util is 0/None when queue idle and the real value when a
+   job is running; assert `it_s`/`eta`/`step` keys exist and are null. Tests must be **fail-soft** — if the hardware
+   probe raises, `/status` still returns 200 (never 500), matching the existing fail-soft pattern in this module.
+3. Update `ui/src/api/hooks/useComfyui.ts` `transformComfyuiStatus()` to map the new fields into the pane's STATS
+   object, and adjust `ui/tests/e2e/specs/comfyui-arbiter-v3.spec.ts` (or imagegen-v2) mock payloads to include them.
+4. `pytest tests/api -q` (targeted) + `cd ui && npm run build && npx playwright test comfyui imagegen` → green; ruff clean.
+5. Commit `feat(comfyui): real util/temp/clock telemetry in /status (#873)`.
+
+**Done when:** pane device grid shows live temp/clock, util only during renders; `it_s`/`eta`/`step` null; all green.
+
+---
+
+## 4. #875 — wire the hardened (non-root) control path (sudoers) *(code-only; needed before hardened ship)*
+
+**Goal:** on a hardened install, `hal0-api` runs **non-root**, so the container-control routes (`/restart`, repair,
+`install_extension`) that shell `comfy-up.sh`/`podman`/`docker` will 403. There's an orphaned
+`packaging/sudoers/hal0-comfyui` referencing a `comfyui.py:_script_argv` + `sudo -n` that don't exist, the file is
+never installed, and the planned `tests/install/test_comfyui_sudoers.py` is missing.
+
+**Decision context:** on the dev box (CT105) hal0-api runs as root, so this isn't blocking *today* — but it must work
+for the shipped hardened product. Scope: make the control paths run privileged via a single, audited sudoers entry.
+
+**Steps:**
+1. Read `packaging/sudoers/hal0-comfyui` (current orphan) and `src/hal0/api/routes/comfyui.py` `/restart` +
+   `installer.py` repair to see exactly which commands need privilege (`/opt/comfyui/comfy-up.sh`, `comfy-down.sh`,
+   `podman`/`docker` inspect/restart).
+2. Make the sudoers file grant `hal0` NOPASSWD for *exactly* those command paths (no wildcards). `visudo -cf
+   packaging/sudoers/hal0-comfyui` must pass.
+3. Have the routes invoke via `sudo -n <script>` when not root (detect EUID); run directly when root.
+4. Add `install -m0440 packaging/sudoers/hal0-comfyui /etc/sudoers.d/hal0-comfyui` to `installer/install.sh`
+   (near the other `/etc` asset installs).
+5. Add `tests/install/test_comfyui_sudoers.py`: file installed by install.sh (grep the install.sh line), command
+   paths in sudoers == the paths the routes actually call, `visudo -cf` clean.
+6. `pytest tests/install tests/api -q` (targeted) → green; ruff clean.
+7. Commit `feat(comfyui): hardened sudoers for container control (#875)`.
+
+**Done when:** non-root control path is wired + tested; sudoers installed by the installer; no wildcard grants.
+
+---
+
+## 5. #874 — reconcile `comfy-up.sh` (standalone `docker run`) vs the arbiter/podman slot *(needs CT105)*
+
+**This is the subtle one — do NOT blind-edit; verify against the live box first.**
+
+**Problem (from review):** `installer/comfyui/scripts/comfy-up.sh` does `docker run` a *standalone* container named
+`comfyui` on `:8188`. But hal0's slot system has a `GpuArbiter` (`src/hal0/slots/arbiter.py`) that manages a podman
+slot `hal0-slot@img` — also on `:8188`. The control routes (`/restart`), installer repair, and
+`install_extension("comfyui")` all call `comfy-up.sh`. If both paths run, you get a port clash / an unmanaged
+container that won't yield the iGPU to inference.
+
+**Why "verify first":** the *live CT105 today* actually uses `comfy-up.sh` and works — so it's unclear whether the
+arbiter/podman-slot path for ComfyUI is the real runtime or aspirational. You must establish ground truth before
+choosing a fix.
+
+**Steps:**
+1. **Inspect live CT105 (read-only):**
+   ```bash
+   ssh hal0 'cd /opt/hal0 && git branch --show-current && git status --porcelain'   # coordinate first (0.4)
+   ssh hal0 'docker ps -a --filter name=comfyui; podman ps -a | grep -i "img\|comfy"; ss -ltnp | grep 8188'
+   ```
+   Determine: is the running ComfyUI a `docker` standalone (comfy-up.sh) or a podman `hal0-slot@img`? Who owns :8188?
+2. Read `src/hal0/slots/arbiter.py` (`ensure_img` / `restore_llm`) and how `/api/comfyui/switchover` drives it.
+   Decide the single owner of the ComfyUI container:
+   - **Option A (preferred if arbiter is real):** route `/restart` + repair + `install_extension` through the
+     arbiter (like `/switchover` does), and demote `comfy-up.sh` to a **manual operator** script only (clearly
+     commented, not called by the API). 
+   - **Option B (if arbiter path is not actually wired for comfyui):** keep `comfy-up.sh` as the one true path and
+     make the arbiter use it / not double-bind :8188.
+   Pick based on step 1's evidence; write the rationale in the PR + a hal0-memory note.
+3. Implement the chosen reconciliation (code-only changes in `comfyui.py` / `installer.py` / `arbiter.py`), with
+   unit tests mocking the chosen mechanism.
+4. **Validate on CT105** (see 0.4 deploy flow): deploy the branch, then exercise `/restart` and a switchover; confirm
+   exactly **one** ComfyUI container exists on :8188 and inference yields/resumes correctly.
+5. Commit `fix(comfyui): single-owner container lifecycle via arbiter (#874)`; record memory.
+
+**Done when:** only one mechanism manages the ComfyUI container; no :8188 clash; verified live on CT105.
+
+---
+
+## 6. Phase 1 — build `ghcr.io/hal0ai/comfyui` (deferred; needs CT105/GPU) 
+
+Only do this when explicitly asked — it was intentionally deferred. Full spec is **Phase 1** of
+`docs/superpowers/plans/2026-06-16-comfyui-platform-integration.md` (Tasks 1.1–1.3). Summary: build a hal0-owned
+ComfyUI server image porting kyuz0's gfx1151 recipe (TheRock ROCm-7 torch wheels pinned by version, launch flags
+`--disable-mmap --bf16-vae --cache-none`, env `TORCH_BLAS_PREFER_HIPBLASLT=1 COMFYUI_ENABLE_MIOPEN=1
+TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL=1`), bake the 11 custom nodes + `hal0_gpu_gate.py`, push to GHCR, pin the
+digest in `manifest.json`. **Build + smoke only run on CT105** (GPU); the smoke test is `tests/comfyui/test_image_smoke.sh`.
+After this lands, #877-I5 (image identity) collapses into "point everything at the new ghcr digest."
+
+---
+
+## 7. Task 6.3 — CT105 live render validation (deferred; needs CT105/GPU)
+
+After the branch is deployed to CT105 (0.4): fetch ONE cheapest model set (`get_esrgan.sh` or
+`get_sdxl.sh --precision fp16`, seconds not hours) via `POST /api/comfyui/models/fetch`, then drive a real render and
+confirm end-to-end: (a) inference slots yield (pane header note appears), (b) progress + preview thumbnail update,
+(c) Cancel works, (d) iGPU returns to inference after idle. Do a **real-browser** pass (Playwright MCP against the
+live dashboard), not just the mocked e2e — a prior lesson: spec-green ≠ works-in-a-real-browser.
+
+---
+
+## Suggested order
+#876 → #877 (I4, I5) → #873 → #875 → #874 → Phase 1 → 6.3.
+(First four are pure code, fast, no CT105. #874/Phase1/6.3 need the GPU box and coordination.)
diff --git a/docs/superpowers/plans/2026-06-16-comfyui-platform-integration.md b/docs/superpowers/plans/2026-06-16-comfyui-platform-integration.md
new file mode 100644
index 00000000..7ec6c297
--- /dev/null
+++ b/docs/superpowers/plans/2026-06-16-comfyui-platform-integration.md
@@ -0,0 +1,378 @@
+# ComfyUI Platform Integration — Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Make ComfyUI a first-class, deterministically-provisioned hal0 platform component (image/video gen) — own image, installer wiring, capability-driven model picker, fully-wired operator pane.
+
+**Architecture:** Build `ghcr.io/hal0ai/comfyui` (port kyuz0 gfx1151 recipe; bake nodes+workflows+gpu_gate). Keep ComfyUI as slot/arbiter-managed `img` runtime (implicit GPU-yield switchover) — NOT a standalone always-on service. Promote to "official" at the **provisioning layer**: ship control scripts + sudoers in-repo, Extensions-registry entry, services/health/repair, capability→model picker. Wire the V2 "Render hero" pane to live ComfyUI APIs + real hal0 telemetry.
+
+**Tech Stack:** Python 3.12 (FastAPI), podman, systemd, ROCm-7 TheRock (gfx1151), ComfyUI, JS/JSX dashboard SPA (ui/), pytest, Playwright.
+
+## Global Constraints
+
+- Base hardware: Strix Halo gfx1151, iGPU + unified memory. ComfyUI = ROCm only.
+- Image identity: `ghcr.io/hal0ai/comfyui`, **digest-pinned** in `manifest.json` `toolbox_images.comfyui`.
+- Launch flags (mandatory): `--disable-mmap --gpu-only --disable-smart-memory --cache-none --bf16-vae`. Port `8188` (hal0 convention; kyuz0 default is 8000 — override).
+- Env (fast path): `TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL=1`, `TORCH_BLAS_PREFER_HIPBLASLT=1`, `COMFYUI_ENABLE_MIOPEN=1`.
+- Model store: `/mnt/ai-models/comfyui/models/<clean-subdir>/` (= `model_store_root()/comfyui`). Writable ZFS bind on CT105. NO `/var/lib/hal0/comfyui/models`.
+- ComfyUI is a seeded, non-deletable `img`-family slot. LLM registry untouched by ComfyUI models.
+- iGPU exclusivity: render enqueue -> arbiter gives ComfyUI GPU -> inference slots yield. Surfaced as header note, never a user toggle.
+- Third-party-official-fix-first: port kyuz0's solved recipe; flag any deviation w/ upstream link.
+- TDD throughout. Frequent commits. Deploy via `scripts/deploy.sh` (rebuilds ui/dist).
+
+---
+
+## Decisions locked (grill 2026-06-16)
+
+1. **B2** — build `ghcr.io/hal0ai/comfyui`, port kyuz0 recipe, bake nodes/workflows/gpu_gate.
+2. Model store `/mnt/ai-models/comfyui/models`, clean names, fix `_comfyui_models_dir`.
+3. **3A** — keep slot/arbiter/gpu-gate lifecycle; "official" = deterministic provisioning.
+4. Capability matrix: txt2img=Qwen-Image-2512+4step; edit=Qwen-Edit-2511+4step; txt2vid/img2vid=LTX-2 default (Wan2.2/Hunyuan quality alts); video-upscale embedded; **+ESRGAN 4× image upscale**; **+SDXL-Lightning fast tier**; defer FLUX.
+5. Model fetch = wrap vendored `get_*.sh`, deferred async pulls, picker records selections.
+6. Pane = ops surface (monitor+control+quick-launch), authoring via `Open ComfyUI ↗`; implicit switchover; live controls.
+7. Test = TDD unit/contract + e2e mock UI + image smoke + CT105 live cheapest-render.
+
+---
+
+## File Structure
+
+**New (repo):**
+- `packaging/toolbox/comfyui.Dockerfile` — hal0 ComfyUI image (FROM rocm-7 base or kyuz0-recipe build).
+- `installer/comfyui/scripts/{enter_imagegen.sh,exit_imagegen.sh,cancel.sh,restart.sh,logs.sh,status.sh}` — the 6 control scripts (currently hand-placed on CT105 only).
+- `installer/comfyui/scripts/{set_extra_paths.sh, get_qwen_image.sh, get_wan22.sh, get_hunyuan15.sh, get_ltx2.sh, get_sdxl.sh, get_esrgan.sh}` — vendored kyuz0 fetchers + 2 new.
+- `installer/comfyui/workflows/*.json` — curated API-format workflows (10 kyuz0 + esrgan + sdxl).
+- `installer/comfyui/extra_model_paths.yaml.tmpl` — 8-key layout, base `/mnt/ai-models/comfyui/models`.
+- `src/hal0/comfyui/__init__.py`, `src/hal0/comfyui/fetch.py` — get_*.sh wrapper -> hal0 job.
+- `src/hal0/comfyui/capabilities.py` — capability→family→variant matrix (the picker source of truth).
+- `tests/comfyui/*` — unit/contract tests.
+- `ui/src/.../ImageGenCard.*` — ported design pane (from Design/design_handoff_comfyui_imagegen/design/).
+
+**Modify:**
+- `src/hal0/install/extensions.py:24-58` — add `comfyui` Extension + install branch.
+- `src/hal0/api/routes/installer.py:419-486` — add comfyui to `_REPAIRABLE_UNITS` + services step.
+- `src/hal0/api/routes/comfyui.py` — point at shipped `/opt/comfyui/*.sh`; un-gate switchover (was 501); add control routes.
+- `src/hal0/registry/pull.py:174` — `_comfyui_models_dir` -> `model_store_root()/comfyui/models`.
+- `src/hal0/registry/curated.py` — add SDXL + ESRGAN curated entries (`comfyui_subdir`,`model_class`).
+- `installer/install.sh` — place `/opt/comfyui/*` scripts + sudoers; comfyui in services start.
+- `packaging/sudoers/hal0-comfyui` — verify cmds match shipped scripts.
+- `manifest.json` — `toolbox_images.comfyui` -> ghcr image (digest via `scripts/update-toolbox-digests.sh`).
+- `installer/etc-hal0/slots/img.toml`, `SEED_PROFILES` (`schema.py:763-770`), `profiles.toml` — profile image -> ghcr.
+- `.github/workflows/` — build+push comfyui image (new job) or document external build.
+
+---
+
+# PHASE 1 — Image (`ghcr.io/hal0ai/comfyui`)
+
+Produces a digest-pinned, reproducible ComfyUI server image w/ baked recipe.
+
+### Task 1.1: Dockerfile — base + ComfyUI + torch wheels
+
+**Files:** Create `packaging/toolbox/comfyui.Dockerfile`; Test `tests/comfyui/test_image_smoke.sh`.
+
+**Interfaces:** Produces image tag `hal0/comfyui:dev`; exposes `:8188`; entrypoint runs ComfyUI w/ Global-Constraints flags+env.
+
+- [ ] **Step 1: Write failing smoke test** `tests/comfyui/test_image_smoke.sh`:
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+IMG="${1:-hal0/comfyui:dev}"
+cid=$(podman run -d --device /dev/dri --device /dev/kfd --group-add video --group-add render \
+  --security-opt seccomp=unconfined -p 18188:8188 "$IMG")
+trap 'podman rm -f "$cid" >/dev/null' EXIT
+for i in $(seq 1 60); do curl -sf localhost:18188/system_stats && break; sleep 2; done
+curl -sf localhost:18188/system_stats | grep -q comfyui_version
+# gpu_gate node loaded:
+podman logs "$cid" 2>&1 | grep -qi "hal0_gpu_gate"
+echo SMOKE_OK
+```
+- [ ] **Step 2: Run -> FAIL** (no image). `bash tests/comfyui/test_image_smoke.sh` -> error pull/run.
+- [ ] **Step 3: Write Dockerfile.** Recipe (port kyuz0 `01-rocm-envs.sh`+`99-toolbox-banner.sh`):
+```dockerfile
+# pin a real digest in CI; rocm-7 gfx1151 base
+FROM rocm/dev-ubuntu-24.04:7.0-complete AS base
+ENV TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL=1 \
+    TORCH_BLAS_PREFER_HIPBLASLT=1 \
+    COMFYUI_ENABLE_MIOPEN=1 \
+    HSA_OVERRIDE_GFX_VERSION=11.5.1
+RUN python3 -m venv /opt/venv
+ENV PATH=/opt/venv/bin:$PATH VIRTUAL_ENV=/opt/venv
+# TheRock gfx1151 nightlies (pin versions in CI, not :latest)
+RUN pip install --index-url https://rocm.nightlies.amd.com/v2-staging/gfx1151 \
+      torch torchvision torchaudio
+RUN git clone --depth 1 https://github.com/comfyanonymous/ComfyUI /opt/ComfyUI
+RUN pip install -r /opt/ComfyUI/requirements.txt transformers==4.56.2 gguf
+# custom nodes (the 11 + gpu_gate baked, Task 1.2)
+WORKDIR /opt/ComfyUI
+EXPOSE 8188
+COPY packaging/toolbox/comfyui-entrypoint.sh /usr/local/bin/comfyui-entrypoint
+ENTRYPOINT ["/usr/local/bin/comfyui-entrypoint"]
+```
+Entrypoint `comfyui-entrypoint.sh`:
+```bash
+#!/usr/bin/env bash
+set -e
+[ -f /opt/comfyui/set_extra_paths.sh ] && /opt/comfyui/set_extra_paths.sh || true
+exec python /opt/ComfyUI/main.py --listen 0.0.0.0 --port 8188 \
+  --disable-mmap --gpu-only --disable-smart-memory --cache-none --bf16-vae
+```
+- [ ] **Step 4: Build + run smoke** `podman build -t hal0/comfyui:dev -f packaging/toolbox/comfyui.Dockerfile . && bash tests/comfyui/test_image_smoke.sh` -> SMOKE_OK (run on CT105, GPU box).
+- [ ] **Step 5: Commit** `feat(comfyui): hal0 ComfyUI image — gfx1151 recipe + flags`.
+
+### Task 1.2: Bake custom nodes (11 + gpu_gate)
+
+**Files:** Modify `comfyui.Dockerfile`; Create `installer/comfyui/custom_nodes/` manifest (reuse existing `hal0_gpu_gate.py`).
+
+- [ ] **Step 1:** Extend smoke test: assert each node dir present via `/object_info` containing gpu-gate + WanVideo + LTXV node classes.
+- [ ] **Step 2:** Run -> FAIL.
+- [ ] **Step 3:** Add to Dockerfile `RUN` block cloning the 11 nodes (pin commits): ComfyUI_essentials, ComfyUI-AMDGPUMonitor, ComfyUI-GGUF, ComfyUI-Manager, ComfyUI-WanVideoWrapper, ComfyUI-VideoHelperSuite, rgthree-comfy, ComfyUI-Model-Manager, ComfyUI-LTXVideo, ComfyUI-Crystools, ComfyUI-Custom-Scripts; `COPY installer/comfyui/custom_nodes/hal0_gpu_gate.py /opt/ComfyUI/custom_nodes/`. Pip-install each node's requirements.txt.
+- [ ] **Step 4:** Rebuild + smoke -> PASS.
+- [ ] **Step 5: Commit** `feat(comfyui): bake 11 custom nodes + gpu_gate`.
+
+### Task 1.3: CI build/push + manifest digest
+
+**Files:** Create `.github/workflows/comfyui-image.yml`; Modify `manifest.json`, `scripts/update-toolbox-digests.sh`.
+
+- [ ] **Step 1:** Test `tests/comfyui/test_manifest.py`: assert `manifest.json toolbox_images.comfyui.image` startswith `ghcr.io/hal0ai/comfyui@sha256:` and digest non-null.
+- [ ] **Step 2:** Run -> FAIL (currently kyuz0 image).
+- [ ] **Step 3:** Add CI job: build comfyui.Dockerfile, push `ghcr.io/hal0ai/comfyui`, capture digest; update `update-toolbox-digests.sh` to include comfyui; set manifest entry.
+- [ ] **Step 4:** Run -> PASS.
+- [ ] **Step 5: Commit** `ci(comfyui): build+push ghcr image, pin digest`.
+
+---
+
+# PHASE 2 — Model store + fetch
+
+### Task 2.1: Reconcile model path
+
+**Files:** Modify `src/hal0/registry/pull.py:174`; Test `tests/registry/test_comfyui_path.py`.
+
+**Interfaces:** Produces `_comfyui_models_dir(subdir) -> Path` = `model_store_root()/comfyui/models/<subdir>`.
+
+- [ ] **Step 1:** Test:
+```python
+def test_comfyui_models_dir_uses_store_root(monkeypatch, tmp_path):
+    monkeypatch.setattr(paths, "model_store_root", lambda: tmp_path)
+    assert pull._comfyui_models_dir("loras") == tmp_path/"comfyui"/"models"/"loras"
+```
+- [ ] **Step 2:** Run -> FAIL (returns `/var/lib/hal0/comfyui/models`).
+- [ ] **Step 3:** Change `_comfyui_models_dir` to derive from `model_store_root()`.
+- [ ] **Step 4:** Run -> PASS.
+- [ ] **Step 5: Commit** `fix(comfyui): model pulls target /mnt/ai-models/comfyui/models`.
+
+### Task 2.2: Capability matrix (picker source of truth)
+
+**Files:** Create `src/hal0/comfyui/capabilities.py`; Test `tests/comfyui/test_capabilities.py`.
+
+**Interfaces:** Produces `CAPABILITIES: dict[str, Capability]`; `Capability(id, label, default_family, alternatives:list[ModelVariant])`; `ModelVariant(family, precision, lora, est_seconds, fetch_script, workflow)`.
+
+- [ ] **Step 1:** Test: `CAPABILITIES["txt2img"].default_family=="qwen-image"`; default variant `est_seconds<=80`; every capability of {txt2img,img2img,txt2video,img2video,image_upscale} present; each variant has a `fetch_script` that exists in `installer/comfyui/scripts/`.
+- [ ] **Step 2:** Run -> FAIL.
+- [ ] **Step 3:** Write matrix per Decision 4 (defaults = 4-step; LTX-2 video default; +sdxl +esrgan).
+- [ ] **Step 4:** Run -> PASS.
+- [ ] **Step 5: Commit** `feat(comfyui): capability→model matrix`.
+
+### Task 2.3: Vendor fetch scripts + 2 new
+
+**Files:** Create `installer/comfyui/scripts/get_*.sh` (vendor 4 kyuz0 + write `get_sdxl.sh`, `get_esrgan.sh`, `set_extra_paths.sh`); Test `tests/comfyui/test_fetch_scripts.py`.
+
+- [ ] **Step 1:** Test: each script `bash -n` clean; `set_extra_paths.sh` emits yaml w/ 8 keys + base `/mnt/ai-models/comfyui/models`; new scripts download to correct subdir (dry-run flag).
+- [ ] **Step 2:** Run -> FAIL.
+- [ ] **Step 3:** Vendor kyuz0 scripts verbatim (cite upstream commit in header); write `get_sdxl.sh` (SDXL base + 8-step Lightning LoRA + sdxl-vae) and `get_esrgan.sh` (4x-UltraSharp + RealESRGAN_x4 -> upscale_models/). Adapt `MODEL_DIR=/mnt/ai-models/comfyui/models`.
+- [ ] **Step 4:** Run -> PASS.
+- [ ] **Step 5: Commit** `feat(comfyui): vendor fetch scripts + sdxl/esrgan`.
+
+### Task 2.4: Fetch wrapper -> hal0 job
+
+**Files:** Create `src/hal0/comfyui/fetch.py`; Test `tests/comfyui/test_fetch.py`.
+
+**Interfaces:** Produces `fetch_model(variant: ModelVariant) -> JobId`; async, progress, cancellable; shells `get_<family>.sh --precision <p>`.
+
+- [ ] **Step 1:** Test (mock subprocess): `fetch_model(variant)` invokes correct script+args, registers a job, streams progress, lands files under store root.
+- [ ] **Step 2:** Run -> FAIL.
+- [ ] **Step 3:** Implement wrapper (reuse hal0 job/registry infra; do NOT route through LLM PullPlan).
+- [ ] **Step 4:** Run -> PASS.
+- [ ] **Step 5: Commit** `feat(comfyui): async model fetch wrapper`.
+
+### Task 2.5: Curated entries (SDXL, ESRGAN)
+
+**Files:** Modify `src/hal0/registry/curated.py`; Test `tests/registry/test_curated_comfyui.py`.
+
+- [ ] **Step 1:** Test: curated catalog includes `sdxl-lightning`, `esrgan-4x` with `model_class=="image"` and correct `comfyui_subdir`.
+- [ ] **Step 2:** Run -> FAIL.
+- [ ] **Step 3:** Add entries.
+- [ ] **Step 4:** Run -> PASS.
+- [ ] **Step 5: Commit** `feat(comfyui): curated sdxl + esrgan`.
+
+---
+
+# PHASE 3 — Installer provisioning (the reliability gap)
+
+### Task 3.1: Ship control scripts
+
+**Files:** Create `installer/comfyui/scripts/{enter_imagegen,exit_imagegen,cancel,restart,logs,status}.sh`; Modify `installer/install.sh`; Test `tests/install/test_comfyui_scripts_shipped.py`.
+
+**Interfaces:** Produces `/opt/comfyui/<name>.sh` placed by install.sh; consumed by `api/routes/comfyui.py` + sudoers.
+
+- [ ] **Step 1:** Test: every script path referenced in `api/routes/comfyui.py` + `packaging/sudoers/hal0-comfyui` exists in `installer/comfyui/scripts/`; `bash -n` clean.
+- [ ] **Step 2:** Run -> FAIL (scripts only on CT105).
+- [ ] **Step 3:** Author the 6 scripts (extract current CT105 copies via `ssh hal0 'cat /opt/comfyui/*.sh'`, sanitize, commit). `enter_imagegen.sh`=arbiter claim GPU + start resident container; `exit_imagegen.sh`=release; `cancel.sh`=`curl :8188/queue -d '{"clear":true}'` + interrupt; etc. Add install.sh block: `install -d /opt/comfyui; install -m0755 installer/comfyui/scripts/*.sh /opt/comfyui/`.
+- [ ] **Step 4:** Run -> PASS.
+- [ ] **Step 5: Commit** `feat(comfyui): ship switchover control scripts in-repo`.
+
+### Task 3.2: Sudoers + extra_model_paths placement
+
+**Files:** Modify `installer/install.sh`, `packaging/sudoers/hal0-comfyui`; Test `tests/install/test_comfyui_sudoers.py`.
+
+- [ ] **Step 1:** Test: install.sh contains `install -m0440 packaging/sudoers/hal0-comfyui /etc/sudoers.d/`; sudoers cmd paths == shipped script paths; `visudo -cf` clean.
+- [ ] **Step 2:** Run -> FAIL.
+- [ ] **Step 3:** Add install.sh lines (sudoers + render extra_model_paths.yaml from tmpl to `/mnt/ai-models/comfyui/extra_model_paths.yaml`).
+- [ ] **Step 4:** Run -> PASS.
+- [ ] **Step 5: Commit** `feat(comfyui): install sudoers + extra_model_paths`.
+
+### Task 3.3: Extensions registry entry
+
+**Files:** Modify `src/hal0/install/extensions.py:24-58`; Test `tests/install/test_extensions_comfyui.py`.
+
+**Interfaces:** Consumes `Extension`; Produces `comfyui` extension (kind `app`, default on) + install branch (`hal0 capability apply image` / slot ensure, NOT systemctl-only).
+
+- [ ] **Step 1:** Test: `comfyui` in `EXTENSIONS`; `install_extension("comfyui")` ensures img slot + container present (mock).
+- [ ] **Step 2:** Run -> FAIL.
+- [ ] **Step 3:** Add Extension + branch (image slot is seeded; branch ensures resident container + extra_paths). 
+- [ ] **Step 4:** Run -> PASS.
+- [ ] **Step 5: Commit** `feat(comfyui): extensions-registry entry`.
+
+### Task 3.4: Services step + repair allowlist
+
+**Files:** Modify `src/hal0/api/routes/installer.py:419-486`, `services_health.py`; Test `tests/api/test_services_comfyui.py`.
+
+- [ ] **Step 1:** Test: `GET /api/install/services` includes comfyui dot; comfyui in `_REPAIRABLE_UNITS`; repair restarts resident container (mock).
+- [ ] **Step 2:** Run -> FAIL.
+- [ ] **Step 3:** Add comfyui to services step + repair (repair = `/opt/comfyui/restart.sh`, not systemctl).
+- [ ] **Step 4:** Run -> PASS.
+- [ ] **Step 5: Commit** `feat(comfyui): installer services step + repair`.
+
+### Task 3.5: Picker integration (capability matrix in setup)
+
+**Files:** Modify `src/hal0/cli/setup_ui.py`, `setup_command.py`, `api/routes/installer.py` (curated-models), `install/orchestrate.py`; Test `tests/install/test_picker_comfyui.py`.
+
+**Interfaces:** Consumes `CAPABILITIES` (2.2); Produces selections recorded (no pull at install, `--no-pull`); auto-mode picks best 4-step per enabled capability.
+
+- [ ] **Step 1:** Test: auto selections cover all 5 capabilities w/ default variants; interactive `_choose_model` lists alternatives w/ est_seconds; selections persisted, NOT pulled.
+- [ ] **Step 2:** Run -> FAIL.
+- [ ] **Step 3:** Wire matrix into picker (TUI + `/curated-models` + auto build). Post-install: expose `POST /api/comfyui/models/fetch` to trigger deferred pulls (uses 2.4).
+- [ ] **Step 4:** Run -> PASS.
+- [ ] **Step 5: Commit** `feat(comfyui): install-time capability model picker`.
+
+---
+
+# PHASE 4 — API: control + monitoring
+
+### Task 4.1: Un-gate switchover + control routes
+
+**Files:** Modify `src/hal0/api/routes/comfyui.py`; Test `tests/api/test_comfyui_routes.py`.
+
+**Interfaces:** Produces `POST /api/comfyui/render/cancel`, `/restart`, `GET /logs`, existing `/status`; switchover implicit (enqueue triggers arbiter; no manual toggle route).
+
+- [ ] **Step 1:** Test: cancel -> calls `/opt/comfyui/cancel.sh` (mock); restart -> restart.sh; status aggregates ComfyUI `/queue`+`/system_stats`; no 501.
+- [ ] **Step 2:** Run -> FAIL (switchover 501).
+- [ ] **Step 3:** Implement routes against shipped scripts; status reads ComfyUI `/queue`,`/history`,`/system_stats`.
+- [ ] **Step 4:** Run -> PASS.
+- [ ] **Step 5: Commit** `feat(comfyui): live control routes, un-gate switchover`.
+
+### Task 4.2: Telemetry contract (real signals)
+
+**Files:** Modify `src/hal0/api/routes/comfyui.py` (status payload); Test same.
+
+**Interfaces:** Produces `status.telemetry = {gtt_used,gtt_total,ram_used,ram_total,util,temp,clock,it_s,eta}`. GTT/RAM/temp/clock from hal0 real telemetry; util NOT raw `gpu_busy_percent` (forced-high artifact) — derive from active-job + duty signals; it_s/eta from ComfyUI ws progress.
+
+- [ ] **Step 1:** Test: payload has all keys; util not hardcoded 100 when idle (use job-presence gate).
+- [ ] **Step 2:** Run -> FAIL.
+- [ ] **Step 3:** Implement; reuse existing hal0 GPU telemetry helpers; gate util on render-active.
+- [ ] **Step 4:** Run -> PASS.
+- [ ] **Step 5: Commit** `feat(comfyui): real-telemetry status payload`.
+
+### Task 4.3: Quick-launch + preview proxy
+
+**Files:** Modify `comfyui.py`; Test same.
+
+**Interfaces:** Produces `POST /api/comfyui/workflows/{id}/launch` (fire curated workflow w/ defaults -> ComfyUI `/prompt`); `GET /api/comfyui/preview` (proxy ComfyUI `/view` latest output).
+
+- [ ] **Step 1:** Test: launch posts workflow json to `/prompt` (mock); preview proxies latest `/history` image bytes.
+- [ ] **Step 2:** Run -> FAIL.
+- [ ] **Step 3:** Implement (workflows from baked `/opt/comfy-workflows/`).
+- [ ] **Step 4:** Run -> PASS.
+- [ ] **Step 5: Commit** `feat(comfyui): quick-launch + preview proxy`.
+
+---
+
+# PHASE 5 — Pane UI (V2 Render hero)
+
+Port `Design/design_handoff_comfyui_imagegen/design/` into ui/. Component reads `RUN/QUEUE/GTT/RAM/STATS` objects (handoff §Integration).
+
+### Task 5.1: Port ImageGenCard + comfy.css (mock data)
+
+**Files:** Create `ui/src/pages/slots/ImageGenCard.jsx`, `comfy.css`, `comfy-core.jsx`; Test `ui/tests/e2e/imagegen.spec.ts` (forced-mock).
+
+- [ ] **Step 1:** e2e test (mock): card renders render-hero + queue + telemetry + workflows strip + footer; reduced-motion freezes pulse; empty-queue state has no overlay (recall #845 lockup).
+- [ ] **Step 2:** Run -> FAIL.
+- [ ] **Step 3:** Port jsx/css; scope under `.comfy-page`; mock fixture matches handoff demo data.
+- [ ] **Step 4:** Run -> PASS (`npx playwright test imagegen`).
+- [ ] **Step 5: Commit** `feat(ui): ImageGen V2 render-hero pane (mock)`.
+
+### Task 5.2: Bind to live API
+
+**Files:** Modify `comfy-core.jsx` (data hooks), slots page mount; Test e2e live-shaped mock.
+
+**Interfaces:** Consumes 4.1/4.2/4.3 routes. RUN<-status.active; QUEUE<-status.queue; GTT/RAM/STATS<-status.telemetry; preview<-/preview.
+
+- [ ] **Step 1:** Test: controls fire correct endpoints (route intercept asserts); progress/queue/telemetry bind; cancel disables while pending.
+- [ ] **Step 2:** Run -> FAIL.
+- [ ] **Step 3:** Wire fetch hooks (900ms tick), control handlers, preview img.
+- [ ] **Step 4:** Run -> PASS.
+- [ ] **Step 5: Commit** `feat(ui): wire ImageGen pane to live ComfyUI API`.
+
+---
+
+# PHASE 6 — Integration, deploy, docs
+
+### Task 6.1: Profile/manifest -> ghcr image
+
+**Files:** Modify `schema.py:763-770` SEED_PROFILES, `installer/etc-hal0/profiles.toml`, `slots/img.toml`, `manifest.json`; Test `tests/config/test_comfyui_profile.py`.
+
+- [ ] **Step 1:** Test: comfyui profile image == ghcr digest; img.toml profile==comfyui, port 8188, device gpu-rocm.
+- [ ] **Step 2:** Run -> FAIL.
+- [ ] **Step 3:** Update all 4 (+ live CT105 `/etc/hal0/profiles.toml` per memory note — deploy.sh won't sync it).
+- [ ] **Step 4:** Run -> PASS.
+- [ ] **Step 5: Commit** `feat(comfyui): point profile/manifest at ghcr image`.
+
+### Task 6.2: Full pytest + e2e + lint
+
+- [ ] Run `PYTHONPATH=src pytest tests/comfyui tests/install tests/api tests/registry tests/config -v` -> all pass (CT132 box or CI; whole-suite hangs locally per memory).
+- [ ] Run `cd ui && npx playwright test imagegen` -> pass.
+- [ ] `ruff format --check` (NOT black). Commit fixes.
+
+### Task 6.3: CT105 live validation (cheapest render)
+
+**Tier-3 (verify-then-act): another session may hold /opt/hal0 — run `wip hal0 status` first; deploy to PREVIEW ref, not main.**
+
+- [ ] `wip hal0 status` clean; `wip hal0 claim "comfyui integration deploy" /opt/hal0`.
+- [ ] Build+push ghcr comfyui image; refresh digest.
+- [ ] `ssh hal0 'cd /opt/hal0 && sudo bash scripts/deploy.sh --ref origin/<branch>'`.
+- [ ] Fetch ONE cheapest model set (ESRGAN or SDXL-Lightning) via `/api/comfyui/models/fetch`.
+- [ ] Real-browser pass (Playwright MCP, not just spec — recall durability lesson): enqueue render -> verify (a) inference slots yield (header note), (b) progress/preview update, (c) cancel works, (d) GPU released after idle.
+- [ ] Capture results; `wip hal0 release`.
+
+### Task 6.4: Docs + memory
+
+- [ ] `hal0-docs` skill: add ComfyUI image-gen page (capabilities, picker, flags, model store).
+- [ ] Update README/PLAN + hal0-web CONTENT_BRIEF (recall docs-after-shipping rule).
+- [ ] `hal0-memory` `memory_add`: integration decisions + gotchas (image recipe, path reconcile, switchover) dataset `shared`, `document_id=comfyui-platform-integration`.
+
+---
+
+## Self-Review
+
+- **Spec coverage:** installer-official ✓(P3); kyuz0 recipe/image ✓(P1); extensions config ✓(3.3); templates baked ✓(1.2,2.3); model picker every capability ✓(2.2,3.5); set_extra_paths ✓(2.3); model_manager→wrapped fetch ✓(2.4); benchmark model choices+adds ✓(Decision 4); launch flags ✓(GC,1.1); pane wired+controls+monitoring ✓(P4,P5); testing ✓(P6).
+- **Placeholders:** none — fetch script bodies vendored verbatim at exec time (cite upstream); CT105 script extraction is a real step (6.3/3.1).
+- **Type consistency:** `ModelVariant`/`Capability` (2.2) consumed by fetch (2.4) + picker (3.5); `status.telemetry` keys (4.2) consumed by UI (5.2); control script paths single-sourced `installer/comfyui/scripts/` (3.1) consumed by sudoers (3.2)+routes (4.1).
+- **Open risk:** TheRock nightly wheel pinning — must pin exact versions in CI (1.1) or builds drift; flagged upstream WIP.
diff --git a/installer/comfyui/extra_model_paths.yaml b/installer/comfyui/extra_model_paths.yaml
new file mode 100644
index 00000000..e7573811
--- /dev/null
+++ b/installer/comfyui/extra_model_paths.yaml
@@ -0,0 +1,15 @@
+comfyui:
+    base_path: /root/comfy-models
+    checkpoints: checkpoints
+    diffusion_models: diffusion_models
+    unet: unet
+    text_encoders: text_encoders
+    clip: clip
+    clip_vision: clip_vision
+    vae: vae
+    loras: loras
+    controlnet: controlnet
+    upscale_models: upscale_models
+    latent_upscale_models: latent_upscale_models
+    embeddings: embeddings
+    style_models: style_models
diff --git a/installer/comfyui/scripts/comfy-down.sh b/installer/comfyui/scripts/comfy-down.sh
new file mode 100755
index 00000000..f18bd8e7
--- /dev/null
+++ b/installer/comfyui/scripts/comfy-down.sh
@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -euo pipefail
+docker stop comfyui >/dev/null 2>&1 && echo "[comfy-down] stopped" || echo "[comfy-down] not running"
diff --git a/installer/comfyui/scripts/comfy-logs.sh b/installer/comfyui/scripts/comfy-logs.sh
new file mode 100755
index 00000000..6ae1c15f
--- /dev/null
+++ b/installer/comfyui/scripts/comfy-logs.sh
@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+docker logs --tail "${1:-60}" -f comfyui
diff --git a/installer/comfyui/scripts/comfy-postinstall.sh b/installer/comfyui/scripts/comfy-postinstall.sh
new file mode 100755
index 00000000..d9145291
--- /dev/null
+++ b/installer/comfyui/scripts/comfy-postinstall.sh
@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+# Reinstall custom-node Python deps into the container venv.
+# WHY: node *code* lives on the mounted custom_nodes (persistent), but node *deps*
+# live in the container's /opt/venv (ephemeral). After any `docker rm` + recreate
+# the deps are gone and the added nodes fail to import. comfy-up.sh runs this
+# automatically on a fresh create; run it by hand if you ever recreate manually
+# or add nodes via the Manager UI and want them to survive a recreate.
+set -uo pipefail
+NAME=comfyui
+if ! docker ps --format '{{.Names}}' | grep -qx "$NAME"; then
+  echo "[comfy-postinstall] container '$NAME' not running — start it first (comfy-up.sh)"; exit 1
+fi
+docker exec "$NAME" bash /root/comfy-models/.node-install.sh
+echo "[comfy-postinstall] node deps reinstalled"
diff --git a/installer/comfyui/scripts/comfy-up.sh b/installer/comfyui/scripts/comfy-up.sh
new file mode 100755
index 00000000..a6700cc7
--- /dev/null
+++ b/installer/comfyui/scripts/comfy-up.sh
@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+# Launch (or resume) the ComfyUI container on hal0 iGPU (gfx1151).
+# - Image is DIGEST-PINNED for reproducibility (a re-pull can't silently change the build).
+#   To update: pull a new tag, then replace the @sha256 below with its RepoDigest.
+# - --restart no: does NOT auto-start on boot, so it never contends with Lemonade at boot.
+#   (After a CT reboot, run this script to bring ComfyUI back up.)
+# - On a FRESH create it self-heals node deps (which live in the ephemeral container venv).
+set -euo pipefail
+IMG=docker.io/kyuz0/amd-strix-halo-comfyui@sha256:0066678ae9043f69a1c8c7699e70626ceffd35c1a8ca03227a05640ad0241ed2
+NAME=comfyui
+ROOT=/mnt/ai-models/comfyui
+if docker ps -a --format "{{.Names}}" | grep -qx "$NAME"; then
+  docker start "$NAME" >/dev/null && echo "[comfy-up] resumed existing container"
+else
+  docker run -d --name "$NAME" --restart no \
+    --device /dev/kfd --device /dev/dri \
+    --group-add video --group-add render \
+    --security-opt apparmor=unconfined --security-opt seccomp=unconfined \
+    --ipc=host --shm-size=8g \
+    -p 8188:8188 \
+    -v "$ROOT/models":/root/comfy-models \
+    -v "$ROOT/output":/opt/ComfyUI/output \
+    -v "$ROOT/input":/opt/ComfyUI/input \
+    -v "$ROOT/user":/opt/ComfyUI/user \
+    -v "$ROOT/custom_nodes":/opt/ComfyUI/custom_nodes \
+    -v "$ROOT/extra_model_paths.yaml":/opt/ComfyUI/extra_model_paths.yaml:ro \
+    --entrypoint bash "$IMG" \
+    -lc "cd /opt/ComfyUI && exec python main.py --listen 0.0.0.0 --port 8188 --disable-mmap --bf16-vae --cache-none" >/dev/null
+  echo "[comfy-up] created container — waiting for it, then installing custom-node deps (fresh venv)…"
+  for i in $(seq 1 40); do [ "$(curl -s -o /dev/null -w "%{http_code}" http://127.0.0.1:8188/ 2>/dev/null)" = "200" ] && break; sleep 3; done
+  if /opt/comfyui/comfy-postinstall.sh; then
+    docker restart "$NAME" >/dev/null && echo "[comfy-up] node deps installed; restarted to load them"
+  else
+    echo "[comfy-up] WARN: postinstall failed — run /opt/comfyui/comfy-postinstall.sh then 'docker restart comfyui'"
+  fi
+fi
+echo "[comfy-up] ComfyUI → http://$(hostname -I | awk '{print $1}'):8188   (logs: /opt/comfyui/comfy-logs.sh)"
diff --git a/installer/comfyui/scripts/get_esrgan.sh b/installer/comfyui/scripts/get_esrgan.sh
new file mode 100755
index 00000000..6d9ae33e
--- /dev/null
+++ b/installer/comfyui/scripts/get_esrgan.sh
@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+# get_esrgan.sh — download ESRGAN upscale models for ComfyUI
+# Targets: upscale_models/4x-UltraSharp.pth + upscale_models/RealESRGAN_x4plus.pth
+# hal0 model store: /mnt/ai-models/comfyui/models
+# Follows kyuz0 vendored-script conventions (curl download, dry-run).
+set -euo pipefail
+
+MODEL_DIR="${MODEL_DIR:-/mnt/ai-models/comfyui/models}"
+DRY_RUN=0
+
+for arg in "$@"; do
+  case "$arg" in
+    --dry-run) DRY_RUN=1 ;;
+  esac
+done
+
+if [[ "$DRY_RUN" -eq 1 ]]; then
+  echo "[dry-run] MODEL_DIR=$MODEL_DIR"
+  echo "[dry-run] Would download to:"
+  echo "  upscale_models/  4x-UltraSharp.pth"
+  echo "  upscale_models/  RealESRGAN_x4plus.pth"
+  exit 0
+fi
+
+mkdir -p "$MODEL_DIR/upscale_models"
+
+download_if_missing() {
+  local url="$1"
+  local dest_file="$MODEL_DIR/upscale_models/$(basename "$url")"
+
+  if [[ -f "$dest_file" ]]; then
+    echo "✓ Already present: $dest_file"
+    return
+  fi
+
+  echo "↓ Downloading $(basename "$url") → $dest_file"
+  curl -fL --progress-bar -o "$dest_file" "$url"
+}
+
+# 4x-UltraSharp (widely used ESRGAN upscale model)
+download_if_missing \
+  "https://huggingface.co/Kim2091/4x-UltraSharp/resolve/main/4x-UltraSharp.pth"
+
+# RealESRGAN x4plus (xinntao/Real-ESRGAN official release)
+download_if_missing \
+  "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth"
+
+echo "✓ ESRGAN models ready in $MODEL_DIR/upscale_models"
diff --git a/installer/comfyui/scripts/get_hunyuan15.sh b/installer/comfyui/scripts/get_hunyuan15.sh
new file mode 100755
index 00000000..64981b12
--- /dev/null
+++ b/installer/comfyui/scripts/get_hunyuan15.sh
@@ -0,0 +1,136 @@
+#!/usr/bin/env bash
+# get_hunyuan15.sh (resume-friendly)
+# Downloads models for ComfyUI HunyuanVideo 1.5 (T2V & I2V)
+# Vendored from https://raw.githubusercontent.com/kyuz0/amd-strix-halo-comfyui-toolboxes/main/scripts/get_hunyuan15.sh
+# vendored 2026-06-16 — adapted: MODEL_DIR defaults to /mnt/ai-models/comfyui/models (hal0 store)
+set -euo pipefail
+
+export HF_HUB_ENABLE_HF_TRANSFER=1
+export HF_HOME="${HF_HOME:-$HOME/.cache/huggingface}"
+HF="/opt/venv/bin/hf"
+
+MODEL_DIR="${MODEL_DIR:-/mnt/ai-models/comfyui/models}"
+STAGE="$MODEL_DIR/.hf_stage_hunyuan15"
+
+# Repositories
+REPO_MAIN="Comfy-Org/HunyuanVideo_1.5_repackaged"
+REPO_VISION="Comfy-Org/sigclip_vision_384"
+
+# Ensure directories exist
+mkdir -p "$MODEL_DIR"/{text_encoders,vae,diffusion_models,clip_vision,latent_upscale_models,loras}
+mkdir -p "$STAGE"
+
+download_if_missing () {
+  local repo="$1"
+  local remote="$2"
+  local dest_path="$3"
+
+  local dest_dir="$MODEL_DIR/$dest_path"
+  local dest_file="$dest_dir/$(basename "$remote")"
+  local staged="$STAGE/$remote"
+
+  if [[ -f "$dest_file" ]]; then
+    echo "✓ Already present: $dest_file"
+    return
+  fi
+
+  echo "↓ Downloading $(basename "$remote") → $dest_file"
+  mkdir -p "$(dirname "$staged")"
+  mkdir -p "$dest_dir"
+
+  "$HF" download "$repo" "$remote" \
+      --repo-type model \
+      --cache-dir "$HF_HOME" \
+      --local-dir "$STAGE"
+  mv -f "$staged" "$dest_file"
+}
+
+usage() {
+  cat <<'USAGE'
+Usage: get_hunyuan15.sh <target>
+
+Targets:
+  common     Text Encoders, VAE, CLIP Vision (Shared dependencies)
+             - text_encoders/qwen_2.5_vl_7b_fp8_scaled.safetensors
+             - text_encoders/byt5_small_glyphxl_fp16.safetensors
+             - vae/hunyuanvideo15_vae_fp16.safetensors
+             - clip_vision/sigclip_vision_patch14_384.safetensors (Only for I2V)
+
+  720p-t2v   Text-to-Video Model (FP16)
+             - diffusion_models/hunyuanvideo1.5_720p_t2v_fp16.safetensors
+
+  720p-i2v   Image-to-Video Model (FP16)
+             - diffusion_models/hunyuanvideo1.5_720p_i2v_fp16.safetensors
+
+  upscale    Upscaling Models (1080p SR + Latent Upsampler)
+             - diffusion_models/hunyuanvideo1.5_1080p_sr_distilled_fp16.safetensors
+             - latent_upscale_models/hunyuanvideo15_latent_upsampler_1080p.safetensors
+
+  lora       HunyuanVideo 1.5 LoRAs
+             - loras/hunyuanvideo1.5_t2v_480p_lightx2v_4step_lora_rank_32_bf16.safetensors
+
+  all        Download EVERYTHING (T2V, I2V, Upscale, LoRA, Common)
+
+Maintenance:
+  clean-stage   Remove staging folder (keeps final models)
+  clean-cache   Remove Hugging Face cache (~/.cache/huggingface)
+
+USAGE
+}
+
+case "${1:-}" in
+  common)
+    echo "==> Text Encoders, VAE, & CLIP Vision"
+    download_if_missing "$REPO_MAIN" "split_files/text_encoders/qwen_2.5_vl_7b_fp8_scaled.safetensors" "text_encoders"
+    download_if_missing "$REPO_MAIN" "split_files/text_encoders/byt5_small_glyphxl_fp16.safetensors" "text_encoders"
+    download_if_missing "$REPO_MAIN" "split_files/vae/hunyuanvideo15_vae_fp16.safetensors" "vae"
+    download_if_missing "$REPO_VISION" "sigclip_vision_patch14_384.safetensors" "clip_vision"
+    ;;
+
+  720p-t2v)
+    echo "==> 720p Text-to-Video Model"
+    download_if_missing "$REPO_MAIN" "split_files/diffusion_models/hunyuanvideo1.5_720p_t2v_fp16.safetensors" "diffusion_models"
+    ;;
+
+  720p-i2v)
+    echo "==> 720p Image-to-Video Model"
+    download_if_missing "$REPO_MAIN" "split_files/diffusion_models/hunyuanvideo1.5_720p_i2v_fp16.safetensors" "diffusion_models"
+    ;;
+
+  upscale)
+    echo "==> 1080p Upscaling Models"
+    download_if_missing "$REPO_MAIN" "split_files/diffusion_models/hunyuanvideo1.5_1080p_sr_distilled_fp16.safetensors" "diffusion_models"
+    download_if_missing "$REPO_MAIN" "split_files/latent_upscale_models/hunyuanvideo15_latent_upsampler_1080p.safetensors" "latent_upscale_models"
+    ;;
+
+  lora)
+    echo "==> HunyuanVideo 1.5 LoRAs"
+    download_if_missing "$REPO_MAIN" "split_files/loras/hunyuanvideo1.5_t2v_480p_lightx2v_4step_lora_rank_32_bf16.safetensors" "loras"
+    ;;
+
+  all)
+    echo "==> Downloading Full Suite (T2V + I2V + Upscale + LoRA)..."
+    "$0" common
+    "$0" 720p-t2v
+    "$0" 720p-i2v
+    "$0" upscale
+    "$0" lora
+    ;;
+
+  clean-stage)
+    rm -rf "$STAGE"; echo "✓ Removed stage: $STAGE"
+    ;;
+  clean-cache)
+    rm -rf "$HF_HOME"; echo "✓ Removed HF cache: $HF_HOME"
+    ;;
+  ""|-h|--help|help)
+    usage
+    ;;
+  *)
+    echo "Unknown target: $1" >&2
+    usage
+    exit 1
+    ;;
+esac
+
+echo "✓ Done."
diff --git a/installer/comfyui/scripts/get_ltx2.sh b/installer/comfyui/scripts/get_ltx2.sh
new file mode 100755
index 00000000..8cf31bbb
--- /dev/null
+++ b/installer/comfyui/scripts/get_ltx2.sh
@@ -0,0 +1,107 @@
+#!/usr/bin/env bash
+# get_ltx2.sh (resume-friendly)
+# Vendored from https://raw.githubusercontent.com/kyuz0/amd-strix-halo-comfyui-toolboxes/main/scripts/get_ltx2.sh
+# vendored 2026-06-16 — adapted: MODEL_DIR defaults to /mnt/ai-models/comfyui/models (hal0 store)
+set -euo pipefail
+
+export HF_HUB_ENABLE_HF_TRANSFER=1
+export HF_HOME="${HF_HOME:-$HOME/.cache/huggingface}"   # persistent HF cache
+HF="/opt/venv/bin/hf"
+
+MODEL_DIR="${MODEL_DIR:-/mnt/ai-models/comfyui/models}"
+STAGE="$MODEL_DIR/.hf_stage_ltx2"                     # persistent staging (enables resume)
+
+mkdir -p "$MODEL_DIR"/{checkpoints,text_encoders,loras,latent_upscale_models}
+mkdir -p "$STAGE"
+
+download_if_missing () {
+  local repo="$1"
+  local remote="$2"
+  local dest_path="$3"  # Relative path under MODEL_DIR, e.g., "text_encoders"
+
+  local dest_dir="$MODEL_DIR/$dest_path"
+  local dest_file="$dest_dir/$(basename "$remote")"
+  local staged="$STAGE/$remote"
+
+  if [[ -f "$dest_file" ]]; then
+    echo "✓ Already present: $dest_file"
+    return
+  fi
+
+  echo "↓ Downloading $(basename "$remote") → $dest_file"
+  mkdir -p "$(dirname "$staged")"        # ensure stage path exists
+  mkdir -p "$dest_dir"                   # ensure dest dir exists
+
+  "$HF" download "$repo" "$remote" \
+      --repo-type model \
+      --cache-dir "$HF_HOME" \
+      --local-dir "$STAGE"
+  mv -f "$staged" "$dest_file"
+}
+
+usage() {
+  cat <<'USAGE'
+Usage: get_ltx2.sh <target> [variant]
+
+Targets:
+  common       Text encoder (Gemma 3) + Spatial Upscaler
+  checkpoint   LTX-2 19B Checkpoint (Default: BF16. Use 'fp8' as 2nd arg for FP8)
+  lora         Distilled LoRA + Camera Control LoRA
+
+Maintenance:
+  clean-stage   Remove staging folder (keeps final models)
+  clean-cache   Remove Hugging Face cache (~/.cache/huggingface)
+
+Notes:
+- Downloads RESUME automatically via persistent --cache-dir and --local-dir.
+USAGE
+}
+
+case "${1:-}" in
+  common)
+    echo "==> Text Encoder + Spatial Upscaler"
+    # Text Encoder: Gemma 3 12B IT FP4 Mixed
+    download_if_missing "Comfy-Org/ltx-2" "split_files/text_encoders/gemma_3_12B_it_fp4_mixed.safetensors" "text_encoders"
+
+    # Spatial Upscaler x2
+    download_if_missing "Lightricks/LTX-2" "ltx-2-spatial-upscaler-x2-1.0.safetensors" "latent_upscale_models"
+    ;;
+
+  checkpoint)
+    VARIANT="${2:-bf16}"
+    echo "==> LTX-2 19B Checkpoint ($VARIANT)"
+
+    if [[ "$VARIANT" == "fp8" ]]; then
+        download_if_missing "Lightricks/LTX-2" "ltx-2-19b-dev-fp8.safetensors" "checkpoints"
+    else
+        # Default / BF16
+        download_if_missing "Lightricks/LTX-2" "ltx-2-19b-dev.safetensors" "checkpoints"
+    fi
+    ;;
+
+  lora)
+    echo "==> LTX-2 LoRAs"
+    # Distilled LoRA
+    download_if_missing "Lightricks/LTX-2" "ltx-2-19b-distilled-lora-384.safetensors" "loras"
+
+    # Camera Control LoRA
+    download_if_missing "Lightricks/LTX-2-19b-LoRA-Camera-Control-Dolly-Left" "ltx-2-19b-lora-camera-control-dolly-left.safetensors" "loras"
+    ;;
+
+  clean-stage)
+    rm -rf "$STAGE"; echo "✓ Removed stage: $STAGE"
+    ;;
+  clean-cache)
+    rm -rf "$HF_HOME"; echo "✓ Removed HF cache: $HF_HOME"
+    ;;
+  ""|-h|--help|help)
+    usage
+    ;;
+  *)
+    echo "Unknown target: $1" >&2
+    usage
+    exit 1
+    ;;
+esac
+
+echo "✓ Done."
diff --git a/installer/comfyui/scripts/get_qwen_image.sh b/installer/comfyui/scripts/get_qwen_image.sh
new file mode 100755
index 00000000..014dc199
--- /dev/null
+++ b/installer/comfyui/scripts/get_qwen_image.sh
@@ -0,0 +1,98 @@
+#!/usr/bin/env bash
+# get_qwen_image.sh (resume-friendly, supports Qwen Image + Qwen Image Edit)
+# Vendored from https://raw.githubusercontent.com/kyuz0/amd-strix-halo-comfyui-toolboxes/main/scripts/get_qwen_image.sh
+# vendored 2026-06-16 — adapted: MODEL_DIR defaults to /mnt/ai-models/comfyui/models (hal0 store)
+set -euo pipefail
+
+export HF_HUB_ENABLE_HF_TRANSFER=1
+export HF_HOME="${HF_HOME:-$HOME/.cache/huggingface}"   # persistent HF cache
+HF="/opt/venv/bin/hf"
+
+MODEL_DIR="${MODEL_DIR:-/mnt/ai-models/comfyui/models}"
+STAGE="$MODEL_DIR/.hf_stage_qwen"                      # persistent staging (resume support)
+
+mkdir -p "$MODEL_DIR"/{text_encoders,vae,diffusion_models,loras}
+mkdir -p "$STAGE"
+
+dl() {
+  local repo="$1"; shift
+  local remote="$1"; shift
+  local subdir="$1"; shift
+  local dest="$MODEL_DIR/$subdir/$(basename "$remote")"
+  local staged="$STAGE/$remote"
+
+  if [[ -f "$dest" ]]; then
+    echo "✓ Already present: $dest"
+    return
+  fi
+
+  echo "↓ Downloading $(basename "$remote") → $dest"
+  mkdir -p "$(dirname "$staged")"
+  "$HF" download "$repo" "$remote" \
+      --repo-type model \
+      --cache-dir "$HF_HOME" \
+      --local-dir "$STAGE"
+  mv -f "$staged" "$dest"
+}
+
+echo "Which Qwen variant do you want to download?"
+echo "  1) Qwen-Image 2512 (20B text-to-image)"
+echo "  2) Qwen-Image-Edit 2511 (image editing)"
+echo "  3) Qwen-Image-Lightning LoRA (4-steps)"
+echo "  4) Qwen-Image-Edit-Lightning LoRA (4-steps, bf16)"
+
+# Check if an argument is provided
+if [ -n "${1:-}" ]; then
+  choice="$1"
+else
+  read -rp "Enter 1, 2, 3 or 4: " choice
+fi
+
+PRECISION="fp8"
+if [[ "${2:-}" == "bf16" ]]; then
+  PRECISION="bf16"
+fi
+
+case "$choice" in
+  1)
+    REPO="Comfy-Org/Qwen-Image_ComfyUI"
+    echo "==> Downloading Qwen-Image 2512 (20B) - $PRECISION"
+    if [[ "$PRECISION" == "bf16" ]]; then
+         dl "$REPO" "split_files/diffusion_models/qwen_image_2512_bf16.safetensors" "diffusion_models"
+    else
+         dl "$REPO" "split_files/diffusion_models/qwen_image_2512_fp8_e4m3fn.safetensors" "diffusion_models"
+    fi
+    dl "$REPO" "split_files/text_encoders/qwen_2.5_vl_7b_fp8_scaled.safetensors" "text_encoders"
+    dl "$REPO" "split_files/vae/qwen_image_vae.safetensors" "vae"
+    ;;
+  2)
+    REPO="Comfy-Org/Qwen-Image-Edit_ComfyUI"
+    echo "==> Downloading Qwen-Image-Edit - $PRECISION"
+    # Requires text encoder + VAE from Qwen-Image
+    BASE="Comfy-Org/Qwen-Image_ComfyUI"
+    dl "$BASE" "split_files/text_encoders/qwen_2.5_vl_7b_fp8_scaled.safetensors" "text_encoders"
+    dl "$BASE" "split_files/vae/qwen_image_vae.safetensors" "vae"
+
+    if [[ "$PRECISION" == "bf16" ]]; then
+        dl "$REPO" "split_files/diffusion_models/qwen_image_edit_2511_bf16.safetensors" "diffusion_models"
+    else
+        dl "$REPO" "split_files/diffusion_models/qwen_image_edit_2511_fp8mixed.safetensors" "diffusion_models"
+    fi
+    ;;
+  3)
+    REPO="lightx2v/Qwen-Image-2512-Lightning"
+    echo "==> Downloading Qwen-Image-2512-Lightning LoRA"
+    dl "$REPO" "Qwen-Image-2512-Lightning-4steps-V1.0-bf16.safetensors" "loras"
+    ;;
+  4)
+    REPO="lightx2v/Qwen-Image-Edit-2511-Lightning"
+    echo "==> Downloading Qwen-Image-Edit-Lightning LoRA"
+    dl "$REPO" "Qwen-Image-Edit-2511-Lightning-4steps-V1.0-bf16.safetensors" "loras"
+    ;;
+  *)
+    echo "Invalid choice. Exiting."
+    exit 1
+    ;;
+esac
+
+echo "✓ Models ready in $MODEL_DIR"
diff --git a/installer/comfyui/scripts/get_sdxl.sh b/installer/comfyui/scripts/get_sdxl.sh
new file mode 100755
index 00000000..69d41cb5
--- /dev/null
+++ b/installer/comfyui/scripts/get_sdxl.sh
@@ -0,0 +1,86 @@
+#!/usr/bin/env bash
+# get_sdxl.sh — download SDXL base + SDXL-Lightning LoRA + SDXL VAE for ComfyUI
+# hal0 model store: /mnt/ai-models/comfyui/models
+# Follows kyuz0 vendored-script conventions (hf download, resume, dry-run).
+set -euo pipefail
+
+export HF_HUB_ENABLE_HF_TRANSFER=1
+export HF_HOME="${HF_HOME:-$HOME/.cache/huggingface}"
+HF="/opt/venv/bin/hf"
+
+MODEL_DIR="${MODEL_DIR:-/mnt/ai-models/comfyui/models}"
+STAGE="$MODEL_DIR/.hf_stage_sdxl"
+
+PRECISION="${PRECISION:-fp16}"
+DRY_RUN=0
+
+# Parse args
+for arg in "$@"; do
+  case "$arg" in
+    --dry-run) DRY_RUN=1 ;;
+    --precision=*) PRECISION="${arg#--precision=}" ;;
+    --precision) shift; PRECISION="${1:-fp16}" ;;
+  esac
+done
+
+if [[ "$DRY_RUN" -eq 1 ]]; then
+  echo "[dry-run] MODEL_DIR=$MODEL_DIR  PRECISION=$PRECISION"
+  echo "[dry-run] Would download to:"
+  echo "  checkpoints/   stabilityai/stable-diffusion-xl-base-1.0 → sd_xl_base_1.0.safetensors"
+  echo "  loras/         ByteDance/SDXL-Lightning → sdxl_lightning_8step_lora.safetensors"
+  echo "  vae/           madebyollin/sdxl-vae-fp16-fix → diffusion_pytorch_model.safetensors"
+  exit 0
+fi
+
+mkdir -p "$MODEL_DIR"/{checkpoints,loras,vae}
+mkdir -p "$STAGE"
+
+download_if_missing() {
+  local repo="$1"
+  local remote="$2"
+  local dest_path="$3"
+  local dest_name="${4:-$(basename "$remote")}"
+
+  local dest_dir="$MODEL_DIR/$dest_path"
+  local dest_file="$dest_dir/$dest_name"
+  local staged="$STAGE/$remote"
+
+  if [[ -f "$dest_file" ]]; then
+    echo "✓ Already present: $dest_file"
+    return
+  fi
+
+  echo "↓ Downloading $(basename "$remote") → $dest_file"
+  mkdir -p "$(dirname "$staged")"
+  mkdir -p "$dest_dir"
+
+  "$HF" download "$repo" "$remote" \
+      --repo-type model \
+      --cache-dir "$HF_HOME" \
+      --local-dir "$STAGE"
+  mv -f "$staged" "$dest_file"
+}
+
+# 1. SDXL base checkpoint (stabilityai/stable-diffusion-xl-base-1.0)
+echo "==> SDXL base checkpoint"
+download_if_missing \
+  "stabilityai/stable-diffusion-xl-base-1.0" \
+  "sd_xl_base_1.0.safetensors" \
+  "checkpoints"
+
+# 2. SDXL VAE (madebyollin/sdxl-vae-fp16-fix)
+echo "==> SDXL VAE (fp16-fix)"
+download_if_missing \
+  "madebyollin/sdxl-vae-fp16-fix" \
+  "diffusion_pytorch_model.safetensors" \
+  "vae" \
+  "sdxl_vae_fp16_fix.safetensors"
+
+# 3. SDXL-Lightning 8-step LoRA (ByteDance/SDXL-Lightning)
+echo "==> SDXL-Lightning 8-step LoRA"
+download_if_missing \
+  "ByteDance/SDXL-Lightning" \
+  "sdxl_lightning_8step_lora.safetensors" \
+  "loras"
+
+echo "✓ SDXL models ready in $MODEL_DIR"
diff --git a/installer/comfyui/scripts/get_wan22.sh b/installer/comfyui/scripts/get_wan22.sh
new file mode 100755
index 00000000..8f33bdd8
--- /dev/null
+++ b/installer/comfyui/scripts/get_wan22.sh
@@ -0,0 +1,127 @@
+#!/usr/bin/env bash
+# get_wan22.sh (resume-friendly)
+# Vendored from https://raw.githubusercontent.com/kyuz0/amd-strix-halo-comfyui-toolboxes/main/scripts/get_wan22.sh
+# vendored 2026-06-16 — adapted: MODEL_DIR defaults to /mnt/ai-models/comfyui/models (hal0 store)
+set -euo pipefail
+
+export HF_HUB_ENABLE_HF_TRANSFER=1
+export HF_HOME="${HF_HOME:-$HOME/.cache/huggingface}"   # persistent HF cache
+HF="/opt/venv/bin/hf"
+
+MODEL_DIR="${MODEL_DIR:-/mnt/ai-models/comfyui/models}"
+STAGE="$MODEL_DIR/.hf_stage_wan22"                     # persistent staging (enables resume)
+
+# Repositories
+REPO_22="Comfy-Org/Wan_2.2_ComfyUI_Repackaged"
+REPO_21="Comfy-Org/Wan_2.1_ComfyUI_repackaged"
+REPO_LORA="lightx2v/Wan2.2-Lightning"
+
+mkdir -p "$MODEL_DIR"/{text_encoders,vae,diffusion_models,loras}
+mkdir -p "$STAGE"
+
+PRECISION="fp8"
+if [[ "${2:-}" == "fp16" ]]; then
+  PRECISION="fp16"
+fi
+
+download_if_missing () {
+  local repo="$1"
+  local remote="$2"
+  local dest_path="$3"  # Relative path under MODEL_DIR, e.g., "text_encoders" or "loras/subdir"
+
+  local dest_dir="$MODEL_DIR/$dest_path"
+  local dest_file="$dest_dir/$(basename "$remote")"
+  local staged="$STAGE/$remote"
+
+  if [[ -f "$dest_file" ]]; then
+    echo "✓ Already present: $dest_file"
+    return
+  fi
+
+  echo "↓ Downloading $(basename "$remote") → $dest_file"
+  mkdir -p "$(dirname "$staged")"        # ensure stage path exists
+  mkdir -p "$dest_dir"                   # ensure dest dir exists
+
+  "$HF" download "$repo" "$remote" \
+      --repo-type model \
+      --cache-dir "$HF_HOME" \
+      --local-dir "$STAGE"
+  mv -f "$staged" "$dest_file"
+}
+
+usage() {
+  cat <<'USAGE'
+Usage: get_wan22.sh <target> [fp16]
+
+Targets:
+  common     Text encoder + VAEs
+  14b-t2v    14B T2V diffusion models (Defaults to FP8, use 'fp16' as 2nd arg for FP16)
+  14b-i2v    14B I2V diffusion models (Defaults to FP8, use 'fp16' as 2nd arg for FP16)
+  lora       Wan2.2 Lightning LoRAs
+
+Maintenance:
+  clean-stage   Remove staging folder (keeps final models)
+  clean-cache   Remove Hugging Face cache (~/.cache/huggingface)
+
+Notes:
+- Downloads RESUME automatically via persistent --cache-dir and --local-dir.
+USAGE
+}
+
+case "${1:-}" in
+  common)
+    echo "==> text encoder + VAEs"
+    if [[ "$PRECISION" == "fp16" ]]; then
+         download_if_missing "$REPO_22" "split_files/text_encoders/umt5_xxl_fp16.safetensors" "text_encoders"
+    else
+         download_if_missing "$REPO_21" "split_files/text_encoders/umt5_xxl_fp8_e4m3fn_scaled.safetensors" "text_encoders"
+    fi
+    download_if_missing "$REPO_22" "split_files/vae/wan_2.1_vae.safetensors" "vae"
+    ;;
+  14b-t2v)
+    echo "==> 14B Text→Video ($PRECISION)"
+    if [[ "$PRECISION" == "fp16" ]]; then
+        download_if_missing "$REPO_22" "split_files/diffusion_models/wan2.2_t2v_high_noise_14B_fp16.safetensors" "diffusion_models"
+        download_if_missing "$REPO_22" "split_files/diffusion_models/wan2.2_t2v_low_noise_14B_fp16.safetensors" "diffusion_models"
+    else
+        download_if_missing "$REPO_22" "split_files/diffusion_models/wan2.2_t2v_high_noise_14B_fp8_scaled.safetensors" "diffusion_models"
+        download_if_missing "$REPO_22" "split_files/diffusion_models/wan2.2_t2v_low_noise_14B_fp8_scaled.safetensors" "diffusion_models"
+    fi
+    ;;
+  14b-i2v)
+    echo "==> 14B Image→Video ($PRECISION)"
+    if [[ "$PRECISION" == "fp16" ]]; then
+        download_if_missing "$REPO_22" "split_files/diffusion_models/wan2.2_i2v_high_noise_14B_fp16.safetensors" "diffusion_models"
+        download_if_missing "$REPO_22" "split_files/diffusion_models/wan2.2_i2v_low_noise_14B_fp16.safetensors" "diffusion_models"
+    else
+        download_if_missing "$REPO_22" "split_files/diffusion_models/wan2.2_i2v_high_noise_14B_fp8_scaled.safetensors" "diffusion_models"
+        download_if_missing "$REPO_22" "split_files/diffusion_models/wan2.2_i2v_low_noise_14B_fp8_scaled.safetensors" "diffusion_models"
+    fi
+    ;;
+  lora)
+    echo "==> Wan2.2 Lightning LoRAs (Seko V2)"
+    LORA_SUBDIR_T2V="loras/Wan2.2-T2V-A14B-4steps-lora-rank64-Seko-V2.0"
+    download_if_missing "$REPO_LORA" "Wan2.2-T2V-A14B-4steps-lora-rank64-Seko-V2.0/high_noise_model.safetensors" "$LORA_SUBDIR_T2V"
+    download_if_missing "$REPO_LORA" "Wan2.2-T2V-A14B-4steps-lora-rank64-Seko-V2.0/low_noise_model.safetensors" "$LORA_SUBDIR_T2V"
+
+    LORA_SUBDIR_I2V="loras/Wan2.2-I2V-A14B-4steps-lora-rank64-Seko-V1"
+    download_if_missing "$REPO_LORA" "Wan2.2-I2V-A14B-4steps-lora-rank64-Seko-V1/high_noise_model.safetensors" "$LORA_SUBDIR_I2V"
+    download_if_missing "$REPO_LORA" "Wan2.2-I2V-A14B-4steps-lora-rank64-Seko-V1/low_noise_model.safetensors" "$LORA_SUBDIR_I2V"
+    ;;
+  clean-stage)
+    rm -rf "$STAGE"; echo "✓ Removed stage: $STAGE"
+    ;;
+  clean-cache)
+    rm -rf "$HF_HOME"; echo "✓ Removed HF cache: $HF_HOME"
+    ;;
+  ""|-h|--help|help)
+    usage
+    ;;
+  *)
+    echo "Unknown target: $1" >&2
+    usage
+    exit 1
+    ;;
+esac
+
+echo "✓ Done."
diff --git a/installer/comfyui/scripts/set_extra_paths.sh b/installer/comfyui/scripts/set_extra_paths.sh
new file mode 100755
index 00000000..b8a7eac0
--- /dev/null
+++ b/installer/comfyui/scripts/set_extra_paths.sh
@@ -0,0 +1,28 @@
+#!/bin/bash
+# set_extra_paths.sh
+# Vendored from https://raw.githubusercontent.com/kyuz0/amd-strix-halo-comfyui-toolboxes/main/scripts/set_extra_paths.sh
+# vendored 2026-06-16 — adapted: MODEL_DIR defaults to /mnt/ai-models/comfyui/models (hal0 store)
+
+set -euo pipefail
+
+CONFY_DIR="${CONFY_DIR:-/opt/ComfyUI}"
+YAML_FILE="$CONFY_DIR/extra_model_paths.yaml"
+MODEL_DIR="${MODEL_DIR:-/mnt/ai-models/comfyui/models}"
+
+mkdir -p "$MODEL_DIR"/{text_encoders,vae,diffusion_models,loras}
+
+cat > "$YAML_FILE" <<EOF
+comfyui:
+    base_path: $MODEL_DIR
+
+    text_encoders: text_encoders
+    vae: vae
+    checkpoints: checkpoints
+    diffusion_models: diffusion_models
+    unet: unet
+    loras: loras
+    latent_upscale_models: latent_upscale_models
+    clip_vision: clip_vision
+EOF
+
+echo "✅ Wrote $YAML_FILE"
diff --git a/installer/etc-hal0/profiles.toml b/installer/etc-hal0/profiles.toml
index a74e7317..603ceb60 100644
--- a/installer/etc-hal0/profiles.toml
+++ b/installer/etc-hal0/profiles.toml
@@ -73,10 +73,9 @@ quant        = ""
 [profile.comfyui]
 # Image-gen slot (ComfyUI on ROCm, kyuz0 Strix Halo build). Exclusive-GPU:
 # the GpuArbiter stops LLM GPU slots while img runs (Phase D, #599).
-image        = "docker.io/kyuz0/amd-strix-halo-comfyui:latest"
+image        = "docker.io/kyuz0/amd-strix-halo-comfyui@sha256:0066678ae9043f69a1c8c7699e70626ceffd35c1a8ca03227a05640ad0241ed2"
 flags        = "--disable-mmap --bf16-vae --cache-none"
 mtp          = false
 device_class = "img"
 intent       = "Image generation"
 quant        = ""
-
diff --git a/installer/install.sh b/installer/install.sh
index b107dc8f..10feed9f 100755
--- a/installer/install.sh
+++ b/installer/install.sh
@@ -943,6 +943,59 @@ for seed_slot in npu tts rerank utility img; do
     fi
 done
 
+# ── ComfyUI control scripts ──────────────────────────────────────────────────
+# Place the manual-ops scripts at /opt/comfyui/ (fixed path — comfy-up.sh
+# self-references /opt/comfyui/comfy-postinstall.sh and /opt/comfyui/comfy-logs.sh
+# so the directory cannot vary with PREFIX). Idempotent: install(1) overwrites
+# in place on re-run.
+# Also create the model/output/input/user/custom_nodes subdirectories and place
+# extra_model_paths.yaml on the share so comfy-up.sh can mount them.
+ui_step "ComfyUI control scripts"
+
+COMFYUI_SCRIPTS_SRC="${REPO_ROOT}/installer/comfyui/scripts"
+COMFYUI_DIR="/opt/comfyui"
+COMFYUI_MODELS_ROOT="/mnt/ai-models/comfyui"
+
+if [[ "${DEV_MODE}" -eq 1 ]]; then
+    info "dev mode — skipping /opt/comfyui install (no system writes)"
+else
+    if [[ -d "${COMFYUI_SCRIPTS_SRC}" ]]; then
+        install -d "${COMFYUI_DIR}"
+        install -m0755 "${COMFYUI_SCRIPTS_SRC}"/*.sh "${COMFYUI_DIR}/"
+        info "wrote ComfyUI control scripts → ${COMFYUI_DIR}/"
+    else
+        warn "${COMFYUI_SCRIPTS_SRC} not found — ComfyUI control scripts not installed"
+    fi
+
+    # Create the model-share subdirs that comfy-up.sh bind-mounts into the container.
+    for _subdir in models output input user custom_nodes; do
+        install -d "${COMFYUI_MODELS_ROOT}/${_subdir}"
+    done
+    info "ensured ${COMFYUI_MODELS_ROOT}/{models,output,input,user,custom_nodes}"
+
+    # Place extra_model_paths.yaml if not already present (operator may have a
+    # customised copy — never overwrite).
+    _EXTRA_PATHS_SRC="${REPO_ROOT}/installer/comfyui/extra_model_paths.yaml"
+    _EXTRA_PATHS_DST="${COMFYUI_MODELS_ROOT}/extra_model_paths.yaml"
+    if [[ -f "${_EXTRA_PATHS_DST}" ]]; then
+        info "${_EXTRA_PATHS_DST} exists — left alone"
+    elif [[ -f "${_EXTRA_PATHS_SRC}" ]]; then
+        install -m0644 "${_EXTRA_PATHS_SRC}" "${_EXTRA_PATHS_DST}"
+        info "wrote ${_EXTRA_PATHS_DST}"
+    else
+        warn "${_EXTRA_PATHS_SRC} not found — extra_model_paths.yaml not placed (create manually before first comfy-up)"
+    fi
+
+    _COMFYUI_SUDOERS_SRC="${REPO_ROOT}/packaging/sudoers/hal0-comfyui"
+    _COMFYUI_SUDOERS_DST="/etc/sudoers.d/hal0-comfyui"
+    if [[ -f "${_COMFYUI_SUDOERS_SRC}" ]]; then
+        install -m0440 "${_COMFYUI_SUDOERS_SRC}" "${_COMFYUI_SUDOERS_DST}"
+        info "wrote ${_COMFYUI_SUDOERS_DST}"
+    else
+        warn "${_COMFYUI_SUDOERS_SRC} not found — ComfyUI sudoers grant not installed"
+    fi
+fi
+
 # ── hal0 system user ────────────────────────────────────────────────────────
 # A dedicated `hal0` system user/group runs the non-root hal0 services:
 # hal0-agent@<id> (the Hermes runner), hermes-gateway, and the shared
diff --git a/manifest.json b/manifest.json
index c9f7f09d..8a934452 100644
--- a/manifest.json
+++ b/manifest.json
@@ -31,7 +31,7 @@
       "_upstream_reference": "https://github.com/thewh1teagle/kokoro-onnx"
     },
     "comfyui": {
-      "tag": "docker.io/kyuz0/amd-strix-halo-comfyui:latest",
+      "tag": "docker.io/kyuz0/amd-strix-halo-comfyui@sha256:0066678ae9043f69a1c8c7699e70626ceffd35c1a8ca03227a05640ad0241ed2",
       "digest": "sha256:0066678ae9043f69a1c8c7699e70626ceffd35c1a8ca03227a05640ad0241ed2",
       "_notes": "live-validated on CT105 2026-06-11 (Wan2.2/Qwen-Image/Flux/SDXL on gfx1151); repinned from unpublished hal0-toolbox-comfyui (Phase D)",
       "_upstream_reference": "https://github.com/comfyanonymous/ComfyUI"
diff --git a/packaging/sudoers/hal0-comfyui b/packaging/sudoers/hal0-comfyui
index 964b3d32..5713f9eb 100644
--- a/packaging/sudoers/hal0-comfyui
+++ b/packaging/sudoers/hal0-comfyui
@@ -1,22 +1,16 @@
 # hal0 — ComfyUI switchover grant for an UNPRIVILEGED hal0-api.
 #
-# On CT105 today hal0-api runs as root and execs /opt/comfyui/*.sh directly;
-# this file is for the hardened install model where hal0-api runs as the
-# `hal0` system user. The API invokes the scripts via `sudo -n <abs path>`
-# (src/hal0/api/routes/comfyui.py:_script_argv), so the grant is exactly the
-# six absolute script paths — no wildcards, no shell, no extra args.
+# On CT105 today hal0-api may run as root; this file is for the hardened
+# install model where hal0-api runs as the `hal0` system user. The API invokes
+# the img slot restart via `sudo -n
+# /usr/bin/systemctl restart hal0-slot@img.service`, so the grant is exactly
+# that command — no wildcards, no shell, no extra args.
 #
 # Install (as root):
 #   install -m 0440 packaging/sudoers/hal0-comfyui /etc/sudoers.d/hal0-comfyui
 #   visudo -cf /etc/sudoers.d/hal0-comfyui
 #
-# The scripts themselves must stay root-owned 0755 (they are the privilege
-# boundary — a hal0-writable script under this grant would be root escalation).
+# Keep the grant pinned to the img slot unit; broad systemctl access would let
+# the API restart arbitrary services.
 
-hal0 ALL=(root) NOPASSWD: \
-    /opt/comfyui/stop-inference.sh, \
-    /opt/comfyui/start-inference.sh, \
-    /opt/comfyui/comfy-up.sh, \
-    /opt/comfyui/comfy-down.sh, \
-    /opt/comfyui/comfy-logs.sh, \
-    /opt/comfyui/comfy-postinstall.sh
+hal0 ALL=(root) NOPASSWD: /usr/bin/systemctl restart hal0-slot@img.service
diff --git a/src/hal0/api/routes/comfyui.py b/src/hal0/api/routes/comfyui.py
index fbc53b4c..8942304b 100644
--- a/src/hal0/api/routes/comfyui.py
+++ b/src/hal0/api/routes/comfyui.py
@@ -31,15 +31,24 @@
 
 import asyncio
 import contextlib
+import logging
 import os
+import re
 import shutil
 from typing import Any
 
 import httpx
 from fastapi import APIRouter, BackgroundTasks, Request
 from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+
+import hal0.comfyui.fetch as _fetch_module
+from hal0.api.routes.power import _probe_power
+from hal0.comfyui.selection import auto_selections, variant_for
+from hal0.hardware import gpu_view
 
 router = APIRouter()
+log = logging.getLogger(__name__)
 
 # iGPU memory ceilings on the Strix Halo target (GB). The host addresses ~80 GB
 # of the 96 GB unified pool from the GPU, with zero swap — so memory pressure is
@@ -55,6 +64,7 @@
 # (arbiter.ensure_img); "inference" hands it back to the LLM stack
 # (arbiter.restore_llm).
 _MODES = ("generation", "inference")
+_WORKFLOW_NAME_RE = re.compile(r"^[A-Za-z0-9._-]+$")
 
 # Short connect so a dead engine surfaces fast; the read budget is modest because
 # /system_stats and /queue are cheap snapshots.
@@ -63,6 +73,9 @@
 
 _client: httpx.AsyncClient | None = None
 
+# Keep strong refs to fire-and-forget tasks so they aren't GC'd mid-flight (RUF006).
+_BG_TASKS: set[asyncio.Task[Any]] = set()
+
 # In-flight switchover tracker. Module-global on purpose: there is exactly one
 # iGPU, so there is exactly one switch — /status surfaces it so the pane's poll
 # can render "switching…" and any error from the last attempt.
@@ -239,6 +252,54 @@ def _queue_counts(queue: dict[str, Any] | None) -> dict[str, int]:
     }
 
 
+def _as_pct(value: Any) -> float | None:
+    if not isinstance(value, (int, float)):
+        return None
+    return round(max(0.0, min(1.0, float(value))) * 100, 1)
+
+
+def _mhz_to_ghz(value: Any) -> float | None:
+    if not isinstance(value, (int, float)):
+        return None
+    return round(float(value) / 1000.0, 2)
+
+
+async def _gpu_telemetry(request: Request, *, render_active: bool) -> dict[str, float | int | None]:
+    """Read live GPU util/temp/clock for /status, degrading per-field to null.
+
+    ``gpu_busy_percent`` is a forced-high artifact on the target AMD host while
+    the GPU is pinned to a high perf level, so util is exposed only while a
+    ComfyUI render is actively running. Temp and shader clock are factual reads
+    and are surfaced independently.
+    """
+    util: float | int | None = 0
+    temp: float | None = None
+    clock: float | None = None
+
+    try:
+        stats = getattr(request.app.state, "hardware_stats", None)
+        if stats is not None and hasattr(stats, "gpu_sample"):
+            sample = await asyncio.to_thread(stats.gpu_sample)
+        else:
+            sample = await asyncio.to_thread(gpu_view.sample)
+        if render_active:
+            util = _as_pct(getattr(sample, "gpu_busy", None))
+    except Exception:
+        util = 0 if not render_active else None
+
+    try:
+        power = await asyncio.to_thread(_probe_power)
+        temp_value = power.get("gpu_temp_c") if isinstance(power, dict) else None
+        clock_mhz = power.get("gpu_sclk_mhz") if isinstance(power, dict) else None
+        temp = round(float(temp_value), 1) if isinstance(temp_value, (int, float)) else None
+        clock = _mhz_to_ghz(clock_mhz)
+    except Exception:
+        temp = None
+        clock = None
+
+    return {"util": util, "temp": temp, "clock": clock}
+
+
 # Model categories surfaced in the pane's "models on share" card, mapped to the
 # share subdirs. ``diffusion`` folds the standalone diffusion/video model dirs.
 _INVENTORY_DIRS: dict[str, tuple[str, ...]] = {
@@ -330,6 +391,7 @@ async def comfyui_status(request: Request) -> dict[str, Any]:
     )
     reachable = stats is not None
     counts = _queue_counts(queue)
+    telemetry = await _gpu_telemetry(request, render_active=counts["running"] > 0)
     engine = _engine_state(container, reachable, counts["running"])
     # Arbiter snapshot is fail-soft like every other probe here: a missing
     # manager or a corrupt state file degrades to null, never a 500.
@@ -358,6 +420,10 @@ async def comfyui_status(request: Request) -> dict[str, Any]:
         "endpoint": ":8188" if (reachable or mode == "generation") else None,
         "memory": _parse_memory(stats),
         "queue": counts,
+        **telemetry,
+        "it_s": None,
+        "eta": None,
+        "step": None,
         "inference": {"hermes": hermes},
         "inventory": _model_inventory(),
         "switchover": dict(_switch),
@@ -539,4 +605,317 @@ async def comfyui_pin(request: Request) -> JSONResponse:
     return JSONResponse(status_code=200, content={"pinned": pinned})
 
 
+# ---------------------------------------------------------------------------
+# POST /models/fetch — deferred model pull trigger (Task 3.5)
+# ---------------------------------------------------------------------------
+
+
+class _SelectionItem(BaseModel):
+    capability: str
+    family: str
+
+
+class _FetchBody(BaseModel):
+    auto: bool | None = None
+    selections: list[_SelectionItem] | None = None
+
+
+@router.post("/models/fetch", status_code=202)
+async def comfyui_models_fetch(body: _FetchBody) -> JSONResponse:
+    """Trigger deferred model pulls for ComfyUI capabilities.
+
+    Body (one of):
+      {"auto": true}
+          Fetches the default variant for every capability (5 total).
+      {"selections": [{"capability": "txt2img", "family": "sdxl"}, ...]}
+          Fetches the named variant(s) explicitly.
+
+    Returns 202 with {"jobs": [job_id, ...]} immediately; each job runs in the
+    background via fetch.fetch_model (subprocess, non-blocking).
+
+    This is the DEFERRED post-install pull path — install runs with --no-pull
+    and this endpoint is called by the dashboard after setup completes.
+    """
+    if body.auto is None and not body.selections:
+        return JSONResponse(
+            status_code=422,
+            content={
+                "error": {
+                    "code": "comfyui.fetch.invalid_body",
+                    "message": "body must be {'auto': true} or {'selections': [...]}",
+                }
+            },
+        )
+
+    if body.auto:
+        variants = auto_selections()
+    else:
+        # Resolve explicit selections; surface unknown cap/family as 422.
+        variants = []
+        for item in body.selections:  # type: ignore[union-attr]
+            try:
+                v = variant_for(item.capability, item.family)
+            except KeyError as exc:
+                return JSONResponse(
+                    status_code=422,
+                    content={
+                        "error": {
+                            "code": "comfyui.fetch.unknown_variant",
+                            "message": str(exc),
+                        }
+                    },
+                )
+            variants.append(v)
+
+    job_ids = [_fetch_module.fetch_model(v) for v in variants]
+    return JSONResponse(status_code=202, content={"jobs": job_ids})
+
+
+def _comfyui_workflows_dir() -> str:
+    """Primary workflow directory — env override for tests; default is the bind-mount path."""
+    return os.environ.get("COMFYUI_WORKFLOWS_DIR", "/mnt/ai-models/comfyui/workflows")
+
+
+def _comfyui_data_dir() -> str:
+    """Root of the ComfyUI data directory (for fallback user/default/workflows path)."""
+    return os.environ.get("COMFYUI_DATA_DIR", "/mnt/ai-models/comfyui")
+
+
+def _find_workflow(name: str) -> str | None:
+    """Locate <name>.json, trying primary then user/default fallback. None if absent."""
+    if not _WORKFLOW_NAME_RE.fullmatch(name) or ".." in name:
+        return None
+    primary = os.path.join(_comfyui_workflows_dir(), f"{name}.json")
+    if os.path.isfile(primary):
+        return primary
+    fallback = os.path.join(_comfyui_data_dir(), "user", "default", "workflows", f"{name}.json")
+    if os.path.isfile(fallback):
+        return fallback
+    return None
+
+
+def _workflow_not_found_response() -> JSONResponse:
+    return JSONResponse(
+        status_code=404,
+        content={
+            "error": {
+                "code": "comfyui.workflow_not_found",
+                "message": "Workflow not found.",
+            }
+        },
+    )
+
+
+# ---------------------------------------------------------------------------
+# POST /render/cancel — clear queue + interrupt current render
+# ---------------------------------------------------------------------------
+
+
+@router.post("/render/cancel", status_code=202)
+async def comfyui_render_cancel() -> JSONResponse:
+    """Cancel current and queued renders.
+
+    Issues POST /queue (clear: true) and POST /interrupt to the ComfyUI
+    HTTP API. Fail-soft: network errors are suppressed — the cancel
+    intent is best-effort and the render state is visible via /status.
+    """
+    base = _comfyui_base_url()
+    client = _get_client()
+
+    async def _post(path: str, body: dict[str, Any]) -> None:
+        with contextlib.suppress(Exception):
+            await client.post(f"{base}{path}", json=body)
+
+    await asyncio.gather(
+        _post("/queue", {"clear": True}),
+        _post("/interrupt", {}),
+    )
+    return JSONResponse(status_code=202, content={"status": "cancel_requested"})
+
+
+# ---------------------------------------------------------------------------
+# POST /restart — restart the slot-managed img runtime
+# ---------------------------------------------------------------------------
+
+
+@router.post("/restart", status_code=202)
+async def comfyui_restart(request: Request, background_tasks: BackgroundTasks) -> JSONResponse:
+    """Restart the slot-managed ComfyUI runtime.
+
+    Runs in the background and returns 202 immediately — the container
+    takes several seconds to come back up. Track readiness via /status.
+    """
+    manager = getattr(request.app.state, "slot_manager", None)
+    if manager is None or not hasattr(manager, "restart"):
+        return _arbiter_unavailable()
+
+    async def _restart_img() -> None:
+        try:
+            await manager.restart("img")
+        except Exception as exc:
+            log.warning("comfyui.img_restart_failed", extra={"error": str(exc)})
+
+    background_tasks.add_task(_restart_img)
+    return JSONResponse(status_code=202, content={"status": "restart_requested"})
+
+
+# ---------------------------------------------------------------------------
+# GET /logs — tail container logs
+# ---------------------------------------------------------------------------
+
+
+@router.get("/logs")
+async def comfyui_logs(tail: int = 60) -> JSONResponse:
+    """Return the last N lines of the ComfyUI container logs.
+
+    Uses ``docker logs --tail N`` (or ``podman``) against the container
+    name. Returns ``{"lines": []}`` when the container runtime is absent
+    or the container has no logs yet — never a 500.
+    """
+    container = _comfyui_container()
+    # Prefer podman if available (post-D9 the img slot runs under podman)
+    runtime = shutil.which("podman") or shutil.which("docker")
+    if not runtime:
+        return JSONResponse(status_code=200, content={"lines": []})
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            runtime,
+            "logs",
+            "--tail",
+            str(tail),
+            container,
+            stdin=asyncio.subprocess.DEVNULL,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        out, err = await asyncio.wait_for(proc.communicate(), timeout=10.0)
+    except (TimeoutError, OSError):
+        return JSONResponse(status_code=200, content={"lines": []})
+    # docker logs writes to stderr for container output; combine both
+    combined = (out + err).decode("utf-8", "replace")
+    lines = [ln for ln in combined.splitlines() if ln]
+    return JSONResponse(status_code=200, content={"lines": lines})
+
+
+# ---------------------------------------------------------------------------
+# POST /workflows/{name}/launch — quick-launch a curated workflow
+# ---------------------------------------------------------------------------
+
+
+@router.post("/workflows/{name}/launch", status_code=202)
+async def comfyui_workflow_launch(name: str) -> JSONResponse:
+    """Quick-launch a workflow by name from the bind-mounted workflows directory.
+
+    Reads <name>.json from the primary workflows dir, falling back to the
+    user/default/workflows path. Posts the API-format workflow JSON to
+    ComfyUI's /prompt endpoint and returns 202 with the prompt_id.
+    404 when the workflow file does not exist.
+    """
+    workflow_path = _find_workflow(name)
+    if workflow_path is None:
+        return _workflow_not_found_response()
+    try:
+        with open(workflow_path) as fh:
+            workflow = fh.read()
+        workflow_data = __import__("json").loads(workflow)
+    except (OSError, ValueError) as exc:
+        log.warning("Failed to read ComfyUI workflow %r from %s: %s", name, workflow_path, exc)
+        return JSONResponse(
+            status_code=500,
+            content={
+                "error": {
+                    "code": "comfyui.workflow_read_error",
+                    "message": "Workflow could not be read.",
+                }
+            },
+        )
+    base = _comfyui_base_url()
+    try:
+        resp = await _get_client().post(
+            f"{base}/prompt",
+            json={"prompt": workflow_data},
+        )
+        result = resp.json() if resp.status_code == 200 else {}
+    except (httpx.HTTPError, ValueError):
+        result = {}
+    prompt_id = result.get("prompt_id")
+    return JSONResponse(
+        status_code=202,
+        content={"status": "queued", "prompt_id": prompt_id},
+    )
+
+
+@router.post("/workflows/{name:path}/launch", include_in_schema=False)
+async def comfyui_invalid_workflow_launch(name: str) -> JSONResponse:
+    """Reject malformed workflow names that include path separators."""
+    return _workflow_not_found_response()
+
+
+# ---------------------------------------------------------------------------
+# GET /preview — proxy the latest output image from ComfyUI history
+# ---------------------------------------------------------------------------
+
+
+def _latest_output_image(history: dict[str, Any]) -> dict[str, str] | None:
+    """Find the newest output image entry in ComfyUI's /history response.
+
+    ComfyUI history is a dict keyed by prompt_id; each entry has an
+    ``outputs`` dict with node-keyed image lists. We pick the entry with
+    the highest timestamp (or first if none) and return the first image.
+    """
+    if not history:
+        return None
+
+    # Sort by timestamp if available, newest first
+    def _ts(entry):
+        return entry.get("timestamp", 0.0)
+
+    candidates = sorted(history.values(), key=_ts, reverse=True)
+    for entry in candidates:
+        outputs = entry.get("outputs", {})
+        for node_out in outputs.values():
+            images = node_out.get("images", [])
+            if images:
+                return images[0]
+    return None
+
+
+@router.get("/preview")
+async def comfyui_preview() -> Any:
+    """Proxy the latest output image from the ComfyUI history.
+
+    Queries /history for the most recent completed prompt, fetches the
+    newest output image via /view?filename=...&type=output, and streams
+    the bytes back with the correct content-type. Returns 404 when there
+    is no output yet.
+    """
+    from fastapi.responses import Response
+
+    history = await _fetch_json("/history")
+    if not isinstance(history, dict):
+        return JSONResponse(status_code=404, content={"error": {"code": "comfyui.no_output"}})
+    img = _latest_output_image(history)
+    if img is None:
+        return JSONResponse(status_code=404, content={"error": {"code": "comfyui.no_output"}})
+    filename = img.get("filename", "")
+    subfolder = img.get("subfolder", "")
+    img_type = img.get("type", "output")
+    params = f"filename={filename}&type={img_type}"
+    if subfolder:
+        params += f"&subfolder={subfolder}"
+    base = _comfyui_base_url()
+    try:
+        resp = await _get_client().get(f"{base}/view?{params}")
+        if resp.status_code != 200:
+            return JSONResponse(
+                status_code=404, content={"error": {"code": "comfyui.image_fetch_failed"}}
+            )
+        content_type = resp.headers.get("content-type", "image/png")
+        return Response(content=resp.content, media_type=content_type)
+    except (httpx.HTTPError, OSError):
+        return JSONResponse(
+            status_code=404, content={"error": {"code": "comfyui.image_fetch_failed"}}
+        )
+
+
 __all__ = ["aclose_client", "router"]
diff --git a/src/hal0/api/routes/installer.py b/src/hal0/api/routes/installer.py
index f4604271..3450a775 100644
--- a/src/hal0/api/routes/installer.py
+++ b/src/hal0/api/routes/installer.py
@@ -421,7 +421,17 @@ async def install_apply_selections(request: Request, background: BackgroundTasks
     "hal0-api.service",
     "hindsight-api.service",
     "hal0-agent@hermes.service",
+    "hal0-slot@img.service",
 }
+_COMFYUI_SLOT_UNIT = "hal0-slot@img.service"
+_SYSTEMCTL = "/usr/bin/systemctl"
+
+
+def _privileged_systemctl_argv(*args: str) -> list[str]:
+    argv = [_SYSTEMCTL, *args]
+    if os.geteuid() == 0:
+        return argv
+    return ["sudo", "-n", *argv]
 
 
 def _unit_active(unit: str) -> bool:
@@ -438,12 +448,34 @@ def _unit_active(unit: str) -> bool:
         return False
 
 
+def _container_active() -> bool:
+    """True when the ComfyUI container is running under podman or docker."""
+    if _unit_active(_COMFYUI_SLOT_UNIT):
+        return True
+    for runtime in ("podman", "docker"):
+        exe = shutil.which(runtime)
+        if exe is None:
+            continue
+        try:
+            out = subprocess.run(
+                [exe, "inspect", "--format", "{{.State.Running}}", "comfyui"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if out.returncode == 0 and out.stdout.strip().lower() == "true":
+                return True
+        except (OSError, subprocess.SubprocessError):
+            pass
+    return False
+
+
 @router.get("/services")
 async def install_services() -> dict[str, Any]:
     """Verify post-install services for the FirstRun services step (design D5).
 
-    Reports Hermes + OpenWebUI health so the wizard can show honest dots and
-    offer the one-click repair below when a unit is down.
+    Reports Hermes + OpenWebUI + ComfyUI health so the wizard can show honest
+    dots and offer the one-click repair below when a unit is down.
     """
     owui = "hal0-openwebui.service"
     hermes_active = bool(os.environ.get("HAL0_HERMES_PUBLIC_URL")) or _unit_active(
@@ -462,6 +494,14 @@ async def install_services() -> dict[str, Any]:
             "active": hermes_active,
             "repairable": True,
         },
+        # ComfyUI is slot-managed by hal0-slot@img.service; the /opt/comfyui
+        # scripts are manual-operator tools only.
+        {
+            "unit": "comfyui",
+            "label": "ComfyUI",
+            "active": _container_active(),
+            "repairable": True,
+        },
     ]
     return {"services": services}
 
@@ -470,9 +510,28 @@ async def install_services() -> dict[str, Any]:
 async def service_repair(unit: str) -> dict[str, Any]:
     """Restart a known unit (design D5 one-click repair).
 
-    Restricted to :data:`_REPAIRABLE_UNITS` so the ``{unit}`` path segment
-    can't be used to restart arbitrary system services.
+    Restricted to :data:`_REPAIRABLE_UNITS` (systemd) or the special-cased
+    ``comfyui`` service id so the ``{unit}`` path segment can't be used to
+    restart arbitrary system services.
+
+    NOTE: ComfyUI is exposed to the UI as ``comfyui`` but the single lifecycle
+    owner is the seeded img slot unit. The legacy ``/opt/comfyui`` scripts stay
+    available for manual operator use only.
     """
+    # Special case: public service id maps to the slot unit that owns :8188.
+    if unit == "comfyui":
+        try:
+            subprocess.run(
+                _privileged_systemctl_argv("restart", _COMFYUI_SLOT_UNIT),
+                check=True,
+                timeout=60,
+            )
+        except (OSError, subprocess.SubprocessError) as exc:
+            raise PickDefaultError(
+                f"comfyui restart failed: {exc}", details={"unit": unit}
+            ) from exc
+        return {"unit": unit, "active": _container_active()}
+
     if unit not in _REPAIRABLE_UNITS:
         raise BadRequest(
             f"unit {unit!r} is not repairable",
diff --git a/src/hal0/cli/setup_command.py b/src/hal0/cli/setup_command.py
index 0f98e9ce..b7dce306 100644
--- a/src/hal0/cli/setup_command.py
+++ b/src/hal0/cli/setup_command.py
@@ -92,8 +92,18 @@ def build_auto_selections(
         if coder:
             name, port = _SETUP_SLOTS["coder"]
             slots.append(SlotSelection("coder", name, port, coder[0].model_id))
+    # Record ComfyUI default capability picks as (capability_id, family) pairs.
+    # No model pull at install — operator triggers downloads later via
+    # POST /api/comfyui/models/fetch.
+    from hal0.comfyui.capabilities import CAPABILITIES as _CAPS
+
+    comfyui_defaults = tuple((cap_id, cap.alternatives[0].family) for cap_id, cap in _CAPS.items())
     return Selections(
-        storage_dir=storage_dir, slots=slots, extensions=ext, npu_opt_in=bool(hw.npu.present)
+        storage_dir=storage_dir,
+        slots=slots,
+        extensions=ext,
+        npu_opt_in=bool(hw.npu.present),
+        comfyui_defaults=comfyui_defaults,
     )
 
 
diff --git a/src/hal0/comfyui/__init__.py b/src/hal0/comfyui/__init__.py
new file mode 100644
index 00000000..0eb66221
--- /dev/null
+++ b/src/hal0/comfyui/__init__.py
@@ -0,0 +1 @@
+# hal0.comfyui package
diff --git a/src/hal0/comfyui/capabilities.py b/src/hal0/comfyui/capabilities.py
new file mode 100644
index 00000000..70d59f68
--- /dev/null
+++ b/src/hal0/comfyui/capabilities.py
@@ -0,0 +1,181 @@
+"""ComfyUI capability registry — Task 2.2."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class ModelVariant:
+    family: str
+    precision: str | None
+    lora: str | None
+    est_seconds: int
+    fetch_script: str
+    workflow: str
+    # Ordered argv sequences for the fetch script.
+    # Each inner tuple = positional/flag args for ONE subprocess invocation.
+    # Empty tuple = one call with no extra args (e.g. get_esrgan.sh).
+    fetch_steps: tuple[tuple[str, ...], ...] = field(default_factory=tuple)
+
+
+@dataclass
+class Capability:
+    id: str
+    label: str
+    default_family: str
+    alternatives: list[ModelVariant] = field(default_factory=list)
+
+
+def default_variant(cap: str | Capability) -> ModelVariant:
+    """Return the default (first) variant for a capability id or Capability."""
+    if isinstance(cap, str):
+        cap = CAPABILITIES[cap]
+    return cap.alternatives[0]
+
+
+CAPABILITIES: dict[str, Capability] = {
+    "txt2img": Capability(
+        id="txt2img",
+        label="Text → Image",
+        default_family="qwen-image",
+        alternatives=[
+            ModelVariant(
+                "qwen-image",
+                "bf16",
+                "lightning-4step",
+                75,
+                "get_qwen_image.sh",
+                "Qwen-Image-2512-BF16-4-Step-LoRA.json",
+                fetch_steps=(("1", "bf16"), ("3", "bf16")),
+            ),
+            ModelVariant(
+                "qwen-image",
+                "bf16",
+                None,
+                359,
+                "get_qwen_image.sh",
+                "Qwen-Image-2512-BF16-20-Steps.json",
+                fetch_steps=(("1", "bf16"),),
+            ),
+            ModelVariant(
+                "sdxl",
+                "fp16",
+                "lightning-8step",
+                10,
+                "get_sdxl.sh",
+                "SDXL-Lightning-8step.json",
+                fetch_steps=(("--precision", "fp16"),),
+            ),
+        ],
+    ),
+    "img2img": Capability(
+        id="img2img",
+        label="Image Edit",
+        default_family="qwen-image-edit",
+        alternatives=[
+            ModelVariant(
+                "qwen-image-edit",
+                "bf16",
+                "lightning-4step",
+                113,
+                "get_qwen_image.sh",
+                "Qwen-Image-Edit-2511-BF16-4-Step-LoRA.json",
+                fetch_steps=(("2", "bf16"), ("4", "bf16")),
+            ),
+            ModelVariant(
+                "qwen-image-edit",
+                "bf16",
+                None,
+                667,
+                "get_qwen_image.sh",
+                "Qwen-Image-Edit-2511-BF16-20-Steps.json",
+                fetch_steps=(("2", "bf16"),),
+            ),
+        ],
+    ),
+    "txt2video": Capability(
+        id="txt2video",
+        label="Text → Video",
+        default_family="ltx2",
+        alternatives=[
+            ModelVariant(
+                "ltx2",
+                "bf16",
+                None,
+                615,
+                "get_ltx2.sh",
+                "LTX2-T2V-BF16.json",
+                fetch_steps=(("common",), ("checkpoint", "bf16"), ("lora",)),
+            ),
+            ModelVariant(
+                "hunyuan15",
+                "fp16",
+                "lightx2v-4step",
+                929,
+                "get_hunyuan15.sh",
+                "Hunyuan-Video-1.5_720p_t2v-4-step-lora.json",
+                fetch_steps=(("common",), ("720p-t2v",), ("lora",)),
+            ),
+            ModelVariant(
+                "wan22",
+                "fp16",
+                "seko-v2-4step",
+                2007,
+                "get_wan22.sh",
+                "Wan2.2-T2V-A14B-FP16-4steps-lora-rank64-Seko-V2.json",
+                fetch_steps=(("common", "fp16"), ("14b-t2v", "fp16"), ("lora",)),
+            ),
+        ],
+    ),
+    "img2video": Capability(
+        id="img2video",
+        label="Image → Video",
+        default_family="ltx2",
+        alternatives=[
+            ModelVariant(
+                "ltx2",
+                "bf16",
+                None,
+                616,
+                "get_ltx2.sh",
+                "LTX2-I2V-BF16.json",
+                fetch_steps=(("common",), ("checkpoint", "bf16"), ("lora",)),
+            ),
+            ModelVariant(
+                "hunyuan15",
+                "fp16",
+                "lightx2v-4step",
+                947,
+                "get_hunyuan15.sh",
+                "Hunyuan-Video-1.5_720p_i2v-4-step-lora.json",
+                fetch_steps=(("common",), ("720p-i2v",), ("lora",)),
+            ),
+            ModelVariant(
+                "wan22",
+                "fp16",
+                "seko-v1-4step",
+                2029,
+                "get_wan22.sh",
+                "Wan2.2-I2V-A14B-4steps-lora-rank64-Seko-V1-FP16.json",
+                fetch_steps=(("common", "fp16"), ("14b-i2v", "fp16"), ("lora",)),
+            ),
+        ],
+    ),
+    "image_upscale": Capability(
+        id="image_upscale",
+        label="Upscale",
+        default_family="esrgan",
+        alternatives=[
+            ModelVariant(
+                "esrgan",
+                None,
+                None,
+                10,
+                "get_esrgan.sh",
+                "ESRGAN-4x-Upscale.json",
+                fetch_steps=((),),
+            ),
+        ],
+    ),
+}
diff --git a/src/hal0/comfyui/fetch.py b/src/hal0/comfyui/fetch.py
new file mode 100644
index 00000000..4aef8a0d
--- /dev/null
+++ b/src/hal0/comfyui/fetch.py
@@ -0,0 +1,115 @@
+"""Task 2.4: Async model fetch wrapper for ComfyUI scripts.
+
+Public API:
+    fetch_model(variant)  -> job_id   (NON-BLOCKING: starts background thread)
+    get_job(job_id)       -> dict | None
+    cancel_job(job_id)    -> bool
+
+Fix #872: scripts take POSITIONAL args (not --precision flags) and require
+MULTIPLE invocations per variant.  fetch_steps on ModelVariant encodes the
+exact argv for each invocation; a background worker iterates them
+sequentially, stopping on the first nonzero exit.
+
+fetch_model returns immediately so POST /api/comfyui/models/fetch can reply
+202 without blocking the FastAPI request for a multi-hour download.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import threading
+import uuid
+from pathlib import Path
+
+from hal0.comfyui.capabilities import ModelVariant
+
+# Scripts live at <repo-root>/installer/comfyui/scripts/
+_SCRIPTS_DIR: Path = (
+    Path(__file__).parent.parent.parent.parent / "installer" / "comfyui" / "scripts"
+)
+
+# Module-level job registry
+_JOBS: dict[str, dict] = {}
+
+
+def _run_sequence(rec: dict, script_path: str, fetch_steps: tuple[tuple[str, ...], ...]) -> None:
+    """Background worker: run each fetch step sequentially.
+
+    Stops on first nonzero exit (status='failed') or on cancellation
+    (status='cancelled', set by cancel_job).  Marks 'done' when all
+    steps exit 0.
+    """
+    for step_args in fetch_steps:
+        if rec["status"] == "cancelled":
+            return
+
+        cmd = ["bash", script_path, *step_args]
+        proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+        rec["_proc"] = proc
+
+        rc = proc.wait()
+
+        if rec["status"] == "cancelled":
+            return
+
+        if rc != 0:
+            rec["returncode"] = rc
+            rec["status"] = "failed"
+            return
+
+    rec["returncode"] = 0
+    rec["status"] = "done"
+
+
+def fetch_model(variant: ModelVariant) -> str:
+    """Start a background fetch for *variant* and return its job_id immediately.
+
+    Steps run in a daemon thread; poll status via get_job().  Non-blocking so
+    the 202-returning API endpoint does not stall on multi-hour downloads.
+    """
+    script_path = str(_SCRIPTS_DIR / variant.fetch_script)
+    job_id = str(uuid.uuid4())
+
+    rec: dict = {
+        "id": job_id,
+        "family": variant.family,
+        "status": "running",
+        "returncode": None,
+        "script": script_path,
+        "_proc": None,
+        "_thread": None,
+    }
+    _JOBS[job_id] = rec
+
+    t = threading.Thread(
+        target=_run_sequence,
+        args=(rec, script_path, variant.fetch_steps),
+        daemon=True,
+    )
+    rec["_thread"] = t
+    t.start()
+    return job_id
+
+
+def get_job(job_id: str) -> dict | None:
+    """Return job dict (without internal fields) or None if unknown.  Live status."""
+    rec = _JOBS.get(job_id)
+    if rec is None:
+        return None
+    return {k: v for k, v in rec.items() if not k.startswith("_")}
+
+
+def cancel_job(job_id: str) -> bool:
+    """Terminate the in-flight step.  Returns True if cancelled, False otherwise."""
+    rec = _JOBS.get(job_id)
+    if rec is None:
+        return False
+
+    if rec["status"] != "running":
+        return False
+
+    rec["status"] = "cancelled"
+    proc = rec.get("_proc")
+    if proc is not None:
+        proc.terminate()
+    return True
diff --git a/src/hal0/comfyui/selection.py b/src/hal0/comfyui/selection.py
new file mode 100644
index 00000000..3fdf4955
--- /dev/null
+++ b/src/hal0/comfyui/selection.py
@@ -0,0 +1,33 @@
+"""Task 3.5: ComfyUI model selection helpers.
+
+Public API:
+    auto_selections() -> list[ModelVariant]
+        Returns the default variant for every capability, in CAPABILITIES order.
+
+    variant_for(capability_id, family) -> ModelVariant
+        Looks up the variant with the given family within the capability.
+        Raises KeyError for unknown capability or unknown family.
+"""
+
+from __future__ import annotations
+
+from hal0.comfyui.capabilities import CAPABILITIES, ModelVariant, default_variant
+
+
+def auto_selections() -> list[ModelVariant]:
+    """Return the default ModelVariant for every capability in CAPABILITIES order."""
+    return [default_variant(cap) for cap in CAPABILITIES.values()]
+
+
+def variant_for(capability_id: str, family: str) -> ModelVariant:
+    """Return the ModelVariant with *family* from the named capability.
+
+    Raises:
+        KeyError: if *capability_id* is not in CAPABILITIES, or if no
+                  alternative in that capability has the given *family*.
+    """
+    cap = CAPABILITIES[capability_id]  # raises KeyError if unknown capability
+    for v in cap.alternatives:
+        if v.family == family:
+            return v
+    raise KeyError(f"{capability_id!r} has no variant with family {family!r}")
diff --git a/src/hal0/config/schema.py b/src/hal0/config/schema.py
index 47823ca5..e4acbc13 100644
--- a/src/hal0/config/schema.py
+++ b/src/hal0/config/schema.py
@@ -766,7 +766,7 @@ class ProvidersConfig(BaseModel):
         "quant": "",
     },
     "comfyui": {
-        "image": "docker.io/kyuz0/amd-strix-halo-comfyui:latest",
+        "image": "docker.io/kyuz0/amd-strix-halo-comfyui@sha256:0066678ae9043f69a1c8c7699e70626ceffd35c1a8ca03227a05640ad0241ed2",
         "flags": "--disable-mmap --bf16-vae --cache-none",
         "mtp": False,
         "device_class": "img",
diff --git a/src/hal0/install/extensions.py b/src/hal0/install/extensions.py
index f3d7e083..6d5723cf 100644
--- a/src/hal0/install/extensions.py
+++ b/src/hal0/install/extensions.py
@@ -23,6 +23,7 @@ class Extension:
 
 EXTENSIONS: list[Extension] = [
     Extension("openwebui", "app", "Open WebUI", "Chat web UI for your models", True),
+    Extension("comfyui", "app", "ComfyUI", "Image & video generation (iGPU)", True),
     Extension("hermes", "agent", "Hermes", "Conversational agent with memory", True),
     Extension("pi", "agent", "Pi", "Coding agent", False),
 ]
@@ -53,6 +54,10 @@ def install_extension(ext_id: str) -> ExtensionOutcome:
             _run(["hal0", "agent", "install", ext.id])
         elif ext.id == "openwebui":
             _run(["systemctl", "enable", "--now", "hal0-openwebui.service"])
+        elif ext.id == "comfyui":
+            # ComfyUI is owned by the seeded img slot. The legacy
+            # /opt/comfyui scripts remain manual operator tools only.
+            _run(["systemctl", "enable", "--now", "hal0-slot@img.service"])
         return ExtensionOutcome(ext_id=ext_id, installed=True)
     except Exception as exc:  # best-effort
         return ExtensionOutcome(ext_id=ext_id, error=str(exc))
diff --git a/src/hal0/install/orchestrate.py b/src/hal0/install/orchestrate.py
index 93727137..d5b75a00 100644
--- a/src/hal0/install/orchestrate.py
+++ b/src/hal0/install/orchestrate.py
@@ -38,6 +38,16 @@ class Selections:
     slots: list[SlotSelection]
     extensions: dict[str, bool]  # extension id -> enabled
     npu_opt_in: bool = False
+    # Task 3.5: ComfyUI default capability selections recorded at install time.
+    # These are NOT pulled at install — the operator triggers pulls later via
+    # POST /api/comfyui/models/fetch.  Stored as (capability_id, family) pairs
+    # so they survive serialisation without depending on capabilities.py here.
+    # NOTE: install-selection integration friction — Selections models LLM slots
+    # (chat/coder), not image-gen pickers; this field is a lightweight sidecar
+    # rather than a first-class slot because ComfyUI picks are capability/family
+    # pairs (no port, no model_id from the LLM registry).  A future refactor
+    # could lift ComfyUI picks into a dedicated setup phase.
+    comfyui_defaults: tuple[tuple[str, str], ...] = ()
 
 
 @dataclass
diff --git a/src/hal0/registry/curated.py b/src/hal0/registry/curated.py
index 8e43f866..7e2b5d43 100644
--- a/src/hal0/registry/curated.py
+++ b/src/hal0/registry/curated.py
@@ -492,6 +492,60 @@ class CuratedModel(BaseModel):
         model_class="sd-1.5",
         comfyui_subdir="checkpoints",
     ),
+    CuratedModel(
+        id="sdxl-lightning",
+        display_name="SDXL Lightning (8-step)",
+        description=(
+            "ByteDance's SDXL + Lightning LoRA distillation. 8-step fast txt2img "
+            "at full 1024x1024 SDXL quality on Strix Halo. CreativeML Open RAIL++"
+        ),
+        family="sdxl",
+        size_gb=6.8,
+        vram_gb_min=8.0,
+        license="CreativeML-OpenRAIL++",
+        license_url="https://huggingface.co/ByteDance/SDXL-Lightning/blob/main/LICENSE.md",
+        hf_repo="ByteDance/SDXL-Lightning",
+        hf_file="sdxl_lightning_8step_lora.safetensors",
+        context_length=0,
+        recommended_slot="img",
+        tags=["image", "sdxl", "fast", "lora"],
+        notes=(
+            "Requires the SDXL base checkpoint (stabilityai/stable-diffusion-xl-base-1.0) "
+            "already present in ComfyUI checkpoints/. Use the sdxl_lightning workflow "
+            "with 8 steps, cfg≈1.0, and the Lightning LoRA loaded at strength 1.0."
+        ),
+        capability="image",
+        model_class="image",
+        comfyui_subdir="checkpoints",
+    ),
+    CuratedModel(
+        id="esrgan-4x",
+        display_name="Real-ESRGAN 4x",
+        description=(
+            "xinntao's RealESRGAN x4plus upscaler. 4x upscale for post-processing "
+            "any ComfyUI output. Runs on CPU or GPU."
+        ),
+        family="esrgan",
+        size_gb=0.064,
+        vram_gb_min=0.5,
+        license="BSD-3-Clause",
+        license_url="https://github.com/xinntao/Real-ESRGAN/blob/master/LICENSE",
+        hf_repo="xinntao/Real-ESRGAN",
+        hf_file="RealESRGAN_x4plus.pth",
+        context_length=0,
+        recommended_slot="img",
+        tags=["image", "upscale", "esrgan"],
+        notes=(
+            "Direct download via get_esrgan.sh (installer/comfyui/scripts/). "
+            "The .pth is fetched from the GitHub release "
+            "v0.1.0 — not a standard HF safetensors pull. "
+            "Lands in ComfyUI upscale_models/ directory."
+        ),
+        capability="image",
+        model_class="image",
+        comfyui_subdir="upscale_models",
+        bundle_only=True,
+    ),
     # ── Bundle-only canonical defs (#500) ────────────────────────────────
     # These give the omni bundle manifests a single, loadable id to
     # reference. Ids match the legacy stock ``server_models.json`` keys
diff --git a/src/hal0/registry/pull.py b/src/hal0/registry/pull.py
index de2051d1..a860dc5a 100644
--- a/src/hal0/registry/pull.py
+++ b/src/hal0/registry/pull.py
@@ -172,20 +172,20 @@ def _final_path(model_id: str, filename: str) -> Path:
 
 
 def _comfyui_models_dir(subdir: str) -> Path:
-    """ComfyUI checkpoints/loras/vae directory under the persistent base dir.
+    """ComfyUI checkpoints/loras/vae directory under the model store.
 
-    Hal0 ComfyUI slots bind-mount ``/var/lib/hal0/comfyui`` into the
-    container at the same path, with ``models/<subdir>/<file>`` being
-    the layout ComfyUI's own ``CheckpointLoaderSimple`` /
-    ``LoraLoader`` / etc. expect when ``--base-directory`` points at
-    that root.
+    ComfyUI models live under the configurable model-store root
+    (default /mnt/ai-models) at /comfyui/models/<subdir>, aligned
+    with the slot's bind-mount path into the container. This ensures
+    ComfyUI's own CheckpointLoaderSimple / LoraLoader / etc. find
+    models when --base-directory points at the root.
 
     The subdir name is sanitised the same way model ids are so a curated
     entry can't escape the comfyui tree by setting
     ``comfyui_subdir="../../etc/passwd"``.
     """
     cleaned = _SANITISE_RE.sub("-", subdir).strip("-.") or "checkpoints"
-    return paths.var_lib() / "comfyui" / "models" / cleaned
+    return Path(paths.model_store_root()) / "comfyui" / "models" / cleaned
 
 
 def _final_path_for_entry(
diff --git a/tests/api/test_comfyui_fetch_route.py b/tests/api/test_comfyui_fetch_route.py
new file mode 100644
index 00000000..bd5dc7d8
--- /dev/null
+++ b/tests/api/test_comfyui_fetch_route.py
@@ -0,0 +1,100 @@
+"""Task 3.5 TDD: POST /api/comfyui/models/fetch route."""
+
+from __future__ import annotations
+
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+import hal0.comfyui.fetch as fetch_module
+from hal0.api import create_app
+from hal0.comfyui.capabilities import CAPABILITIES
+
+
+@pytest.fixture
+def client(tmp_hal0_home, monkeypatch):
+    """Isolated TestClient with fetch_model monkeypatched."""
+    call_log = []
+
+    def fake_fetch(variant):
+        job_id = f"fake-{variant.family}-{len(call_log)}"
+        call_log.append((variant, job_id))
+        return job_id
+
+    monkeypatch.setattr(fetch_module, "fetch_model", fake_fetch)
+
+    app: FastAPI = create_app()
+    with TestClient(app) as c:
+        yield c, call_log
+
+
+def test_auto_fetch_returns_202(client):
+    c, _call_log = client
+    resp = c.post("/api/comfyui/models/fetch", json={"auto": True})
+    assert resp.status_code == 202
+
+
+def test_auto_fetch_returns_5_jobs(client):
+    c, _call_log = client
+    resp = c.post("/api/comfyui/models/fetch", json={"auto": True})
+    data = resp.json()
+    assert "jobs" in data
+    assert len(data["jobs"]) == 5
+
+
+def test_auto_fetch_calls_fetch_model_per_capability(client):
+    c, call_log = client
+    c.post("/api/comfyui/models/fetch", json={"auto": True})
+    assert len(call_log) == len(CAPABILITIES)
+
+
+def test_auto_fetch_job_ids_match_response(client):
+    c, call_log = client
+    resp = c.post("/api/comfyui/models/fetch", json={"auto": True})
+    returned_ids = set(resp.json()["jobs"])
+    produced_ids = {jid for _, jid in call_log}
+    assert returned_ids == produced_ids
+
+
+def test_explicit_selections(client):
+    """Explicit selection list resolves to correct variants and calls fetch."""
+    c, call_log = client
+    resp = c.post(
+        "/api/comfyui/models/fetch",
+        json={
+            "selections": [
+                {"capability": "txt2img", "family": "sdxl"},
+                {"capability": "txt2video", "family": "wan22"},
+            ]
+        },
+    )
+    assert resp.status_code == 202
+    data = resp.json()
+    assert len(data["jobs"]) == 2
+    families = [v.family for v, _ in call_log]
+    assert "sdxl" in families
+    assert "wan22" in families
+
+
+def test_unknown_capability_returns_422(client):
+    c, _ = client
+    resp = c.post(
+        "/api/comfyui/models/fetch",
+        json={"selections": [{"capability": "bogus", "family": "foo"}]},
+    )
+    assert resp.status_code == 422
+
+
+def test_unknown_family_returns_422(client):
+    c, _ = client
+    resp = c.post(
+        "/api/comfyui/models/fetch",
+        json={"selections": [{"capability": "txt2img", "family": "no-such-model"}]},
+    )
+    assert resp.status_code == 422
+
+
+def test_missing_body_returns_422(client):
+    c, _ = client
+    resp = c.post("/api/comfyui/models/fetch", json={})
+    assert resp.status_code == 422
diff --git a/tests/api/test_comfyui_phase4.py b/tests/api/test_comfyui_phase4.py
new file mode 100644
index 00000000..faa438c4
--- /dev/null
+++ b/tests/api/test_comfyui_phase4.py
@@ -0,0 +1,531 @@
+"""Phase 4 TDD tests — control + monitoring routes for ComfyUI.
+
+Covers:
+  POST /api/comfyui/render/cancel   — clears queue + interrupts
+  POST /api/comfyui/restart         — restarts the slot-managed img runtime
+  GET  /api/comfyui/logs?tail=N     — container log lines
+  POST /api/comfyui/workflows/{name}/launch — reads workflow file + posts /prompt
+  GET  /api/comfyui/preview         — proxies latest output image bytes
+
+All network + subprocess calls are mocked — no real ComfyUI or container.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from types import SimpleNamespace
+from typing import ClassVar
+from unittest.mock import AsyncMock, MagicMock, Mock, patch
+
+import pytest
+from fastapi.testclient import TestClient
+
+# ---------------------------------------------------------------------------
+# Module-state isolation (same pattern as test_comfyui_proxy.py)
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture(autouse=True)
+def _reset_comfyui_state():
+    from hal0.api.routes import comfyui as mod
+
+    mod._reset_state()
+    yield
+    mod._reset_state()
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+_BASE = "hal0.api.routes.comfyui"
+
+
+def _make_proc(returncode: int = 0, stdout: bytes = b"") -> MagicMock:
+    """Return an AsyncMock that looks like asyncio.Process."""
+    proc = MagicMock()
+    proc.returncode = returncode
+    proc.communicate = AsyncMock(return_value=(stdout, b""))
+    return proc
+
+
+# ---------------------------------------------------------------------------
+# POST /api/comfyui/render/cancel
+# ---------------------------------------------------------------------------
+
+
+class TestRenderCancel:
+    def test_cancel_posts_clear_and_interrupt_returns_202(self, client: TestClient):
+        """cancel must POST {base}/queue?clear=true AND {base}/interrupt."""
+        posted = []
+
+        async def fake_post(url, **kwargs):
+            posted.append(url)
+            resp = MagicMock()
+            resp.status_code = 200
+            return resp
+
+        with patch(f"{_BASE}._get_client") as mock_client:
+            http = MagicMock()
+            http.post = AsyncMock(side_effect=fake_post)
+            mock_client.return_value = http
+
+            r = client.post("/api/comfyui/render/cancel")
+
+        assert r.status_code == 202
+        # both endpoints called
+        assert any("/queue" in u for u in posted), f"no /queue in {posted}"
+        assert any("/interrupt" in u for u in posted), f"no /interrupt in {posted}"
+
+    def test_cancel_is_fail_soft_when_comfyui_unreachable(self, client: TestClient):
+        """Network errors must still return 202 (fail-soft)."""
+        import httpx
+
+        with patch(f"{_BASE}._get_client") as mock_client:
+            http = MagicMock()
+            http.post = AsyncMock(side_effect=httpx.ConnectError("refused"))
+            mock_client.return_value = http
+
+            r = client.post("/api/comfyui/render/cancel")
+
+        assert r.status_code == 202
+
+
+# ---------------------------------------------------------------------------
+# POST /api/comfyui/restart
+# ---------------------------------------------------------------------------
+
+
+class TestRestart:
+    def test_restart_uses_slot_manager_img_restart(self, isolated_app_client):
+        """restart must use the slot-owned img runtime, not /opt/comfyui scripts."""
+        app, client = isolated_app_client
+        restarted = []
+
+        class _SlotManager:
+            async def restart(self, name):
+                restarted.append(name)
+
+        app.state.slot_manager = _SlotManager()
+
+        with patch("asyncio.create_subprocess_exec") as create_proc:
+            r = client.post("/api/comfyui/restart")
+
+        assert r.status_code == 202
+        assert restarted == ["img"]
+        create_proc.assert_not_called()
+
+    def test_restart_returns_503_when_slot_manager_unavailable(self, isolated_app_client):
+        app, client = isolated_app_client
+        app.state.slot_manager = None
+
+        r = client.post("/api/comfyui/restart")
+
+        assert r.status_code == 503
+        assert r.json()["error"]["code"] == "comfyui.arbiter_unavailable"
+
+    def test_restart_background_failure_is_fail_soft(self, isolated_app_client):
+        app, client = isolated_app_client
+
+        class _SlotManager:
+            async def restart(self, name):
+                raise RuntimeError("boom")
+
+        app.state.slot_manager = _SlotManager()
+
+        r = client.post("/api/comfyui/restart")
+
+        assert r.status_code == 202
+
+
+# ---------------------------------------------------------------------------
+# GET /api/comfyui/logs?tail=N
+# ---------------------------------------------------------------------------
+
+
+class TestLogs:
+    def _make_log_proc(self, lines: list[str]) -> MagicMock:
+        out = "\n".join(lines).encode()
+        return _make_proc(returncode=0, stdout=out)
+
+    def test_logs_returns_lines_list(self, client: TestClient):
+        log_lines = ["2026-06-16 startup ok", "loading model", "ready"]
+        proc = self._make_log_proc(log_lines)
+
+        with patch("asyncio.create_subprocess_exec", return_value=proc):
+            r = client.get("/api/comfyui/logs?tail=60")
+
+        assert r.status_code == 200
+        body = r.json()
+        assert "lines" in body
+        assert body["lines"] == log_lines
+
+    def test_logs_default_tail_60(self, client: TestClient):
+        """Default tail when not supplied must be 60."""
+        call_args_store = []
+
+        async def capture(*args, **kwargs):
+            call_args_store.extend(args)
+            return _make_proc(stdout=b"line1\nline2")
+
+        with patch("asyncio.create_subprocess_exec", side_effect=capture):
+            r = client.get("/api/comfyui/logs")
+
+        assert r.status_code == 200
+        joined = " ".join(str(a) for a in call_args_store)
+        assert "60" in joined, f"tail=60 not found in subprocess args: {call_args_store}"
+
+    def test_logs_custom_tail(self, client: TestClient):
+        """tail= query param must be forwarded to the container runtime."""
+        call_args_store = []
+
+        async def capture(*args, **kwargs):
+            call_args_store.extend(args)
+            return _make_proc(stdout=b"x")
+
+        with patch("asyncio.create_subprocess_exec", side_effect=capture):
+            r = client.get("/api/comfyui/logs?tail=10")
+
+        assert r.status_code == 200
+        joined = " ".join(str(a) for a in call_args_store)
+        assert "10" in joined
+
+    def test_logs_empty_when_no_container_runtime(self, client: TestClient):
+        """If docker/podman not found, return empty lines not a 500."""
+        with patch("shutil.which", return_value=None):
+            r = client.get("/api/comfyui/logs")
+
+        assert r.status_code == 200
+        assert r.json() == {"lines": []}
+
+
+# ---------------------------------------------------------------------------
+# POST /api/comfyui/workflows/{name}/launch
+# ---------------------------------------------------------------------------
+
+_SAMPLE_WORKFLOW = {
+    "1": {
+        "inputs": {"text": "a dog", "clip": ["2", 1]},
+        "class_type": "CLIPTextEncode",
+    }
+}
+
+
+class TestWorkflowLaunch:
+    def test_launch_reads_workflow_and_posts_to_prompt(
+        self, client: TestClient, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ):
+        """Happy path: workflow file found, POSTed to /prompt, 202 returned."""
+        wf_dir = tmp_path / "comfyui" / "workflows"
+        wf_dir.mkdir(parents=True)
+        wf_file = wf_dir / "test_wf.json"
+        wf_file.write_text(json.dumps(_SAMPLE_WORKFLOW))
+
+        monkeypatch.setenv("COMFYUI_WORKFLOWS_DIR", str(wf_dir))
+
+        prompt_id = "abc-123"
+
+        async def fake_post(url, **kwargs):
+            resp = MagicMock()
+            resp.status_code = 200
+            resp.json = Mock(return_value={"prompt_id": prompt_id})
+            return resp
+
+        with patch(f"{_BASE}._get_client") as mock_client:
+            http = MagicMock()
+            http.post = AsyncMock(side_effect=fake_post)
+            mock_client.return_value = http
+
+            r = client.post("/api/comfyui/workflows/test_wf/launch")
+
+        assert r.status_code == 202
+        body = r.json()
+        assert body["prompt_id"] == prompt_id
+
+    def test_launch_404_when_workflow_missing(
+        self, client: TestClient, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ):
+        wf_dir = tmp_path / "comfyui" / "workflows"
+        wf_dir.mkdir(parents=True)
+        monkeypatch.setenv("COMFYUI_WORKFLOWS_DIR", str(wf_dir))
+
+        r = client.post("/api/comfyui/workflows/nonexistent/launch")
+
+        assert r.status_code == 404
+        body = r.json()
+        assert body["error"]["message"] == "Workflow not found."
+        assert "nonexistent" not in body["error"]["message"]
+
+    def test_launch_rejects_invalid_workflow_name_before_filesystem_lookup(
+        self, client: TestClient, monkeypatch: pytest.MonkeyPatch
+    ):
+        monkeypatch.setenv("COMFYUI_WORKFLOWS_DIR", "/tmp/hal0-workflows")
+
+        with patch("hal0.api.routes.comfyui.os.path.isfile") as isfile:
+            r = client.post("/api/comfyui/workflows/..secret/launch")
+
+        assert r.status_code == 404
+        assert r.json()["error"]["message"] == "Workflow not found."
+        isfile.assert_not_called()
+
+    def test_launch_rejects_slash_workflow_name_without_filesystem_lookup(
+        self, client: TestClient, monkeypatch: pytest.MonkeyPatch
+    ):
+        monkeypatch.setenv("COMFYUI_WORKFLOWS_DIR", "/tmp/hal0-workflows")
+
+        with patch("hal0.api.routes.comfyui.os.path.isfile") as isfile:
+            r = client.post("/api/comfyui/workflows/bad%2Fname/launch")
+
+        assert r.status_code in {404, 422}
+        isfile.assert_not_called()
+
+    def test_launch_read_error_does_not_leak_raw_exception(
+        self, client: TestClient, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ):
+        wf_dir = tmp_path / "comfyui" / "workflows"
+        wf_dir.mkdir(parents=True)
+        (wf_dir / "broken.json").write_text("{not json")
+        monkeypatch.setenv("COMFYUI_WORKFLOWS_DIR", str(wf_dir))
+
+        r = client.post("/api/comfyui/workflows/broken/launch")
+
+        assert r.status_code == 500
+        body = r.json()
+        assert body["error"] == {
+            "code": "comfyui.workflow_read_error",
+            "message": "Workflow could not be read.",
+        }
+        assert "Expecting property name" not in r.text
+
+    def test_launch_falls_back_to_user_default_dir(
+        self, client: TestClient, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ):
+        """If primary dir has no match, fall back to user/default/workflows/."""
+        primary = tmp_path / "comfyui" / "workflows"
+        primary.mkdir(parents=True)
+        fallback = tmp_path / "comfyui" / "user" / "default" / "workflows"
+        fallback.mkdir(parents=True)
+        wf_file = fallback / "fb_wf.json"
+        wf_file.write_text(json.dumps(_SAMPLE_WORKFLOW))
+
+        # Point primary to the dir that does NOT have the file
+        monkeypatch.setenv("COMFYUI_WORKFLOWS_DIR", str(primary))
+        # Fallback is derived relative to the workflows dir's parent's parent
+        # The implementation should infer it from COMFYUI_MODELS_DIR base path
+        monkeypatch.setenv("COMFYUI_MODELS_DIR", str(tmp_path / "comfyui" / "models"))
+        # Override to point at the right base
+        monkeypatch.setenv("COMFYUI_DATA_DIR", str(tmp_path / "comfyui"))
+
+        async def fake_post(url, **kwargs):
+            resp = MagicMock()
+            resp.status_code = 200
+            resp.json = Mock(return_value={"prompt_id": "xyz"})
+            return resp
+
+        with patch(f"{_BASE}._get_client") as mock_client:
+            http = MagicMock()
+            http.post = AsyncMock(side_effect=fake_post)
+            mock_client.return_value = http
+
+            r = client.post("/api/comfyui/workflows/fb_wf/launch")
+
+        assert r.status_code == 202
+        assert r.json()["prompt_id"] == "xyz"
+
+
+# ---------------------------------------------------------------------------
+# GET /api/comfyui/preview
+# ---------------------------------------------------------------------------
+
+_HISTORY_RESP = {
+    "abc123": {
+        "outputs": {
+            "9": {"images": [{"filename": "ComfyUI_00001_.png", "subfolder": "", "type": "output"}]}
+        },
+        "timestamp": 1718530000.0,
+    }
+}
+
+
+class TestPreview:
+    def test_preview_404_when_no_history(self, client: TestClient):
+        """Empty history → 404."""
+
+        async def fetch(path):
+            if "/history" in path:
+                return {}
+            return None
+
+        with patch(f"{_BASE}._fetch_json", new_callable=AsyncMock, side_effect=fetch):
+            r = client.get("/api/comfyui/preview")
+
+        assert r.status_code == 404
+
+    def test_preview_streams_image_bytes(self, client: TestClient):
+        """When history has output, the image bytes are proxied back."""
+        png_bytes = b"\x89PNG\r\n\x1a\n" + b"\x00" * 20
+
+        async def fetch(path):
+            if "/history" in path:
+                return _HISTORY_RESP
+            return None
+
+        async def fake_get(url, **kwargs):
+            resp = MagicMock()
+            resp.status_code = 200
+            resp.content = png_bytes
+            resp.headers = {"content-type": "image/png"}
+            return resp
+
+        with (
+            patch(f"{_BASE}._fetch_json", new_callable=AsyncMock, side_effect=fetch),
+            patch(f"{_BASE}._get_client") as mock_client,
+        ):
+            http = MagicMock()
+            http.get = AsyncMock(side_effect=fake_get)
+            mock_client.return_value = http
+
+            r = client.get("/api/comfyui/preview")
+
+        assert r.status_code == 200
+        assert r.content == png_bytes
+        assert "image" in r.headers.get("content-type", "")
+
+    def test_preview_404_when_history_has_no_outputs(self, client: TestClient):
+        """History entry with empty outputs → 404."""
+        history = {"abc": {"outputs": {}, "timestamp": 1.0}}
+
+        async def fetch(path):
+            if "/history" in path:
+                return history
+            return None
+
+        with patch(f"{_BASE}._fetch_json", new_callable=AsyncMock, side_effect=fetch):
+            r = client.get("/api/comfyui/preview")
+
+        assert r.status_code == 404
+
+
+# ---------------------------------------------------------------------------
+# Telemetry: status payload checks (4.2)
+# ---------------------------------------------------------------------------
+
+
+class TestStatusTelemetry:
+    """Ensure /status fields needed by the pane are present and well-formed."""
+
+    _SYSTEM_STATS: ClassVar[dict] = {
+        "system": {"ram_total": 128 * 1024**3, "ram_free": 46 * 1024**3},
+        "devices": [
+            {
+                "name": "Radeon 8060S",
+                "type": "cuda",
+                "vram_total": 80 * 1024**3,
+                "vram_free": 26 * 1024**3,
+            }
+        ],
+    }
+    _QUEUE_IDLE: ClassVar[dict] = {"queue_running": [], "queue_pending": []}
+    _QUEUE_BUSY: ClassVar[dict] = {
+        "queue_running": [[0, "abc", {}, {}, {}]],
+        "queue_pending": [],
+    }
+
+    def _patch_status(
+        self,
+        stats,
+        queue,
+        *,
+        gpu_busy: float | None = 0.97,
+        power: dict | None = None,
+    ):
+        base = _BASE
+        power = power or {"gpu_temp_c": 68.5, "gpu_sclk_mhz": 2700.0}
+
+        async def fetch(path):
+            if "system_stats" in path:
+                return stats
+            if "queue" in path:
+                return queue
+            return None
+
+        return (
+            patch(f"{base}._container_state", new_callable=AsyncMock, return_value="running"),
+            patch(f"{base}._systemd_active", new_callable=AsyncMock, return_value=False),
+            patch(f"{base}._fetch_json", new_callable=AsyncMock, side_effect=fetch),
+            patch(
+                f"{base}.gpu_view.sample",
+                return_value=SimpleNamespace(gpu_busy=gpu_busy),
+            ),
+            patch(f"{base}._probe_power", return_value=power),
+        )
+
+    def test_status_memory_fields_present(self, client: TestClient):
+        patches = self._patch_status(self._SYSTEM_STATS, self._QUEUE_IDLE)
+        with patches[0], patches[1], patches[2], patches[3], patches[4]:
+            body = client.get("/api/comfyui/status").json()
+
+        mem = body["memory"]
+        assert mem is not None
+        assert "gtt_used_gb" in mem
+        assert "gtt_ceil_gb" in mem
+        assert "ram_used_gb" in mem
+        assert "ram_ceil_gb" in mem
+
+    def test_util_is_none_or_zero_when_no_running_job(self, client: TestClient):
+        """gpu_busy_percent is forced-high artifact — util must be 0/None when idle."""
+        patches = self._patch_status(self._SYSTEM_STATS, self._QUEUE_IDLE, gpu_busy=1.0)
+        with patches[0], patches[1], patches[2], patches[3], patches[4]:
+            body = client.get("/api/comfyui/status").json()
+
+        assert body["util"] == 0
+
+    def test_running_status_surfaces_live_gpu_telemetry(self, client: TestClient):
+        patches = self._patch_status(
+            self._SYSTEM_STATS,
+            self._QUEUE_BUSY,
+            gpu_busy=0.63,
+            power={"gpu_temp_c": 68.5, "gpu_sclk_mhz": 2700.0},
+        )
+        with patches[0], patches[1], patches[2], patches[3], patches[4]:
+            body = client.get("/api/comfyui/status").json()
+
+        assert body["util"] == 63.0
+        assert body["temp"] == 68.5
+        assert body["clock"] == 2.7
+
+    def test_it_s_eta_step_exist_as_null(self, client: TestClient):
+        """it/s, eta, step require a future ComfyUI websocket subscription."""
+        patches = self._patch_status(self._SYSTEM_STATS, self._QUEUE_BUSY)
+        with patches[0], patches[1], patches[2], patches[3], patches[4]:
+            body = client.get("/api/comfyui/status").json()
+
+        for field in ("it_s", "eta", "step"):
+            assert field in body
+            assert body[field] is None
+
+    def test_telemetry_probe_failure_is_fail_soft(self, client: TestClient):
+        base = _BASE
+
+        async def fetch(path):
+            if "system_stats" in path:
+                return self._SYSTEM_STATS
+            if "queue" in path:
+                return self._QUEUE_BUSY
+            return None
+
+        with (
+            patch(f"{base}._container_state", new_callable=AsyncMock, return_value="running"),
+            patch(f"{base}._systemd_active", new_callable=AsyncMock, return_value=False),
+            patch(f"{base}._fetch_json", new_callable=AsyncMock, side_effect=fetch),
+            patch(f"{base}.gpu_view.sample", side_effect=RuntimeError("gpu unavailable")),
+            patch(f"{base}._probe_power", side_effect=RuntimeError("hwmon unavailable")),
+        ):
+            response = client.get("/api/comfyui/status")
+
+        assert response.status_code == 200
+        body = response.json()
+        assert body["util"] is None
+        assert body["temp"] is None
+        assert body["clock"] is None
diff --git a/tests/api/test_services_comfyui.py b/tests/api/test_services_comfyui.py
new file mode 100644
index 00000000..e0805e32
--- /dev/null
+++ b/tests/api/test_services_comfyui.py
@@ -0,0 +1,96 @@
+"""TDD — Task 3.4: ComfyUI installer services step + repair.
+
+Assertions:
+  (a) GET /api/install/services includes a comfyui entry.
+  (b) repair path for comfyui restarts the slot-managed img unit.
+"""
+
+from __future__ import annotations
+
+
+def test_services_includes_comfyui(isolated_client, monkeypatch):
+    import hal0.api.routes.installer as inst
+
+    monkeypatch.setattr(inst, "_unit_active", lambda u: False)
+    r = isolated_client.get("/api/install/services")
+    assert r.status_code == 200, r.text
+    services = r.json()["services"]
+    units = [s.get("unit") or s.get("id") or "" for s in services]
+    assert any("comfyui" in u for u in units), (
+        f"comfyui not in services response; got units: {units}"
+    )
+
+
+def test_comfyui_repair_restarts_img_slot_unit(isolated_client, monkeypatch):
+    import hal0.api.routes.installer as inst
+
+    calls = []
+
+    def _fake_run(cmd, **kw):
+        calls.append(list(cmd))
+
+        class _R:
+            returncode = 0
+            stdout = ""
+
+        return _R()
+
+    monkeypatch.setattr(inst.subprocess, "run", _fake_run)
+    monkeypatch.setattr(inst.os, "geteuid", lambda: 0)
+    monkeypatch.setattr(inst, "_unit_active", lambda u: False)
+    monkeypatch.setattr(inst, "_container_active", lambda: True)
+
+    r = isolated_client.post("/api/install/services/comfyui/repair")
+    assert r.status_code == 200, r.text
+    assert calls, "repair made no subprocess calls"
+    assert calls[0] == [inst._SYSTEMCTL, "restart", inst._COMFYUI_SLOT_UNIT]
+
+
+def test_comfyui_repair_uses_sudo_when_non_root(isolated_client, monkeypatch):
+    import hal0.api.routes.installer as inst
+
+    calls = []
+
+    def _fake_run(cmd, **kw):
+        calls.append(list(cmd))
+
+        class _R:
+            returncode = 0
+            stdout = ""
+
+        return _R()
+
+    monkeypatch.setattr(inst.subprocess, "run", _fake_run)
+    monkeypatch.setattr(inst.os, "geteuid", lambda: 1001)
+    monkeypatch.setattr(inst, "_unit_active", lambda u: False)
+    monkeypatch.setattr(inst, "_container_active", lambda: True)
+
+    r = isolated_client.post("/api/install/services/comfyui/repair")
+    assert r.status_code == 200, r.text
+    assert calls[0] == ["sudo", "-n", inst._SYSTEMCTL, "restart", inst._COMFYUI_SLOT_UNIT]
+
+
+def test_comfyui_repair_not_blocked_by_unknown_unit_check(isolated_client, monkeypatch):
+    """Ensure comfyui repair returns 200, not 400 'unit not repairable'."""
+    import hal0.api.routes.installer as inst
+
+    calls = []
+
+    def _fake_run(cmd, **kw):
+        calls.append(list(cmd))
+
+        class _R:
+            returncode = 0
+            stdout = ""
+
+        return _R()
+
+    monkeypatch.setattr(inst.subprocess, "run", _fake_run)
+    monkeypatch.setattr(inst.os, "geteuid", lambda: 0)
+    monkeypatch.setattr(inst, "_unit_active", lambda u: False)
+    monkeypatch.setattr(inst, "_container_active", lambda: True)
+
+    r = isolated_client.post("/api/install/services/comfyui/repair")
+    assert r.status_code != 400, (
+        "comfyui repair returned 400 — it must not be gated by the systemd allowlist"
+    )
diff --git a/tests/comfyui/test_capabilities.py b/tests/comfyui/test_capabilities.py
new file mode 100644
index 00000000..a53517cd
--- /dev/null
+++ b/tests/comfyui/test_capabilities.py
@@ -0,0 +1,62 @@
+"""Task 2.2: ComfyUI capability registry — TDD tests."""
+
+import os
+
+from hal0.comfyui.capabilities import CAPABILITIES, default_variant
+
+SCRIPTS_DIR = os.path.join(
+    os.path.dirname(__file__),
+    "../../installer/comfyui/scripts",
+)
+
+
+def test_all_capability_ids_present():
+    assert set(CAPABILITIES.keys()) == {
+        "txt2img",
+        "img2img",
+        "txt2video",
+        "img2video",
+        "image_upscale",
+    }
+
+
+def test_txt2img_default_family():
+    assert CAPABILITIES["txt2img"].default_family == "qwen-image"
+
+
+def test_default_variant_est_seconds():
+    v = default_variant("txt2img")
+    assert v.est_seconds <= 80
+
+
+def test_ltx2_default_txt2video():
+    assert CAPABILITIES["txt2video"].default_family == "ltx2"
+    assert default_variant("txt2video").family == "ltx2"
+
+
+def test_ltx2_default_img2video():
+    assert CAPABILITIES["img2video"].default_family == "ltx2"
+    assert default_variant("img2video").family == "ltx2"
+
+
+def test_every_variant_fetch_script_exists():
+    for cap_id, cap in CAPABILITIES.items():
+        for v in cap.alternatives:
+            script_path = os.path.abspath(os.path.join(SCRIPTS_DIR, v.fetch_script))
+            assert os.path.isfile(script_path), (
+                f"{cap_id}/{v.family}: fetch_script {v.fetch_script!r} not found at {script_path}"
+            )
+
+
+def test_default_variant_is_first_alternative():
+    for cap_id, cap in CAPABILITIES.items():
+        v = default_variant(cap_id)
+        assert v is cap.alternatives[0], f"{cap_id}: default_variant should be first alternative"
+
+
+def test_capability_labels():
+    assert CAPABILITIES["txt2img"].label == "Text → Image"
+    assert CAPABILITIES["img2img"].label == "Image Edit"
+    assert CAPABILITIES["txt2video"].label == "Text → Video"
+    assert CAPABILITIES["img2video"].label == "Image → Video"
+    assert CAPABILITIES["image_upscale"].label == "Upscale"
diff --git a/tests/comfyui/test_fetch.py b/tests/comfyui/test_fetch.py
new file mode 100644
index 00000000..ac2c942c
--- /dev/null
+++ b/tests/comfyui/test_fetch.py
@@ -0,0 +1,306 @@
+"""#872: fetch_model TDD — recording shim captures every Popen call argv.
+
+Replaces old wrong-contract test that asserted --precision flag form for
+positional-arg scripts.
+
+fetch_model is NON-BLOCKING: it starts a daemon-thread worker and returns
+immediately.  Tests wait for the worker to finish (via _wait_done) before
+asserting terminal status / reading the recorder.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from unittest.mock import MagicMock
+
+from hal0.comfyui.capabilities import CAPABILITIES, default_variant
+from hal0.comfyui.fetch import cancel_job, fetch_model, get_job
+
+# ── helpers ───────────────────────────────────────────────────────────────────
+
+
+def _make_proc(returncode=0, pid=12345):
+    """Return a mock Popen process.  wait() returns returncode."""
+    proc = MagicMock()
+    proc.pid = pid
+    proc.returncode = returncode
+    proc.poll.return_value = returncode
+    proc.wait.return_value = returncode
+    return proc
+
+
+def _wait_done(job_id, timeout=5.0):
+    """Poll get_job until status != 'running' (worker finished).  Returns the job."""
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        job = get_job(job_id)
+        if job is not None and job["status"] != "running":
+            return job
+        time.sleep(0.005)
+    raise AssertionError(f"job {job_id} still running after {timeout}s")
+
+
+class _PopenRecorder:
+    """Monkeypatch target: records every Popen call's argv list."""
+
+    def __init__(self, procs):
+        self._procs = list(procs)
+        self._idx = 0
+        self.calls: list[list[str]] = []
+
+    def __call__(self, cmd, **kw):
+        self.calls.append(list(cmd))
+        p = self._procs[self._idx % len(self._procs)]
+        self._idx += 1
+        return p
+
+
+# ── variant fixtures ───────────────────────────────────────────────────────────
+
+LTX2_T2V = default_variant("txt2video")  # ltx2: common / checkpoint bf16 / lora
+LTX2_I2V = default_variant("img2video")  # ltx2 i2v
+ESRGAN = default_variant("image_upscale")  # esrgan: single empty-args call
+QWEN4STEP = default_variant("txt2img")  # qwen-image 4-step: choices 1+3
+QWEN4STEP_IMG = default_variant("img2img")  # qwen-image-edit 4-step: choices 2+4
+
+WAN22_T2V = CAPABILITIES["txt2video"].alternatives[2]
+WAN22_I2V = CAPABILITIES["img2video"].alternatives[2]
+HUNYUAN_T2V = CAPABILITIES["txt2video"].alternatives[1]
+
+
+# ── TestFetchSteps: ModelVariant carries correct fetch_steps ──────────────────
+
+
+class TestFetchSteps:
+    def test_ltx2_t2v_has_three_steps(self):
+        assert len(LTX2_T2V.fetch_steps) == 3
+
+    def test_ltx2_t2v_step_order(self):
+        steps = LTX2_T2V.fetch_steps
+        assert steps[0] == ("common",)
+        assert steps[1] == ("checkpoint", "bf16")
+        assert steps[2] == ("lora",)
+
+    def test_wan22_t2v_three_steps(self):
+        steps = WAN22_T2V.fetch_steps
+        assert len(steps) == 3
+        assert steps[0] == ("common", "fp16")
+        assert steps[1] == ("14b-t2v", "fp16")
+        assert steps[2] == ("lora",)
+
+    def test_wan22_i2v_uses_i2v_target(self):
+        steps = WAN22_I2V.fetch_steps
+        assert steps[1] == ("14b-i2v", "fp16")
+
+    def test_qwen_4step_two_calls(self):
+        steps = QWEN4STEP.fetch_steps
+        assert len(steps) == 2
+        assert steps[0] == ("1", "bf16")
+        assert steps[1] == ("3", "bf16")
+
+    def test_qwen_edit_4step_choices_2_and_4(self):
+        steps = QWEN4STEP_IMG.fetch_steps
+        assert steps[0] == ("2", "bf16")
+        assert steps[1] == ("4", "bf16")
+
+    def test_esrgan_one_empty_step(self):
+        steps = ESRGAN.fetch_steps
+        assert len(steps) == 1
+        assert steps[0] == ()
+
+    def test_hunyuan_t2v_no_precision_in_steps(self):
+        for step in HUNYUAN_T2V.fetch_steps:
+            assert "bf16" not in step and "fp16" not in step
+
+    def test_sdxl_flag_form(self):
+        sdxl = CAPABILITIES["txt2img"].alternatives[2]
+        assert sdxl.fetch_steps == (("--precision", "fp16"),)
+
+
+# ── TestFetchModel: multi-step invocation ─────────────────────────────────────
+
+
+class TestFetchModel:
+    def test_returns_job_id_string(self, monkeypatch):
+        rec = _PopenRecorder([_make_proc(0)] * 3)
+        monkeypatch.setattr("hal0.comfyui.fetch.subprocess.Popen", rec)
+        job_id = fetch_model(LTX2_T2V)
+        assert isinstance(job_id, str) and len(job_id) > 0
+        _wait_done(job_id)
+
+    def test_non_blocking_returns_while_step_running(self, monkeypatch):
+        """fetch_model must return BEFORE a slow step finishes; status=='running' then."""
+        release = threading.Event()
+        started = threading.Event()
+        proc = _make_proc(0)
+
+        def slow_wait():
+            started.set()
+            release.wait(timeout=5.0)
+            return 0
+
+        proc.wait.side_effect = slow_wait
+        monkeypatch.setattr("hal0.comfyui.fetch.subprocess.Popen", lambda *a, **kw: proc)
+
+        job_id = fetch_model(ESRGAN)
+        # worker has entered the (blocked) wait()
+        assert started.wait(timeout=5.0)
+        # fetch_model already returned while the step is still in wait()
+        assert get_job(job_id)["status"] == "running"
+        # let it finish cleanly
+        release.set()
+        _wait_done(job_id)
+
+    def test_ltx2_t2v_invokes_script_three_times(self, monkeypatch):
+        """get_ltx2.sh called 3 times: common, checkpoint bf16, lora."""
+        rec = _PopenRecorder([_make_proc(0)] * 3)
+        monkeypatch.setattr("hal0.comfyui.fetch.subprocess.Popen", rec)
+        job_id = fetch_model(LTX2_T2V)
+        _wait_done(job_id)
+        assert len(rec.calls) == 3
+
+    def test_ltx2_t2v_step_argv(self, monkeypatch):
+        rec = _PopenRecorder([_make_proc(0)] * 3)
+        monkeypatch.setattr("hal0.comfyui.fetch.subprocess.Popen", rec)
+        job_id = fetch_model(LTX2_T2V)
+        _wait_done(job_id)
+        # call[0]: bash get_ltx2.sh common
+        assert rec.calls[0][0] == "bash"
+        assert rec.calls[0][1].endswith("get_ltx2.sh")
+        assert rec.calls[0][2] == "common"
+        # call[1]: bash get_ltx2.sh checkpoint bf16
+        assert rec.calls[1][2:] == ["checkpoint", "bf16"]
+        # call[2]: bash get_ltx2.sh lora
+        assert rec.calls[2][2] == "lora"
+
+    def test_wan22_t2v_14b_t2v_step(self, monkeypatch):
+        rec = _PopenRecorder([_make_proc(0)] * 3)
+        monkeypatch.setattr("hal0.comfyui.fetch.subprocess.Popen", rec)
+        job_id = fetch_model(WAN22_T2V)
+        _wait_done(job_id)
+        assert rec.calls[1][2:] == ["14b-t2v", "fp16"]
+
+    def test_qwen_4step_two_calls_choices_1_and_3(self, monkeypatch):
+        rec = _PopenRecorder([_make_proc(0)] * 2)
+        monkeypatch.setattr("hal0.comfyui.fetch.subprocess.Popen", rec)
+        job_id = fetch_model(QWEN4STEP)
+        _wait_done(job_id)
+        assert len(rec.calls) == 2
+        assert rec.calls[0][2:] == ["1", "bf16"]
+        assert rec.calls[1][2:] == ["3", "bf16"]
+
+    def test_esrgan_one_call_no_extra_args(self, monkeypatch):
+        rec = _PopenRecorder([_make_proc(0)])
+        monkeypatch.setattr("hal0.comfyui.fetch.subprocess.Popen", rec)
+        job_id = fetch_model(ESRGAN)
+        _wait_done(job_id)
+        assert len(rec.calls) == 1
+        # argv: ["bash", "<path>/get_esrgan.sh"]
+        assert len(rec.calls[0]) == 2
+        assert rec.calls[0][1].endswith("get_esrgan.sh")
+
+    def test_job_has_family_field(self, monkeypatch):
+        rec = _PopenRecorder([_make_proc(0)] * 3)
+        monkeypatch.setattr("hal0.comfyui.fetch.subprocess.Popen", rec)
+        job_id = fetch_model(LTX2_T2V)
+        assert get_job(job_id)["family"] == "ltx2"
+        _wait_done(job_id)
+
+    def test_job_has_script_field(self, monkeypatch):
+        rec = _PopenRecorder([_make_proc(0)] * 3)
+        monkeypatch.setattr("hal0.comfyui.fetch.subprocess.Popen", rec)
+        job_id = fetch_model(LTX2_T2V)
+        job = get_job(job_id)
+        assert "script" in job
+        assert job["script"].endswith("get_ltx2.sh")
+        _wait_done(job_id)
+
+    def test_nonzero_step_marks_failed_and_stops(self, monkeypatch):
+        """Step 0 fails → job=failed, step 1+ NOT called."""
+        rec = _PopenRecorder([_make_proc(1)])  # only 1 proc; if called again it would loop
+        monkeypatch.setattr("hal0.comfyui.fetch.subprocess.Popen", rec)
+        job_id = fetch_model(LTX2_T2V)
+        job = _wait_done(job_id)
+        assert job["status"] == "failed"
+        assert len(rec.calls) == 1
+
+    def test_all_steps_done_marks_done(self, monkeypatch):
+        rec = _PopenRecorder([_make_proc(0)] * 3)
+        monkeypatch.setattr("hal0.comfyui.fetch.subprocess.Popen", rec)
+        job_id = fetch_model(LTX2_T2V)
+        job = _wait_done(job_id)
+        assert job["status"] == "done"
+        assert job["returncode"] == 0
+
+
+# ── TestGetJob ────────────────────────────────────────────────────────────────
+
+
+class TestGetJob:
+    def test_unknown_job_id_returns_none(self):
+        assert get_job("nonexistent-xyz") is None
+
+    def test_job_done_when_all_procs_exit_0(self, monkeypatch):
+        rec = _PopenRecorder([_make_proc(0)] * 3)
+        monkeypatch.setattr("hal0.comfyui.fetch.subprocess.Popen", rec)
+        job_id = fetch_model(LTX2_T2V)
+        assert _wait_done(job_id)["status"] == "done"
+
+    def test_job_failed_when_first_step_nonzero(self, monkeypatch):
+        rec = _PopenRecorder([_make_proc(1)])
+        monkeypatch.setattr("hal0.comfyui.fetch.subprocess.Popen", rec)
+        job_id = fetch_model(ESRGAN)
+        job = _wait_done(job_id)
+        assert job["status"] == "failed"
+        assert job["returncode"] == 1
+
+
+# ── TestCancelJob ─────────────────────────────────────────────────────────────
+
+
+class TestCancelJob:
+    def test_cancel_unknown_job_returns_false(self):
+        assert cancel_job("does-not-exist") is False
+
+    def test_cancel_done_job_returns_false(self, monkeypatch):
+        rec = _PopenRecorder([_make_proc(0)])
+        monkeypatch.setattr("hal0.comfyui.fetch.subprocess.Popen", rec)
+        job_id = fetch_model(ESRGAN)
+        _wait_done(job_id)
+        # job is done now; cancel should return False
+        assert cancel_job(job_id) is False
+
+    def test_cancel_failed_job_returns_false(self, monkeypatch):
+        rec = _PopenRecorder([_make_proc(1)])
+        monkeypatch.setattr("hal0.comfyui.fetch.subprocess.Popen", rec)
+        job_id = fetch_model(ESRGAN)
+        _wait_done(job_id)
+        assert cancel_job(job_id) is False
+
+    def test_cancel_running_job_terminates_and_marks_cancelled(self, monkeypatch):
+        """Cancel a job whose current step is still in wait(); proc.terminate() fires."""
+        release = threading.Event()
+        started = threading.Event()
+        proc = _make_proc(0)
+
+        def slow_wait():
+            started.set()
+            release.wait(timeout=5.0)
+            return 0
+
+        proc.wait.side_effect = slow_wait
+        monkeypatch.setattr("hal0.comfyui.fetch.subprocess.Popen", lambda *a, **kw: proc)
+
+        job_id = fetch_model(LTX2_T2V)
+        assert started.wait(timeout=5.0)  # worker is blocked in step 0's wait()
+
+        result = cancel_job(job_id)
+        assert result is True
+        proc.terminate.assert_called_once()
+        assert get_job(job_id)["status"] == "cancelled"
+
+        # unblock worker; it must observe cancelled and NOT advance to step 1
+        release.set()
+        time.sleep(0.05)
+        assert get_job(job_id)["status"] == "cancelled"
diff --git a/tests/comfyui/test_fetch_dryrun.py b/tests/comfyui/test_fetch_dryrun.py
new file mode 100644
index 00000000..a7ed725e
--- /dev/null
+++ b/tests/comfyui/test_fetch_dryrun.py
@@ -0,0 +1,44 @@
+"""#872: Real (non-mock) smoke tests for flag-form fetch scripts.
+
+Runs get_esrgan.sh --dry-run and get_sdxl.sh --precision fp16 --dry-run
+to verify the argv built by fetch_model is actually valid for those scripts.
+No network access; no HF tool required.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+SCRIPTS_DIR = Path(__file__).parent.parent.parent / "installer" / "comfyui" / "scripts"
+
+
+def _run_script(name: str, *args: str, tmp_path: Path) -> subprocess.CompletedProcess:
+    env = {
+        "MODEL_DIR": str(tmp_path),
+        "HOME": str(tmp_path),
+        "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+    }
+    return subprocess.run(
+        ["bash", str(SCRIPTS_DIR / name), *args],
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+
+
+def test_esrgan_dryrun(tmp_path):
+    """get_esrgan.sh --dry-run exits 0 and mentions upscale_models."""
+    result = _run_script("get_esrgan.sh", "--dry-run", tmp_path=tmp_path)
+    assert result.returncode == 0, f"get_esrgan.sh --dry-run failed:\n{result.stderr}"
+    assert "upscale_models" in result.stdout
+
+
+def test_sdxl_precision_dryrun(tmp_path):
+    """get_sdxl.sh --precision fp16 --dry-run exits 0 and mentions checkpoints/loras/vae."""
+    result = _run_script("get_sdxl.sh", "--precision", "fp16", "--dry-run", tmp_path=tmp_path)
+    assert result.returncode == 0, (
+        f"get_sdxl.sh --precision fp16 --dry-run failed:\n{result.stderr}"
+    )
+    for subdir in ("checkpoints", "loras", "vae"):
+        assert subdir in result.stdout, f"dry-run output missing '{subdir}'"
diff --git a/tests/comfyui/test_fetch_scripts.py b/tests/comfyui/test_fetch_scripts.py
new file mode 100644
index 00000000..df197ab5
--- /dev/null
+++ b/tests/comfyui/test_fetch_scripts.py
@@ -0,0 +1,129 @@
+"""
+TDD: Task 2.3 — vendor fetch scripts + 2 new (get_sdxl.sh, get_esrgan.sh).
+
+Tests:
+  1. Every script passes bash -n (syntax check).
+  2. set_extra_paths.sh output YAML has exactly 8 model-type keys + base_path /mnt/ai-models/comfyui/models.
+  3. get_sdxl.sh --dry-run lists expected target subdirs (checkpoints, loras, vae).
+  4. get_esrgan.sh --dry-run lists expected target subdir (upscale_models).
+"""
+
+import subprocess
+from pathlib import Path
+
+import pytest
+import yaml
+
+SCRIPTS_DIR = Path(__file__).parent.parent.parent / "installer" / "comfyui" / "scripts"
+MODEL_STORE = "/mnt/ai-models/comfyui/models"
+
+EXPECTED_SCRIPTS = [
+    "set_extra_paths.sh",
+    "get_qwen_image.sh",
+    "get_wan22.sh",
+    "get_hunyuan15.sh",
+    "get_ltx2.sh",
+    "get_sdxl.sh",
+    "get_esrgan.sh",
+]
+
+EXPECTED_YAML_KEYS = {
+    "text_encoders",
+    "vae",
+    "checkpoints",
+    "diffusion_models",
+    "unet",
+    "loras",
+    "latent_upscale_models",
+    "clip_vision",
+}
+
+
+@pytest.mark.parametrize("name", EXPECTED_SCRIPTS)
+def test_script_exists(name):
+    assert (SCRIPTS_DIR / name).exists(), f"Missing: {SCRIPTS_DIR / name}"
+
+
+@pytest.mark.parametrize("name", EXPECTED_SCRIPTS)
+def test_script_bash_syntax(name):
+    path = SCRIPTS_DIR / name
+    result = subprocess.run(["bash", "-n", str(path)], capture_output=True, text=True)
+    assert result.returncode == 0, f"bash -n failed for {name}:\n{result.stderr}"
+
+
+@pytest.mark.parametrize("name", EXPECTED_SCRIPTS)
+def test_script_executable(name):
+    path = SCRIPTS_DIR / name
+    assert path.stat().st_mode & 0o111, f"Not executable: {name}"
+
+
+def test_set_extra_paths_yaml_keys(tmp_path):
+    """set_extra_paths.sh must write YAML with 8 model-type keys + correct base_path."""
+    fake_comfy = tmp_path / "ComfyUI"
+    fake_comfy.mkdir()
+    yaml_file = fake_comfy / "extra_model_paths.yaml"
+    model_store = tmp_path / "model-store" / "comfyui" / "models"
+
+    script = SCRIPTS_DIR / "set_extra_paths.sh"
+    env = {
+        "CONFY_DIR": str(fake_comfy),
+        "MODEL_DIR": str(model_store),
+        "HOME": str(tmp_path),
+        "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+    }
+    result = subprocess.run(
+        ["bash", str(script)],
+        env=env,
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode == 0, f"set_extra_paths.sh failed:\n{result.stderr}\n{result.stdout}"
+    assert yaml_file.exists(), "YAML file not written"
+
+    data = yaml.safe_load(yaml_file.read_text())
+    comfy_section = data.get("comfyui", {})
+
+    assert comfy_section.get("base_path") == str(model_store), (
+        f"base_path wrong: {comfy_section.get('base_path')!r} != {str(model_store)!r}"
+    )
+
+    actual_keys = set(comfy_section.keys()) - {"base_path"}
+    assert actual_keys == EXPECTED_YAML_KEYS, (
+        f"YAML keys mismatch.\n  expected: {sorted(EXPECTED_YAML_KEYS)}\n  actual:   {sorted(actual_keys)}"
+    )
+
+
+def test_get_sdxl_dry_run(tmp_path):
+    """get_sdxl.sh --dry-run must mention checkpoints, loras, and vae subdirs."""
+    script = SCRIPTS_DIR / "get_sdxl.sh"
+    result = subprocess.run(
+        ["bash", str(script), "--dry-run"],
+        capture_output=True,
+        text=True,
+        env={
+            "MODEL_DIR": str(tmp_path),
+            "HOME": str(tmp_path),
+            "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+        },
+    )
+    assert result.returncode == 0, f"get_sdxl.sh --dry-run failed:\n{result.stderr}"
+    output = result.stdout
+    for subdir in ("checkpoints", "loras", "vae"):
+        assert subdir in output, f"--dry-run output missing '{subdir}'"
+
+
+def test_get_esrgan_dry_run(tmp_path):
+    """get_esrgan.sh --dry-run must mention upscale_models subdir."""
+    script = SCRIPTS_DIR / "get_esrgan.sh"
+    result = subprocess.run(
+        ["bash", str(script), "--dry-run"],
+        capture_output=True,
+        text=True,
+        env={
+            "MODEL_DIR": str(tmp_path),
+            "HOME": str(tmp_path),
+            "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+        },
+    )
+    assert result.returncode == 0, f"get_esrgan.sh --dry-run failed:\n{result.stderr}"
+    assert "upscale_models" in result.stdout, "--dry-run output missing 'upscale_models'"
diff --git a/tests/comfyui/test_selection.py b/tests/comfyui/test_selection.py
new file mode 100644
index 00000000..8796c2da
--- /dev/null
+++ b/tests/comfyui/test_selection.py
@@ -0,0 +1,51 @@
+"""Task 3.5 TDD: selection.py — auto_selections + variant_for."""
+
+from __future__ import annotations
+
+import pytest
+
+from hal0.comfyui.capabilities import CAPABILITIES, ModelVariant
+from hal0.comfyui.selection import auto_selections, variant_for
+
+
+def test_auto_selections_count():
+    """One variant per capability (5 total)."""
+    result = auto_selections()
+    assert len(result) == len(CAPABILITIES) == 5
+
+
+def test_auto_selections_are_model_variants():
+    for v in auto_selections():
+        assert isinstance(v, ModelVariant)
+
+
+def test_auto_selections_match_defaults():
+    """Each returned variant == the capability's first alternative."""
+    result = auto_selections()
+    cap_list = list(CAPABILITIES.values())
+    for v, cap in zip(result, cap_list, strict=False):
+        assert v is cap.alternatives[0], f"{cap.id}: expected first alternative"
+
+
+def test_variant_for_known():
+    """variant_for('txt2video', 'wan22') resolves to the wan22 variant."""
+    v = variant_for("txt2video", "wan22")
+    assert v.family == "wan22"
+
+
+def test_variant_for_default_family():
+    """variant_for returns the correct variant for the default family."""
+    v = variant_for("txt2img", "qwen-image")
+    assert v.family == "qwen-image"
+    assert v is CAPABILITIES["txt2img"].alternatives[0]
+
+
+def test_variant_for_unknown_capability_raises():
+    with pytest.raises(KeyError):
+        variant_for("nonexistent", "foo")
+
+
+def test_variant_for_unknown_family_raises():
+    """Unknown family within a valid capability raises KeyError."""
+    with pytest.raises(KeyError):
+        variant_for("txt2img", "no-such-model")
diff --git a/tests/install/test_comfyui_extra_paths.py b/tests/install/test_comfyui_extra_paths.py
new file mode 100644
index 00000000..d1096a25
--- /dev/null
+++ b/tests/install/test_comfyui_extra_paths.py
@@ -0,0 +1,41 @@
+"""TDD — Task 3.2: extra_model_paths.yaml template shipped.
+
+Assertions:
+  (a) installer/comfyui/extra_model_paths.yaml exists.
+  (b) Parses as valid YAML.
+  (c) comfyui.base_path == "/root/comfy-models".
+  (d) Required keys present: checkpoints, loras, vae, upscale_models.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+REPO = Path(__file__).parent.parent.parent
+YAML_PATH = REPO / "installer" / "comfyui" / "extra_model_paths.yaml"
+
+
+def test_extra_model_paths_file_exists():
+    assert YAML_PATH.exists(), f"Missing: {YAML_PATH}"
+
+
+def test_extra_model_paths_parses_as_yaml():
+    yaml = pytest.importorskip("yaml")
+    data = yaml.safe_load(YAML_PATH.read_text())
+    assert isinstance(data, dict), "YAML root must be a mapping"
+
+
+def test_extra_model_paths_base_path():
+    yaml = pytest.importorskip("yaml")
+    data = yaml.safe_load(YAML_PATH.read_text())
+    assert data["comfyui"]["base_path"] == "/root/comfy-models"
+
+
+def test_extra_model_paths_required_keys():
+    yaml = pytest.importorskip("yaml")
+    data = yaml.safe_load(YAML_PATH.read_text())
+    section = data["comfyui"]
+    for key in ("checkpoints", "loras", "vae", "upscale_models"):
+        assert key in section, f"Missing key: {key}"
diff --git a/tests/install/test_comfyui_scripts_shipped.py b/tests/install/test_comfyui_scripts_shipped.py
new file mode 100644
index 00000000..7af33ed4
--- /dev/null
+++ b/tests/install/test_comfyui_scripts_shipped.py
@@ -0,0 +1,103 @@
+"""TDD — Task 3.1: Ship ComfyUI control scripts.
+
+Three assertions:
+  (a) All shipped scripts exist in installer/comfyui/scripts/ and are bash -n clean.
+  (b) Every /opt/comfyui/*.sh path referenced in src/hal0/api/routes/comfyui.py
+      has a matching shipped script in installer/comfyui/scripts/.
+  (c) installer/install.sh contains the /opt/comfyui placement block.
+"""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from pathlib import Path
+
+# Repo root = three levels up from tests/install/
+REPO = Path(__file__).parent.parent.parent
+SCRIPTS_DIR = REPO / "installer" / "comfyui" / "scripts"
+COMFYUI_PY = REPO / "src" / "hal0" / "api" / "routes" / "comfyui.py"
+INSTALL_SH = REPO / "installer" / "install.sh"
+
+EXPECTED_SCRIPTS = [
+    "comfy-up.sh",
+    "comfy-down.sh",
+    "comfy-logs.sh",
+    "comfy-postinstall.sh",
+]
+
+
+# ── (a) scripts exist and are bash -n clean ──────────────────────────────────
+
+
+def test_all_scripts_exist():
+    missing = [s for s in EXPECTED_SCRIPTS if not (SCRIPTS_DIR / s).exists()]
+    assert not missing, f"Missing scripts in {SCRIPTS_DIR}: {missing}"
+
+
+def test_all_scripts_are_executable():
+    import stat
+
+    not_exec = [s for s in EXPECTED_SCRIPTS if not (SCRIPTS_DIR / s).stat().st_mode & stat.S_IXUSR]
+    assert not not_exec, f"Scripts not executable: {not_exec}"
+
+
+def test_all_scripts_bash_syntax_clean():
+    errors = []
+    for name in EXPECTED_SCRIPTS:
+        path = SCRIPTS_DIR / name
+        if not path.exists():
+            errors.append(f"{name}: file not found")
+            continue
+        result = subprocess.run(
+            ["bash", "-n", str(path)],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            errors.append(f"{name}: {result.stderr.strip()}")
+    assert not errors, "bash -n failures:\n" + "\n".join(errors)
+
+
+# ── (b) comfyui.py /opt/comfyui/*.sh references covered ─────────────────────
+
+
+def test_comfyui_py_script_refs_all_shipped():
+    """Every /opt/comfyui/<name>.sh referenced in comfyui.py must be shipped.
+
+    NOTE: comfyui.py currently does NOT shell out (the API comment explicitly
+    states the scripts are for manual ops only).  This test will pass with an
+    empty reference set, but will catch regressions if someone adds a
+    subprocess call to a script that isn't shipped.
+    """
+    source = COMFYUI_PY.read_text()
+    # Match any string literal containing /opt/comfyui/<something>.sh
+    refs = re.findall(r"/opt/comfyui/([\w.-]+\.sh)", source)
+    shipped = {s for s in EXPECTED_SCRIPTS}
+    missing = [r for r in refs if r not in shipped]
+    assert not missing, f"comfyui.py references /opt/comfyui/ scripts not in shipped set: {missing}"
+
+
+# ── (c) install.sh places scripts at /opt/comfyui ────────────────────────────
+
+
+def test_install_sh_contains_opt_comfyui_placement():
+    content = INSTALL_SH.read_text()
+    assert "/opt/comfyui" in content, "installer/install.sh has no /opt/comfyui placement block"
+    # More specific: must use install command to copy the scripts
+    assert "installer/comfyui/scripts" in content or "comfyui/scripts" in content, (
+        "installer/install.sh does not reference installer/comfyui/scripts"
+    )
+
+
+def test_install_sh_uses_install_command_for_scripts():
+    content = INSTALL_SH.read_text()
+    # Should contain something like: install -m0755 .../comfyui/scripts/*.sh /opt/comfyui/
+    # We look for the pattern of install + comfyui scripts + /opt/comfyui
+    has_install_block = (
+        "install -d /opt/comfyui" in content
+        or 'install -d "${PREFIX}/opt/comfyui"' in content
+        or 'install -d "${PREFIX}/opt/comfyui"' in content
+        or "COMFYUI_DIR" in content
+    )
+    assert has_install_block, "install.sh does not contain 'install -d /opt/comfyui' or equivalent"
diff --git a/tests/install/test_comfyui_sudoers.py b/tests/install/test_comfyui_sudoers.py
new file mode 100644
index 00000000..b7a4ecbe
--- /dev/null
+++ b/tests/install/test_comfyui_sudoers.py
@@ -0,0 +1,53 @@
+"""ComfyUI sudoers contract for hardened non-root hal0-api installs."""
+
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+REPO = Path(__file__).parent.parent.parent
+SUDOERS = REPO / "packaging" / "sudoers" / "hal0-comfyui"
+INSTALL_SH = REPO / "installer" / "install.sh"
+
+
+def _sudoers_commands() -> set[str]:
+    body = "\n".join(
+        line for line in SUDOERS.read_text().splitlines() if not line.lstrip().startswith("#")
+    )
+    body = body.replace("\\\n", " ")
+    match = re.search(r"NOPASSWD:\s*(?P<commands>.+)", body, flags=re.S)
+    assert match, "sudoers file must contain a NOPASSWD grant"
+    return {cmd.strip() for cmd in match.group("commands").split(",") if cmd.strip()}
+
+
+def test_install_sh_installs_comfyui_sudoers_file() -> None:
+    content = INSTALL_SH.read_text()
+    assert "install -m0440" in content
+    assert "packaging/sudoers/hal0-comfyui" in content
+    assert "/etc/sudoers.d/hal0-comfyui" in content
+
+
+def test_sudoers_grants_only_route_invoked_comfyui_commands() -> None:
+    from hal0.api.routes import installer
+
+    expected = f"{installer._SYSTEMCTL} restart {installer._COMFYUI_SLOT_UNIT}"
+    assert _sudoers_commands() == {expected}
+
+
+def test_sudoers_grants_no_wildcards() -> None:
+    assert "*" not in "\n".join(_sudoers_commands())
+
+
+def test_sudoers_visudo_check_passes_when_available() -> None:
+    visudo = shutil.which("visudo")
+    if visudo is None:
+        return
+    result = subprocess.run(
+        [visudo, "-cf", str(SUDOERS)],
+        capture_output=True,
+        text=True,
+        timeout=10,
+    )
+    assert result.returncode == 0, result.stderr or result.stdout
diff --git a/tests/install/test_extensions_comfyui.py b/tests/install/test_extensions_comfyui.py
new file mode 100644
index 00000000..d41af3cb
--- /dev/null
+++ b/tests/install/test_extensions_comfyui.py
@@ -0,0 +1,41 @@
+"""TDD — Task 3.3: ComfyUI extensions-registry entry.
+
+Assertions:
+  (a) "comfyui" is in EXTENSIONS (by id).
+  (b) install_extension("comfyui") enables the slot-managed img unit.
+"""
+
+from __future__ import annotations
+
+
+def test_comfyui_in_extensions():
+    from hal0.install.extensions import EXTENSIONS
+
+    ids = [e.id for e in EXTENSIONS]
+    assert "comfyui" in ids, f"comfyui missing from EXTENSIONS; got: {ids}"
+
+
+def test_comfyui_extension_metadata():
+    from hal0.install.extensions import get_extension
+
+    ext = get_extension("comfyui")
+    assert ext is not None
+    assert ext.kind == "app"
+    assert ext.default_enabled is True
+
+
+def test_install_extension_comfyui_enables_img_slot(monkeypatch):
+    """install_extension('comfyui') must use the slot-owned img runtime."""
+    import hal0.install.extensions as exts
+
+    called = []
+
+    def _fake_run(cmd, **kw):
+        called.append(cmd)
+
+    monkeypatch.setattr(exts, "_run", _fake_run)
+
+    result = exts.install_extension("comfyui")
+    assert result.installed is True or result.skipped is None
+    assert called, "install_extension('comfyui') made no subprocess call"
+    assert called[0] == ["systemctl", "enable", "--now", "hal0-slot@img.service"]
diff --git a/tests/registry/test_comfyui_path.py b/tests/registry/test_comfyui_path.py
new file mode 100644
index 00000000..670070da
--- /dev/null
+++ b/tests/registry/test_comfyui_path.py
@@ -0,0 +1,15 @@
+"""TDD: test _comfyui_models_dir uses model_store_root() instead of hardcoded /var/lib/hal0."""
+
+from hal0.config import paths
+from hal0.registry import pull
+
+
+def test_comfyui_models_dir_uses_store_root(monkeypatch, tmp_path):
+    """_comfyui_models_dir must return model_store_root()/comfyui/models/<subdir>."""
+    # Monkeypatch model_store_root to return tmp_path
+    monkeypatch.setattr(paths, "model_store_root", lambda: str(tmp_path))
+
+    result = pull._comfyui_models_dir("loras")
+    expected = tmp_path / "comfyui" / "models" / "loras"
+
+    assert result == expected
diff --git a/tests/registry/test_curated_comfyui.py b/tests/registry/test_curated_comfyui.py
new file mode 100644
index 00000000..18261848
--- /dev/null
+++ b/tests/registry/test_curated_comfyui.py
@@ -0,0 +1,60 @@
+"""TDD: curated catalogue includes sdxl-lightning and esrgan-4x entries.
+
+Task 2.5 — ComfyUI image-gen models: SDXL Lightning + ESRGAN 4x.
+"""
+
+from __future__ import annotations
+
+from hal0.registry.curated import CURATED_MODELS, get_curated
+
+
+def _by_id(model_id: str):
+    return next((m for m in CURATED_MODELS if m.id == model_id), None)
+
+
+def test_sdxl_lightning_present():
+    """sdxl-lightning must be in the curated catalogue."""
+    ids = {m.id for m in CURATED_MODELS}
+    assert "sdxl-lightning" in ids
+
+
+def test_esrgan_4x_present():
+    """esrgan-4x must be in the curated catalogue."""
+    ids = {m.id for m in CURATED_MODELS}
+    assert "esrgan-4x" in ids
+
+
+def test_sdxl_lightning_model_class_image():
+    m = get_curated("sdxl-lightning")
+    assert m is not None
+    assert m.model_class == "image", f"got {m.model_class!r}"
+
+
+def test_esrgan_4x_model_class_image():
+    m = get_curated("esrgan-4x")
+    assert m is not None
+    assert m.model_class == "image", f"got {m.model_class!r}"
+
+
+def test_sdxl_lightning_comfyui_subdir():
+    m = get_curated("sdxl-lightning")
+    assert m is not None
+    assert m.comfyui_subdir == "checkpoints"
+
+
+def test_esrgan_4x_comfyui_subdir():
+    m = get_curated("esrgan-4x")
+    assert m is not None
+    assert m.comfyui_subdir == "upscale_models"
+
+
+def test_sdxl_lightning_capability_image():
+    m = get_curated("sdxl-lightning")
+    assert m is not None
+    assert m.capability == "image"
+
+
+def test_esrgan_4x_capability_image():
+    m = get_curated("esrgan-4x")
+    assert m is not None
+    assert m.capability == "image"
diff --git a/tests/registry/test_curated_image_models.py b/tests/registry/test_curated_image_models.py
index e14d8565..31dda60e 100644
--- a/tests/registry/test_curated_image_models.py
+++ b/tests/registry/test_curated_image_models.py
@@ -5,7 +5,7 @@
   1. The curated catalogue itself — every image entry validates and
      declares the metadata the workflow translator + pull layer need.
   2. ``hal0.registry.pull.run_pull`` honours ``comfyui_subdir`` so
-     SDXL Turbo lands in ``/var/lib/hal0/comfyui/models/checkpoints/``
+     SDXL Turbo lands in ``model_store_root()/comfyui/models/checkpoints/``
      instead of the default per-id models tree.
 """
 
@@ -74,21 +74,19 @@ def test_get_curated_lookup_for_image_entries() -> None:
 # ─── pull path routing ───────────────────────────────────────────────────────
 
 
-def test_final_path_routes_to_comfyui_subdir(tmp_hal0_home: str) -> None:
+def test_final_path_routes_to_comfyui_subdir(
+    tmp_hal0_home: str, monkeypatch: pytest.MonkeyPatch
+) -> None:
     """An entry with comfyui_subdir lands under the ComfyUI models tree."""
+    model_store = Path(tmp_hal0_home) / "model-store"
+    monkeypatch.setenv("HAL0_MODEL_STORE", str(model_store))
     p = _final_path_for_entry(
         "sdxl-turbo",
         "sd_xl_turbo_1.0_fp16.safetensors",
         comfyui_subdir="checkpoints",
     )
     expected = (
-        Path(tmp_hal0_home)
-        / "var-lib"
-        / "hal0"
-        / "comfyui"
-        / "models"
-        / "checkpoints"
-        / "sd_xl_turbo_1.0_fp16.safetensors"
+        model_store / "comfyui" / "models" / "checkpoints" / "sd_xl_turbo_1.0_fp16.safetensors"
     )
     assert p == expected
 
@@ -100,14 +98,16 @@ def test_final_path_falls_back_to_default_layout(tmp_hal0_home: str) -> None:
     assert p == expected
 
 
-def test_comfyui_subdir_is_path_safe(tmp_hal0_home: str) -> None:
+def test_comfyui_subdir_is_path_safe(tmp_hal0_home: str, monkeypatch: pytest.MonkeyPatch) -> None:
     """A malicious comfyui_subdir can't escape the comfyui/models tree."""
+    model_store = Path(tmp_hal0_home) / "model-store"
+    monkeypatch.setenv("HAL0_MODEL_STORE", str(model_store))
     p = _comfyui_models_dir("../../etc/passwd")
     # Sanitiser maps anything outside [A-Za-z0-9._-] to '-' and strips
     # leading dashes — result is a single flat name under comfyui/models.
     assert p.name == "etc-passwd"
-    # Critically: the path stays directly under <hal0_home>/var-lib/hal0/comfyui/models/
-    assert p.parent == paths.var_lib() / "comfyui" / "models"
+    # Critically: the path stays directly under model_store_root()/comfyui/models/
+    assert p.parent == Path(paths.model_store_root()) / "comfyui" / "models"
 
 
 def test_comfyui_subdir_empty_falls_back_to_checkpoints(tmp_hal0_home: str) -> None:
@@ -117,8 +117,12 @@ def test_comfyui_subdir_empty_falls_back_to_checkpoints(tmp_hal0_home: str) -> N
 
 
 @pytest.mark.asyncio
-async def test_run_pull_writes_to_comfyui_subdir(tmp_hal0_home: str) -> None:
+async def test_run_pull_writes_to_comfyui_subdir(
+    tmp_hal0_home: str, monkeypatch: pytest.MonkeyPatch
+) -> None:
     """End-to-end: a pull with comfyui_subdir lands under the right tree."""
+    model_store = Path(tmp_hal0_home) / "model-store"
+    monkeypatch.setenv("HAL0_MODEL_STORE", str(model_store))
     payload = b"FAKE-SAFETENSORS" + b"\x00" * 256
     digest = hashlib.sha256(payload).hexdigest()
 
@@ -147,7 +151,7 @@ def handler(req: httpx.Request) -> httpx.Response:
     assert job.state == "completed", f"got {job.state}: {job.error}"
     assert job.sha256 == digest
     final = Path(job.path)
-    # The pull must land under <hal0_home>/var-lib/hal0/comfyui/models/checkpoints/
+    # The pull must land under model_store_root()/comfyui/models/checkpoints/
     assert "comfyui" in final.parts
     assert "checkpoints" in final.parts
     assert final.name == "sd_xl_turbo_1.0_fp16.safetensors"
diff --git a/ui/src/api/endpoints.ts b/ui/src/api/endpoints.ts
index d1765c84..f5dbbf87 100644
--- a/ui/src/api/endpoints.ts
+++ b/ui/src/api/endpoints.ts
@@ -18,6 +18,13 @@ export const ENDPOINTS = {
   // Pin image mode (disables the arbiter's idle auto-restore). 501 when the
   // switchover gate is off.
   comfyuiPin: '/api/comfyui/pin',
+  // Render control
+  comfyuiRenderCancel: '/api/comfyui/render/cancel',
+  comfyuiRestart: '/api/comfyui/restart',
+  comfyuiLogs: '/api/comfyui/logs',
+  comfyuiWorkflowLaunch: (name: string) => `/api/comfyui/workflows/${encodeURIComponent(name)}/launch`,
+  // Latest output image proxy
+  comfyuiPreview: '/api/comfyui/preview',
 
   slotMetrics: '/api/slots/metrics',
   slot: (name: string) => `/api/slots/${encodeURIComponent(name)}`,
diff --git a/ui/src/api/hooks/useComfyui.ts b/ui/src/api/hooks/useComfyui.ts
index 459e60c8..2db824b6 100644
--- a/ui/src/api/hooks/useComfyui.ts
+++ b/ui/src/api/hooks/useComfyui.ts
@@ -60,6 +60,12 @@ export interface ComfyuiStatus {
   endpoint: string | null
   memory: ComfyuiMemory | null
   queue: { running: number; pending: number }
+  util: number | null
+  temp: number | null
+  clock: number | null
+  it_s: number | null
+  eta: string | null
+  step: number | null
   inference: { hermes: boolean }
   inventory: Record<string, number> | null
   switchover: ComfyuiSwitchover
@@ -77,6 +83,12 @@ export const COMFYUI_FALLBACK: ComfyuiStatus = {
   endpoint: null,
   memory: null,
   queue: { running: 0, pending: 0 },
+  util: 0,
+  temp: null,
+  clock: null,
+  it_s: null,
+  eta: null,
+  step: null,
   inference: { hermes: false },
   inventory: null,
   switchover: { active: false, target: null, error: null },
@@ -130,3 +142,147 @@ export function useComfyuiPin() {
       }),
   })
 }
+
+// Cancel current + queued renders (best-effort, 202).
+export function useComfyuiRenderCancel() {
+  return useMutation({
+    mutationFn: () => api<{ status: string }>(ENDPOINTS.comfyuiRenderCancel, { method: 'POST' }),
+  })
+}
+
+// Restart ComfyUI container (202, fire-and-forget).
+export function useComfyuiRestart() {
+  return useMutation({
+    mutationFn: () => api<{ status: string }>(ENDPOINTS.comfyuiRestart, { method: 'POST' }),
+  })
+}
+
+// Fetch container logs (tail=N, default 60).
+export function useComfyuiLogs(tail = 60) {
+  return useQuery({
+    queryKey: ['comfyui', 'logs', tail],
+    queryFn: () => apiGet<{ lines: string[] }>(`${ENDPOINTS.comfyuiLogs}?tail=${tail}`),
+    enabled: false, // on-demand only
+  })
+}
+
+// Quick-launch a named workflow (202).
+export function useComfyuiWorkflowLaunch() {
+  return useMutation({
+    mutationFn: (name: string) =>
+      api<{ status: string; prompt_id: string | null }>(
+        ENDPOINTS.comfyuiWorkflowLaunch(name),
+        { method: 'POST' },
+      ),
+  })
+}
+
+// ── V2 pane data transform ───────────────────────────────────────────────────
+//
+// The server /status payload has queue counts, memory, and device telemetry.
+// Per-job detail (name, kind, node, progress) is not fully surfaced yet; it/s,
+// ETA, and step are explicit nulls until a ComfyUI websocket subscription lands.
+// The component renders placeholders for absent fields — never crashes on
+// undefined.
+//
+// active_render and queue_jobs are optional extensions that may be injected
+// by the window.__comfyuiV2MockOverride seam or a future richer backend.
+
+export interface ComfyuiV2Run {
+  name: string
+  kind: string
+  pct: number
+  eta: string
+  node: string
+  step: number
+  total: number
+  its: number
+  loaded: string
+}
+
+export interface ComfyuiV2QueueJob {
+  name: string
+  kind: string
+}
+
+export interface ComfyuiV2PaneData {
+  engine: {
+    name: string
+    endpoint: string
+    image: string
+    restart: string
+  }
+  run: ComfyuiV2Run | null
+  queue: ComfyuiV2QueueJob[]
+  gtt: { used: number; ceil: number }
+  ram: { used: number; ceil: number }
+  stats: { util: number; temp: number; clk: number; its: number }
+}
+
+// Transform a live /status payload (+ optional V2 extension fields) into the
+// component's data shape. All absent numeric fields get safe defaults so the
+// pane renders coherently even when ComfyUI isn't running.
+export function transformComfyuiStatus(
+  status: ComfyuiStatus & {
+    active_render?: ComfyuiV2Run | null
+    queue_jobs?: ComfyuiV2QueueJob[]
+  },
+): ComfyuiV2PaneData {
+  const mem = status.memory
+  const hasRun = (status.queue?.running ?? 0) > 0
+
+  // active_render is the rich per-job detail block — only present in the mock
+  // or a future richer backend. Fall back to a placeholder skeleton when the
+  // render count says something is running but the detail is absent.
+  let run: ComfyuiV2Run | null = null
+  if (status.active_render !== undefined) {
+    run = status.active_render ?? null
+  } else if (hasRun) {
+    run = {
+      name: 'rendering…',
+      kind: '—',
+      pct: 0,
+      eta: '—',
+      node: '—',
+      step: 1,
+      total: 1,
+      its: 0,
+      loaded: '—',
+    }
+  }
+
+  // queue_jobs mirrors pending job list detail. Falls back to placeholder rows
+  // equal to the pending count when detail is absent.
+  let queue: ComfyuiV2QueueJob[]
+  if (status.queue_jobs !== undefined) {
+    queue = status.queue_jobs
+  } else {
+    const pending = status.queue?.pending ?? 0
+    queue = Array.from({ length: pending }, (_, i) => ({ name: `job ${i + 1}`, kind: '—' }))
+  }
+
+  return {
+    engine: {
+      name: 'ComfyUI',
+      endpoint: status.endpoint ?? ':8188',
+      image: status.container?.name ?? 'comfyui',
+      restart: 'no',
+    },
+    run,
+    queue,
+    gtt: {
+      used: mem?.gtt_used_gb ?? 0,
+      ceil: mem?.gtt_ceil_gb ?? 80,
+    },
+    ram: {
+      used: mem?.ram_used_gb ?? 0,
+      ceil: mem?.ram_ceil_gb ?? 96,
+    },
+    stats: {
+      util: status.util ?? 0,
+      temp: status.temp ?? 0,
+      clk: status.clock ?? 0,
+      its: status.it_s ?? 0,
+    },
+  }
+}
diff --git a/ui/src/dash/comfyui-pane.css b/ui/src/dash/comfyui-pane.css
index 35acaa29..1fb87bab 100644
--- a/ui/src/dash/comfyui-pane.css
+++ b/ui/src/dash/comfyui-pane.css
@@ -1,289 +1,353 @@
-/* ComfyUI "generation engine" pane — slots-page Image-Gen tab.
+/* hal0 dashboard — ComfyUI "Image Gen" pane · V2 "Render hero" styles.
  *
- * Ported (auto-scoped) from the hal0 Design System exploration
- * Design System/explorations/comfyui-row/row.css. Every selector is scoped
- * under `.comfy-pane` so the design's generic class names (.engine, .queue,
- * .gauge, .flow, .tel, .switchover …) can't collide with dashboard globals.
- * The design's :root token block is re-scoped to .comfy-pane below; the
- * --comfy* accent is ALSO mirrored into dashboard.css :root so the page tabs
- * can reference it. Motion/sunken tokens the design assumes but the live
- * stylesheet lacks (--dur*, --ease, --bg-sunken) are added to the same block. */
+ * Ported from Design/design_handoff_comfyui_imagegen/design/comfy.css.
+ * Scoped under .comfy-page so the blue --comfy accent tokens apply only
+ * inside the ImageGen pane. The outer pane wrapper also carries
+ * .comfy-v2-pane (used by e2e selectors).
+ *
+ * Shared vocabulary (.wcard/.wcard-h/.wcard-b/.wfoot/.blk-h/.ldot/.sctrl)
+ * mirrors the Inference pane and NPU widget design language. Primitives
+ * already in engine-panes.css / npu.css are re-declared here scoped to
+ * .comfy-page so the blue accent overrides them correctly within this pane.
+ *
+ * CRITICAL (PR #845 lockup): the empty-state element (.queue-empty-state)
+ * must be in-flow — never position:absolute;inset:0 overlay. */
+
+/* ── Accent tokens (scoped to .comfy-page) ─────────────────────────────────── */
+.comfy-page {
+  --comfy:      #5EA4F9;
+  --comfy-hi:   #8CC0FF;
+  --comfy-soft: rgba(94,164,249,0.10);
+  --comfy-line: rgba(94,164,249,0.32);
+  --comfy-bg:   #0C1622;
+  --comfy-glow: rgba(94,164,249,0.55);
+  --comfy-dim:  rgba(94,164,249,0.16);
+  --ease:       cubic-bezier(0.22, 1, 0.36, 1);
+}
+.comfy-page * { box-sizing: border-box; }
+
+/* ── Card shell ─────────────────────────────────────────────────────────────── */
+.comfy-page .wcard {
+  border: 1px solid var(--line);
+  border-radius: var(--rad-lg);
+  background: var(--bg-1);
+  overflow: hidden;
+}
+.comfy-page .wcard.active {
+  border-color: var(--comfy-line);
+  box-shadow: 0 0 0 1px var(--comfy-line), 0 0 44px -22px var(--comfy-glow);
+}
 
-.comfy-pane {
-  --dur: 0.18s;
-  --dur-fast: 0.12s;
-  --dur-slow: 0.22s;
-  --ease: cubic-bezier(0.22, 1, 0.36, 1);
-  --bg-sunken: #070707;
-  font-family: var(--geist);
-  color: var(--fg);
- --comfy:       #5EA4F9;
-  --comfy-hi:    #8CC0FF;
-  --comfy-soft:  rgba(94,164,249,0.10);
-  --comfy-line:  rgba(94,164,249,0.34);
-  --comfy-bg:    #0C1622;          
-  --comfy-glow:  rgba(94,164,249,0.20);
-  --npu:         var(--dev-npu);
-  --npu-soft:    rgba(200,150,255,0.08);
-  --npu-line:    rgba(200,150,255,0.30); }
-.comfy-pane .proto { font-family: var(--geist); color: var(--fg); background: var(--bg); }
-.comfy-pane .proto * { box-sizing: border-box; }
-.comfy-pane .sec-label { display: flex; align-items: center; gap: 10px;
-  font-family: var(--jbm); font-size: 12px; letter-spacing: 0.04em;
-  color: var(--fg-3); margin: 0 0 16px; }
-.comfy-pane .sec-label b { color: var(--comfy); font-weight: 500; text-transform: uppercase; letter-spacing: 0.1em; }
-.comfy-pane .sec-label .dim { color: var(--fg-5); }
-.comfy-pane .sec-label .meta { color: var(--fg-4); text-transform: uppercase; letter-spacing: 0.08em; font-size: 11px; }
-.comfy-pane .engine { border: 1px solid var(--line); border-radius: var(--rad-lg);
-  background: var(--bg-1); overflow: hidden; }
-.comfy-pane .engine.active { border-color: var(--comfy-line); box-shadow: 0 0 0 1px var(--comfy-line), 0 0 40px -20px var(--comfy-glow); }
-.comfy-pane .engine.active::before { content: ""; }
-.comfy-pane .engine-h { display: flex; align-items: center; gap: 12px;
-  padding: 14px 18px; border-bottom: 1px solid var(--line-soft);
-  background: var(--bg); }
-.comfy-pane .engine.active .engine-h { background: linear-gradient(90deg, var(--comfy-soft), transparent 60%); }
-.comfy-pane .engine-glyph { width: 26px; height: 26px; border-radius: var(--rad-sm);
+/* ── Card header ────────────────────────────────────────────────────────────── */
+.comfy-page .wcard-h {
+  display: flex;
+  align-items: center;
+  gap: 11px;
+  padding: 13px 16px;
+  border-bottom: 1px solid var(--line-soft);
+  background: linear-gradient(90deg, var(--comfy-soft), transparent 58%);
+}
+.comfy-page .wcard-h .glyph {
+  width: 26px; height: 26px;
+  border-radius: var(--rad-sm);
   display: inline-flex; align-items: center; justify-content: center;
-  background: var(--comfy-soft); color: var(--comfy); border: 1px solid var(--comfy-line); }
-.comfy-pane .engine-title { font-family: var(--jbm); font-size: 15px; font-weight: 500; color: var(--fg); }
-.comfy-pane .engine-sub { font-family: var(--jbm); font-size: 11px; color: var(--fg-4); }
-.comfy-pane .engine-h .grow { flex: 1; }
-.comfy-pane .epill { display: inline-flex; align-items: center; gap: 7px;
-  padding: 3px 10px; border-radius: 999px;
+  background: var(--comfy-soft);
+  color: var(--comfy);
+  border: 1px solid var(--comfy-line);
+  flex-shrink: 0;
+}
+.comfy-page .wcard-h .col  { display: flex; flex-direction: column; gap: 2px; min-width: 0; }
+.comfy-page .wcard-h .ttl  { font-family: var(--jbm); font-size: 14.5px; font-weight: 500; color: var(--fg); letter-spacing: -0.01em; line-height: 1.1; }
+.comfy-page .wcard-h .sub  { font-family: var(--jbm); font-size: 10.5px; color: var(--fg-4); }
+.comfy-page .wcard-h .grow { flex: 1; }
+.comfy-page .wcard-h .meta { font-family: var(--jbm); font-size: 10px; color: var(--fg-4); white-space: nowrap; }
+.comfy-page .wcard-h .meta b { color: var(--fg-2); font-weight: 500; }
+.comfy-page .wcard-b { padding: 16px; }
+
+/* ── State pill ─────────────────────────────────────────────────────────────── */
+.comfy-page .epill {
+  display: inline-flex; align-items: center; gap: 7px;
+  padding: 3px 10px; border-radius: var(--rad-pill);
   font-family: var(--jbm); font-size: 11px;
-  border: 1px solid var(--line); color: var(--fg-3); background: var(--bg-1); }
-.comfy-pane .epill .dot { width: 7px; height: 7px; border-radius: 50%; background: var(--fg-4); }
-.comfy-pane .epill.exclusive { color: var(--comfy); border-color: var(--comfy-line); background: var(--comfy-soft); }
-.comfy-pane .epill.exclusive .dot { background: var(--comfy); box-shadow: 0 0 8px var(--comfy); }
-.comfy-pane .epill.running { color: var(--comfy); border-color: var(--comfy-line); background: var(--comfy-soft); }
-.comfy-pane .epill.running .dot { background: var(--comfy); box-shadow: 0 0 8px var(--comfy); }
-.comfy-pane .epill.generating { color: var(--comfy); border-color: var(--comfy-line); background: var(--comfy-soft); }
-.comfy-pane .epill.generating .dot { background: var(--comfy); box-shadow: 0 0 8px var(--comfy); animation: pulse 1.2s ease-in-out infinite; }
-.comfy-pane .epill.starting { color: var(--warn); border-color: var(--warn-line); background: var(--warn-soft); }
-.comfy-pane .epill.starting .dot { background: var(--warn); box-shadow: 0 0 8px var(--warn); animation: pulse 1.2s ease-in-out infinite; }
-.comfy-pane .epill.stopped { color: var(--fg-3); }
-.comfy-pane .epill.stopped .dot { background: var(--fg-4); }
-.comfy-pane .epill.error { color: var(--err); border-color: var(--err-line); background: var(--err-soft); }
-.comfy-pane .epill.error .dot { background: var(--err); }
-.comfy-pane .switchover { display: inline-flex; align-items: center; gap: 11px; }
-.comfy-pane .switchover .mode { font-family: var(--jbm); font-size: 10px; text-transform: uppercase; letter-spacing: 0.08em;
-  color: var(--fg-4); }
-.comfy-pane .switchover .mode.on { color: var(--comfy); }
-.comfy-pane .switchover .mode.llm-on { color: var(--accent); }
-.comfy-pane .toggle { --tg-color: var(--accent);
-  position: relative; width: 38px; height: 22px; border-radius: 999px;
-  background: var(--bg-3); border: 1px solid var(--line-strong);
-  cursor: pointer; flex-shrink: 0; transition: background var(--dur) var(--ease), border-color var(--dur) var(--ease); }
-.comfy-pane .toggle .knob { position: absolute; top: 2px; left: 2px; width: 16px; height: 16px; border-radius: 50%;
-  background: var(--fg-3); transition: transform var(--dur) var(--ease), background var(--dur) var(--ease); }
-.comfy-pane .toggle.on { background: var(--tg-color); border-color: var(--tg-color); }
-.comfy-pane .toggle.on .knob { transform: translateX(16px); background: #0a0a0a; }
-.comfy-pane .toggle.comfy { --tg-color: var(--comfy); }
-.comfy-pane .toggle.big { width: 46px; height: 26px; }
-.comfy-pane .toggle.big .knob { width: 20px; height: 20px; }
-.comfy-pane .toggle.big.on .knob { transform: translateX(20px); }
-.comfy-pane .toggle.busy { opacity: 0.6; cursor: progress; }
-.comfy-pane .rchip { display: inline-flex; align-items: center; gap: 5px; padding: 2px 8px;
-  border-radius: 3px; font-family: var(--jbm); font-size: 10px; letter-spacing: 0.02em;
-  background: var(--bg-2); color: var(--fg-3); border: 1px solid var(--line); text-transform: lowercase; }
-.comfy-pane .rchip.comfy { color: var(--comfy); border-color: var(--comfy-line); background: var(--comfy-soft); }
-.comfy-pane .rchip.npu { color: var(--npu); border-color: var(--npu-line); background: var(--npu-soft); }
-.comfy-pane .rchip.ok { color: var(--ok); border-color: var(--ok-line); background: var(--ok-soft); }
-.comfy-pane .rchip.warn { color: var(--warn); border-color: var(--warn-line); background: var(--warn-soft); }
-.comfy-pane .rbtn { display: inline-flex; align-items: center; gap: 6px; padding: 5px 11px; height: 28px;
-  font-family: var(--jbm); font-size: 11px; border-radius: var(--rad-sm); cursor: pointer;
-  background: transparent; color: var(--fg-2); border: 1px solid var(--line); white-space: nowrap; }
-.comfy-pane .rbtn:hover { border-color: var(--line-strong); background: var(--bg-2); color: var(--fg); }
-.comfy-pane .rbtn.primary { background: var(--comfy); border-color: var(--comfy); color: #04111f; font-weight: 600; }
-.comfy-pane .rbtn.primary:hover { filter: brightness(1.08); background: var(--comfy); }
-.comfy-pane .rbtn.ghost-comfy { color: var(--comfy); border-color: var(--comfy-line); }
-.comfy-pane .rbtn.ghost-comfy:hover { background: var(--comfy-soft); }
-.comfy-pane .rbtn.danger { color: var(--err); border-color: var(--err-line); }
-.comfy-pane .rbtn.danger:hover { background: var(--err-soft); }
-.comfy-pane .rbtn.sm { height: 24px; padding: 3px 8px; font-size: 10.5px; }
-.comfy-pane .engine-b { padding: 16px 18px; display: flex; flex-direction: column; gap: 16px; }
-.comfy-pane .engine-foot { padding: 11px 18px; border-top: 1px solid var(--line-soft); background: var(--bg);
-  font-family: var(--jbm); font-size: 11px; color: var(--fg-4);
-  display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
-.comfy-pane .engine-foot .k { color: var(--fg-5); }
-.comfy-pane .engine-foot .v { color: var(--fg-3); }
-.comfy-pane .engine-foot .v.comfy { color: var(--comfy); }
-.comfy-pane .engine-foot .sep { color: var(--fg-5); }
-.comfy-pane .subgrid { display: grid; gap: 12px; }
-.comfy-pane .subcard { border: 1px solid var(--line); border-radius: var(--rad); background: var(--bg);
-  padding: 12px 14px; display: flex; flex-direction: column; gap: 9px; }
-.comfy-pane .subcard-h { display: flex; align-items: center; gap: 8px; font-family: var(--jbm); font-size: 10px; text-transform: uppercase; letter-spacing: 0.08em; color: var(--fg-4); }
-.comfy-pane .subcard-h .grow { flex: 1; }
-.comfy-pane .card-section { margin-top: 4px; padding-top: 12px; border-top: 1px solid var(--line-soft); display: flex; flex-direction: column; gap: 10px; }
-.comfy-pane .gauge { display: flex; flex-direction: column; gap: 6px; }
-.comfy-pane .gauge-h { display: flex; justify-content: space-between; font-family: var(--jbm); font-size: 11px; color: var(--fg-3); }
-.comfy-pane .gauge-h b { color: var(--fg); font-weight: 500; }
-.comfy-pane .gauge-h .ceil { color: var(--fg-5); }
-.comfy-pane .gauge-track { height: 8px; border-radius: 2px; background: var(--bg-3); overflow: hidden; display: flex; }
-.comfy-pane .gauge-track i { display: block; height: 100%; }
-.comfy-pane .gauge-track i.comfy { background: var(--comfy); }
-.comfy-pane .gauge-track i.warnz { background: var(--warn); }
-.comfy-pane .gauge-track i.os { background: var(--bg-4); }
-.comfy-pane .gauge-note { font-family: var(--jbm); font-size: 10px; color: var(--fg-4); }
-.comfy-pane .gauge-note.pressure { color: var(--warn); }
-.comfy-pane .minigauge { display: inline-flex; flex-direction: column; gap: 4px; min-width: 132px; }
-.comfy-pane .minigauge .lbl { display: flex; justify-content: space-between; font-family: var(--jbm); font-size: 10px; color: var(--fg-4); }
-.comfy-pane .minigauge .lbl b { color: var(--fg-2); font-weight: 500; }
-.comfy-pane .minigauge .bar { height: 5px; border-radius: 2px; background: var(--bg-3); overflow: hidden; }
-.comfy-pane .minigauge .bar i { display: block; height: 100%; background: var(--comfy); }
-.comfy-pane .minigauge .bar i.warnz { background: var(--warn); }
-.comfy-pane .genbar { display: flex; flex-direction: column; gap: 7px; }
-.comfy-pane .genbar-h { display: flex; align-items: center; gap: 10px; font-family: var(--jbm); font-size: 11.5px; color: var(--fg-2); }
-.comfy-pane .genbar-h .job { color: var(--fg); }
-.comfy-pane .genbar-h .grow { flex: 1; }
-.comfy-pane .genbar-h .pct { color: var(--comfy); }
-.comfy-pane .genbar-track { height: 6px; border-radius: 2px; background: var(--bg-3); overflow: hidden; position: relative; }
-.comfy-pane .genbar-fill { height: 100%; background: var(--comfy); position: relative; overflow: hidden; }
-.comfy-pane .genbar-fill::after { content: ""; position: absolute; inset: 0; background: linear-gradient(90deg, transparent, rgba(255,255,255,0.22), transparent); animation: cf-shimmer 1.4s linear infinite; }
-@keyframes cf-shimmer {from { transform: translateX(-100%); }to { transform: translateX(100%); } }
-.comfy-pane .genbar-steps { display: flex; justify-content: space-between; font-family: var(--jbm); font-size: 10px; color: var(--fg-4); }
-.comfy-pane .inv { display: flex; flex-wrap: wrap; gap: 8px; }
-.comfy-pane .inv-pill { display: inline-flex; align-items: baseline; gap: 6px; padding: 5px 10px;
-  border: 1px solid var(--line); border-radius: var(--rad-sm); background: var(--bg);
-  font-family: var(--jbm); font-size: 11px; color: var(--fg-3); }
-.comfy-pane .inv-pill b { color: var(--fg); font-weight: 500; font-size: 13px; }
-.comfy-pane .inv-pill .u { color: var(--fg-5); }
-.comfy-pane .flows { display: flex; flex-wrap: wrap; gap: 8px; }
-.comfy-pane .flow { display: inline-flex; align-items: center; gap: 8px; padding: 7px 12px;
-  border: 1px solid var(--line); border-radius: var(--rad); background: var(--bg);
-  font-family: var(--jbm); font-size: 11.5px; color: var(--fg-2); cursor: pointer; }
-.comfy-pane .flow:hover { border-color: var(--comfy-line); color: var(--comfy); background: var(--comfy-soft); }
-.comfy-pane .flow .ic { color: var(--comfy); display: inline-flex; }
-.comfy-pane .flow .arr { color: var(--fg-5); }
-.comfy-pane .llm-rows { display: flex; flex-direction: column; gap: 8px; }
-.comfy-pane .llm-row { display: flex; align-items: center; gap: 12px; padding: 11px 16px;
-  border: 1px solid var(--line); border-radius: var(--rad); background: var(--bg-1);
-  transition: opacity var(--dur) var(--ease), filter var(--dur) var(--ease); }
-.comfy-pane .llm-row .dot { width: 7px; height: 7px; border-radius: 50%; flex-shrink: 0; }
-.comfy-pane .llm-row .name { font-family: var(--jbm); font-size: 13px; font-weight: 500; color: var(--fg); width: 80px; }
-.comfy-pane .llm-row .model { font-family: var(--jbm); font-size: 12px; color: var(--fg-3); flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-.comfy-pane .llm-row .grow { flex: 1; }
-.comfy-pane .llm-row.yielded { opacity: 0.5; }
-.comfy-pane .llm-row.yielded .dot { background: var(--warn); }
-.comfy-pane .llm-row.up .dot { background: var(--ok); box-shadow: 0 0 8px var(--ok); }
-.comfy-pane .yield-tag { font-family: var(--jbm); font-size: 10px; color: var(--warn); border: 1px solid var(--warn-line); background: var(--warn-soft); padding: 1px 7px; border-radius: 3px; text-transform: lowercase; }
-.comfy-pane .gpu-mode { display: inline-flex; border: 1px solid var(--line-strong); border-radius: var(--rad); overflow: hidden;
-  background: var(--bg-1); }
-.comfy-pane .gpu-mode button { display: inline-flex; align-items: center; gap: 8px; padding: 8px 16px;
-  background: transparent; border: none; cursor: pointer;
-  font-family: var(--jbm); font-size: 12px; color: var(--fg-3); letter-spacing: 0.02em; }
-.comfy-pane .gpu-mode button + button { border-left: 1px solid var(--line); }
-.comfy-pane .gpu-mode button.on-llm { background: var(--accent-bg); color: var(--accent); }
-.comfy-pane .gpu-mode button.on-comfy { background: var(--comfy-bg); color: var(--comfy); }
-.comfy-pane .gpu-mode button .dot { width: 6px; height: 6px; border-radius: 50%; background: currentColor; box-shadow: 0 0 8px currentColor; }
-.comfy-pane .cf-scrim { position: absolute; inset: 0; background: rgba(0,0,0,0.66); backdrop-filter: blur(2px);
-  display: flex; align-items: center; justify-content: center; border-radius: var(--rad-lg); }
-.comfy-pane .cf { width: 520px; max-width: calc(100% - 40px);
-  background: var(--bg-1); border: 1px solid var(--line-strong); border-radius: var(--rad-lg);
-  box-shadow: var(--shadow-menu); overflow: hidden; }
-.comfy-pane .cf-h { padding: 18px 20px 14px; border-bottom: 1px solid var(--line-soft); }
-.comfy-pane .cf-eye { font-family: var(--jbm); font-size: 10px; text-transform: uppercase; letter-spacing: 0.1em; color: var(--comfy); margin-bottom: 6px; }
-.comfy-pane .cf-eye.warn { color: var(--warn); }
-.comfy-pane .cf-title { font-family: var(--jbm); font-size: 17px; font-weight: 500; margin: 0; letter-spacing: -0.01em; color: var(--fg); }
-.comfy-pane .cf-b { padding: 16px 20px; display: flex; flex-direction: column; gap: 13px; }
-.comfy-pane .cf-lede { font-size: 13px; color: var(--fg-2); line-height: 1.55; }
-.comfy-pane .cf-lede .mono { font-family: var(--jbm); color: var(--fg); }
-.comfy-pane .cf-blast { display: flex; flex-direction: column; gap: 8px; }
-.comfy-pane .cf-blast .row { display: flex; align-items: flex-start; gap: 10px; font-size: 12.5px; color: var(--fg-2); line-height: 1.45; }
-.comfy-pane .cf-blast .row .ic { color: var(--warn); flex-shrink: 0; margin-top: 1px; }
-.comfy-pane .cf-blast .row .ic.ok { color: var(--ok); }
-.comfy-pane .cf-steps { border: 1px solid var(--line); border-radius: var(--rad); background: var(--bg-sunken);
-  padding: 11px 13px; font-family: var(--jbm); font-size: 11.5px; color: var(--fg-3); line-height: 1.7; }
-.comfy-pane .cf-steps .n { color: var(--comfy); }
-.comfy-pane .cf-steps .cmd { color: var(--fg-2); }
-.comfy-pane .cf-steps .arr { color: var(--fg-5); }
-.comfy-pane .cf-guard { display: flex; align-items: center; gap: 9px; padding: 10px 12px;
-  border: 1px solid var(--err-line); background: var(--err-soft); border-radius: var(--rad);
-  font-size: 12px; color: var(--err); font-family: var(--jbm); }
-.comfy-pane .cf-f { padding: 13px 20px; border-top: 1px solid var(--line-soft); background: var(--bg); display: flex; align-items: center; gap: 10px; }
-.comfy-pane .cf-f .note { font-family: var(--jbm); font-size: 10.5px; color: var(--fg-4); }
-.comfy-pane .cf-f .grow { flex: 1; }
-.comfy-pane .row-flex { display: flex; align-items: center; gap: 10px; }
-.comfy-pane .col { display: flex; flex-direction: column; }
-.comfy-pane .grow { flex: 1; }
-.comfy-pane .mono { font-family: var(--jbm); }
-.comfy-pane .dimx { color: var(--fg-4); }
-.comfy-pane .spin { animation: cf-spin 1s linear infinite; display: inline-flex; }
-@keyframes cf-spin {to { transform: rotate(360deg); } }
-.comfy-pane .engine-body { max-height: 0; overflow: hidden; transition: max-height var(--dur-slow) var(--ease); }
-.comfy-pane .engine.open .engine-body { max-height: 1400px; }
-.comfy-pane .collapsed-prog { padding: 12px 18px 14px; border-top: 1px solid var(--line-soft); }
-.comfy-pane .engine.open .collapsed-prog { display: none; }
-.comfy-pane .tel-strip { display: flex; align-items: center; gap: 0; flex-wrap: wrap; row-gap: 8px; margin-top: 12px; padding-top: 11px; border-top: 1px solid var(--line-soft); }
-.comfy-pane .tel { display: inline-flex; align-items: center; gap: 7px; padding: 0 14px; border-right: 1px solid var(--line-soft); font-family: var(--jbm); }
-.comfy-pane .tel:first-child { padding-left: 0; }
-.comfy-pane .tel:last-child { border-right: none; }
-.comfy-pane .tel .l { font-size: 9px; text-transform: uppercase; letter-spacing: 0.07em; color: var(--fg-4); }
-.comfy-pane .tel .v { font-size: 12.5px; color: var(--fg); }
-.comfy-pane .tel .v.comfy { color: var(--comfy); }
-.comfy-pane .tel .v.warn { color: var(--warn); }
-.comfy-pane .tel .v .u { color: var(--fg-4); font-size: 10px; margin-left: 1px; }
-.comfy-pane .tel .minibar { width: 52px; height: 5px; border-radius: 2px; background: var(--bg-3); overflow: hidden; }
-.comfy-pane .tel .minibar i { display: block; height: 100%; }
-.comfy-pane .tel .qn { display: inline-flex; align-items: center; justify-content: center; min-width: 15px; height: 15px; padding: 0 4px; border-radius: 999px; background: var(--comfy); color: #04111f; font-size: 9.5px; font-weight: 600; }
-.comfy-pane .engine-foot.has-q { justify-content: flex-start; }
-.comfy-pane .engine-foot .foot-id { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; min-width: 0; }
-.comfy-pane .qcaret { margin-left: auto;
-  display: inline-flex; align-items: stretch;
-  border: 1px solid var(--comfy-line); border-radius: var(--rad-sm);
-  background: var(--comfy-soft); cursor: pointer; overflow: hidden;
-  transition: border-color var(--dur-fast) var(--ease), background var(--dur-fast) var(--ease); }
-.comfy-pane .qcaret:hover { background: rgba(94,164,249,0.16); }
-.comfy-pane .qcaret .q { display: inline-flex; align-items: center; gap: 7px; padding: 5px 10px;
-  font-family: var(--jbm); font-size: 11px; color: var(--comfy); }
-.comfy-pane .qcaret .q .qn { display: inline-flex; align-items: center; justify-content: center; min-width: 16px; height: 16px;
-  padding: 0 4px; border-radius: 999px; background: var(--comfy); color: #04111f;
-  font-size: 10px; font-weight: 600; }
-.comfy-pane .qcaret .q .qrun { color: var(--fg-4); }
-.comfy-pane .qcaret .car { display: inline-flex; align-items: center; justify-content: center; width: 28px;
-  border-left: 1px solid var(--comfy-line); color: var(--comfy);
-  transition: transform var(--dur) var(--ease); }
-.comfy-pane .engine.open .qcaret .car { transform: rotate(180deg); }
-.comfy-pane .qcaret.empty { border-color: var(--line); background: transparent; }
-.comfy-pane .qcaret.empty .q { color: var(--fg-3); }
-.comfy-pane .qcaret.empty .car { border-left-color: var(--line); color: var(--fg-3); }
-.comfy-pane .queue { border: 1px solid var(--line); border-radius: var(--rad); background: var(--bg); overflow: hidden; }
-.comfy-pane .queue-h { display: flex; align-items: center; gap: 8px; padding: 9px 14px;
-  border-bottom: 1px solid var(--line-soft); font-family: var(--jbm); font-size: 10px;
-  text-transform: uppercase; letter-spacing: 0.08em; color: var(--fg-4); }
-.comfy-pane .queue-h .grow { flex: 1; }
-.comfy-pane .queue-h .clear { color: var(--fg-4); cursor: pointer; text-transform: none; letter-spacing: 0; font-size: 11px; }
-.comfy-pane .queue-h .clear:hover { color: var(--err); }
-.comfy-pane .qrow { display: grid; grid-template-columns: 16px minmax(0,1fr) 150px 84px 28px;
-  align-items: center; gap: 12px; padding: 9px 14px;
-  border-bottom: 1px solid var(--line-soft); font-family: var(--jbm); font-size: 12px; }
-.comfy-pane .qrow:last-child { border-bottom: none; }
-.comfy-pane .qrow.running { background: var(--comfy-soft); }
-.comfy-pane .qrow .qdot { width: 7px; height: 7px; border-radius: 50%; background: var(--fg-5); }
-.comfy-pane .qrow.running .qdot { background: var(--comfy); box-shadow: 0 0 8px var(--comfy); animation: pulse 1.2s ease-in-out infinite; }
-.comfy-pane .qrow .qname { color: var(--fg); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-.comfy-pane .qrow .qname .qkind { color: var(--fg-4); }
-.comfy-pane .qrow .qmini { height: 4px; border-radius: 2px; background: var(--bg-3); overflow: hidden; }
-.comfy-pane .qrow .qmini i { display: block; height: 100%; background: var(--comfy); }
-.comfy-pane .qrow .qstat { font-size: 11px; color: var(--fg-4); text-align: right; }
-.comfy-pane .qrow.running .qstat { color: var(--comfy); }
-.comfy-pane .qrow .qx { display: inline-flex; align-items: center; justify-content: center; width: 24px; height: 24px; border-radius: var(--rad-sm); color: var(--fg-4); cursor: pointer; }
-.comfy-pane .qrow .qx:hover { color: var(--err); background: var(--err-soft); }
-.comfy-pane .queue-empty { padding: 18px 14px; text-align: center; font-family: var(--jbm); font-size: 11.5px; color: var(--fg-4); }
-.comfy-pane .qrow .qpos { color: var(--fg-5); }
-.comfy-pane .gpu-stats { display: flex; gap: 22px; padding-top: 12px; margin-top: 4px;
-  border-top: 1px solid var(--line-soft); }
-.comfy-pane .gpu-stats .gs { display: flex; flex-direction: column; gap: 2px; }
-.comfy-pane .gpu-stats .gs b { font-family: var(--jbm); font-size: 18px; font-weight: 500; color: var(--fg); letter-spacing: -0.01em; }
-.comfy-pane .gpu-stats .gs .u { font-family: var(--jbm); font-size: 10px; text-transform: uppercase; letter-spacing: 0.06em; color: var(--fg-4); }
+  border: 1px solid var(--line); color: var(--fg-3); background: var(--bg-1);
+  white-space: nowrap;
+}
+.comfy-page .epill .dot { width: 7px; height: 7px; border-radius: 50%; background: var(--fg-4); }
+.comfy-page .epill.generating { color: var(--comfy); border-color: var(--comfy-line); background: var(--comfy-soft); }
+.comfy-page .epill.generating .dot {
+  background: var(--comfy);
+  box-shadow: 0 0 8px var(--comfy);
+  animation: pulse 1.4s ease-in-out infinite;
+}
+
+/* ── Device pill ────────────────────────────────────────────────────────────── */
+.comfy-page .cf-pill {
+  display: inline-flex; align-items: center; gap: 6px;
+  padding: 2px 8px; border-radius: 3px;
+  font-family: var(--jbm); font-size: 10px; letter-spacing: 0.03em;
+  color: var(--comfy); border: 1px solid var(--comfy-line);
+  background: var(--comfy-soft); white-space: nowrap;
+}
+.comfy-page .cf-pill .d {
+  width: 5px; height: 5px; border-radius: 50%;
+  background: currentColor; box-shadow: 0 0 6px currentColor;
+}
+
+/* ── GPU-contention status note ─────────────────────────────────────────────── */
+.comfy-page .gpu-note {
+  display: inline-flex; align-items: center; gap: 7px;
+  padding: 3px 10px; border-radius: var(--rad-sm);
+  font-family: var(--jbm); font-size: 10px;
+  color: var(--warn); border: 1px solid var(--warn-line);
+  background: var(--warn-soft); white-space: nowrap;
+}
+.comfy-page .gpu-note .b { color: var(--fg-2); }
+
+/* ── Live dot ───────────────────────────────────────────────────────────────── */
+.comfy-page .ldot { width: 8px; height: 8px; border-radius: 50%; background: var(--fg-5); flex-shrink: 0; }
+.comfy-page .ldot.generating {
+  background: var(--comfy);
+  box-shadow: 0 0 7px var(--comfy-glow);
+  animation: pulse 1.4s var(--ease) infinite;
+}
+.comfy-page .ldot.pending { background: var(--fg-4); }
+.comfy-page .ldot.ready   { background: var(--ok); }
+
+/* ── Block header ───────────────────────────────────────────────────────────── */
+.comfy-page .blk-h {
+  display: flex; align-items: center; gap: 8px;
+  font-family: var(--jbm); font-size: 10px;
+  text-transform: uppercase; letter-spacing: 0.08em;
+  color: var(--fg-4); margin: 0 0 12px;
+}
+.comfy-page .blk-h .ic     { color: var(--fg-4); display: inline-flex; }
+.comfy-page .blk-h .ic.acc { color: var(--comfy); }
+.comfy-page .blk-h .grow   { flex: 1; }
+.comfy-page .blk-h .note   { font-size: 10px; text-transform: none; letter-spacing: 0; color: var(--fg-5); }
+
+/* ── Pulse keyframe (shared; reduced-motion overrides below) ────────────────── */
+@keyframes pulse {
+  0%, 100% { opacity: 1; }
+  50%       { opacity: 0.35; }
+}
+
+/* ─── CRITICAL: reduced-motion freezes pulse ────────────────────────────────── */
+@media (prefers-reduced-motion: reduce) {
+  .comfy-page .ldot.generating,
+  .comfy-page .epill.generating .dot {
+    animation: none;
+  }
+  .comfy-page .gbar i::after,
+  .comfy-page .steps-pips .pip.now i::after,
+  .comfy-page .preview .scan {
+    animation: none;
+  }
+}
+
+/* ── Radial Gauge (270° sweep) ──────────────────────────────────────────────── */
+.comfy-page .gauge { position: relative; }
+.comfy-page .gauge svg { display: block; }
+.comfy-page .gauge .gtrack { fill: none; stroke: var(--bg-3); }
+.comfy-page .gauge .gfill  {
+  fill: none; stroke: var(--comfy); stroke-linecap: round;
+  filter: drop-shadow(0 0 6px var(--comfy-glow));
+  transition: stroke-dashoffset 0.6s var(--ease);
+}
+.comfy-page .gauge .gfill.warn { stroke: var(--warn); filter: drop-shadow(0 0 6px rgba(232,185,78,0.5)); }
+.comfy-page .gauge .gc {
+  position: absolute; inset: 0;
+  display: flex; flex-direction: column; align-items: center; justify-content: center;
+}
+.comfy-page .gauge .gc .pct  { font-family: var(--jbm); font-size: 36px; font-weight: 500; letter-spacing: -0.03em; color: var(--fg); line-height: 1; }
+.comfy-page .gauge .gc .pct .s { font-size: 16px; color: var(--fg-3); }
+.comfy-page .gauge .gc .lbl  { font-family: var(--jbm); font-size: 9.5px; text-transform: uppercase; letter-spacing: 0.09em; color: var(--comfy); margin-top: 7px; }
+.comfy-page .gauge .gc .sub  { font-family: var(--jbm); font-size: 10px; color: var(--fg-4); margin-top: 3px; }
+.comfy-page .gauge.sm .gc .pct { font-size: 22px; }
+.comfy-page .gauge.sm .gc .pct .s { font-size: 11px; }
+.comfy-page .gauge.sm .gc .lbl { font-size: 8px; margin-top: 4px; letter-spacing: 0.07em; }
+.comfy-page .gauge.sm .gc .sub { font-size: 9px; margin-top: 2px; }
+
+/* ── 2×2 device metric grid ─────────────────────────────────────────────────── */
+.comfy-page .mx2 {
+  display: grid; grid-template-columns: 1fr 1fr;
+  gap: 1px; background: var(--line-soft);
+  border: 1px solid var(--line-soft); border-radius: var(--rad-sm); overflow: hidden;
+}
+.comfy-page .cstat { background: var(--bg-1); padding: 11px 13px; display: flex; flex-direction: column; gap: 5px; }
+.comfy-page .cstat .cl { font-family: var(--jbm); font-size: 9px; text-transform: uppercase; letter-spacing: 0.07em; color: var(--fg-5); }
+.comfy-page .cstat .cv { font-family: var(--jbm); font-size: 18px; font-weight: 500; letter-spacing: -0.02em; color: var(--fg); line-height: 1; }
+.comfy-page .cstat .cv .u { font-size: 10px; color: var(--fg-4); margin-left: 3px; letter-spacing: 0; }
+.comfy-page .cstat .cv.acc { color: var(--comfy); }
+
+/* ── Active render progress block ───────────────────────────────────────────── */
+.comfy-page .job { border: 1px solid var(--comfy-line); border-radius: var(--rad); background: var(--comfy-bg); padding: 13px 15px; display: flex; flex-direction: column; gap: 11px; }
+.comfy-page .job-h { display: flex; align-items: center; gap: 9px; }
+.comfy-page .job-h .nm { font-family: var(--jbm); font-size: 13.5px; font-weight: 500; color: var(--fg); }
+.comfy-page .job-h .kind { font-family: var(--jbm); font-size: 11px; color: var(--fg-4); }
+.comfy-page .job-h .grow { flex: 1; }
+.comfy-page .job-h .pct { font-family: var(--jbm); font-size: 22px; font-weight: 500; letter-spacing: -0.02em; color: var(--comfy); line-height: 1; }
+.comfy-page .job-h .pct.big { font-size: 40px; }
+
+.comfy-page .gbar { height: 7px; border-radius: 3px; background: var(--bg-3); overflow: hidden; position: relative; }
+.comfy-page .gbar.tall { height: 10px; }
+.comfy-page .gbar i { display: block; height: 100%; background: var(--comfy); position: relative; overflow: hidden; transition: width 0.5s var(--ease); }
+.comfy-page .gbar i::after {
+  content: "";
+  position: absolute; inset: 0;
+  background: linear-gradient(90deg, transparent, rgba(255,255,255,0.22), transparent);
+  animation: cf-shimmer 1.5s linear infinite;
+}
+@keyframes cf-shimmer { from { transform: translateX(-100%); } to { transform: translateX(100%); } }
+
+.comfy-page .job-steps { display: flex; justify-content: space-between; font-family: var(--jbm); font-size: 10.5px; color: var(--fg-4); }
+.comfy-page .job-steps .node { color: var(--fg-3); }
+.comfy-page .job-loaded { font-family: var(--jbm); font-size: 10.5px; color: var(--fg-4); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.comfy-page .job-empty  { font-family: var(--jbm); font-size: 12px; color: var(--fg-4); padding: 4px 0; }
+
+/* ── Step pip timeline ──────────────────────────────────────────────────────── */
+.comfy-page .steps-pips { display: flex; gap: 6px; }
+.comfy-page .steps-pips .pip { flex: 1; height: 4px; border-radius: 2px; background: var(--bg-3); position: relative; overflow: hidden; }
+.comfy-page .steps-pips .pip.done i { position: absolute; inset: 0; background: var(--comfy); }
+.comfy-page .steps-pips .pip.now  i { position: absolute; inset: 0; background: var(--comfy); }
+.comfy-page .steps-pips .pip.now  i::after {
+  content: ""; position: absolute; inset: 0;
+  background: linear-gradient(90deg, transparent, rgba(255,255,255,0.3), transparent);
+  animation: cf-shimmer 1.5s linear infinite;
+}
+
+/* ── Preview frame (striped placeholder) ────────────────────────────────────── */
+.comfy-page .preview {
+  position: relative;
+  border: 1px solid var(--comfy-line); border-radius: var(--rad); overflow: hidden;
+  background-color: var(--bg-sunken);
+  background-image: repeating-linear-gradient(135deg, transparent 0 9px, rgba(94,164,249,0.05) 9px 18px);
+  display: flex; flex-direction: column; align-items: center; justify-content: center;
+  gap: 8px; min-height: 184px;
+}
+.comfy-page .preview .scan {
+  position: absolute; left: 0; right: 0; height: 2px;
+  background: linear-gradient(90deg, transparent, var(--comfy), transparent);
+  opacity: 0.7;
+  animation: cf-scan 2.6s var(--ease) infinite;
+}
+@keyframes cf-scan { 0% { top: 6%; } 50% { top: 94%; } 100% { top: 6%; } }
+.comfy-page .preview .glyph { color: var(--comfy); opacity: 0.6; }
+.comfy-page .preview .lab { font-family: var(--jbm); font-size: 10.5px; color: var(--fg-4); text-align: center; line-height: 1.6; }
+.comfy-page .preview .lab b { color: var(--fg-2); font-weight: 500; }
+
+/* ── Queue rows (card-styled, V2 row layout) ────────────────────────────────── */
+.comfy-page .qcard {
+  border: 1px solid var(--line); border-radius: var(--rad-sm);
+  background: var(--bg-2); padding: 10px 12px;
+  display: flex; flex-direction: column; gap: 8px;
+  position: relative; overflow: hidden;
+}
+.comfy-page .qcard::before { content: ""; position: absolute; left: 0; top: 0; bottom: 0; width: 2px; background: var(--qc-hue, var(--line)); }
+.comfy-page .qcard.running::before { background: var(--comfy); }
+.comfy-page .qcard.pending { opacity: 0.78; }
+.comfy-page .qcard.pending::before { background: var(--fg-5); }
+
+/* Row layout for V2 queue */
+.comfy-page .qcard.row { flex-direction: row; align-items: center; gap: 11px; padding: 11px 14px; }
+.comfy-page .qcard.row .qjob { display: flex; flex-direction: column; gap: 1px; min-width: 0; }
+.comfy-page .qcard.row .qjob .qnm   { font-family: var(--jbm); font-size: 12.5px; font-weight: 500; color: var(--fg); }
+.comfy-page .qcard.row .qjob .qkind { font-family: var(--jbm); font-size: 10px; color: var(--fg-4); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.comfy-page .qcard.row .qprog { display: flex; align-items: center; gap: 9px; }
+.comfy-page .qcard.row .qprog .bar { width: 96px; height: 5px; border-radius: 2px; background: var(--bg-3); overflow: hidden; }
+.comfy-page .qcard.row .qprog .bar i { display: block; height: 100%; background: var(--comfy); }
+.comfy-page .qcard.row .qprog .pc { font-family: var(--jbm); font-size: 11px; color: var(--comfy); }
+.comfy-page .qcard.row .qspeed { font-family: var(--jbm); font-size: 11px; color: var(--fg-2); white-space: nowrap; }
+.comfy-page .qcard.row .stat   { font-family: var(--jbm); font-size: 11px; color: var(--fg-4); white-space: nowrap; }
+.comfy-page .grow { flex: 1; }
+
+/* ── Empty-queue state — IN-FLOW, never an overlay (PR #845 lockup guard) ───── */
+/* MUST NOT use position:absolute;inset:0 — see PR #845. */
+.comfy-page .queue-empty-state {
+  font-family: var(--jbm);
+  font-size: 12px;
+  color: var(--fg-4);
+  padding: 16px 0;
+  min-height: 48px;       /* in-flow, never zero height */
+  display: flex;
+  align-items: center;
+}
+
+/* ── Per-item controls ──────────────────────────────────────────────────────── */
+.comfy-page .ctrls { display: inline-flex; align-items: center; gap: 4px; }
+.comfy-page .sctrl {
+  display: inline-flex; align-items: center; justify-content: center;
+  width: 24px; height: 24px; border-radius: var(--rad-sm);
+  border: 1px solid var(--line); background: var(--bg-1);
+  color: var(--fg-4); cursor: pointer;
+  transition: border-color 0.15s, background 0.15s, color 0.15s;
+}
+.comfy-page .sctrl:hover { border-color: var(--line-strong); background: var(--bg-3); color: var(--fg-2); }
+.comfy-page .sctrl.stop    { color: var(--err);  border-color: var(--err-line); }
+.comfy-page .sctrl.stop:hover    { background: var(--err-soft); }
+.comfy-page .sctrl.restart { color: var(--info); border-color: var(--info-line); }
+.comfy-page .sctrl.restart:hover { background: var(--info-soft); }
+.comfy-page .sctrl.acc { color: var(--comfy); border-color: var(--comfy-line); }
+.comfy-page .sctrl.acc:hover { background: var(--comfy-soft); }
+
+/* ── Throughput spark ───────────────────────────────────────────────────────── */
+.comfy-page .cspark { display: flex; align-items: flex-end; gap: 2px; height: 30px; }
+.comfy-page .cspark i { flex: 1; background: var(--comfy); border-radius: 1px; min-height: 2px; opacity: 0.42; }
+.comfy-page .cspark i.hot { opacity: 1; }
+.comfy-page .tp-num { font-family: var(--jbm); font-weight: 500; letter-spacing: -0.02em; color: var(--comfy); line-height: 1; }
+.comfy-page .tp-num .u { font-size: 11px; color: var(--fg-4); margin-left: 4px; letter-spacing: 0; font-weight: 400; }
+
+/* ── Lower section: workflows + models on share ─────────────────────────────── */
+.comfy-page .wcard-sub {
+  display: grid; grid-template-columns: 1.3fr 1fr; gap: 24px;
+  margin-top: 16px; padding-top: 16px; border-top: 1px solid var(--line-soft);
+}
+
+.comfy-page .flows { display: flex; flex-wrap: wrap; gap: 8px; }
+.comfy-page .flow {
+  display: inline-flex; align-items: center; gap: 7px;
+  padding: 7px 11px; border: 1px solid var(--line); border-radius: var(--rad-sm);
+  background: var(--bg); font-family: var(--jbm); font-size: 11.5px;
+  color: var(--fg-2); cursor: pointer;
+  transition: border-color 0.14s, color 0.14s, background 0.14s;
+}
+.comfy-page .flow:hover { border-color: var(--comfy-line); color: var(--comfy); background: var(--comfy-soft); }
+.comfy-page .flow .ic  { color: var(--comfy); display: inline-flex; }
+.comfy-page .flow .arr { color: var(--fg-5); }
+.comfy-page .flow .tag { color: var(--fg-4); font-size: 10px; margin-left: 1px; }
+
+.comfy-page .inv { display: flex; flex-wrap: wrap; gap: 8px; }
+.comfy-page .inv-pill {
+  display: inline-flex; align-items: baseline; gap: 6px;
+  padding: 5px 10px; border: 1px solid var(--line); border-radius: var(--rad-sm);
+  background: var(--bg); font-family: var(--jbm); font-size: 11px; color: var(--fg-3);
+}
+.comfy-page .inv-pill b { color: var(--fg); font-weight: 500; font-size: 13px; }
+.comfy-page .inv-pill .u { color: var(--fg-5); }
+.comfy-page .inv-models { font-family: var(--jbm); font-size: 10.5px; color: var(--fg-4); margin-top: 10px; }
+
+/* ── Card footer (container identity + controls) ────────────────────────────── */
+.comfy-page .wfoot {
+  display: flex; align-items: center; gap: 8px; flex-wrap: wrap;
+  padding: 11px 16px; border-top: 1px solid var(--line-soft);
+  background: var(--bg); font-family: var(--jbm); font-size: 11px; color: var(--fg-4);
+}
+.comfy-page .wfoot .foot-id { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; min-width: 0; }
+.comfy-page .wfoot .k   { color: var(--fg-5); }
+.comfy-page .wfoot .v   { color: var(--fg-3); }
+.comfy-page .wfoot .v.acc { color: var(--comfy); }
+.comfy-page .wfoot .sep { color: var(--fg-5); }
+.comfy-page .wfoot .grow { flex: 1; }
+.comfy-page .wfoot .foot-ctrls { display: inline-flex; gap: 6px; }
 
-/* Header right cluster + switchover toggle. These lived in the design's
-   comfyui-pane.html inline <style> (not row.css), so they're added here to
-   match. engine-h wraps on narrow widths so the toggle can't clip. */
-.comfy-pane .engine-h { flex-wrap: wrap; row-gap: 10px; }
-.comfy-pane .eh-right { display: inline-flex; align-items: center; gap: 12px; flex-shrink: 0; }
-.comfy-pane .sw-wrap { display: inline-flex; align-items: center; gap: 9px; }
-.comfy-pane .sw-wrap .mode { font-family: var(--jbm); font-size: 10px; text-transform: uppercase; letter-spacing: 0.08em; color: var(--fg-4); white-space: nowrap; }
-.comfy-pane .sw-wrap .mode.on { color: var(--comfy); }
-.comfy-pane .sw-wrap .mode.llm-on { color: var(--accent); }
-.comfy-pane .toggle { cursor: pointer; }
+/* ── Render-button row ──────────────────────────────────────────────────────── */
+.comfy-page .rbtn {
+  display: inline-flex; align-items: center; gap: 6px;
+  padding: 5px 11px; height: 28px;
+  font-family: var(--jbm); font-size: 11px; border-radius: var(--rad-sm);
+  cursor: pointer; background: transparent; color: var(--fg-2);
+  border: 1px solid var(--line); white-space: nowrap;
+  transition: border-color 0.14s, background 0.14s, color 0.14s;
+}
+.comfy-page .rbtn:hover { border-color: var(--line-strong); background: var(--bg-2); color: var(--fg); }
+.comfy-page .rbtn.acc { color: var(--comfy); border-color: var(--comfy-line); }
+.comfy-page .rbtn.acc:hover { background: var(--comfy-soft); }
diff --git a/ui/src/dash/comfyui-pane.jsx b/ui/src/dash/comfyui-pane.jsx
index 6b18f65f..27d8bd1a 100644
--- a/ui/src/dash/comfyui-pane.jsx
+++ b/ui/src/dash/comfyui-pane.jsx
@@ -1,42 +1,32 @@
-// hal0 dashboard — ComfyUI "generation engine" pane (slots-page Image-Gen tab).
+// hal0 dashboard — ComfyUI "Image Gen" pane · V2 "Render hero".
 //
-// Ported from the hal0 Design System exploration
-// (Design System/explorations/comfyui-row/{comfyui-pane,row}.{html,jsx}). The
-// design models ComfyUI as ONE containerized generation engine — not per-model
-// slots — that is mutually exclusive with the LLM stack on the single iGPU.
+// Ported from Design/design_handoff_comfyui_imagegen/design/ (Task 5.1).
+// Mock data only — live API wiring is Task 5.2. Feed `data` prop with
+// the RUN/QUEUE/GTT/RAM/STATS/ENGINE shape from comfy-core or the mock.
 //
-// What's wired live (read-only, via useComfyui → /api/comfyui/status):
-//   - engine state + which mode owns the GPU (docker + systemd)
-//   - GTT / RAM gauges + memory pressure (ComfyUI /system_stats)
-//   - queue depth (ComfyUI /queue)
-//   - model inventory counts (verified file counts on the share)
-// The switchover toggle opens a blast-radius confirm dialog, then calls the
-// feature-gated POST /api/comfyui/switchover (202; the API's GPU arbiter
-// drains + stops the LLM slots and starts the ComfyUI img slot in-process —
-// no shell-out. The status poll's `switchover` block drives the transitional
-// UI — never an optimistic flip; 501 toast when the host gate is off).
-// The `arbiter` block on /status (mode img|llm, pinned, idle_restore_at) is
-// arbiter-truth: it drives the mode chip, the pin toggle and the auto-restore
-// countdown; when it is null (gate off / older backend) the pane fails soft
-// to the legacy container-telemetry display.
+// Host must add class "comfy-page" to the mount wrapper for the blue
+// --comfy accent scope to apply (see comfyui-pane.css).
 //
-// Deliberately NOT wired yet (need ComfyUI's WS /ws + AMDGPUMonitor, or the
-// privileged path): per-node progress %, it/s, GPU util/temp/clocks, per-job
-// queue names, and the container start/stop/restart controls. Those render in a
-// disabled/"—" state so the layout stays faithful without inventing numbers.
+// Empty-queue note (recall PR #845 lockup): the empty state must be
+// in-flow with min-height, never position:absolute;inset:0 overlay.
+//
+// The only looping animation is @keyframes pulse (1.4s, ldot.generating).
+// prefers-reduced-motion:reduce disables it via CSS `animation:none`.
 
+import './comfyui-pane.css'
 import {
   useComfyui,
-  useComfyuiSwitchover,
-  useComfyuiPin,
+  useComfyuiRenderCancel,
+  useComfyuiRestart,
+  useComfyuiWorkflowLaunch,
+  transformComfyuiStatus,
   COMFYUI_FALLBACK,
 } from '@/api/hooks/useComfyui'
 
-const { useState } = React
+const { useState, useEffect, useRef } = React
 
-// ── icons (16×16, 1.5 stroke — hal0 thin-line family + generation glyphs).
-// Ported from the design's row.jsx so the pane is self-contained.
-const RI = ({ d, size = 16, sw = 1.5, children, fill = 'none' }) => (
+// ── icons (16×16, hal0 thin-line family) ─────────────────────────────────────
+const CI = ({ d, size = 16, sw = 1.5, children, fill = 'none' }) => (
   <svg
     width={size}
     height={size}
@@ -51,717 +41,626 @@ const RI = ({ d, size = 16, sw = 1.5, children, fill = 'none' }) => (
     {d ? <path d={d} /> : children}
   </svg>
 )
-const RIcons = {
+
+const CIcons = {
   comfy: (
-    <RI>
+    <CI>
       <circle cx="4" cy="4" r="2" />
       <circle cx="12" cy="6" r="2" />
       <circle cx="6" cy="12" r="2" />
       <path d="M6 4.5l4 1M5.4 10.2l5-3.6" />
-    </RI>
-  ),
-  stop: (
-    <RI>
-      <rect x="4" y="4" width="8" height="8" rx="1" />
-    </RI>
+    </CI>
   ),
-  ext: <RI d="M6 3H3v10h10v-3M9 3h4v4M9 9l4-4" />,
+  bolt: <CI d="M9 2L4 9h3l-1 5 5-7H8l1-5z" fill="currentColor" sw="0" />,
   image: (
-    <RI>
+    <CI>
       <rect x="2.5" y="3" width="11" height="10" rx="1.5" />
       <circle cx="6" cy="6.5" r="1.2" />
       <path d="M3 11l3-2.5 2.5 2 2-1.5L13 11.5" />
-    </RI>
+    </CI>
   ),
   video: (
-    <RI>
+    <CI>
       <rect x="2" y="4" width="9" height="8" rx="1.5" />
       <path d="M11 7l3-2v6l-3-2z" />
-    </RI>
+    </CI>
   ),
   layers: (
-    <RI>
+    <CI>
       <path d="M8 2l6 3-6 3-6-3 6-3z" />
       <path d="M2 8l6 3 6-3M2 11l6 3 6-3" />
-    </RI>
+    </CI>
   ),
   cube: (
-    <RI>
+    <CI>
       <path d="M8 2l5.5 3v6L8 14l-5.5-3V5L8 2z" />
       <path d="M8 8l5.5-3M8 8v6M8 8L2.5 5" />
-    </RI>
+    </CI>
   ),
-  bolt: <RI d="M9 2L4 9h3l-1 5 5-7H8l1-5z" fill="currentColor" />,
-  queue: <RI d="M3 4h10M3 8h10M3 12h6" />,
-  cancel: (
-    <RI>
-      <circle cx="8" cy="8" r="5.5" />
-      <path d="M6 6l4 4M10 6l-4 4" />
-    </RI>
-  ),
-  chev: <RI d="M4 6l4 4 4-4" />,
+  queue: <CI d="M3 4h10M3 8h10M3 12h6" />,
   mem: (
-    <RI>
+    <CI>
       <rect x="2" y="5" width="12" height="6" rx="1" />
       <path d="M5 5V3M8 5V3M11 5V3M5 13v-2M11 13v-2" />
-    </RI>
+    </CI>
+  ),
+  gauge: (
+    <CI>
+      <path d="M3 12a5 5 0 1 1 10 0" />
+      <path d="M8 12l3-3.5" />
+      <circle cx="8" cy="12" r="1" fill="currentColor" sw="0" />
+    </CI>
+  ),
+  ext:  <CI d="M6 3H3v10h10v-3M9 3h4v4M9 9l4-4" />,
+  stop: (
+    <CI>
+      <rect x="4" y="4" width="8" height="8" rx="1" />
+    </CI>
   ),
-  logs: <RI d="M3 3h10M3 6h10M3 9h7M3 12h5" />,
   refresh: (
-    <RI>
+    <CI>
       <path d="M14 8a6 6 0 1 1-2-4.5" />
       <path d="M14 1v3.5h-3.5" />
-    </RI>
-  ),
-  close: <RI d="M4 4l8 8M12 4l-4 4" />,
-  warn: (
-    <RI>
-      <path d="M8 2l6 11H2L8 2z" />
-      <path d="M8 7v3M8 12v0.01" />
-    </RI>
+    </CI>
   ),
+  logs:  <CI d="M3 3h10M3 6h10M3 9h7M3 12h5" />,
+  close: <CI d="M4 4l8 8M12 4l-4 4" />,
+}
+
+const Ci = ({ name, size = 16 }) =>
+  CIcons[name] ? React.cloneElement(CIcons[name], { size }) : null
+
+// ── reduced-motion detection ─────────────────────────────────────────────────
+const REDUCE =
+  typeof window !== 'undefined' &&
+  window.matchMedia &&
+  window.matchMedia('(prefers-reduced-motion: reduce)').matches
+
+// ── shared tick (900ms; freezes under reduced-motion) ────────────────────────
+function useTick(ms = 900) {
+  const [t, setT] = useState(0)
+  useEffect(() => {
+    if (REDUCE) return
+    const id = setInterval(() => setT((x) => x + 1), ms)
+    return () => clearInterval(id)
+  }, [ms])
+  return t
 }
-const Ic = ({ name, size = 16 }) =>
-  RIcons[name] ? React.cloneElement(RIcons[name], { size }) : null
 
-function Toggle({ on, comfy = false, busy = false }) {
+// deterministic jitter for live readout breathing
+const jit = (base, amp, t, ph = 0) =>
+  REDUCE ? base : +(base + amp * Math.sin(t * 0.8 + ph)).toFixed(base < 10 ? 1 : 0)
+
+// ── Radial Gauge — 270° sweep (same primitive as NPU widget) ─────────────────
+function Gauge({ pct, label, sub, size = 116, warn = false }) {
+  const sw = Math.round(size * 0.065)
+  const r = size / 2 - sw - 4
+  const cx = size / 2
+  const cy = size / 2
+  const C = 2 * Math.PI * r
+  const arc = C * 0.75
+  const fill = Math.max(0, Math.min(1, (pct || 0) / 100)) * arc
   return (
-    <span
-      className={'toggle' + (on ? ' on' : '') + (comfy ? ' comfy' : '') + (busy ? ' busy' : '')}
-    >
-      <span className="knob" />
-    </span>
+    <div className={'gauge' + (size < 140 ? ' sm' : '')} style={{ width: size, height: size }}>
+      <svg width={size} height={size} viewBox={`0 0 ${size} ${size}`}>
+        <circle
+          className="gtrack"
+          cx={cx} cy={cy} r={r}
+          strokeWidth={sw}
+          strokeDasharray={`${arc} ${C}`}
+          strokeLinecap="round"
+          transform={`rotate(135 ${cx} ${cy})`}
+        />
+        <circle
+          className={'gfill' + (warn ? ' warn' : '')}
+          cx={cx} cy={cy} r={r}
+          strokeWidth={sw}
+          strokeDasharray={`${fill} ${C}`}
+          transform={`rotate(135 ${cx} ${cy})`}
+        />
+      </svg>
+      <div className="gc">
+        <div className="pct">
+          {Math.round(pct || 0)}
+          <span className="s">%</span>
+        </div>
+        <div className="lbl">{label}</div>
+        {sub ? <div className="sub">{sub}</div> : null}
+      </div>
+    </div>
   )
 }
 
-function EngineGlyph() {
+// ── Bar sparkline ─────────────────────────────────────────────────────────────
+const SPARK_DEFAULT = [1.5, 1.7, 1.6, 1.8, 1.9, 1.7, 2.0, 1.8, 1.9, 2.1, 1.9, 2.0, 1.8, 1.9, 2.0, 1.9]
+
+function BarSpark({ data = SPARK_DEFAULT, hotN = 4, style }) {
+  const max = Math.max(...data, 1)
   return (
-    <span className="engine-glyph">
-      <Ic name="comfy" size={16} />
-    </span>
+    <div className="cspark" style={style}>
+      {data.map((v, i) => (
+        <i
+          key={i}
+          className={i >= data.length - hotN ? 'hot' : ''}
+          style={{ height: (v / max * 100) + '%' }}
+        />
+      ))}
+    </div>
   )
 }
 
-// GTT (iGPU) gauge over the 80GB ceiling + a RAM bar under it. `null` used
-// values render an em-dash bar rather than a fabricated fill.
-function GttGauge({ usedGb, ceil = 80, ramGb, ramCeil = 96, pressure = false }) {
-  const pct = usedGb == null ? 0 : Math.min(100, (usedGb / ceil) * 100)
-  const ramPct = ramGb == null ? 0 : Math.min(100, (ramGb / ramCeil) * 100)
+// ── Block header ─────────────────────────────────────────────────────────────
+function BlkH({ icon, acc, children, note }) {
   return (
-    <div className="gauge">
-      <div className="gauge-h">
-        <span>GTT (iGPU)</span>
-        <span>
-          <b>{usedGb == null ? '—' : usedGb}</b> / {ceil} <span className="ceil">GB</span>
-        </span>
-      </div>
-      <div className="gauge-track">
-        <i className={pressure ? 'warnz' : 'comfy'} style={{ width: pct + '%' }} />
-      </div>
-      <div className="gauge-h" style={{ marginTop: 4 }}>
-        <span style={{ color: 'var(--fg-4)' }}>RAM</span>
-        <span style={{ color: 'var(--fg-3)' }}>
-          {ramGb == null ? '—' : ramGb} / {ramCeil} GB
-        </span>
-      </div>
-      <div className="gauge-track" style={{ height: 6 }}>
-        <i className="os" style={{ width: ramPct + '%' }} />
-      </div>
-      {pressure && (
-        <div className="gauge-note pressure">⚠ memory pressure — no swap on this host</div>
+    <div className="blk-h">
+      <span className={'ic' + (acc ? ' acc' : '')}>
+        <Ci name={icon} size={13} />
+      </span>
+      {children}
+      {note != null && (
+        <>
+          <span className="grow" />
+          <span className="note">{note}</span>
+        </>
       )}
     </div>
   )
 }
 
-// ComfyUI's own web UI lives on the runtime host's :8188 (the dashboard is
-// served from :8080), so links derive from the current hostname.
-function comfyHref() {
-  const host =
-    typeof window !== 'undefined' && window.location ? window.location.hostname : '127.0.0.1'
-  return `http://${host}:8188`
-}
-
-function toast(msg, kind) {
-  if (typeof window !== 'undefined' && window.__hal0Toast) window.__hal0Toast(msg, kind)
+// ── Step pips timeline ────────────────────────────────────────────────────────
+function StepPips({ step, total }) {
+  const pips = Array.from({ length: total }, (_, i) => {
+    if (i < step - 1) return 'done'
+    if (i === step - 1) return 'now'
+    return ''
+  })
+  return (
+    <div className="steps-pips">
+      {pips.map((c, i) => (
+        <span className={'pip ' + c} key={i}>
+          {c ? <i /> : null}
+        </span>
+      ))}
+    </div>
+  )
 }
 
-const STATE_LABEL = {
-  stopped: 'stopped',
-  starting: 'starting…',
-  running: 'running · idle',
-  generating: 'generating',
-  error: 'error',
-}
+// ── Workflows quick-launch ─────────────────────────────────────────────────────
+const FLOWS_DEFAULT = [
+  { ic: 'image',  a: 'text',   b: 'image',   tag: 'qwen-image',  name: 'qwen-image' },
+  { ic: 'image',  a: 'image',  b: 'image',                        name: 'img2img' },
+  { ic: 'video',  a: 'text',   b: 'video',   tag: 'wan 2.2',     name: 'wan2.2-t2v' },
+  { ic: 'video',  a: 'image',  b: 'video',   tag: 'i2v',         name: 'wan2.2-i2v' },
+  { ic: 'layers', a: 'still',  b: 'animate', tag: 'chain',       name: 'animate' },
+  { ic: 'cube',   a: 'upscale',b: '4×',                          name: 'upscale-4x' },
+]
 
-// Switchover confirm — states the blast radius before flipping the iGPU.
-function SwitchoverConfirm({ target, queuePending, busy, onCancel, onConfirm }) {
-  const toGen = target === 'generation'
+function WorkflowsBlock({ flows = FLOWS_DEFAULT, onLaunch }) {
   return (
-    <div className="cf-scrim" onClick={onCancel}>
-      <div className="cf" onClick={(e) => e.stopPropagation()}>
-        <div className="cf-h">
-          <div className={'cf-eye' + (toGen ? '' : ' warn')}>
-            {toGen ? 'ComfyUI · take the iGPU' : 'Inference · restore the LLM stack'}
-          </div>
-          <h3 className="cf-title">
-            {toGen ? 'Switch to generation mode?' : 'Switch back to inference mode?'}
-          </h3>
-        </div>
-        <div className="cf-b">
-          <p className="cf-lede">
-            {toGen ? (
-              <>
-                Only one of <span className="mono">{'{ inference, ComfyUI }'}</span> can hold the
-                single iGPU. Switching drains in-flight requests, then <b>stops the LLM slots</b>{' '}
-                and starts the ComfyUI container. The stopped slots restore automatically after
-                the engine sits idle — pinning image mode disables that auto-restore.
-              </>
-            ) : (
-              <>
-                This stops the ComfyUI container and <b>restores the LLM slots</b> that were
-                stopped by the switchover. In-flight renders are not interrupted by the
-                dashboard — drain the queue first.
-              </>
-            )}
-          </p>
-          {toGen && (
-            <div className="cf-blast">
-              <div className="row">
-                <span className="ic">
-                  <Ic name="warn" size={14} />
-                </span>
-                Telegram / Discord bots go dark until you switch back.
-              </div>
-              <div className="row">
-                <span className="ic">
-                  <Ic name="warn" size={14} />
-                </span>
-                Background memory extraction pauses (NPU gemma3-4b slot); it recovers
-                automatically. Rerank pauses too (GPU slot); embeddings are unaffected (NPU).
-              </div>
-            </div>
-          )}
-          {!toGen && queuePending > 0 && (
-            <div className="cf-guard">
-              <Ic name="warn" size={14} /> {queuePending} job{queuePending === 1 ? '' : 's'} still
-              queued — they will be dropped when the container stops.
-            </div>
-          )}
-          <div className="cf-steps">
-            {toGen ? (
-              <>
-                <span className="n">1</span> <span className="cmd">drain + stop LLM slots</span>{' '}
-                <span className="arr">→</span> <span className="cmd">start ComfyUI</span>
-              </>
-            ) : (
-              <>
-                <span className="n">1</span> <span className="cmd">stop ComfyUI</span>{' '}
-                <span className="arr">→</span> <span className="cmd">restore LLM slots</span>
-              </>
-            )}
-          </div>
-        </div>
-        <div className="cf-f">
-          <span className="note">the GPU arbiter on the runtime host runs the switchover</span>
-          <span className="grow" style={{ flex: 1 }} />
-          <button className="rbtn" onClick={onCancel} disabled={busy}>
-            Cancel
-          </button>
+    <div>
+      <BlkH icon="bolt" acc note="opens in ComfyUI ↗">workflows</BlkH>
+      <div className="flows">
+        {flows.map((f, i) => (
           <button
-            className={'rbtn ' + (toGen ? 'primary' : 'danger')}
-            onClick={onConfirm}
-            disabled={busy}
+            className="flow"
+            key={i}
+            onClick={() => onLaunch && onLaunch(f.name)}
+            data-workflow={f.name}
           >
-            {busy ? 'switching…' : toGen ? 'Switch to generation' : 'Switch to inference'}
+            <span className="ic"><Ci name={f.ic} size={14} /></span>
+            <span>{f.a}</span>
+            <span className="arr">→</span>
+            <span>{f.b}</span>
+            {f.tag && <span className="tag">{f.tag}</span>}
           </button>
-        </div>
+        ))}
       </div>
     </div>
   )
 }
 
-const FLOWS = [
-  { ic: 'image', a: 'text', b: 'image', note: 'qwen-image' },
-  { ic: 'image', a: 'image', b: 'image' },
-  { ic: 'video', a: 'text', b: 'video', note: 'wan 2.2' },
-  { ic: 'video', a: 'image', b: 'video', note: 'i2v' },
-  { ic: 'layers', a: 'still', b: 'animate', note: 'chain' },
-  { ic: 'cube', a: 'upscale', b: '4×' },
+// ── Models on share inventory ─────────────────────────────────────────────────
+const INV_DEFAULT = [
+  { n: 6,  l: 'checkpoints' },
+  { n: 4,  l: 'video', u: true },
+  { n: 11, l: 'loras' },
+  { n: 3,  l: 'vae' },
 ]
+const MODELS_DEFAULT = 'Wan 2.2 · Qwen-Image · HunyuanVideo 1.5 · LTX-2'
 
-export function ComfyuiPane() {
-  const q = useComfyui()
-  const sw = useComfyuiSwitchover()
-  const pin = useComfyuiPin()
-  const st = q.data || COMFYUI_FALLBACK
-  const [open, setOpen] = useState(false)
-  const [confirm, setConfirm] = useState(null) // target mode or null
-
-  const gen = st.mode === 'generation'
-  const containerUp = st.container?.state === 'running'
-  // GPU-arbiter truth block (null → fail soft to the legacy display).
-  const arb = st.arbiter || null
-  // Post-migration the engine IS the podman img slot, so when the arbiter
-  // block is present its mode is the engine truth: img implies the engine is
-  // up even if container telemetry lags a poll; llm implies stopped. Container
-  // telemetry stays the fallback when the arbiter is unavailable.
-  const engineRaw = st.engine || 'stopped'
-  const engine = arb
-    ? arb.mode === 'img'
-      ? engineRaw === 'stopped'
-        ? 'running'
-        : engineRaw
-      : 'stopped'
-    : engineRaw
-  // Idle auto-restore countdown — recomputed on each status poll (renders in
-  // minutes, so no per-second timer needed).
-  const restoreMin =
-    arb && arb.mode === 'img' && !arb.pinned && arb.idle_restore_at
-      ? Math.max(1, Math.ceil((arb.idle_restore_at * 1000 - Date.now()) / 60_000))
-      : null
-  // A switch in flight overrides the snapshot state: the pane's poll is what
-  // tracks the transition to terminal (202 + the arbiter's in-process
-  // transition server-side).
-  const switching = !!st.switchover?.active
-  const switchError = st.switchover?.error || null
-  const stateLabel = switching
-    ? `switching to ${st.switchover.target}…`
-    : STATE_LABEL[engine] || engine
-  const mem = st.memory
-  const gtt = mem?.gtt_used_gb ?? null
-  const gttCeil = mem?.gtt_ceil_gb ?? 80
-  const ram = mem?.ram_used_gb ?? null
-  const ramCeil = mem?.ram_ceil_gb ?? 96
-  const pressure = !!mem?.pressure
-  const running = st.queue?.running || 0
-  const pending = st.queue?.pending || 0
-  const queueTotal = running + pending
-  const inv = st.inventory
-
-  const href = comfyHref()
-  const openComfy = () => window.open(href, '_blank', 'noopener')
-
-  // Pin toggle — synchronous 200 {"pinned":bool}, so mirror the switchover's
-  // refetch-not-optimistic pattern: toast, then refetch /status so the arbiter
-  // block (pin state + countdown) re-renders from server truth.
-  // Fire-and-forget pin flip — toast immediately and refetch on success so the
-  // arbiter block re-renders from server truth; never block the toggle on the
-  // round-trip. (Mirrors the non-blocking control pattern from PR #781.)
-  const doPin = () => {
-    if (!arb || pin.isPending) return
-    const next = !arb.pinned
-    pin.mutate(
-      { pinned: next },
-      {
-        onSuccess: () => {
-          toast(next ? 'Image mode pinned — auto-restore disabled.' : 'Unpinned — auto-restore re-armed.', 'ok')
-          q.refetch()
-        },
-        onError: (err) => {
-          const code = String(err?.code || '')
-          if (code === 'comfyui.switchover_disabled' || err?.status === 501) {
-            toast(
-              'ComfyUI switchover is disabled on this host — set HAL0_COMFYUI_SWITCHOVER_ENABLED=1 ' +
-                'on hal0-api to enable it.',
-              'warn'
-            )
-          } else {
-            toast(err?.message ? `pin failed: ${err.message}` : 'pin failed', 'warn')
-          }
-        },
-      }
-    )
-  }
+function ModelsBlock({ inv = INV_DEFAULT, models = MODELS_DEFAULT }) {
+  return (
+    <div>
+      <BlkH icon="layers" note="manager ↗">models on share</BlkH>
+      <div className="inv">
+        {inv.map((m, i) => (
+          <span className="inv-pill" key={i}>
+            <b>{m.n}</b>
+            {m.u ? <span className="u">{m.l}</span> : ` ${m.l}`}
+          </span>
+        ))}
+      </div>
+      <div className="inv-models">{models}</div>
+    </div>
+  )
+}
 
-  // Fire-and-forget switchover — close the confirm dialog and toast the moment
-  // the user commits, rather than after the round-trip. The switchover POST is
-  // already async (202; the GPU arbiter drains/flips in the background) and the
-  // status poll's `switchover` block drives the transitional UI, so the click
-  // never has to wait. (Mirrors the non-blocking control pattern from PR #781.)
-  const doSwitch = () => {
-    const target = confirm
-    // The confirm dialog already warned that queued renders drop — that
-    // consent is what authorizes force when tearing down a busy queue.
-    const force = target === 'inference' && queueTotal > 0 ? true : undefined
-    setConfirm(null)
-    toast(`Switching to ${target} mode…`, 'info')
-    sw.mutate(
-      { mode: target, force },
-      {
-        onError: (err) => {
-          // Hal0Error carries the backend envelope's code directly (e.g.
-          // comfyui.switchover_disabled / comfyui.busy) + the HTTP status.
-          const code = String(err?.code || '')
-          if (code === 'comfyui.switchover_disabled' || err?.status === 501) {
-            toast(
-              'ComfyUI switchover is disabled on this host — set HAL0_COMFYUI_SWITCHOVER_ENABLED=1 ' +
-                'on hal0-api to enable it.',
-              'warn'
-            )
-          } else if (code === 'comfyui.busy') {
-            toast('Renders are still running or queued — drain the queue first.', 'warn')
-          } else if (code === 'comfyui.switch_in_progress') {
-            toast('A switchover is already in progress — wait for it to finish.', 'warn')
-          } else {
-            toast(err?.message ? `switchover failed: ${err.message}` : 'switchover failed', 'warn')
-          }
-        },
-        onSettled: () => setTimeout(() => q.refetch(), 1500),
-      }
-    )
-  }
+// ── Mock data (handoff demo values) ─────────────────────────────────────────
+export const COMFYUI_V2_MOCK = {
+  engine: {
+    name: 'ComfyUI',
+    endpoint: ':8188',
+    image: 'ghcr.io/hal0ai/comfyui@sha256:9f3c…b21a',
+    restart: 'no',
+  },
+  run: {
+    name: 'wan2.2-i2v',
+    kind: '480p · 81 frames',
+    pct: 72,
+    eta: '~38s',
+    node: 'KSampler (low-noise)',
+    step: 3,
+    total: 4,
+    its: 1.9,
+    loaded: 'wan-hi + wan-lo · umt5-xxl · wan-vae · 2 loras',
+  },
+  queue: [
+    { name: 'qwen-image', kind: 'txt2img · 1328²' },
+    { name: 'sdxl',       kind: 'upscale 4×' },
+  ],
+  gtt: { used: 54, ceil: 80 },
+  ram: { used: 61, ceil: 96 },
+  stats: { util: 97, temp: 71, clk: 2.7, its: 1.9 },
+}
 
+// ── Card header ───────────────────────────────────────────────────────────────
+function CardHead({ engine, run, pct }) {
+  const hasRun = run != null
   return (
-    <div className="comfy-pane">
-      <div className="proto">
-        {/* section label */}
-        <div className="sec-label">
-          <b>Generation Engine</b>
-          <span className="dim">·</span>
-          <span className="mono" style={{ color: 'var(--comfy)' }}>
-            ComfyUI
-          </span>
-          <span className="dim">·</span>
-          <span className="meta">1 container</span>
-          <span className="dim">·</span>
-          <span className="meta">exclusive iGPU</span>
-          <span className="grow" style={{ flex: 1 }} />
-          <span className="meta">{containerUp ? 'docker · :8188' : 'docker · stopped'}</span>
-        </div>
+    <div className="wcard-h">
+      <span className="glyph"><Ci name="comfy" size={16} /></span>
+      <span className="col">
+        <span className="ttl">ComfyUI</span>
+        <span className="sub">image-gen engine · docker</span>
+      </span>
+      <span className={'epill' + (hasRun ? ' generating' : '')}>
+        <span className="dot" />
+        {hasRun ? `generating · ${Math.round(pct)}%` : 'idle'}
+      </span>
+      <span className="cf-pill">
+        <span className="d" />
+        iGPU · exclusive
+      </span>
+      <span className="grow" />
+      <span className="gpu-note">
+        <Ci name="bolt" size={11} /> inference slots <span className="b">paused</span> while rendering
+      </span>
+      <span className="meta">docker · <b>{engine.endpoint}</b></span>
+    </div>
+  )
+}
 
-        <div className={'engine' + (gen ? ' active' : '') + (open ? ' open' : '')}>
-          {/* header */}
-          <div className="engine-h">
-            <EngineGlyph />
-            <span className="col">
-              <span className="engine-title">ComfyUI</span>
-              <span className="engine-sub">generation engine · docker</span>
-            </span>
-            <span className={'epill ' + (switching ? 'starting' : engine)}>
-              <span className="dot" />
-              {stateLabel}
-            </span>
-            {/* Arbiter mode chip — arbiter-truth display; hidden (fail-soft)
-                when the arbiter block is null. */}
-            {arb && (
-              <span
-                className={'epill ' + (arb.mode === 'img' ? 'running' : 'stopped')}
-                data-testid="comfy-arbiter-chip"
-                title={
-                  arb.mode === 'img'
-                    ? 'The GPU arbiter holds the iGPU for image generation — LLM slots are stopped.'
-                    : 'The LLM stack holds the iGPU — the image engine is parked.'
-                }
-              >
-                <span className="dot" />
-                {arb.mode === 'img' ? 'image mode' : 'inference'}
-                {arb.pinned && arb.mode === 'img' ? ' · pinned' : ''}
-              </span>
-            )}
-            {restoreMin != null && (
-              <span className="meta" data-testid="comfy-restore-countdown">
-                auto-restore in ~{restoreMin}m
-              </span>
+// ── Card footer ───────────────────────────────────────────────────────────────
+function CardFoot({ engine, onRestart, onLogs }) {
+  return (
+    <div className="wfoot">
+      <div className="foot-id">
+        <span className="k">container</span>
+        <span className="v acc">comfyui</span>
+        <span className="sep">·</span>
+        <span className="k">image</span>
+        <span className="v">{engine.image}</span>
+        <span className="sep">·</span>
+        <span className="k">restart</span>
+        <span className="v">{engine.restart}</span>
+        <span className="sep">·</span>
+        <span className="k">endpoint</span>
+        <span className="v acc">{engine.endpoint}</span>
+      </div>
+      <span className="grow" />
+      <span className="foot-ctrls">
+        <button className="sctrl stop" title="Stop container"><Ci name="stop" size={12} /></button>
+        <button className="sctrl restart" title="Restart" onClick={onRestart}><Ci name="refresh" size={12} /></button>
+        <button className="sctrl" title="Logs" onClick={onLogs}><Ci name="logs" size={12} /></button>
+      </span>
+    </div>
+  )
+}
+
+// ── Empty-queue state (in-flow, NO overlay) ───────────────────────────────────
+// CRITICAL: must NOT be position:absolute;inset:0 — see PR #845 lockup.
+// min-height keeps the block in-flow with visible height.
+function EmptyQueueState({ comfyBaseUrl }) {
+  return (
+    <div className="queue-empty-state">
+      <span>nothing queued · drop a workflow in</span>
+      {comfyBaseUrl ? (
+        <a className="rbtn acc" href={comfyBaseUrl} target="_blank" rel="noopener noreferrer" style={{ marginLeft: 8 }}>
+          <Ci name="ext" size={12} /> Open ComfyUI ↗
+        </a>
+      ) : (
+        <button className="rbtn acc" style={{ marginLeft: 8 }}>
+          <Ci name="ext" size={12} /> Open ComfyUI ↗
+        </button>
+      )}
+    </div>
+  )
+}
+
+// ── Main ImageGenCard ─────────────────────────────────────────────────────────
+export function ImageGenCard({
+  mock = COMFYUI_V2_MOCK,
+  onCancel,
+  onRestart,
+  onLogs,
+  onLaunch,
+  comfyBaseUrl,
+}) {
+  const { engine, run, queue, gtt, ram, stats } = mock
+  const t = useTick(900)
+
+  // Active render state (null = no render running)
+  const hasRun = run != null
+
+  // Jitter live readouts
+  const pct  = hasRun ? Math.min(99, jit(run.pct, 1.2, t)) : 0
+  const its  = hasRun ? jit(run.its, 0.18, t, 0.6) : 0
+  const used = jit(gtt.used, 1.4, t)
+
+  const gttPct  = used / gtt.ceil * 100
+  const gttWarn = gttPct >= 80
+
+  return (
+    <div className="wcard active">
+      <CardHead engine={engine} run={run} pct={pct} />
+      <div className="wcard-b">
+
+        {/* ── Render hero: preview frame + active-render progress ── */}
+        <div style={{ display: 'grid', gridTemplateColumns: '300px 1fr', gap: 22, alignItems: 'stretch' }}>
+          {/* Preview frame */}
+          <div className="preview">
+            <span className="scan" />
+            {hasRun && comfyBaseUrl ? (
+              <img
+                src="/api/comfyui/preview"
+                alt="latest render output"
+                className="preview-img"
+                style={{ position: 'absolute', inset: 0, width: '100%', height: '100%', objectFit: 'cover', opacity: 0.7 }}
+              />
+            ) : (
+              <span className="glyph"><Ci name="video" size={30} /></span>
             )}
-            {switchError && !switching && (
-              <span className="meta" style={{ color: 'var(--warn)' }} title={switchError}>
-                last switch failed
+            {hasRun ? (
+              <span className="lab">
+                <b>{run.name}</b><br />{run.kind}<br />
+                live preview ↦ frame {Math.round(pct / 100 * 81)}/81
               </span>
+            ) : (
+              <span className="lab">no active render</span>
             )}
-            <span className="grow" style={{ flex: 1 }} />
-            <span className="eh-right">
-              {/* Pin toggle — only with an arbiter; disables idle auto-restore. */}
-              {arb && (
-                <button
-                  className={'rbtn' + (arb.pinned ? ' primary' : '')}
-                  data-testid="comfy-pin-toggle"
-                  onClick={doPin}
-                  disabled={pin.isPending}
-                  title={
-                    arb.pinned
-                      ? 'Image mode is pinned — auto-restore disabled. Click to unpin.'
-                      : 'Pin image mode (disables the idle auto-restore of LLM slots)'
-                  }
-                >
-                  {pin.isPending ? '…' : arb.pinned ? 'pinned' : 'pin'}
-                </button>
-              )}
-              <button
-                className="rbtn ghost-comfy"
-                disabled={!containerUp}
-                style={!containerUp ? { opacity: 0.4 } : null}
-                onClick={openComfy}
-                title={containerUp ? 'Open ComfyUI' : 'ComfyUI is not running'}
-              >
-                <Ic name="ext" size={13} /> Open ↗
-              </button>
-              <span
-                className="sw-wrap"
-                onClick={() => !switching && setConfirm(gen ? 'inference' : 'generation')}
-                style={{ cursor: switching ? 'wait' : 'pointer' }}
-                title={
-                  switching
-                    ? 'Switchover in progress…'
-                    : 'Switch the iGPU between inference and generation'
-                }
-              >
-                <span className={'mode' + (!gen ? ' llm-on' : '')}>inference</span>
-                <Toggle on={gen} comfy busy={sw.isPending || switching} />
-                <span className={'mode' + (gen ? ' on' : '')}>generation</span>
-              </span>
-            </span>
           </div>
 
-          {/* collapsed telemetry strip — real read-only metrics inline */}
-          {containerUp && !open && (
-            <div className="collapsed-prog">
-              <div className="tel-strip">
-                <span className="tel">
-                  <span className="l">GTT</span>
-                  <span className="minibar">
-                    <i
-                      style={{
-                        width: (gtt == null ? 0 : (gtt / gttCeil) * 100) + '%',
-                        background: pressure ? 'var(--warn)' : 'var(--comfy)',
-                      }}
-                    />
-                  </span>
-                  <span className={'v' + (pressure ? ' warn' : '')}>
-                    {gtt == null ? '—' : gtt}
-                    <span className="u">/{gttCeil} GB</span>
-                  </span>
-                </span>
-                <span className="tel">
-                  <span className="l">RAM</span>
-                  <span className="v">
-                    {ram == null ? '—' : ram}
-                    <span className="u">/{ramCeil} GB</span>
-                  </span>
-                </span>
-                <span className="tel">
-                  <span className="l">queue</span>
-                  {queueTotal > 0 ? (
-                    <span className="qn">{queueTotal}</span>
+          {/* Active render progress detail */}
+          <div>
+            <BlkH icon="bolt" acc note={hasRun ? `eta ${run.eta}` : undefined}>
+              active render
+            </BlkH>
+            {hasRun ? (
+              <div className="job" style={{ background: 'transparent', border: 'none', padding: 0, gap: 13 }}>
+                <div className="job-h" style={{ alignItems: 'flex-end' }}>
+                  <div className="col" style={{ display: 'flex', flexDirection: 'column', gap: 4 }}>
+                    <span className="nm">
+                      {run.name} <span className="kind">· {run.kind}</span>
+                    </span>
+                    <span className="job-loaded">{run.node} · step {run.step}/{run.total}</span>
+                  </div>
+                  <span className="grow" />
+                  <span className="pct big">{Math.round(pct)}%</span>
+                </div>
+                <div className="gbar tall">
+                  <i style={{ width: pct + '%' }} />
+                </div>
+                <StepPips step={run.step} total={run.total} />
+                <div className="job-steps" style={{ marginTop: 2 }}>
+                  <span className="node">loaded: {run.loaded}</span>
+                  <span>{its} it/s</span>
+                </div>
+                <div style={{ display: 'flex', gap: 8, marginTop: 4 }}>
+                  <button className="rbtn" onClick={onCancel}><Ci name="stop" size={13} /> Cancel render</button>
+                  {comfyBaseUrl ? (
+                    <a className="rbtn acc" href={comfyBaseUrl} target="_blank" rel="noopener noreferrer">
+                      <Ci name="ext" size={13} /> Open ComfyUI ↗
+                    </a>
                   ) : (
-                    <span className="v dimx">idle</span>
+                    <button className="rbtn acc"><Ci name="ext" size={13} /> Open ComfyUI ↗</button>
                   )}
-                  {running > 0 && (
-                    <span className="v dimx" style={{ fontSize: 11 }}>
-                      {running} running
+                </div>
+              </div>
+            ) : (
+              <div className="job-empty">engine idle · no job running</div>
+            )}
+          </div>
+        </div>
+
+        {/* ── Lower row: queue (2/3) + telemetry (1/3) ── */}
+        <div style={{
+          display: 'grid',
+          gridTemplateColumns: '2fr 1fr',
+          gap: 22,
+          marginTop: 18,
+          paddingTop: 16,
+          borderTop: '1px solid var(--line-soft)',
+        }}>
+          {/* Queue */}
+          <div>
+            <BlkH icon="queue" note={`${hasRun ? '1 running' : '0 running'} · ${queue.length} pending`}>
+              queue
+            </BlkH>
+            {queue.length === 0 && !hasRun ? (
+              <EmptyQueueState comfyBaseUrl={comfyBaseUrl} />
+            ) : (
+              <div style={{ display: 'flex', flexDirection: 'column', gap: 9 }}>
+                {/* Running row */}
+                {hasRun && (
+                  <div className="qcard row running">
+                    <span className="ldot generating" />
+                    <span className="qjob">
+                      <span className="qnm">{run.name}</span>
+                      <span className="qkind">{run.kind} · {run.node}</span>
                     </span>
-                  )}
-                </span>
-                <span className="tel">
-                  <span className="l">engine</span>
-                  <span className="v comfy">{engine}</span>
-                </span>
-                {pressure && (
-                  <span className="tel">
-                    <span className="v warn" style={{ fontSize: 11 }}>
-                      ⚠ no swap
+                    <span className="grow" />
+                    <span className="qprog">
+                      <span className="bar"><i style={{ width: pct + '%' }} /></span>
+                      <span className="pc">{Math.round(pct)}%</span>
                     </span>
-                  </span>
+                    <span className="qspeed">{its} it/s</span>
+                    <span className="ctrls">
+                      <button className="sctrl stop" title="Cancel" onClick={onCancel}><Ci name="stop" size={12} /></button>
+                      <button className="sctrl restart" title="Restart" onClick={onRestart}><Ci name="refresh" size={12} /></button>
+                    </span>
+                  </div>
                 )}
+                {/* Pending rows */}
+                {queue.map((j, i) => (
+                  <div className="qcard row pending" key={j.name}>
+                    <span className="ldot pending" />
+                    <span className="qjob">
+                      <span className="qnm">{j.name}</span>
+                      <span className="qkind">{j.kind}</span>
+                    </span>
+                    <span className="grow" />
+                    <span className="stat">#{i + 1} · queued</span>
+                    <span className="ctrls">
+                      <button className="sctrl" title="Logs"><Ci name="logs" size={12} /></button>
+                      <button className="sctrl" title="Remove"><Ci name="close" size={12} /></button>
+                    </span>
+                  </div>
+                ))}
+              </div>
+            )}
+          </div>
+
+          {/* Telemetry: GTT gauge + RAM spark + device metric grid */}
+          <div style={{ display: 'flex', flexDirection: 'column', gap: 16 }}>
+            <div style={{ display: 'flex', alignItems: 'center', gap: 16 }}>
+              <Gauge
+                pct={gttPct}
+                label="gtt"
+                sub={`${used} / ${gtt.ceil}`}
+                size={116}
+                warn={gttWarn}
+              />
+              <div style={{ minWidth: 0 }}>
+                <div className="blk-h" style={{ margin: '0 0 5px' }}>system ram</div>
+                <div className="tp-num" style={{ fontSize: 22 }}>
+                  {ram.used}<span className="u">/ {ram.ceil} GB</span>
+                </div>
+                <BarSpark style={{ height: 24, marginTop: 8 }} />
               </div>
             </div>
-          )}
-
-          {/* expandable body */}
-          <div className="engine-body">
-            <div className="inner">
-              <div className="engine-b">
-                {/* active job — read-only summary (live per-node progress needs WS) */}
-                <div className="subcard">
-                  <div className="subcard-h">
-                    <Ic name="bolt" size={13} /> active job
-                  </div>
-                  <div className="mono dimx" style={{ fontSize: 12, padding: '2px 0' }}>
-                    {!containerUp
-                      ? 'engine stopped · switch to generation to run jobs'
-                      : running > 0
-                        ? `${running} job${running === 1 ? '' : 's'} running · open ComfyUI for live per-node progress ↗`
-                        : 'engine idle · no job running'}
-                  </div>
+            <div>
+              <BlkH icon="gauge" note="iGPU">device</BlkH>
+              <div className="mx2">
+                <div className="cstat">
+                  <span className="cl">util</span>
+                  <span className="cv acc">{stats.util}<span className="u">%</span></span>
                 </div>
-
-                {/* queue (counts from /queue; per-job names live in ComfyUI) */}
-                <div className="queue">
-                  <div className="queue-h">
-                    <Ic name="queue" size={13} /> queue
-                    <span style={{ color: 'var(--fg-5)', marginLeft: 2 }}>· {pending} pending</span>
-                    <span className="grow" style={{ flex: 1 }} />
-                    <span
-                      className="clear"
-                      onClick={openComfy}
-                      style={{ cursor: 'pointer' }}
-                      title="Manage the queue in ComfyUI"
-                    >
-                      open queue ↗
-                    </span>
-                  </div>
-                  <div className="queue-empty">
-                    {queueTotal === 0
-                      ? 'nothing queued · drop a workflow in ComfyUI to enqueue'
-                      : `${running} running · ${pending} pending — manage in ComfyUI ↗`}
-                  </div>
+                <div className="cstat">
+                  <span className="cl">temp</span>
+                  <span className="cv">{stats.temp}<span className="u">°C</span></span>
                 </div>
-
-                {/* bottom 50/50 — memory + iGPU | models on share + workflows */}
-                <div className="subgrid" style={{ gridTemplateColumns: '1fr 1fr' }}>
-                  <div className="subcard">
-                    <div className="subcard-h">
-                      <Ic name="mem" size={13} /> memory <span style={{ color: 'var(--fg-5)' }}>· iGPU</span>
-                    </div>
-                    <GttGauge usedGb={gtt} ceil={gttCeil} ramGb={ram} ramCeil={ramCeil} pressure={pressure} />
-                    <div className="gpu-stats">
-                      <span className="gs">
-                        <b style={{ color: 'var(--comfy)' }}>{st.reachable ? engine : '—'}</b>
-                        <span className="u">state</span>
-                      </span>
-                      <span className="gs">
-                        <b>{st.inference?.hermes ? 'up' : 'down'}</b>
-                        <span className="u">hermes</span>
-                      </span>
-                      <span className="gs">
-                        <b>{containerUp ? 'up' : 'down'}</b>
-                        <span className="u">container</span>
-                      </span>
-                    </div>
-                  </div>
-                  <div className="subcard">
-                    <div className="subcard-h">
-                      <Ic name="layers" size={13} /> models on share
-                      <span className="grow" style={{ flex: 1 }} />
-                      <span className="rchip comfy" onClick={openComfy} style={{ cursor: 'pointer' }}>
-                        manager ↗
-                      </span>
-                    </div>
-                    {inv ? (
-                      <div className="inv">
-                        <span className="inv-pill">
-                          <b>{inv.checkpoints ?? 0}</b> checkpoints
-                        </span>
-                        <span className="inv-pill">
-                          <b>{inv.diffusion ?? 0}</b> <span className="u">diffusion</span>
-                        </span>
-                        <span className="inv-pill">
-                          <b>{inv.loras ?? 0}</b> loras
-                        </span>
-                        <span className="inv-pill">
-                          <b>{inv.vae ?? 0}</b> vae
-                        </span>
-                      </div>
-                    ) : (
-                      <div className="mono dimx" style={{ fontSize: 11 }}>
-                        model share not mounted
-                      </div>
-                    )}
-
-                    <div className="card-section">
-                      <div className="subcard-h">
-                        <span style={{ color: 'var(--comfy)' }}>
-                          <Ic name="bolt" size={13} />
-                        </span>{' '}
-                        workflows
-                        <span className="grow" style={{ flex: 1 }} />
-                        <span
-                          className="dimx"
-                          style={{ fontSize: 10, textTransform: 'none', letterSpacing: 0 }}
-                        >
-                          opens in ComfyUI ↗
-                        </span>
-                      </div>
-                      <div className="flows">
-                        {FLOWS.map((f, i) => (
-                          <button key={i} className="flow" onClick={openComfy}>
-                            <span className="ic">
-                              <Ic name={f.ic} size={14} />
-                            </span>
-                            <span>{f.a}</span>
-                            <span className="arr">→</span>
-                            <span>{f.b}</span>
-                            {f.note && (
-                              <span className="dimx" style={{ fontSize: 10, marginLeft: 2 }}>
-                                {f.note}
-                              </span>
-                            )}
-                          </button>
-                        ))}
-                      </div>
-                    </div>
-                  </div>
+                <div className="cstat">
+                  <span className="cl">clock</span>
+                  <span className="cv">{stats.clk}<span className="u">GHz</span></span>
                 </div>
-
-                {/* container controls — write ops need the privileged path; shown
-                    disabled until that's wired, so the layout stays honest. */}
-                <div className="row-flex">
-                  <button className="rbtn" disabled style={{ opacity: 0.4 }} title="needs the privileged switchover path">
-                    <Ic name="stop" size={13} /> Stop container
-                  </button>
-                  <button className="rbtn" disabled style={{ opacity: 0.4 }} title="needs the privileged switchover path">
-                    <Ic name="refresh" size={13} /> Restart
-                  </button>
-                  <button className="rbtn" onClick={openComfy} title="Open ComfyUI logs / console">
-                    <Ic name="logs" size={13} /> Logs ↗
-                  </button>
-                  <span className="grow" style={{ flex: 1 }} />
-                  <span className="mono dimx" style={{ fontSize: 11 }}>
-                    {st.inference?.hermes ? 'inference holds the iGPU' : containerUp ? 'generation holds the iGPU' : 'iGPU idle'}
-                  </span>
+                <div className="cstat">
+                  <span className="cl">speed</span>
+                  <span className="cv acc">{stats.its}<span className="u">it/s</span></span>
                 </div>
               </div>
             </div>
           </div>
+        </div>
 
-          {/* footer — container identity + queue/caret expand control */}
-          <div className="engine-foot has-q">
-            <div className="foot-id">
-              <span className="k">container</span>
-              <span className="v comfy">{st.container?.name || 'comfyui'}</span>
-              <span className="sep">·</span>
-              <span className="k">state</span>
-              <span className="v">{st.container?.state || 'absent'}</span>
-              <span className="sep">·</span>
-              <span className="k">mode</span>
-              <span className="v comfy">{st.mode}</span>
-              <span className="sep">·</span>
-              <span className="k">endpoint</span>
-              <span className="v comfy">{st.endpoint || '—'}</span>
-            </div>
-            <button
-              className={'qcaret' + (queueTotal === 0 ? ' empty' : '')}
-              onClick={() => setOpen((o) => !o)}
-              aria-expanded={open}
-            >
-              <span className="q">
-                <Ic name="queue" size={13} /> queue
-                {queueTotal > 0 ? (
-                  <span className="qn">{queueTotal}</span>
-                ) : (
-                  <span className="qrun">empty</span>
-                )}
-                {running > 0 && <span className="qrun">· {running} running</span>}
-              </span>
-              <span className="car">
-                <Ic name="chev" size={13} />
-              </span>
-            </button>
-          </div>
+        {/* ── Workflows + Models lower section ── */}
+        <div className="wcard-sub">
+          <WorkflowsBlock onLaunch={onLaunch} />
+          <ModelsBlock />
         </div>
       </div>
 
-      {confirm && (
-        <SwitchoverConfirm
-          target={confirm}
-          queuePending={pending}
-          busy={sw.isPending}
-          onCancel={() => setConfirm(null)}
-          onConfirm={doSwitch}
-        />
-      )}
+      <CardFoot engine={engine} onRestart={onRestart} onLogs={onLogs} />
+    </div>
+  )
+}
+
+// ── Pane wrapper (mount point from slots.jsx) ─────────────────────────────────
+// Adds .comfy-v2-pane root + .comfy-page scope for blue accent CSS vars.
+//
+// Priority for data source (highest wins):
+//   1. window.__comfyuiV2MockOverride  — e2e seam, set before mount
+//   2. live API poll (useComfyui + transformComfyuiStatus)
+//   3. COMFYUI_V2_MOCK                — static fallback for dev/storybook
+//
+// The mock override seam bypasses the hook entirely so e2e tests that inject
+// window.__comfyuiV2MockOverride get deterministic rendering without needing
+// to intercept /api/comfyui/status.
+export function ComfyuiPane() {
+  // Mock override seam (e2e / dev)
+  const override =
+    typeof window !== 'undefined' ? window.__comfyuiV2MockOverride : undefined
+
+  // Live API poll — disabled when the override is set
+  const { data: liveStatus } = useComfyui({ active: !override })
+
+  // Derive pane data: override > live transform > static mock
+  let paneData
+  if (override) {
+    paneData = override
+  } else if (liveStatus) {
+    paneData = transformComfyuiStatus(liveStatus)
+  } else {
+    paneData = COMFYUI_V2_MOCK
+  }
+
+  // Control mutations
+  const cancelMutation = useComfyuiRenderCancel()
+  const restartMutation = useComfyuiRestart()
+  const launchMutation = useComfyuiWorkflowLaunch()
+
+  // Derive the ComfyUI base URL from live status endpoint field
+  const comfyBaseUrl = liveStatus?.endpoint
+    ? liveStatus.endpoint.startsWith('http')
+      ? liveStatus.endpoint
+      : `http://127.0.0.1:8188`
+    : undefined
+
+  // .comfy-pane kept for backward-compat (some mount selectors still use it).
+  return (
+    <div className="comfy-v2-pane comfy-pane comfy-page">
+      <ImageGenCard
+        mock={paneData}
+        onCancel={() => cancelMutation.mutate()}
+        onRestart={() => restartMutation.mutate()}
+        onLogs={() => {
+          // Fetch logs and open in a basic alert for now; a logs drawer is a
+          // future enhancement (the endpoint is wired, UI depth TBD).
+          fetch('/api/comfyui/logs?tail=60')
+            .then((r) => r.json())
+            .then((d) => {
+              if (Array.isArray(d?.lines) && d.lines.length > 0) {
+                alert(d.lines.join('\n'))
+              } else {
+                alert('no logs available')
+              }
+            })
+            .catch(() => alert('logs fetch failed'))
+        }}
+        onLaunch={(name) => launchMutation.mutate(name)}
+        comfyBaseUrl={comfyBaseUrl}
+      />
     </div>
   )
 }
 
-Object.assign(window, { ComfyuiPane })
+Object.assign(window, { ComfyuiPane, ImageGenCard })
diff --git a/ui/tests/e2e/specs/comfyui-arbiter-v3.spec.ts b/ui/tests/e2e/specs/comfyui-arbiter-v3.spec.ts
index c8eef339..cb03fac6 100644
--- a/ui/tests/e2e/specs/comfyui-arbiter-v3.spec.ts
+++ b/ui/tests/e2e/specs/comfyui-arbiter-v3.spec.ts
@@ -1,158 +1,240 @@
 /**
- * comfyui-arbiter-v3 — Playwright coverage for the GPU arbiter surface
- * (Phase D8): global "GPU: image mode" banner, arbiter mode chip, pin
- * toggle, and idle auto-restore countdown on the ComfyUI pane.
+ * comfyui-arbiter-v3 — V2 live-wired pane integration tests (Task 5.2).
  *
- * Harness mirrors profiles-crud-v3.spec.ts: VITE_MOCK_HAL0=1 build,
- * but /api/comfyui/* is NOT in the mockFetch allowlist, so page.route
- * intercepts both the status GET (read path) and the pin POST (raw:true
- * write path).
+ * Replaces the removed V1 switchover/pin UI tests. Tests the V2 pane's
+ * live API binding: page.route mocks /api/comfyui/* responses and asserts
+ * that status fields render into hero/queue/telemetry and that control
+ * buttons fire the correct POST endpoints.
+ *
+ * Convention (mirrors profiles-crud-v3.spec.ts):
+ *   - VITE_MOCK_HAL0=1 build; /api/comfyui/* is NOT in MOCK_ALLOWLIST
+ *   - page.route intercepts all comfyui routes
+ *   - The V2 pane is on .comfy-v2-pane (slots page Image Gen tab)
  */
 
 import { test, expect, json } from '../fixtures/apiMock'
 
-// Full /api/comfyui/status shape (D1-D7 backend): `mode` is arbiter-truth,
-// `arbiter` is the new block (null when the arbiter is unavailable).
-function comfyStatus(overrides: Record<string, any> = {}) {
+// Full /api/comfyui/status shape with V2 extension fields
+function comfyV2Status(overrides: Record<string, any> = {}) {
   return {
-    mode: 'inference',
-    reachable: false,
-    engine: 'stopped',
-    container: { name: 'comfyui', state: 'exited' },
-    endpoint: null,
-    memory: null,
-    queue: { running: 0, pending: 0 },
-    inference: { hermes: true },
-    inventory: { checkpoints: 3, diffusion: 2, loras: 8, vae: 2 },
-    switchover: { active: false, target: null, error: null },
-    arbiter: null,
-    ...overrides,
-  }
-}
-
-const IMG_STATUS = () =>
-  comfyStatus({
     mode: 'generation',
     reachable: true,
-    engine: 'running',
+    engine: 'generating',
     container: { name: 'comfyui', state: 'running' },
-    endpoint: 'http://127.0.0.1:8188',
+    endpoint: ':8188',
+    memory: {
+      gtt_used_gb: 54,
+      gtt_ceil_gb: 80,
+      ram_used_gb: 61,
+      ram_ceil_gb: 96,
+      pressure: false,
+    },
+    queue: { running: 1, pending: 2 },
+    util: 63,
+    temp: 68.5,
+    clock: 2.7,
+    it_s: null,
+    eta: null,
+    step: null,
     inference: { hermes: false },
+    inventory: { checkpoints: 6, video: 4, loras: 11, vae: 3 },
+    switchover: { active: false, target: null, error: null },
     arbiter: {
       mode: 'img',
       pinned: false,
       saved_llm_slots: ['primary', 'agent'],
-      // ~10 minutes out so the countdown renders a stable "~10m".
-      idle_restore_at: Math.floor(Date.now() / 1000) + 600,
+      idle_restore_at: null,
     },
-  })
+    // V2 render-hero extension fields (not in base /status spec but accepted
+    // by transformComfyuiStatus when present — same shape as mock fixture)
+    active_render: {
+      name: 'wan2.2-i2v',
+      kind: '480p · 81 frames',
+      pct: 72,
+      eta: '~38s',
+      node: 'KSampler (low-noise)',
+      step: 3,
+      total: 4,
+      its: 1.9,
+      loaded: 'wan-hi + wan-lo · umt5-xxl · wan-vae · 2 loras',
+    },
+    queue_jobs: [
+      { name: 'qwen-image', kind: 'txt2img · 1328²' },
+      { name: 'sdxl', kind: 'upscale 4×' },
+    ],
+    ...overrides,
+  }
+}
 
-const LLM_STATUS = () =>
-  comfyStatus({
-    arbiter: { mode: 'llm', pinned: false, saved_llm_slots: [], idle_restore_at: null },
+// Idle-engine variant — no active render, no pending jobs
+function comfyV2Idle() {
+  return comfyV2Status({
+    engine: 'running',
+    queue: { running: 0, pending: 0 },
+    util: 0,
+    active_render: null,
+    queue_jobs: [],
   })
+}
 
 async function gotoImageTab(page: any) {
   await page.goto('/#slots')
   await page.waitForSelector('.slot-tab.comfy', { timeout: 10_000 })
   await page.click('.slot-tab.comfy')
-  await page.waitForSelector('.comfy-pane', { timeout: 10_000 })
+  // V2 pane root has class .comfy-v2-pane
+  await page.waitForSelector('.comfy-v2-pane', { timeout: 10_000 })
 }
 
-test.describe('ComfyUI GPU arbiter — Phase D8', () => {
-  // ── 1. img mode: global banner + image-mode chip + countdown ──────────────
+test.describe('ComfyUI V2 live-wired pane (Task 5.2)', () => {
+
+  // ── 1. status renders into hero ──────────────────────────────────────────
+
+  test('status: generating state renders job name + progress in hero', async ({ page }) => {
+    await page.route('**/api/comfyui/status', (route: any) => json(route, comfyV2Status()))
+    await gotoImageTab(page)
+
+    const pane = page.locator('.comfy-v2-pane')
+    await expect(pane).toContainText('wan2.2-i2v')
+    await expect(pane.locator('.gbar').first()).toBeVisible()
+    await expect(pane).toContainText('~38s')
+    await expect(pane).toContainText('it/s')
+  })
+
+  // ── 2. status renders into queue ─────────────────────────────────────────
+
+  test('status: queue rows bind — 1 running + 2 pending', async ({ page }) => {
+    await page.route('**/api/comfyui/status', (route: any) => json(route, comfyV2Status()))
+    await gotoImageTab(page)
 
-  test('arbiter.mode img → global banner + image-mode chip + countdown', async ({ page }) => {
-    await page.route('**/api/comfyui/status', (route) => json(route, IMG_STATUS()))
+    const pane = page.locator('.comfy-v2-pane')
+    await expect(pane.locator('.qcard.row.running')).toBeVisible()
+    await expect(pane.locator('.qcard.row.running .ldot.generating')).toBeVisible()
 
-    await page.goto('/#slots')
+    const pending = pane.locator('.qcard.row.pending')
+    await expect(pending).toHaveCount(2)
+    await expect(pending.nth(0)).toContainText('qwen-image')
+    await expect(pending.nth(1)).toContainText('sdxl')
+  })
 
-    // Global banner renders in the view-banners strip (any route).
-    const banner = page.locator('.banner', { hasText: 'GPU: image mode' })
-    await expect(banner).toBeVisible({ timeout: 10_000 })
-    await expect(banner).toContainText('LLM slots are stopped')
+  // ── 3. status renders into telemetry gauges ──────────────────────────────
 
-    // Pane: arbiter chip shows image mode + the auto-restore countdown.
-    await page.click('.slot-tab.comfy')
-    await page.waitForSelector('.comfy-pane', { timeout: 10_000 })
-    const chip = page.locator('[data-testid="comfy-arbiter-chip"]')
-    await expect(chip).toBeVisible()
-    await expect(chip).toContainText('image mode')
+  test('status: GTT gauge shows memory values from /status memory block', async ({ page }) => {
+    await page.route('**/api/comfyui/status', (route: any) => json(route, comfyV2Status()))
+    await gotoImageTab(page)
 
-    const countdown = page.locator('[data-testid="comfy-restore-countdown"]')
-    await expect(countdown).toBeVisible()
-    await expect(countdown).toContainText(/auto-restore in ~\d+m/)
+    const pane = page.locator('.comfy-v2-pane')
+    const gauge = pane.locator('.gauge').first()
+    await expect(gauge).toBeVisible()
+    await expect(gauge).toContainText('gtt')
+    // gtt_used_gb: 54 should appear in sub label
+    await expect(gauge).toContainText('54')
   })
 
-  // ── 2. pin toggle → POST /api/comfyui/pin {"pinned":true} ────────────────
+  test('status: device telemetry shows util, temp, and clock from /status', async ({ page }) => {
+    await page.route('**/api/comfyui/status', (route: any) => json(route, comfyV2Status()))
+    await gotoImageTab(page)
 
-  test('pin toggle POSTs {"pinned":true}; pinned reflected, countdown hidden', async ({ page }) => {
-    const posts: any[] = []
-    let pinned = false
+    const pane = page.locator('.comfy-v2-pane')
+    await expect(pane).toContainText('63%')
+    await expect(pane).toContainText('68.5°C')
+    await expect(pane).toContainText('2.7GHz')
+  })
 
-    await page.route('**/api/comfyui/status', (route) => {
-      const st = IMG_STATUS()
-      st.arbiter!.pinned = pinned
-      return json(route, st)
-    })
-    await page.route('**/api/comfyui/pin', (route) => {
-      if (route.request().method() === 'POST') {
-        try { posts.push(JSON.parse(route.request().postData() || '{}')) } catch { posts.push({}) }
-        pinned = posts[posts.length - 1].pinned === true
-        return json(route, { pinned })
-      }
-      return json(route, { pinned })
+  // ── 4. Cancel render fires POST /api/comfyui/render/cancel ───────────────
+
+  test('Cancel render button fires POST /render/cancel', async ({ page }) => {
+    const posts: string[] = []
+    await page.route('**/api/comfyui/status', (route: any) => json(route, comfyV2Status()))
+    await page.route('**/api/comfyui/render/cancel', (route: any) => {
+      posts.push(route.request().method())
+      return json(route, { status: 'cancel_requested' }, 202)
     })
 
     await gotoImageTab(page)
 
-    const pinBtn = page.locator('[data-testid="comfy-pin-toggle"]')
-    await expect(pinBtn).toBeVisible()
-    await expect(page.locator('[data-testid="comfy-restore-countdown"]')).toBeVisible()
+    const cancelBtn = page.locator('.comfy-v2-pane button', { hasText: 'Cancel render' }).first()
+    await expect(cancelBtn).toBeVisible()
+    await cancelBtn.click()
+
+    await expect.poll(() => posts.length, { timeout: 5_000 }).toBeGreaterThan(0)
+    expect(posts[0]).toBe('POST')
+  })
+
+  // ── 5. Workflow chip fires POST /api/comfyui/workflows/{name}/launch ──────
+
+  test('workflow chip click fires POST /workflows/{name}/launch', async ({ page }) => {
+    const launched: string[] = []
+    await page.route('**/api/comfyui/status', (route: any) => json(route, comfyV2Status()))
+    await page.route(/\/api\/comfyui\/workflows\/[^/]+\/launch/, (route: any) => {
+      const url = route.request().url()
+      // extract name from URL
+      const match = url.match(/\/workflows\/([^/]+)\/launch/)
+      if (match) launched.push(decodeURIComponent(match[1]))
+      return json(route, { status: 'queued', prompt_id: 'mock-id' }, 202)
+    })
 
-    await pinBtn.click()
+    await gotoImageTab(page)
 
-    // POST body asserted.
-    await expect.poll(() => posts.length).toBeGreaterThan(0)
-    expect(posts[0]).toEqual({ pinned: true })
+    // Click the first workflow chip (qwen-image)
+    const chips = page.locator('.comfy-v2-pane .flow')
+    await expect(chips).toHaveCount(6)
+    await chips.first().click()
 
-    // Pinned state reflected after refetch: pin active, countdown hidden.
-    await expect(pinBtn).toContainText('pinned', { timeout: 10_000 })
-    await expect(page.locator('[data-testid="comfy-restore-countdown"]')).not.toBeVisible()
+    await expect.poll(() => launched.length, { timeout: 5_000 }).toBeGreaterThan(0)
+    expect(launched[0]).toBe('qwen-image')
   })
 
-  // ── 3. llm mode: banner gone, inference chip ─────────────────────────────
+  // ── 6. Restart button fires POST /api/comfyui/restart ────────────────────
 
-  test('arbiter.mode llm → no banner, inference chip', async ({ page }) => {
-    await page.route('**/api/comfyui/status', (route) => json(route, LLM_STATUS()))
+  test('footer Restart button fires POST /restart', async ({ page }) => {
+    const posts: string[] = []
+    await page.route('**/api/comfyui/status', (route: any) => json(route, comfyV2Status()))
+    await page.route('**/api/comfyui/restart', (route: any) => {
+      posts.push(route.request().method())
+      return json(route, { status: 'restart_requested' }, 202)
+    })
 
     await gotoImageTab(page)
 
-    await expect(page.locator('.banner', { hasText: 'GPU: image mode' })).not.toBeVisible()
+    const restartBtn = page.locator('.comfy-v2-pane .wfoot .sctrl.restart')
+    await expect(restartBtn).toBeVisible()
+    await restartBtn.click()
 
-    const chip = page.locator('[data-testid="comfy-arbiter-chip"]')
-    await expect(chip).toBeVisible()
-    await expect(chip).toContainText('inference')
+    await expect.poll(() => posts.length, { timeout: 5_000 }).toBeGreaterThan(0)
+    expect(posts[0]).toBe('POST')
+  })
 
-    // No countdown in llm mode.
-    await expect(page.locator('[data-testid="comfy-restore-countdown"]')).not.toBeVisible()
+  // ── 7. Idle state: empty queue renders in-flow (no overlay lockup) ────────
+
+  test('idle: empty-queue state renders in-flow, no click-blocking overlay', async ({ page }) => {
+    await page.route('**/api/comfyui/status', (route: any) => json(route, comfyV2Idle()))
+    await gotoImageTab(page)
+
+    const pane = page.locator('.comfy-v2-pane')
+    await expect(pane.locator('.queue-empty-state')).toBeVisible()
+
+    // Open ComfyUI button must be clickable (would fail if overlay intercepts)
+    const openBtn = pane.locator('button, a', { hasText: 'Open ComfyUI' }).first()
+    await expect(openBtn).toBeVisible()
+    await expect(openBtn).toBeEnabled()
+    await openBtn.click({ trial: true })
   })
 
-  // ── 4. arbiter null: fail-soft — no chip/banner/pin, legacy pane intact ──
+  // ── 8. Graceful degrade: absent active_render uses placeholder skeleton ───
 
-  test('arbiter null → no chip/banner/pin; legacy pane intact', async ({ page }) => {
-    await page.route('**/api/comfyui/status', (route) => json(route, comfyStatus()))
+  test('degrade: no active_render field → placeholder skeleton renders without crash', async ({ page }) => {
+    // Status says 1 running but no active_render detail
+    const statusNoDetail = comfyV2Status({ active_render: undefined, queue_jobs: undefined })
+    delete statusNoDetail.active_render
+    delete statusNoDetail.queue_jobs
 
+    await page.route('**/api/comfyui/status', (route: any) => json(route, statusNoDetail))
     await gotoImageTab(page)
 
-    await expect(page.locator('.banner', { hasText: 'GPU: image mode' })).not.toBeVisible()
-    await expect(page.locator('[data-testid="comfy-arbiter-chip"]')).toHaveCount(0)
-    await expect(page.locator('[data-testid="comfy-pin-toggle"]')).toHaveCount(0)
-    await expect(page.locator('[data-testid="comfy-restore-countdown"]')).toHaveCount(0)
-
-    // Legacy display: engine card + mode toggle + footer identity still render.
-    await expect(page.locator('.comfy-pane .engine')).toBeVisible()
-    await expect(page.locator('.comfy-pane .sw-wrap')).toBeVisible()
-    await expect(page.locator('.comfy-pane .engine-foot')).toContainText('inference')
+    const pane = page.locator('.comfy-v2-pane')
+    // Pane must not crash — the card header should be visible
+    await expect(pane.locator('.wcard-h')).toBeVisible()
+    // running row is shown (1 running)
+    await expect(pane.locator('.qcard.row.running')).toBeVisible()
   })
 })
diff --git a/ui/tests/e2e/specs/imagegen-v2.spec.ts b/ui/tests/e2e/specs/imagegen-v2.spec.ts
new file mode 100644
index 00000000..18bceed1
--- /dev/null
+++ b/ui/tests/e2e/specs/imagegen-v2.spec.ts
@@ -0,0 +1,215 @@
+/**
+ * imagegen-v2 — Playwright coverage for the V2 "Render hero" ImageGen pane.
+ *
+ * Tests: render-hero, queue rows, telemetry gauge, workflows strip, container
+ * footer, empty-queue (no overlay lockup, recall PR #845), reduced-motion
+ * freezes pulse animation.
+ *
+ * Harness: VITE_MOCK_HAL0=1 build. /api/comfyui/status is NOT in MOCK_ALLOWLIST
+ * so page.route drives the pane (same convention as comfyui-arbiter-v3.spec.ts).
+ */
+
+import { test, expect, json } from '../fixtures/apiMock'
+
+// V2 fixture — generating state (handoff demo values)
+function comfyV2Status(overrides: Record<string, any> = {}) {
+  return {
+    mode: 'generation',
+    reachable: true,
+    engine: 'generating',
+    container: { name: 'comfyui', state: 'running' },
+    endpoint: ':8188',
+    memory: { gtt_used_gb: 54, gtt_ceil_gb: 80, ram_used_gb: 61, ram_ceil_gb: 96, pressure: false },
+    queue: { running: 1, pending: 2 },
+    inference: { hermes: false },
+    inventory: { checkpoints: 6, video: 4, loras: 11, vae: 3 },
+    switchover: { active: false, target: null, error: null },
+    arbiter: { mode: 'img', pinned: false, saved_llm_slots: ['primary', 'agent'], idle_restore_at: null },
+    // V2 render-hero specific fields (mock)
+    active_render: {
+      name: 'wan2.2-i2v',
+      kind: '480p · 81 frames',
+      pct: 72,
+      eta: '~38s',
+      node: 'KSampler (low-noise)',
+      step: 3,
+      total: 4,
+      its: 1.9,
+      loaded: 'wan-hi + wan-lo · umt5-xxl · wan-vae · 2 loras',
+    },
+    queue_jobs: [
+      { name: 'qwen-image', kind: 'txt2img · 1328²' },
+      { name: 'sdxl', kind: 'upscale 4×' },
+    ],
+    ...overrides,
+  }
+}
+
+// Empty-queue variant — no active render, no pending jobs
+function comfyV2Empty() {
+  return comfyV2Status({
+    engine: 'running',
+    queue: { running: 0, pending: 0 },
+    active_render: null,
+    queue_jobs: [],
+  })
+}
+
+async function gotoImageTab(page: any) {
+  await page.route('**/api/comfyui/status', (route: any) => json(route, comfyV2Status()))
+  await page.goto('/#slots')
+  await page.waitForSelector('.slot-tab.comfy', { timeout: 10_000 })
+  await page.click('.slot-tab.comfy')
+  // V2 pane root has class .comfy-v2-pane
+  await page.waitForSelector('.comfy-v2-pane', { timeout: 10_000 })
+}
+
+test.describe('ImageGen V2 render-hero pane', () => {
+  // ── 1. Render hero renders ──────────────────────────────────────────────
+  test('render-hero: job name, progress bar, step info, it/s, eta, controls', async ({ page }) => {
+    await gotoImageTab(page)
+    const pane = page.locator('.comfy-v2-pane')
+
+    // job name in hero
+    await expect(pane.locator('.preview')).toBeVisible()
+    await expect(pane).toContainText('wan2.2-i2v')
+
+    // active-render progress block
+    const jobBlock = pane.locator('.job').first()
+    await expect(jobBlock).toBeVisible()
+    await expect(jobBlock).toContainText('KSampler (low-noise)')
+    // progress bar (gbar) renders
+    await expect(pane.locator('.gbar').first()).toBeVisible()
+    // step pips present
+    await expect(pane.locator('.steps-pips')).toBeVisible()
+    // it/s and eta present
+    await expect(pane).toContainText('it/s')
+    await expect(pane).toContainText('~38s')
+
+    // Cancel + Open controls
+    await expect(pane.locator('button', { hasText: 'Cancel render' })).toBeVisible()
+    // Open ComfyUI may be a <button> or <a> depending on whether the live endpoint is known
+    await expect(pane.locator('button, a').filter({ hasText: 'Open ComfyUI' }).first()).toBeVisible()
+  })
+
+  // ── 2. Queue rows ───────────────────────────────────────────────────────
+  test('queue: running row + 2 pending rows render', async ({ page }) => {
+    await gotoImageTab(page)
+    const pane = page.locator('.comfy-v2-pane')
+
+    // running row: ldot.generating
+    await expect(pane.locator('.qcard.row.running')).toBeVisible()
+    await expect(pane.locator('.qcard.row.running .ldot.generating')).toBeVisible()
+
+    // 2 pending rows
+    const pending = pane.locator('.qcard.row.pending')
+    await expect(pending).toHaveCount(2)
+    await expect(pending.nth(0)).toContainText('qwen-image')
+    await expect(pending.nth(1)).toContainText('sdxl')
+  })
+
+  // ── 3. Telemetry gauge ──────────────────────────────────────────────────
+  test('telemetry: GTT gauge renders with correct label + values', async ({ page }) => {
+    await gotoImageTab(page)
+    const pane = page.locator('.comfy-v2-pane')
+
+    const gauge = pane.locator('.gauge').first()
+    await expect(gauge).toBeVisible()
+    // shows GTT label and used/ceil (54/80)
+    await expect(gauge).toContainText('gtt')
+    await expect(gauge).toContainText('54')
+
+    // 2×2 device metric grid
+    await expect(pane.locator('.mx2')).toBeVisible()
+    await expect(pane.locator('.mx2')).toContainText('util')
+    await expect(pane.locator('.mx2')).toContainText('temp')
+    await expect(pane.locator('.mx2')).toContainText('clock')
+  })
+
+  // ── 4. Workflows strip ──────────────────────────────────────────────────
+  test('workflows strip renders 6 flow buttons', async ({ page }) => {
+    await gotoImageTab(page)
+    const pane = page.locator('.comfy-v2-pane')
+
+    await expect(pane.locator('.flows')).toBeVisible()
+    await expect(pane.locator('.flow')).toHaveCount(6)
+  })
+
+  // ── 5. Models on share ─────────────────────────────────────────────────
+  test('models block: inv pills render (checkpoints, loras, vae…)', async ({ page }) => {
+    await gotoImageTab(page)
+    const pane = page.locator('.comfy-v2-pane')
+
+    await expect(pane.locator('.inv')).toBeVisible()
+    // "6 checkpoints" pill
+    await expect(pane.locator('.inv-pill').first()).toContainText('6')
+  })
+
+  // ── 6. Container footer ─────────────────────────────────────────────────
+  test('footer: container identity + controls render', async ({ page }) => {
+    await gotoImageTab(page)
+    const pane = page.locator('.comfy-v2-pane')
+
+    const foot = pane.locator('.wfoot')
+    await expect(foot).toBeVisible()
+    await expect(foot).toContainText('comfyui')
+    await expect(foot).toContainText(':8188')
+    // stop, restart, logs controls
+    await expect(foot.locator('.sctrl.stop')).toBeVisible()
+    await expect(foot.locator('.sctrl.restart')).toBeVisible()
+  })
+
+  // ── 7. Empty-queue state: NO click-blocking overlay ─────────────────────
+  // Recall PR #845 lockup: position:absolute;inset:0 overlay ate all clicks.
+  // Verify: a clickable element in/below the empty-queue area is reachable.
+  test('empty-queue: no full-bleed overlay — clickable element underneath', async ({ page }) => {
+    // Inject the empty-queue mock before navigation via window seam
+    // (same pattern as window.__hal0UpdateStateOverride in mock.ts).
+    const emptyMock = {
+      engine: { name: 'ComfyUI', endpoint: ':8188', image: 'ghcr.io/hal0ai/comfyui@sha256:9f3c…b21a', restart: 'no' },
+      run: null,
+      queue: [],
+      gtt: { used: 54, ceil: 80 },
+      ram: { used: 61, ceil: 96 },
+      stats: { util: 0, temp: 60, clk: 2.5, its: 0 },
+    }
+    await page.route('**/api/comfyui/status', (route: any) => json(route, comfyV2Empty()))
+    await page.addInitScript((mock: any) => {
+      (window as any).__comfyuiV2MockOverride = mock
+    }, emptyMock)
+    await page.goto('/#slots')
+    await page.waitForSelector('.slot-tab.comfy', { timeout: 10_000 })
+    await page.click('.slot-tab.comfy')
+    await page.waitForSelector('.comfy-v2-pane', { timeout: 10_000 })
+
+    const pane = page.locator('.comfy-v2-pane')
+    // Empty-queue state shows an in-flow message (not a bleed overlay)
+    await expect(pane.locator('.queue-empty-state')).toBeVisible()
+
+    // Verify the Open ComfyUI button (below/near empty state) is clickable.
+    // A full-bleed overlay would intercept this click and cause an error or wrong element.
+    // Open ComfyUI may be <button> or <a> — check either
+    const openBtn = pane.locator('button, a').filter({ hasText: 'Open ComfyUI' }).first()
+    await expect(openBtn).toBeVisible()
+    // isEnabled asserts no invisible overlay blocking it
+    await expect(openBtn).toBeEnabled()
+    // Actually clicking: if an overlay intercepts, Playwright strict mode raises
+    await openBtn.click({ trial: true })
+  })
+
+  // ── 8. Reduced-motion: pulse animation frozen ───────────────────────────
+  test('reduced-motion: ldot.generating has no animation', async ({ page }) => {
+    // Emulate prefers-reduced-motion: reduce
+    await page.emulateMedia({ reducedMotion: 'reduce' })
+    await gotoImageTab(page)
+    const pane = page.locator('.comfy-v2-pane')
+
+    // The generating dot should exist but its computed animation should be none/paused
+    const dot = pane.locator('.ldot.generating').first()
+    await expect(dot).toBeVisible()
+
+    // Check animation-name is none (reduced-motion rule in CSS)
+    const animName = await dot.evaluate((el) => getComputedStyle(el).animationName)
+    expect(animName).toBe('none')
+  })
+})