comfyui-mcp 0.20.0 → 0.20.2

package/plugin/skills/director/SKILL.md

@@ -21,6 +21,14 @@ The Director skill orchestrates a complete short film production from a text sto
 - Each scene is independently retryable without affecting others
 - `clear_vram` between every model family switch
 
+## CRITICAL: Inspect modes + verify every output
+
+This pipeline drives the user's live canvas across many stages, so two habits are non-negotiable:
+
+- **Inspect node modes before each render.** After loading any pack/template/subgraph and before `panel_run`, call `panel_get_graph` and check each node's `mode`. A `bypass` node is skipped (passes input through); a `mute` node and everything downstream don't execute. If the path/branch/switch you need is bypassed or muted, enable it with `panel_set_node_mode` (set the wanted node `active`, the unwanted one `bypass`/`mute`). Never assume a switch or route is already active.
+- **Verify the output matches before moving on.** Every Phase-N render is a gate: actually LOOK at the produced frame/clip (view it) and confirm it matches the intent BEFORE advancing or reporting progress. If it's wrong, diagnose (wrong prompt path? a bypassed/muted builder or switch? wrong widget? wrong ref image?), fix, and rerun. Do NOT declare a phase done or report progress you haven't verified.
+- **Bypass completed stages before queuing the next one.** If you build the multi-stage pipeline on ONE canvas (e.g. Krea2 → LTX → WAN) rather than running each phase in isolation, once a stage has run and its output is captured/staged, `panel_set_node_mode(mode:"bypass")` that stage's nodes BEFORE you `panel_run` the next stage — otherwise `panel_run` re-executes the whole graph and you pay for / wait on already-finished work (a real, costly failure mode). Keep only the active stage live; feed the prior output forward with `stage_output_as_input` (bypass the producer, feed its captured output to the consumer's loader).
+
 ## CRITICAL: Character Consistency
 
 **Independent Z-Image generations per scene produce different-looking characters.** This was the #1 problem discovered during testing. The solution:
@@ -219,12 +227,16 @@ Show hero frame and all character refs. User approves or requests regeneration w
 
 Edits are **sequential** — each depends on the previous output:
 1. Run edit, wait for completion
-2. `upload_image` the output
-3. Use uploaded output as source for next edit
+2. **Stage the output as the next stage's input with `stage_output_as_input`** (pass the output's `{ filename, subfolder?, type? }`); it returns the registered input filename
+3. Use that returned filename as the `image` in the next edit's `LoadImage`
 4. Update state file after each edit
 
 Independent edits (both from hero) can run in parallel.
 
+### CRITICAL: feeding an output into the next loader (don't guess paths)
+
+To pipe ANY stage's output into the next stage's loader (`LoadImage` here, `VHS_LoadVideo` / `LoadAudio` in the video phases), call **`stage_output_as_input`** with the output's `{ filename, subfolder?, type? }` and drop the returned input filename into the loader's `image`/`video`/`audio` widget. For a file already on local disk, use `upload_image` / `upload_video` / `upload_audio`. **NEVER copy the output file into, or guess, a filesystem `input/` path** — ComfyUI's input and output directories may be CUSTOM (`--input-directory` / `--output-directory`), so a guessed path makes the loader reject the file (`Invalid image file`) and wastes the render. `stage_output_as_input` goes through the server API (`/view` → `/upload/image`), which resolves the real dirs correctly.
+
 ### Timing
 
 - First edit: ~87s (model loading)

package/plugin/skills/krea2-txt2img/SKILL.md

@@ -16,7 +16,21 @@ use up to 50 seats). Two variants:
 1. **Krea 2 Raw** — the base checkpoint before extra post-training. For
    fine-tuning / maximum fidelity, more steps.
 2. **Krea 2 Turbo** — post-trained + **distilled**; generates in **~8 steps at
-   cfg 1**. This is what the `krea2-txt2img` pack ships.
+   cfg 1**. This is what the krea2 txt2img packs ship.
+
+## Two packs (no group toggles, no bypassed nodes)
+
+The old single `krea2-txt2img` graph (prompt mode toggled by bypassing nodes) is
+split into two standalone packs — pick by how you prompt:
+
+- **`krea2-txt2img-manual`** — plain prose prompt (the `MANUAL PROMPT` node).
+- **`krea2-txt2img-json`** — Ideogram-4-style structured JSON / area prompting
+  (`Ideogram4PromptBuilderKJ`).
+
+Both are single-pipeline graphs with no group toggles — each pack's one prompt
+source is active and the other prompt node is removed (no prompt-mode bypass to
+flip). `ImageSharpenKJ` runs before `SaveImage`. Two **optional** post-proc nodes
+ship **bypassed** in both (see below). Both are render-verified.
 
 Krea 2 has **native ComfyUI support** (`comfy/text_encoders/krea2.py`, ComfyUI ≥
 v0.26.0): the `CLIPLoader` uses **`type=krea2`**, with a **Qwen3-VL 4B** text
@@ -36,28 +50,48 @@ adherence and structured-JSON prompts.
 
 - **core**: `UNETLoader` (krea2_turbo) → `CLIPLoader` (type=krea2) → `VAELoader`
   (qwen_image_vae), wired via KJNodes `SetNode`/`GetNode` buses into a subgraph
-  (`CLIPTextEncode` → `KSampler` → `VAEDecode`, with an rgthree `Any Switch` that
-  picks the manual prompt vs the JSON-builder prompt).
+  (`CLIPTextEncode` → `KSampler` → `VAEDecode`). An rgthree `Any Switch` sits in
+  front of the encoder; in each pack only that pack's prompt source is wired to it
+  (manual node in `-manual`, JSON builder in `-json`).
 - **rgthree-comfy**: Power Lora Loader, Any Switch, Label, Fast Groups.
 - **ComfyUI-KJNodes**: Set/Get, `Ideogram4PromptBuilderKJ`, `ImageSharpenKJ`.
-- **ComfyUI-RBG-SmartSeedVariance**: `RBG_Smart_Seed_Variance` (opt-in).
-- **ComfyUI-ConditioningKrea2Rebalance**: `ConditioningKrea2Rebalance` — the Krea 2
-  **safety-filter bypass**. Ship it **bypassed**; the filter is intact by default.
+- **ComfyUI-RBG-SmartSeedVariance**: `RBG_Smart_Seed_Variance` — **optional**, ships
+  **bypassed** in the positive-conditioning loop.
+- **ComfyUI-ConditioningKrea2Rebalance**: `ConditioningKrea2Rebalance` — **optional**,
+  ships **bypassed** (after seed-variance), in the same loop.
 
 ## Settings that matter
 
 - **steps 8, cfg 1** — Turbo is distilled; more steps/higher cfg over-cooks it.
 - **sampler `er_sde`, scheduler `simple`** — the verified defaults.
 - **1920×1080** default; Krea 2 handles a wide aspect range.
-- The JSON prompt-builder (`Ideogram4PromptBuilderKJ`), seed-variance, and
-  laplacian-sharpen post-proc ship **bypassed** — opt-in.
+- The prompt source is fixed per pack (manual node vs JSON builder) — no
+  prompt-mode bypass to flip.
+
+## Optional post-proc (ship bypassed — un-bypass to use)
+
+Both packs leave these two nodes in the positive-conditioning loop, **bypassed**
+(passthrough). Un-bypass on the live canvas with `panel_set_node_mode` (or in the
+UI) when you want them:
+
+- **`RBG_Smart_Seed_Variance`** — controlled variations of the same prompt without
+  changing the composition. Enable it, set its seed mode to `randomize`, and tune
+  the variance mode (e.g. `🌿 Balanced`) / strength widgets. Leave bypassed for a
+  deterministic single result.
+- **`ConditioningKrea2Rebalance`** — rebalances the per-token conditioning weights
+  (the comma-separated weight string, e.g. `1.0,…,2.5,5.0,1.1,4.0,1.0`). The
+  upstream author frames it as removing Krea 2's built-in **safety filter**, so
+  **leave it bypassed for the model's default safety behavior**; only enable (and
+  adjust the weights) with a specific, authorized reason.
 
 ## JSON / area prompting
 
 Like Ideogram 4, Krea 2's Qwen3-VL encoder reads structured prompts (per-region
-desc + bounding boxes + palettes). To use it: **un-bypass `Ideogram4PromptBuilderKJ`
-(node 14) and bypass the manual prompt (node 143)** — the rgthree `Any Switch`
-feeds whichever is active into the encoder. Gotchas learned the hard way:
+desc + bounding boxes + palettes). For structured prompting just use the
+**`krea2-txt2img-json`** pack — its `Ideogram4PromptBuilderKJ` drives the encoder
+directly (no bypass to flip). After the render, VERIFY the image matches the JSON
+you set (view it) BEFORE continuing; if it doesn't, a field is probably stale —
+fix and rerun. Gotchas learned the hard way:
 
 - **Set ALL the builder fields**, not just the prompt/boxes — `background`,
   `technical`, `style`, `lighting` (widgets 3/5/6/7). Leaving stale values leaks
@@ -70,11 +104,13 @@ feeds whichever is active into the encoder. Gotchas learned the hard way:
 
 ## Render-verified
 
-5 images render crisp at 1920×1080 / 8 steps / cfg 1 / er_sde — 3 prose (wildlife,
-urban night, still-life) + 2 Ideogram-JSON (still-life, landscape). **Note:** the
-`ImageSharpenKJ` (rcas 0.55) before `SaveImage` ships **active** — bypassing it
-drops the image link (a converter gap: bypass-passthrough doesn't cross a subgraph
-IMAGE output), and the contrast-adaptive sharpen suits Krea 2's crisp look anyway.
+Both packs render crisp at 1920×1080 / 8 steps / cfg 1 / er_sde with the optional
+loop nodes bypassed (default) — `-manual` on a prose snow-leopard prompt, `-json`
+on a tea still-life whose teapot/cup/figs each land in their bbox region.
+**Note:** the `ImageSharpenKJ` (rcas 0.55) before `SaveImage` is **active** —
+bypassing it drops the image link (a converter gap: bypass-passthrough doesn't
+cross a subgraph IMAGE output), and the contrast-adaptive sharpen suits Krea 2's
+crisp look anyway.
 
 ## Gotchas
 

package/plugin/skills/ltxv2-video/SKILL.md

@@ -219,6 +219,18 @@ Dedicated sigma schedule for LTX-V2 latent space:
 
 Connect the optional `latent` input for latent-aware shift scaling.
 
+> **Feeding a prior stage's output into I2V (e.g. Krea2 image → LTX video).** The
+> `LoadImage` that feeds `LTXVImgToVideo.image` needs the source frame registered
+> as a ComfyUI INPUT. When that frame is an OUTPUT from an earlier stage, call
+> **`stage_output_as_input`** with its `{ filename, subfolder?, type? }` and drop
+> the returned input filename into `LoadImage`. (For a file already on local
+> disk, `upload_image`.) **NEVER copy the output file into, or guess, a
+> filesystem `input/` path** — ComfyUI's input/output dirs may be CUSTOM
+> (`--input-directory` / `--output-directory`), so a guessed path makes
+> `LoadImage` reject the file (`Invalid image file`) and wastes the render.
+> `stage_output_as_input` goes through the server API (`/view` → `/upload/image`)
+> and resolves the real dirs correctly.
+
 ### LTXVImgToVideo (For I2V)
 
 All-in-one node that encodes image, creates latent, and wraps conditioning:
@@ -240,6 +252,14 @@ All-in-one node that encodes image, creates latent, and wraps conditioning:
 }
 ```
 
+> **Gotcha — `strength` controls motion; DON'T set it to 1.0.** `LTXVImgToVideo.strength`
+> is how strongly the output adheres to the start image: **higher = more adherence = LESS
+> motion**. Setting it to **1.0 pins every frame to the start image → a FROZEN i2v with
+> ZERO motion** (the storyboard frames come out basically identical). Keep the verified
+> value **~0.6** (as in the example above) for proper motion. If a generated i2v clip
+> shows little/no motion, the FIRST thing to check is that `strength` wasn't bumped toward
+> 1.0.
+
 ### LTXVLatentUpsampler (For Two-Stage Upscale)
 
 ```json

package/plugin/skills/video-extend/SKILL.md

@@ -372,6 +372,15 @@ This also matters for **chaining** — color-match every new segment to the
 Pusa adds a bounded window (~4 s) per run. To go longer, **feed the output back
 in**:
 
+0. **Stage the output clip as the next run's input** with
+   **`stage_output_as_input`** (pass the rendered clip's
+   `{ filename, subfolder?, type? }`); use the returned input filename in
+   `VHS_LoadVideo`. **NEVER copy the output .mp4 into, or guess, a filesystem
+   `input/` path** — ComfyUI's input/output dirs may be CUSTOM
+   (`--input-directory` / `--output-directory`), so a guessed path makes
+   `VHS_LoadVideo` fail to find/decode the file and wastes the run. The tool
+   routes through the server API (`/view` → `/upload/image`), which resolves the
+   real dirs correctly. (For a clip already on local disk, `upload_video`.)
 1. Run the extension → decode → save (or keep the frames in-graph).
 2. Take the **tail of the *new* output** (the last ~13 frames) as the next
    `WanVideoEncode` input.

package/plugin/skills/wan-flf-video/SKILL.md

@@ -521,7 +521,7 @@ When the start and end frames have different subject sizes (e.g., small cat →
 1. **Generate anchor frame** with Z-Image/SDXL/Flux (portrait orientation for standing subjects)
 2. **Qwen Edit to create second frame** — the edit preserves scene context
 3. **Clear VRAM** between model families
-4. **Upload both frames** with `upload_image`
+4. **Stage both frames as inputs.** When the frames are ComfyUI OUTPUTS from a prior stage (the generated/edited frames above), use **`stage_output_as_input`** with each output's `{ filename, subfolder?, type? }` and feed the returned input filename into each `LoadImage`. (For a frame already on local disk, use `upload_image`.) **NEVER copy the output file into, or guess, a filesystem `input/` path** — ComfyUI's input/output dirs may be CUSTOM (`--input-directory` / `--output-directory`), so a guessed path makes `LoadImage` reject the file (`Invalid image file`) and wastes the render. `stage_output_as_input` routes through the server API (`/view` → `/upload/image`), which resolves the real dirs correctly.
 5. **Run dual hi-lo FLF** with morph LoRA if morphing is desired
 6. **Optionally upscale** with SeedVR2 to 1080p
 

package/plugin/skills/workflow-layout/SKILL.md

@@ -27,7 +27,10 @@ real node sizes and rail positions first, then compute positions from them.
 - **Subgraphs** (nest nodes into one collapsible node): `panel_create_subgraph(node_ids)`,
   `panel_enter_subgraph` / `panel_exit_subgraph`, `panel_get_subgraph`,
   `panel_promote_widget`, **`panel_move_rail(rail, [x,y])`** (`rail` = `"input"|"output"`,
-  must be inside the subgraph).
+  must be inside the subgraph), **`panel_expose_subgraph_output(from_node_id, from_output)`** /
+  **`panel_expose_subgraph_input(to_node_id, to_input)`** (expose an interior slot on the
+  boundary rail — must be inside the subgraph), and **`panel_unpack_subgraph(node_id)`**
+  (expand/dissolve a subgraph back into the parent — the inverse of `panel_create_subgraph`).
 - `panel_canvas({action:"fit"})` to frame the result; `panel_save_workflow` to persist.
 
 ## The layout algorithm (dependency-layered, overlap-free)
@@ -69,6 +72,16 @@ above) → then pin the rails to the node band:
 Keep rails at the same Y as the first row. Read current rail positions from
 `panel_get_graph` (`rails`) before deciding. `panel_exit_subgraph` when done.
 
+**Wiring interior nodes to the boundary (don't connect to a guessed rail id).** To expose
+an interior node's output/input on the boundary so the PARENT graph can wire it, do NOT
+`panel_connect` to a rail node id you guessed — use `panel_expose_subgraph_output(from_node_id,
+from_output)` (interior output → output rail) and `panel_expose_subgraph_input(to_node_id,
+to_input)` (interior input → input rail), both while inside the subgraph. `panel_get_graph`'s
+`rails` shows which boundary slots already exist and which still need exposing. To expand/
+dissolve a subgraph back into the parent (inline its inner nodes + rewire external links,
+removing the wrapper — the inverse of `panel_create_subgraph`), use
+`panel_unpack_subgraph(node_id)`. All undoable with Ctrl+Z.
+
 ## Groups vs subgraphs — choose deliberately
 
 - **Group** (colored box): lightweight visual band; nodes stay in place and editable. Reach

package/scripts/panel-load-workflow-smoke.mjs

@@ -3,7 +3,7 @@
 // Proves two PART-A/PART-B behaviours on the Codex backend (the one that
 // silently spent credits before):
 //   A) "set up a krea2 workflow on my canvas" → the agent calls
-//      panel_load_workflow({pack:"krea2-txt2img"}), which fires `graph_load` on
+//      panel_load_workflow({pack:"krea2-txt2img-manual"}), which fires `graph_load` on
 //      the (mock) panel with the pack's real UI graph (node_count>0) — i.e. a
 //      one-shot load, NOT a node-by-node rebuild.
 //   B) a prompt that implies API nodes → the agent ASKS the user about cost