Update Oz custom node: multi-frame ShotAnalyzer, LoRACharacterPicker, ApplyCharacterLoRA, StitchReel, StringAtIndex, character_picker_sync.js, save_with_metadata OUTPUT_NODE fix

ComfyUI_Oz/js/character_picker_sync.js

@@ -0,0 +1,245 @@
+// ==========================================================================
+// Oz LoRA Character Picker -> RealityPromptGenerator sync
+// ==========================================================================
+// Two mechanisms:
+//   1) api.fetchApi hijack: when JS calls /oz/generate_creative_prompts,
+//      we replace `character_description` (the field Grok sees) with the
+//      picker's computed grok_instruction. This is the SOURCE OF TRUTH.
+//   2) Live sync of picker widget changes -> RPG.properties.character_text_input
+//      (UI feedback only — Grok uses path 1 even if the textarea is stale).
+//
+// Activates ONLY if at least one ozW_LoRACharacterPicker is present in the
+// graph. Falls back to existing behavior otherwise.
+// ==========================================================================
+
+import { app } from "../../scripts/app.js";
+import { api } from "../../scripts/api.js";
+
+const PICKER_TYPE = "ozW_LoRACharacterPicker";
+const RPG_TYPE = "ozW_RealityPromptGenerator";
+const SYNC_WIDGETS = new Set(["lora_name", "trigger_override", "character_description"]);
+const TARGET_ENDPOINT = "/oz/generate_creative_prompts";
+const LOG_PREFIX = "[ozw.picker_sync]";
+
+// ---------- Helpers ----------
+function getNodes() {
+    return app.graph?.nodes ?? app.graph?._nodes ?? [];
+}
+
+function findPickers() {
+    return getNodes().filter(
+        (n) => n && (n.type === PICKER_TYPE || n.comfyClass === PICKER_TYPE)
+    );
+}
+
+function findRPGs() {
+    return getNodes().filter(
+        (n) => n && (n.type === RPG_TYPE || n.comfyClass === RPG_TYPE)
+    );
+}
+
+function readWidget(node, name) {
+    return node?.widgets?.find((w) => w.name === name)?.value ?? "";
+}
+
+function escapeRegex(s) {
+    return String(s).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function stripTriggerPrefix(description, trigger) {
+    // Start-anchored, case-insensitive. Only strips when trigger is a whole
+    // token at the start (followed by end-of-string or a separator). Matches
+    // the Python `_build_grok_instruction` dedup exactly.
+    const re = new RegExp(
+        `^${escapeRegex(trigger)}(?=$|(?:\\s|[,;:\\-–—]))(?:\\s*[,;:\\-–—]\\s*|\\s+)*`,
+        "i"
+    );
+    return description.replace(re, "").trim();
+}
+
+function buildGrokInstruction(picker) {
+    if (!picker) return "";
+    const overrideRaw = readWidget(picker, "trigger_override");
+    const loraName = readWidget(picker, "lora_name") || "";
+    let description = (readWidget(picker, "character_description") || "")
+        .toString()
+        .trim();
+
+    let trigger = (overrideRaw || "").toString().trim();
+    if (!trigger) {
+        if (loraName && loraName !== "none") {
+            const base = String(loraName).split("/").pop() || "";
+            trigger = base.replace(/\.[^.]+$/, "");
+        }
+    }
+    if (!trigger) return "";
+
+    if (description) {
+        description = stripTriggerPrefix(description, trigger);
+    }
+
+    if (description) {
+        return `always start each prompt exactly with "${trigger}, ${description}"`;
+    }
+    return `always start each prompt exactly with "${trigger},"`;
+}
+
+// Pick the picker that should drive a given Grok call. Strategy:
+// 1) If a picker has any output link to an RPG, use it.
+// 2) Else, if there's exactly one picker in the graph, use it.
+// 3) Else, return null (no override).
+function selectPickerForCall() {
+    const pickers = findPickers();
+    if (pickers.length === 0) return null;
+
+    const rpgIds = new Set(findRPGs().map((n) => n.id));
+
+    // Prefer a picker that has a link reaching any RPG node
+    for (const p of pickers) {
+        for (const out of p.outputs ?? []) {
+            const links = out.links;
+            if (!links) continue;
+            for (const lid of links) {
+                const link = p.graph?.links?.[lid] ?? app.graph?.links?.[lid];
+                if (!link) continue;
+                if (rpgIds.has(link.target_id)) {
+                    return p;
+                }
+            }
+        }
+    }
+
+    // Fallback: single picker in graph
+    if (pickers.length === 1) return pickers[0];
+
+    return null;
+}
+
+// ---------- Push sync (UI feedback) ----------
+function syncPickerToAllRPGs(picker) {
+    if (!picker) return;
+    const text = buildGrokInstruction(picker);
+    // Mirror to picker.properties for inspection
+    picker.properties = picker.properties || {};
+    picker.properties.grok_instruction = text;
+
+    const rpgs = findRPGs();
+    for (const rpg of rpgs) {
+        rpg.properties = rpg.properties || {};
+        rpg.properties.character_text_input = text;
+        // If a real ComfyUI widget exists with that name, mirror to it
+        const w = rpg.widgets?.find((x) => x.name === "character_text_input");
+        if (w) {
+            w.value = text;
+        }
+        rpg.setDirtyCanvas?.(true, true);
+    }
+}
+
+// ---------- Hook picker widget callbacks ----------
+function attachWidgetHooks(picker) {
+    if (!picker || picker._ozPickerHooked) return;
+    picker._ozPickerHooked = true;
+    for (const w of picker.widgets ?? []) {
+        if (!SYNC_WIDGETS.has(w.name)) continue;
+        const original = w.callback;
+        w.callback = function (...args) {
+            const result = original?.apply(this, args);
+            try {
+                syncPickerToAllRPGs(picker);
+            } catch (e) {
+                console.warn(LOG_PREFIX, "sync error:", e);
+            }
+            return result;
+        };
+    }
+}
+
+// ---------- api.fetchApi hijack ----------
+const _originalFetchApi = api.fetchApi.bind(api);
+api.fetchApi = async function (path, options = {}) {
+    try {
+        const isTarget =
+            typeof path === "string" &&
+            path.endsWith(TARGET_ENDPOINT) &&
+            options &&
+            (options.method === "POST" || options.method === "post") &&
+            options.body;
+
+        if (isTarget) {
+            const picker = selectPickerForCall();
+            if (picker) {
+                const instruction = buildGrokInstruction(picker);
+                if (instruction) {
+                    let body;
+                    try {
+                        body =
+                            typeof options.body === "string"
+                                ? JSON.parse(options.body)
+                                : options.body;
+                    } catch (e) {
+                        body = null;
+                    }
+                    if (body && typeof body === "object") {
+                        // Override every character-description-ish field the
+                        // backend might consume.
+                        body.character_description = instruction;
+                        body.character_reference = instruction;
+                        body.character_text = instruction;
+                        // Force server to rebuild system_prompt with our value.
+                        // The server's build_system_prompt() will re-inject this
+                        // into the CHARACTER CONSISTENCY section automatically.
+                        if ("system_prompt" in body) {
+                            // Replace any pre-built system_prompt; server rebuilds
+                            // it from character_description anyway.
+                            body.system_prompt = "";
+                        }
+                        options = { ...options, body: JSON.stringify(body) };
+                        console.log(
+                            LOG_PREFIX,
+                            "Overrode character_description for Grok:",
+                            instruction.slice(0, 120) + (instruction.length > 120 ? "..." : "")
+                        );
+                    }
+                }
+            }
+        }
+    } catch (e) {
+        console.warn(LOG_PREFIX, "hijack failed:", e);
+    }
+    return _originalFetchApi(path, options);
+};
+
+// ---------- Extension registration ----------
+app.registerExtension({
+    name: "ozw.character_picker_sync",
+
+    async nodeCreated(node) {
+        if (!node) return;
+        if (node.comfyClass === PICKER_TYPE || node.type === PICKER_TYPE) {
+            // Defer: widgets may not be ready immediately
+            setTimeout(() => {
+                attachWidgetHooks(node);
+                try {
+                    syncPickerToAllRPGs(node);
+                } catch (e) {
+                    /* noop */
+                }
+            }, 100);
+        }
+    },
+
+    async afterConfigureGraph() {
+        // Workflow loaded from JSON: hook all pickers and run initial sync
+        try {
+            for (const p of findPickers()) {
+                attachWidgetHooks(p);
+                syncPickerToAllRPGs(p);
+            }
+        } catch (e) {
+            console.warn(LOG_PREFIX, "afterConfigureGraph failed:", e);
+        }
+    },
+});
+
+console.log(LOG_PREFIX, "loaded — character picker sync active");

ComfyUI_Oz/nodes/input_nodes/reality_prompt_generator.py

@@ -82,6 +82,18 @@ class Oz_RealityPromptGenerator:
                         "tooltip": "Aspect ratio label (e.g., '16:9'). Connect from Oz Aspect Ratio Selector.",
                     },
                 ),
+                "prompt_prefix": (
+                    "STRING",
+                    {
+                        "default": "",
+                        "multiline": False,
+                        "tooltip": (
+                            "Optional prefix prepended to every positive prompt before output.\n"
+                            "Useful for LoRA trigger words (e.g., 'su4ka').\n"
+                            "Trailing commas/spaces are normalized."
+                        ),
+                    },
+                ),
             },
             "hidden": {
                 "node_id": "UNIQUE_ID",
@@ -134,6 +146,7 @@ class Oz_RealityPromptGenerator:
         images4=None,
         character_image=None,
         aspect_label="1:1",
+        prompt_prefix="",
         node_id=None,
         prompt_batch_data="[]",
         resolved_mode="txt2img",
@@ -157,6 +170,11 @@ class Oz_RealityPromptGenerator:
             print(f"[RPG] Error parsing prompt_batch_data: {e}")
             prompt_batch = []
 
+        # 1b) Normalize optional prompt prefix (e.g., LoRA trigger word)
+        prefix = (prompt_prefix or "").strip(" ,")
+        if prefix:
+            print(f"[RPG] Applying prompt prefix: '{prefix}'")
+
         # 2) Get image count from actual connected images
         image_count = 0
         if images is not None:
@@ -183,6 +201,10 @@ class Oz_RealityPromptGenerator:
                 # Normal mode - use positive_prompt field
                 pos = positive_prompt.strip()
 
+            # Apply prefix to positive prompt only (LoRA triggers, style hints, etc.)
+            if prefix:
+                pos = f"{prefix}, {pos}" if pos else prefix
+
             neg = (entry.get("negative_prompt") or "").strip()
             rc = max(1, int(entry.get("repeat_count", 1)))
 
@@ -229,12 +251,14 @@ class Oz_RealityPromptGenerator:
         prompt_batch_data = kwargs.get("prompt_batch_data", "[]")
         global_negative = kwargs.get("global_negative", "")
         expected_image_count = kwargs.get("expected_image_count", -1)
+        prompt_prefix = (kwargs.get("prompt_prefix", "") or "").strip(" ,")
 
         # Create a hash of all inputs that affect output
         hasher = hashlib.sha256()
         hasher.update(prompt_batch_data.encode("utf-8"))
         hasher.update(global_negative.encode("utf-8"))
         hasher.update(str(expected_image_count).encode("utf-8"))
+        hasher.update(prompt_prefix.encode("utf-8"))
 
         return hasher.hexdigest()
 

ComfyUI_Oz/nodes/output_nodes/save_with_metadata.py

@@ -18,7 +18,7 @@ def is_tool(name):
 EXIFTOOL_AVAILABLE = is_tool("exiftool") or is_tool("exiftool.exe")
 
 class Oz_SaveWithAuthenticMetadata:
-    OUTPUT_NODE = False 
+    OUTPUT_NODE = True 
     CATEGORY = "Oz/Authenticity"
     FUNCTION = "save_image"
 

ComfyUI_Oz/nodes/utility_nodes/__init__.py

@@ -105,6 +105,22 @@ from .load_image_from_path import NODE_CLASS_MAPPINGS as LOADER_MAPPINGS, NODE_D
 from .line_splitter import Oz_LineSplitter
 from .image_prompt_iterator import Oz_ImagePromptIterator
 from .debug_prompt_overlay import Oz_DebugPromptOverlay
+from .oz_string_at_index import (
+    NODE_CLASS_MAPPINGS as STRING_AT_INDEX_MAPPINGS,
+    NODE_DISPLAY_NAME_MAPPINGS as STRING_AT_INDEX_DISPLAY_MAPPINGS,
+)
+from .oz_stitch_reel import (
+    NODE_CLASS_MAPPINGS as STITCH_REEL_MAPPINGS,
+    NODE_DISPLAY_NAME_MAPPINGS as STITCH_REEL_DISPLAY_MAPPINGS,
+)
+from .oz_shot_analyzer import (
+    NODE_CLASS_MAPPINGS as SHOT_ANALYZER_MAPPINGS,
+    NODE_DISPLAY_NAME_MAPPINGS as SHOT_ANALYZER_DISPLAY_MAPPINGS,
+)
+from .lora_character_picker import (
+    NODE_CLASS_MAPPINGS as LORA_PICKER_MAPPINGS,
+    NODE_DISPLAY_NAME_MAPPINGS as LORA_PICKER_DISPLAY_MAPPINGS,
+)
 from .prompt_batch_preview import (
     NODE_CLASS_MAPPINGS as PREVIEW_MAPPINGS,
     NODE_DISPLAY_NAME_MAPPINGS as PREVIEW_DISPLAY_MAPPINGS,
@@ -163,6 +179,10 @@ NODE_CLASS_MAPPINGS = {
     "ozW_DebugPromptOverlay": Oz_DebugPromptOverlay,
     **PREVIEW_MAPPINGS,
     **MASK_TO_CROP_MAPPINGS,
+    **LORA_PICKER_MAPPINGS,
+    **SHOT_ANALYZER_MAPPINGS,
+    **STITCH_REEL_MAPPINGS,
+    **STRING_AT_INDEX_MAPPINGS,
 }
 
 NODE_DISPLAY_NAME_MAPPINGS = {
@@ -212,6 +232,10 @@ NODE_DISPLAY_NAME_MAPPINGS = {
     "ozW_DebugPromptOverlay": "🐛 Oz Debug Prompt Overlay",
     **PREVIEW_DISPLAY_MAPPINGS,
     **MASK_TO_CROP_DISPLAY_MAPPINGS,
+    **LORA_PICKER_DISPLAY_MAPPINGS,
+    **SHOT_ANALYZER_DISPLAY_MAPPINGS,
+    **STITCH_REEL_DISPLAY_MAPPINGS,
+    **STRING_AT_INDEX_DISPLAY_MAPPINGS,
 }
 
 __all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"]

ComfyUI_Oz/nodes/utility_nodes/lora_character_picker.py

@@ -0,0 +1,210 @@
+# ---
+# Filename: ../Oz/nodes/utility_nodes/lora_character_picker.py
+# Central character control for a workflow:
+#   1. Picks a LoRA from models/loras/ (auto-discovered).
+#   2. Outputs the trigger word (for RPG.prompt_prefix).
+#   3. Outputs a Grok instruction (for RPG.character_text_input).
+#   4. Outputs the lora_name STRING (for Oz_ApplyCharacterLoRA).
+#
+# Switch character in one click: change picker -> three downstream
+# nodes (RPG.prompt_prefix, RPG.character_text_input, ApplyCharacterLoRA)
+# automatically follow.
+# ---
+
+import os
+import re
+import folder_paths
+import comfy.sd
+import comfy.utils
+
+
+def _build_grok_instruction(trigger, description):
+    """
+    Build the Grok system prompt instruction that prepends the LoRA
+    trigger word to every generated prompt.
+
+    Dedup: strip the trigger from the start of the description if it
+    appears as a complete token (not inside another word). Avoids the
+    `papa`/`papaya` false positive.
+
+    Returns empty string when there's nothing to inject.
+    """
+    trigger = (trigger or "").strip()
+    description = (description or "").strip()
+    if not trigger:
+        return ""
+
+    if description:
+        # Start-anchored, case-insensitive, with lookahead for end-of-string
+        # or separator. Only fires when the trigger is a whole token.
+        pattern = re.compile(
+            rf"^{re.escape(trigger)}(?=$|(?:\s|[,;:\-–—]))(?:\s*[,;:\-–—]\s*|\s+)*",
+            re.IGNORECASE,
+        )
+        description = pattern.sub("", description, count=1).strip()
+
+    if description:
+        return f'always start each prompt exactly with "{trigger}, {description}"'
+    return f'always start each prompt exactly with "{trigger},"'
+
+
+class Oz_LoRACharacterPicker:
+    """
+    Picks a character LoRA and exposes everything a downstream prompt
+    generator needs in one place.
+
+    Wire outputs:
+      trigger_word     -> RealityPromptGenerator.prompt_prefix
+      grok_instruction -> RealityPromptGenerator.character_text_input
+      lora_name        -> Oz_ApplyCharacterLoRA.lora_name
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        try:
+            loras = folder_paths.get_filename_list("loras")
+        except Exception:
+            loras = []
+        choices = ["none"] + sorted(loras)
+        return {
+            "required": {
+                "lora_name": (choices, {"default": "none"}),
+            },
+            "optional": {
+                "trigger_override": (
+                    "STRING",
+                    {
+                        "default": "",
+                        "multiline": False,
+                        "tooltip": (
+                            "Optional override. If non-empty, used INSTEAD of the LoRA filename stem.\n"
+                            "Useful when the LoRA's trigger word differs from its filename."
+                        ),
+                    },
+                ),
+                "character_description": (
+                    "STRING",
+                    {
+                        "default": "",
+                        "multiline": True,
+                        "tooltip": (
+                            "Free-form character description appended after the trigger in the\n"
+                            "Grok instruction. Example: 'woman with long black hair and ice blue eyes'.\n"
+                            "Leave empty to only force the trigger prefix."
+                        ),
+                    },
+                ),
+            },
+        }
+
+    # NOTE: slot 0 (trigger_word) and slot 1 (lora_name) are unchanged for
+    # backward compatibility. Slot 2 (grok_instruction) is added at the end.
+    RETURN_TYPES = ("STRING", "STRING", "STRING")
+    RETURN_NAMES = ("trigger_word", "lora_name", "grok_instruction")
+    FUNCTION = "pick"
+    CATEGORY = "Oz/Prompts"
+
+    def pick(self, lora_name, trigger_override="", character_description=""):
+        override = (trigger_override or "").strip()
+        if override:
+            trigger = override
+        elif not lora_name or lora_name == "none":
+            trigger = ""
+        else:
+            base = os.path.basename(lora_name)
+            trigger = os.path.splitext(base)[0]
+
+        out_lora = lora_name if lora_name else "none"
+        instruction = _build_grok_instruction(trigger, character_description)
+        return (trigger, out_lora, instruction)
+
+
+class Oz_ApplyCharacterLoRA:
+    """
+    Loads a LoRA from a STRING input (driven by Oz_LoRACharacterPicker)
+    and applies it to a MODEL/CLIP pair.
+
+    Standard LoraLoader pattern (see ComfyUI nodes.py LoraLoader) but with
+    `lora_name` as a wireable STRING input instead of a widget dropdown.
+
+    Pass-through behavior:
+      - lora_name "" or "none"               -> returns model, clip unchanged
+      - strength_model == 0 and strength_clip == 0 -> returns unchanged
+      - clip not connected                   -> applies model-only
+    """
+
+    def __init__(self):
+        self.loaded_lora = None  # (path, lora_state_dict)
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "model": ("MODEL",),
+                "lora_name": (
+                    "STRING",
+                    {
+                        "default": "",
+                        "multiline": False,
+                        "forceInput": True,
+                        "tooltip": "LoRA filename. Wire from Oz_LoRACharacterPicker.lora_name.",
+                    },
+                ),
+                "strength_model": (
+                    "FLOAT",
+                    {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01},
+                ),
+            },
+            "optional": {
+                "clip": ("CLIP",),
+                "strength_clip": (
+                    "FLOAT",
+                    {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01},
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("MODEL", "CLIP")
+    RETURN_NAMES = ("MODEL", "CLIP")
+    FUNCTION = "apply"
+    CATEGORY = "Oz/Prompts"
+
+    def apply(self, model, lora_name, strength_model, clip=None, strength_clip=1.0):
+        # Fast paths
+        name = (lora_name or "").strip()
+        if not name or name.lower() == "none":
+            return (model, clip)
+        if strength_model == 0 and strength_clip == 0:
+            return (model, clip)
+
+        try:
+            lora_path = folder_paths.get_full_path_or_raise("loras", name)
+        except Exception as e:
+            print(f"[Oz_ApplyCharacterLoRA] LoRA not found: {name} ({e}) — passthrough")
+            return (model, clip)
+
+        # Cached load
+        lora = None
+        if self.loaded_lora is not None and self.loaded_lora[0] == lora_path:
+            lora = self.loaded_lora[1]
+        else:
+            self.loaded_lora = None
+            lora = comfy.utils.load_torch_file(lora_path, safe_load=True)
+            self.loaded_lora = (lora_path, lora)
+
+        # comfy.sd.load_lora_for_models supports clip=None for model-only
+        model_lora, clip_lora = comfy.sd.load_lora_for_models(
+            model, clip, lora, strength_model, strength_clip
+        )
+        return (model_lora, clip_lora)
+
+
+NODE_CLASS_MAPPINGS = {
+    "ozW_LoRACharacterPicker": Oz_LoRACharacterPicker,
+    "ozW_ApplyCharacterLoRA": Oz_ApplyCharacterLoRA,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ozW_LoRACharacterPicker": "🎭 Oz LoRA Character Picker",
+    "ozW_ApplyCharacterLoRA": "🎬 Oz Apply Character LoRA",
+}

ComfyUI_Oz/nodes/utility_nodes/oz_shot_analyzer.py

@@ -0,0 +1,608 @@
+# ---
+# Filename: ../Oz/nodes/utility_nodes/oz_shot_analyzer.py
+# Automatic per-shot Grok analysis — multi-frame mode (reads clip_paths from
+# ShotSplitter's manifest_json, samples N frames per clip, single Grok call
+# per shot) with optional glamour-style bias and safety fallback.
+# ---
+
+import asyncio
+import base64
+import io
+import hashlib
+import json
+import random
+import re
+import traceback
+
+import cv2
+import torch
+import numpy as np
+from PIL import Image
+
+# Reuse existing Grok plumbing
+from ..api_nodes.creative_api import (
+    generate_with_grok,
+)
+
+
+DEFAULT_NEGATIVE = (
+    "unrealistic, illustration, painting, drawing, art, artistic, low quality, "
+    "deformed, bad anatomy, blurry, amateur, watermark, text, cartoon, 3d render, "
+    "flat chest, covered up, baggy, plain figure, frumpy"
+)
+
+
+# ==========================================================================
+# System prompt builder (custom — does NOT use creative_api.build_system_prompt
+# because we need precise control over multi-frame + glamour bias blocks)
+# ==========================================================================
+def _build_system_prompt(
+    character_instruction: str,
+    multi_frame: bool,
+    glamour_bias: bool,
+) -> str:
+    parts = [
+        "You are an expert AI prompt engineer specializing in creating "
+        "high-quality, detailed prompts for REALISTIC photographic image "
+        "generation models.",
+        "",
+        "IMPORTANT: All outputs are REALISTIC photography. Do not include "
+        "illustration, painting, drawing, or non-photographic elements.",
+    ]
+
+    if character_instruction.strip():
+        parts.append("")
+        parts.append("CHARACTER CONSISTENCY:")
+        parts.append(character_instruction.strip())
+
+    parts.append("")
+    parts.append("MODE: Image-to-Image Generation")
+    parts.append(
+        "Describe the input as it appears: preserve the environment, setting, "
+        "lighting, props, outfit type/color/material, and subject's action. Do "
+        "not invent elements that are not visible in the source."
+    )
+
+    if multi_frame:
+        parts.append("")
+        parts.append("MULTI-FRAME INPUT:")
+        parts.append(
+            "You will receive 3–5 frames sampled evenly from a single video shot "
+            "(frame 1 = start, last frame = end). Treat them as ONE continuous "
+            "moment. Identify the dominant pose, the most revealing body angle "
+            "visible, and any outfit details visible across frames. Output a "
+            "SINGLE unified positive prompt describing the best representative "
+            "still from this shot — do NOT list frames separately."
+        )
+
+    if glamour_bias:
+        parts.append("")
+        parts.append("PRESENTATION STYLE:")
+        parts.append(
+            "Output prompts must render the character in an OnlyFans-style "
+            "glamour photography aesthetic. Even when the source shows modest "
+            "or loose clothing, always describe the figure as visibly "
+            "curvaceous — full, rounded breasts visible through the fabric, "
+            "hourglass silhouette prominent, seductive body language. Use "
+            "clinical photography/fashion language (not erotica). Never "
+            "describe a flat or androgynous body."
+        )
+        parts.append("")
+        parts.append("OUTFIT FIDELITY:")
+        parts.append(
+            "Preserve garment type, color, material, and layering EXACTLY as "
+            "seen in the source. Adjust only how the garment fits — describe "
+            "it as form-fitting, body-hugging, or slightly form-revealing "
+            "rather than baggy or oversized, unless the source is heavy "
+            "outerwear (coat, parka). Same outfit, same scene, same props, "
+            "but the body underneath reads as curvaceous and feminine."
+        )
+
+    parts.append("")
+    parts.append(
+        "OUTPUT FORMAT: Return a single valid JSON object (NOT an array) "
+        "with these keys:"
+    )
+    parts.append('- "positive": a detailed positive prompt (string)')
+    parts.append('- "negative": a negative prompt (string, can be empty)')
+    parts.append('- "tags": array of short tag strings')
+    parts.append("")
+    parts.append("Example:")
+    parts.append('{"positive": "woman in a black mini dress, neon lights behind, '
+                 '85mm f/1.8, shallow depth of field", "negative": "", "tags": '
+                 '["portrait", "night", "neon"]}')
+
+    return "\n".join(parts)
+
+
+def _build_user_prompt(multi_frame: bool, n_frames: int) -> str:
+    if multi_frame:
+        return (
+            f"Analyze the {n_frames} frames from this video shot and generate "
+            "ONE unified positive prompt that best describes the dominant "
+            "moment. Follow the system instructions strictly. Return JSON only."
+        )
+    return (
+        "Analyze this image and generate ONE detailed positive prompt. "
+        "Follow the system instructions strictly. Return JSON only."
+    )
+
+
+# ==========================================================================
+# Frame helpers
+# ==========================================================================
+def _load_clip_frames(clip_path: str, max_resolution: int = 768):
+    """
+    Load all frames of a video clip via OpenCV. Returns a list of
+    (H, W, 3) uint8 numpy arrays in RGB. Frames are resized so the longest
+    side does not exceed `max_resolution` (to cap base64 payload size).
+    """
+    cap = cv2.VideoCapture(clip_path)
+    if not cap.isOpened():
+        print(f"[Oz_ShotAnalyzer] cv2 cannot open: {clip_path}")
+        return []
+
+    frames = []
+    while True:
+        ok, frame_bgr = cap.read()
+        if not ok:
+            break
+        frame = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
+        h, w = frame.shape[:2]
+        if max(h, w) > max_resolution:
+            scale = max_resolution / max(h, w)
+            new_w = int(round(w * scale))
+            new_h = int(round(h * scale))
+            frame = cv2.resize(frame, (new_w, new_h), interpolation=cv2.INTER_AREA)
+        frames.append(frame)
+    cap.release()
+    return frames
+
+
+def _sample_evenly(frames, n: int):
+    """Sample n evenly spaced frames from a list."""
+    total = len(frames)
+    if total == 0:
+        return []
+    if total <= n:
+        return list(frames)
+    indices = [round(i * (total - 1) / (n - 1)) for i in range(n)]
+    return [frames[i] for i in indices]
+
+
+def _numpy_to_base64_png(arr: "np.ndarray") -> str:
+    pil = Image.fromarray(arr.astype(np.uint8), "RGB")
+    buf = io.BytesIO()
+    pil.save(buf, format="PNG", optimize=False)
+    return base64.b64encode(buf.getvalue()).decode("ascii")
+
+
+def _tensor_to_base64_png(img_tensor: torch.Tensor, max_resolution: int = 768) -> str:
+    if img_tensor.dim() == 4:
+        img_tensor = img_tensor[0]
+    arr = img_tensor.detach().cpu().numpy()
+    arr = np.clip(arr, 0.0, 1.0)
+    arr = (arr * 255.0).astype(np.uint8)
+    h, w = arr.shape[:2]
+    if max(h, w) > max_resolution:
+        scale = max_resolution / max(h, w)
+        new_w = int(round(w * scale))
+        new_h = int(round(h * scale))
+        arr = cv2.resize(arr, (new_w, new_h), interpolation=cv2.INTER_AREA)
+    return _numpy_to_base64_png(arr)
+
+
+# ==========================================================================
+# Grok call helpers (async)
+# ==========================================================================
+async def _grok_call(
+    system_prompt: str,
+    user_prompt: str,
+    frames_b64: list,
+    api_key: str,
+    model: str,
+    temperature: float,
+    top_p: float,
+):
+    """
+    Single Grok call with 1 or more images. Returns the parsed dict
+    {positive, negative, tags} or an empty dict on failure.
+    """
+    try:
+        prompts = await generate_with_grok(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            model=model,
+            api_key=api_key,
+            temperature=temperature,
+            top_p=top_p,
+            images=frames_b64,
+        )
+    except Exception as e:
+        print(f"[Oz_ShotAnalyzer] Grok call failed: {e}")
+        return {}
+    if not prompts:
+        return {}
+    return prompts[0] if isinstance(prompts, list) else prompts
+
+
+def _run_async(coro):
+    try:
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            import concurrent.futures
+            with concurrent.futures.ThreadPoolExecutor() as ex:
+                return ex.submit(lambda: asyncio.run(coro)).result()
+    except RuntimeError:
+        pass
+    return asyncio.run(coro)
+
+
+# ==========================================================================
+# Extract trigger word from character_instruction for fallback injection
+# ==========================================================================
+def _extract_trigger(char_instr: str) -> str:
+    """
+    Pull the trigger word out of an instruction like:
+        'always start each prompt exactly with "papeech, woman with..."'
+    Returns empty string on failure.
+    """
+    if not char_instr:
+        return ""
+    m = re.search(r'"([^",]+)', char_instr)
+    if m:
+        return m.group(1).strip()
+    return ""
+
+
+def _force_trigger_prefix(prompt: str, trigger: str) -> str:
+    """Add trigger to start of prompt if not already there (word-boundary check)."""
+    if not trigger or not prompt:
+        return prompt
+    has_trigger = re.match(
+        rf"^{re.escape(trigger)}(?=$|(?:\s|[,;:\-–—]))",
+        prompt,
+        re.IGNORECASE,
+    )
+    if has_trigger:
+        return prompt
+    return f"{trigger}, {prompt}"
+
+
+# ==========================================================================
+# Main node
+# ==========================================================================
+class Oz_ShotAnalyzer:
+    """
+    Per-shot Grok analysis for a video split by Oz_ShotSplitter.
+
+    Two modes:
+      1) Multi-frame (preferred): wire `manifest_json` from ShotSplitter.
+         For each shot in the manifest, this loads the clip file, samples
+         N evenly-spaced frames, encodes them all, and sends ONE Grok
+         request per shot with multiple images for synthesis.
+
+      2) Single-frame (fallback): uses the `images` IMAGE batch
+         (typically first_frames from ShotSplitter) and sends one frame
+         per Grok call.
+
+    Optional `glamour_bias` injects PRESENTATION STYLE + OUTFIT FIDELITY
+    blocks into the system prompt. If Grok returns empty on a bias-on
+    call, the analyzer retries that shot with bias OFF as a safety
+    fallback.
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "images": ("IMAGE",),
+                "character_instruction": (
+                    "STRING",
+                    {
+                        "default": "",
+                        "multiline": True,
+                        "forceInput": True,
+                        "tooltip": (
+                            "Character instruction from LoRA Character Picker.\n"
+                            "Wire from picker.grok_instruction."
+                        ),
+                    },
+                ),
+                "xai_api_key": (
+                    "STRING",
+                    {"default": "", "multiline": False},
+                ),
+            },
+            "optional": {
+                "manifest_json": (
+                    "STRING",
+                    {
+                        "default": "",
+                        "multiline": False,
+                        "forceInput": True,
+                        "tooltip": (
+                            "Wire from Oz_ShotSplitter.manifest_json for multi-frame "
+                            "mode. If empty, falls back to single-frame on `images`."
+                        ),
+                    },
+                ),
+                "frames_per_shot": (
+                    "INT",
+                    {"default": 3, "min": 1, "max": 10},
+                ),
+                "glamour_bias": ("BOOLEAN", {"default": True}),
+                "model": (
+                    "STRING",
+                    {
+                        "default": "grok-4.20-beta-0309-reasoning",
+                        "multiline": False,
+                    },
+                ),
+                "temperature": (
+                    "FLOAT",
+                    {"default": 0.9, "min": 0.0, "max": 2.0, "step": 0.05},
+                ),
+                "top_p": (
+                    "FLOAT",
+                    {"default": 0.9, "min": 0.0, "max": 1.0, "step": 0.05},
+                ),
+                "max_resolution": (
+                    "INT",
+                    {"default": 768, "min": 256, "max": 2048},
+                ),
+                "negative_prompt": (
+                    "STRING",
+                    {"default": DEFAULT_NEGATIVE, "multiline": True},
+                ),
+                "seed_base": (
+                    "INT",
+                    {
+                        "default": 1111111,
+                        "min": 0,
+                        "max": 0xFFFFFFFFFFFFFFFF,
+                    },
+                ),
+                "max_shots": (
+                    "INT",
+                    {
+                        "default": 50,
+                        "min": 1,
+                        "max": 500,
+                        "tooltip": "Hard cap to prevent runaway Grok costs.",
+                    },
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("STRING", "STRING", "INT", "INT")
+    RETURN_NAMES = (
+        "prompt_list_positive",
+        "prompt_list_negative",
+        "seed_list",
+        "generation_count",
+    )
+
+    INPUT_IS_LIST = False
+    OUTPUT_IS_LIST = (True, True, True, False)
+
+    FUNCTION = "analyze"
+    CATEGORY = "Oz/Prompts"
+
+    @classmethod
+    def IS_CHANGED(cls, **kwargs):
+        h = hashlib.sha256()
+        for key in (
+            "character_instruction",
+            "xai_api_key",
+            "manifest_json",
+            "frames_per_shot",
+            "glamour_bias",
+            "model",
+            "temperature",
+            "top_p",
+            "max_resolution",
+            "negative_prompt",
+            "seed_base",
+            "max_shots",
+        ):
+            h.update(repr(kwargs.get(key, "")).encode("utf-8"))
+        imgs = kwargs.get("images")
+        if isinstance(imgs, torch.Tensor):
+            h.update(str(imgs.shape).encode("utf-8"))
+            try:
+                h.update(str(imgs.sum().item()).encode("utf-8"))
+            except Exception:
+                pass
+        return h.hexdigest()
+
+    # ----- analysis paths -----
+    def _run_one_shot(
+        self,
+        frames_b64: list,
+        char_instr: str,
+        api_key: str,
+        model: str,
+        temperature: float,
+        top_p: float,
+        multi_frame: bool,
+        glamour_bias: bool,
+        trigger: str,
+        negative_default: str,
+    ) -> dict:
+        """
+        One Grok call with optional safety fallback: if bias-on returns empty,
+        retry with bias off. Returns {positive, negative}.
+        """
+        def _call(bias):
+            system_prompt = _build_system_prompt(
+                char_instr, multi_frame=multi_frame, glamour_bias=bias
+            )
+            user_prompt = _build_user_prompt(multi_frame, len(frames_b64))
+            return _run_async(
+                _grok_call(
+                    system_prompt=system_prompt,
+                    user_prompt=user_prompt,
+                    frames_b64=frames_b64,
+                    api_key=api_key,
+                    model=model,
+                    temperature=temperature,
+                    top_p=top_p,
+                )
+            )
+
+        result = _call(glamour_bias)
+        pos = (result.get("positive") or "").strip()
+        if glamour_bias and not pos:
+            print("[Oz_ShotAnalyzer] Empty response with bias ON — retrying bias OFF")
+            result = _call(False)
+            pos = (result.get("positive") or "").strip()
+
+        neg = (result.get("negative") or "").strip() or negative_default
+        pos = _force_trigger_prefix(pos, trigger)
+        return {"positive": pos, "negative": neg}
+
+    def analyze(
+        self,
+        images,
+        character_instruction,
+        xai_api_key,
+        manifest_json="",
+        frames_per_shot=3,
+        glamour_bias=True,
+        model="grok-4.20-beta-0309-reasoning",
+        temperature=0.9,
+        top_p=0.9,
+        max_resolution=768,
+        negative_prompt=DEFAULT_NEGATIVE,
+        seed_base=1111111,
+        max_shots=50,
+    ):
+        char_instr = (character_instruction or "").strip()
+        api_key = (xai_api_key or "").strip()
+        manifest = (manifest_json or "").strip()
+        trigger = _extract_trigger(char_instr)
+
+        # ----- Multi-frame mode via manifest_json -----
+        shots = []
+        if manifest:
+            try:
+                parsed = json.loads(manifest)
+                if isinstance(parsed, list):
+                    shots = parsed
+            except Exception as e:
+                print(f"[Oz_ShotAnalyzer] manifest_json parse failed: {e}")
+                shots = []
+
+        if shots:
+            shots = shots[:max_shots]
+            print(
+                f"[Oz_ShotAnalyzer] MULTI-FRAME mode: {len(shots)} shots, "
+                f"{frames_per_shot} frames/shot, bias={glamour_bias}"
+            )
+            positives, negatives, seeds = [], [], []
+            for i, shot in enumerate(shots):
+                path = shot.get("path", "")
+                if not path:
+                    print(f"[Oz_ShotAnalyzer] shot {i + 1} has no path, skipping")
+                    positives.append("")
+                    negatives.append(negative_prompt)
+                    seeds.append(seed_base + i)
+                    continue
+                try:
+                    raw_frames = _load_clip_frames(path, max_resolution=max_resolution)
+                    if not raw_frames:
+                        print(f"[Oz_ShotAnalyzer] shot {i + 1}: no frames loaded")
+                        positives.append("")
+                        negatives.append(negative_prompt)
+                        seeds.append(seed_base + i)
+                        continue
+                    sampled = _sample_evenly(raw_frames, frames_per_shot)
+                    frames_b64 = [_numpy_to_base64_png(f) for f in sampled]
+                    print(
+                        f"[Oz_ShotAnalyzer] shot {i + 1}/{len(shots)}: "
+                        f"loaded={len(raw_frames)}, sent={len(frames_b64)}"
+                    )
+                    result = self._run_one_shot(
+                        frames_b64=frames_b64,
+                        char_instr=char_instr,
+                        api_key=api_key,
+                        model=model,
+                        temperature=temperature,
+                        top_p=top_p,
+                        multi_frame=True,
+                        glamour_bias=glamour_bias,
+                        trigger=trigger,
+                        negative_default=negative_prompt,
+                    )
+                    pos = result["positive"]
+                    neg = result["negative"]
+                    print(f"[Oz_ShotAnalyzer] shot {i + 1}: {pos[:100]}{'...' if len(pos) > 100 else ''}")
+                except Exception as e:
+                    print(f"[Oz_ShotAnalyzer] shot {i + 1} failed: {e}")
+                    traceback.print_exc()
+                    pos = ""
+                    neg = negative_prompt
+                positives.append(pos)
+                negatives.append(neg)
+                seeds.append(seed_base + i)
+            print(f"[Oz_ShotAnalyzer] Done. {len(shots)} shots processed.")
+            return (positives, negatives, seeds, len(shots))
+
+        # ----- Single-frame fallback mode -----
+        if not isinstance(images, torch.Tensor):
+            print("[Oz_ShotAnalyzer] ERROR: images is not a tensor and no manifest")
+            return ([""], [""], [0], 0)
+
+        if images.dim() == 3:
+            batch = images.unsqueeze(0)
+        else:
+            batch = images
+        count = batch.shape[0]
+        count = min(count, max_shots)
+        if count == 0:
+            print("[Oz_ShotAnalyzer] ERROR: empty batch")
+            return ([""], [""], [0], 0)
+
+        print(f"[Oz_ShotAnalyzer] SINGLE-FRAME mode: {count} images, bias={glamour_bias}")
+        positives, negatives, seeds = [], [], []
+        for i in range(count):
+            try:
+                frame_b64 = _tensor_to_base64_png(
+                    batch[i:i + 1], max_resolution=max_resolution
+                )
+                result = self._run_one_shot(
+                    frames_b64=[frame_b64],
+                    char_instr=char_instr,
+                    api_key=api_key,
+                    model=model,
+                    temperature=temperature,
+                    top_p=top_p,
+                    multi_frame=False,
+                    glamour_bias=glamour_bias,
+                    trigger=trigger,
+                    negative_default=negative_prompt,
+                )
+                pos = result["positive"]
+                neg = result["negative"]
+                print(f"[Oz_ShotAnalyzer] shot {i + 1}: {pos[:100]}{'...' if len(pos) > 100 else ''}")
+            except Exception as e:
+                print(f"[Oz_ShotAnalyzer] shot {i + 1} failed: {e}")
+                traceback.print_exc()
+                pos = ""
+                neg = negative_prompt
+            positives.append(pos)
+            negatives.append(neg)
+            seeds.append(seed_base + i)
+
+        print(f"[Oz_ShotAnalyzer] Done. {count} shots processed.")
+        return (positives, negatives, seeds, count)
+
+
+NODE_CLASS_MAPPINGS = {
+    "ozW_ShotAnalyzer": Oz_ShotAnalyzer,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ozW_ShotAnalyzer": "🎞️ Oz Shot Analyzer (Grok)",
+}

ComfyUI_Oz/nodes/utility_nodes/oz_stitch_reel.py

@@ -0,0 +1,404 @@
+# ---
+# Filename: ../Oz/nodes/utility_nodes/oz_stitch_reel.py
+# Auto-stitches the per-shot outputs from TSVideoCombine into a single
+# final reel using ffmpeg concat demuxer (-c copy, no re-encode, no A/V
+# desync). Designed to run ONCE per Queue Prompt via INPUT_IS_LIST=True.
+# ---
+
+import glob
+import os
+import re
+import shutil
+import subprocess
+import time
+import traceback
+
+import folder_paths
+
+
+def _ffprobe_duration(path: str) -> float:
+    """Return video duration in seconds, or 0 on failure."""
+    try:
+        r = subprocess.run(
+            [
+                "ffprobe", "-v", "error",
+                "-show_entries", "format=duration",
+                "-of", "default=noprint_wrappers=1:nokey=1",
+                path,
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        return float(r.stdout.strip()) if r.stdout.strip() else 0.0
+    except Exception:
+        return 0.0
+
+
+def _ffmpeg_available():
+    return shutil.which("ffmpeg") is not None
+
+
+class Oz_StitchReel:
+    """
+    Collects the N per-shot mp4 files emitted by TSVideoCombine during a
+    multi-shot Run and concatenates them into one reel using ffmpeg
+    concat demuxer with stream copy (no re-encode, no A/V desync).
+
+    Wire ANY list-producing output from the iterating pipeline (e.g. the
+    seed_list from Oz_ShotAnalyzer, or the IMAGE batch from VAEDecode) to
+    the `trigger` input. INPUT_IS_LIST=True guarantees this node runs
+    exactly once after all iterations have completed.
+
+    The node scans the ComfyUI output directory for files matching
+    `pattern` created in the last `window_seconds` seconds, sorts them
+    lexicographically (zero-padded counters), and concatenates with
+    `ffmpeg -f concat -safe 0 -i list.txt -c copy reel.mp4`.
+    """
+
+    INPUT_IS_LIST = True
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "trigger": (
+                    "IMAGE",
+                    {
+                        "tooltip": (
+                            "Wire from WanVideoDecode.images (or any IMAGE "
+                            "output AFTER the Wan pipeline). This ensures "
+                            "the stitcher waits until all per-shot iterations "
+                            "complete before scanning the output folder."
+                        ),
+                    },
+                ),
+                "pattern": (
+                    "STRING",
+                    {
+                        "default": "wan_shot_002_*.mp4",
+                        "multiline": False,
+                        "tooltip": (
+                            "Glob pattern (relative to ComfyUI output dir) "
+                            "to pick up per-shot .mp4 files."
+                        ),
+                    },
+                ),
+                "output_prefix": (
+                    "STRING",
+                    {"default": "reel", "multiline": False},
+                ),
+            },
+            "optional": {
+                "source_video_path": (
+                    "STRING",
+                    {
+                        "default": "",
+                        "multiline": False,
+                        "tooltip": (
+                            "Optional: full path to the original source video "
+                            "uploaded to ShotSplitter. When set, the stitcher "
+                            "pads each Wan shot with its frozen last frame to "
+                            "match the original source-shot duration, then "
+                            "overlays the source's full audio track on the "
+                            "stitched video. Leaves the result perfectly "
+                            "synced with the original audio."
+                        ),
+                    },
+                ),
+                "wait_seconds": (
+                    "FLOAT",
+                    {
+                        "default": 3.0,
+                        "min": 0.0,
+                        "max": 60.0,
+                        "step": 0.5,
+                        "tooltip": (
+                            "Delay before scanning, to ensure TSVideoCombine "
+                            "has flushed all files to disk."
+                        ),
+                    },
+                ),
+                "window_seconds": (
+                    "FLOAT",
+                    {
+                        "default": 600.0,
+                        "min": 10.0,
+                        "max": 36000.0,
+                        "step": 10.0,
+                        "tooltip": (
+                            "Only consider files modified within this many "
+                            "seconds. Avoids picking up stale files from "
+                            "previous runs."
+                        ),
+                    },
+                ),
+                "genpts": (
+                    "BOOLEAN",
+                    {
+                        "default": False,
+                        "tooltip": (
+                            "Add -fflags +genpts to regenerate timestamps. "
+                            "Enable only if you see A/V desync."
+                        ),
+                    },
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("reel_path",)
+    FUNCTION = "stitch"
+    CATEGORY = "Oz/Output"
+    OUTPUT_NODE = True
+
+    @classmethod
+    def IS_CHANGED(cls, **kwargs):
+        # Always re-run so each Queue Prompt produces a fresh reel.
+        return time.time()
+
+    def stitch(
+        self,
+        trigger,
+        pattern,
+        output_prefix,
+        source_video_path="",
+        wait_seconds=3.0,
+        window_seconds=600.0,
+        genpts=False,
+    ):
+        # With INPUT_IS_LIST=True every input arrives as a list even widgets
+        def _scalar(v, default=None):
+            if isinstance(v, list):
+                return v[0] if v else default
+            return v
+
+        pattern = _scalar(pattern, "wan_shot_002_*.mp4")
+        output_prefix = _scalar(output_prefix, "reel")
+        source_video_path = (_scalar(source_video_path, "") or "").strip()
+        wait_seconds = float(_scalar(wait_seconds, 3.0))
+        window_seconds = float(_scalar(window_seconds, 600.0))
+        genpts = bool(_scalar(genpts, False))
+
+        # trigger is also a list — its length tells us how many shots ran.
+        # With IMAGE trigger + INPUT_IS_LIST=True, each iteration contributes
+        # one IMAGE tensor to the list; len(trigger) == number of shots.
+        if isinstance(trigger, list):
+            expected_count = len(trigger)
+        else:
+            expected_count = 1
+
+        if not _ffmpeg_available():
+            msg = "ffmpeg not found on PATH"
+            print(f"[Oz_StitchReel] ERROR: {msg}")
+            return {"ui": {"text": [msg]}, "result": ("",)}
+
+        print(
+            f"[Oz_StitchReel] waiting {wait_seconds}s for TSVideoCombine "
+            f"to flush files (expected_count={expected_count})"
+        )
+        time.sleep(wait_seconds)
+
+        output_dir = folder_paths.get_output_directory()
+        search = os.path.join(output_dir, pattern)
+        now = time.time()
+
+        candidates = [
+            fp
+            for fp in glob.glob(search)
+            if os.path.isfile(fp)
+            and (now - os.path.getmtime(fp)) <= window_seconds
+        ]
+
+        if not candidates:
+            msg = f"No files matched {search} in the last {window_seconds}s"
+            print(f"[Oz_StitchReel] ERROR: {msg}")
+            return {"ui": {"text": [msg]}, "result": ("",)}
+
+        # Sort lexicographically (zero-padded counter keeps chronological order)
+        candidates.sort()
+
+        # If we know expected_count, take the most recent N by mtime then
+        # re-sort by name. This avoids catching stale files from a prior Run
+        # that happen to share the pattern.
+        if expected_count > 0 and len(candidates) > expected_count:
+            by_mtime = sorted(
+                candidates, key=lambda f: os.path.getmtime(f), reverse=True
+            )
+            candidates = sorted(by_mtime[:expected_count])
+
+        print(f"[Oz_StitchReel] {len(candidates)} clip(s) to stitch:")
+        for fp in candidates:
+            print(f"  - {os.path.basename(fp)}")
+
+        concat_dir = os.path.join(output_dir, "_concat")
+        os.makedirs(concat_dir, exist_ok=True)
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+
+        # ----- Option C branch: source_video_path given -----
+        # Pad each Wan shot with frozen last frame to match the corresponding
+        # source shot's duration, concat video-only, then mux the FULL source
+        # audio track on top. Result: perfect original audio timing.
+        if source_video_path and os.path.exists(source_video_path):
+            src_stem = os.path.splitext(os.path.basename(source_video_path))[0]
+            shots_dir = os.path.join(output_dir, "shots", src_stem)
+            source_shots = sorted(
+                glob.glob(os.path.join(shots_dir, "shot_*.mp4"))
+            ) if os.path.isdir(shots_dir) else []
+
+            source_durations = [_ffprobe_duration(p) for p in source_shots]
+            print(
+                f"[Oz_StitchReel] source_video={source_video_path}\n"
+                f"[Oz_StitchReel] {len(source_shots)} source shots in "
+                f"{shots_dir}, durations={source_durations}"
+            )
+
+            if len(source_shots) != len(candidates):
+                print(
+                    f"[Oz_StitchReel] WARN: {len(source_shots)} source shots "
+                    f"vs {len(candidates)} wan shots — will match by index"
+                )
+
+            n = min(len(source_shots), len(candidates))
+            padded_dir = os.path.join(concat_dir, f"padded_{timestamp}")
+            os.makedirs(padded_dir, exist_ok=True)
+
+            padded_files = []
+            for i in range(n):
+                wan_fp = candidates[i]
+                target_dur = source_durations[i] if i < len(source_durations) else 0.0
+                wan_dur = _ffprobe_duration(wan_fp)
+                padded_fp = os.path.join(padded_dir, f"padded_{i:04d}.mp4")
+                if target_dur <= 0 or wan_dur <= 0 or abs(target_dur - wan_dur) < 0.02:
+                    # No padding needed (or no info) — copy as-is (video only, no audio)
+                    cmd_p = [
+                        "ffmpeg", "-y", "-i", wan_fp,
+                        "-c:v", "copy", "-an",
+                        padded_fp,
+                    ]
+                else:
+                    pad_dur = max(0.0, target_dur - wan_dur)
+                    # tpad with clone mode freezes the last frame for pad_dur seconds;
+                    # -t trims to exact target. -an drops any audio stream.
+                    cmd_p = [
+                        "ffmpeg", "-y", "-i", wan_fp,
+                        "-vf", f"tpad=stop_mode=clone:stop_duration={pad_dur:.4f}",
+                        "-t", f"{target_dur:.4f}",
+                        "-an",
+                        "-c:v", "libx264", "-preset", "veryfast",
+                        "-pix_fmt", "yuv420p",
+                        padded_fp,
+                    ]
+                print(
+                    f"[Oz_StitchReel] shot {i+1}/{n}: "
+                    f"wan_dur={wan_dur:.3f}s target={target_dur:.3f}s"
+                )
+                r = subprocess.run(cmd_p, capture_output=True, text=True)
+                if r.returncode != 0:
+                    print(f"[Oz_StitchReel] pad failed for shot {i+1}: {r.stderr[-500:]}")
+                    return {
+                        "ui": {"text": [f"pad failed shot {i+1}"]},
+                        "result": ("",),
+                    }
+                padded_files.append(padded_fp)
+
+            # Build concat list of padded files
+            list_path = os.path.join(concat_dir, f"_concat_padded_{timestamp}.txt")
+            with open(list_path, "w") as f:
+                for fp in padded_files:
+                    safe = fp.replace("'", "'\\''")
+                    f.write(f"file '{safe}'\n")
+
+            reel_path = os.path.join(output_dir, f"{output_prefix}_{timestamp}.mp4")
+
+            # Concat video-only + overlay source audio
+            cmd = [
+                "ffmpeg", "-y",
+                "-f", "concat", "-safe", "0", "-i", list_path,
+                "-i", source_video_path,
+                "-map", "0:v:0", "-map", "1:a:0?",
+                "-c:v", "copy",
+                "-c:a", "aac", "-b:a", "192k",
+                "-shortest",
+                reel_path,
+            ]
+            print(f"[Oz_StitchReel] {' '.join(cmd)}")
+        else:
+            # ----- Simple concat (original behavior) -----
+            list_path = os.path.join(concat_dir, f"_concat_{timestamp}.txt")
+            with open(list_path, "w") as f:
+                for fp in candidates:
+                    safe = fp.replace("'", "'\\''")
+                    f.write(f"file '{safe}'\n")
+
+            reel_path = os.path.join(output_dir, f"{output_prefix}_{timestamp}.mp4")
+
+            cmd = ["ffmpeg", "-y", "-f", "concat", "-safe", "0"]
+            if genpts:
+                cmd += ["-fflags", "+genpts"]
+            cmd += ["-i", list_path, "-c", "copy", reel_path]
+
+            print(f"[Oz_StitchReel] {' '.join(cmd)}")
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            if result.returncode != 0:
+                print(f"[Oz_StitchReel] ffmpeg failed (code {result.returncode}):")
+                print(result.stderr[-2000:] if result.stderr else "<no stderr>")
+                # Fallback: try with genpts
+                if not genpts:
+                    print("[Oz_StitchReel] retrying with -fflags +genpts")
+                    cmd2 = [
+                        "ffmpeg",
+                        "-y",
+                        "-f",
+                        "concat",
+                        "-safe",
+                        "0",
+                        "-fflags",
+                        "+genpts",
+                        "-i",
+                        list_path,
+                        "-c",
+                        "copy",
+                        reel_path,
+                    ]
+                    result = subprocess.run(
+                        cmd2, capture_output=True, text=True, check=False
+                    )
+                    if result.returncode != 0:
+                        return {
+                            "ui": {"text": [f"ffmpeg failed: {result.stderr[-500:]}"]},
+                            "result": ("",),
+                        }
+        except Exception as e:
+            print(f"[Oz_StitchReel] subprocess error: {e}")
+            traceback.print_exc()
+            return {"ui": {"text": [f"subprocess error: {e}"]}, "result": ("",)}
+
+        if not os.path.exists(reel_path):
+            return {
+                "ui": {"text": ["ffmpeg reported success but output missing"]},
+                "result": ("",),
+            }
+
+        size_mb = os.path.getsize(reel_path) / 1024 / 1024
+        msg = (
+            f"[Oz_StitchReel] ✅ reel saved: "
+            f"{os.path.basename(reel_path)} ({size_mb:.1f} MB)"
+        )
+        print(msg)
+        return {"ui": {"text": [msg]}, "result": (reel_path,)}
+
+
+NODE_CLASS_MAPPINGS = {
+    "ozW_StitchReel": Oz_StitchReel,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ozW_StitchReel": "🎬 Oz Stitch Reel (ffmpeg concat)",
+}

ComfyUI_Oz/nodes/utility_nodes/oz_string_at_index.py

@@ -0,0 +1,65 @@
+# ---
+# Filename: ../Oz/nodes/utility_nodes/oz_string_at_index.py
+# Takes a STRING list (with INPUT_IS_LIST=True) and returns ONE element
+# at the given index as a scalar STRING. Safety net for nodes that don't
+# support ComfyUI's list auto-iteration (e.g. VHS_LoadVideoPath).
+# ---
+
+
+class Oz_StringAtIndex:
+    """
+    Extracts one scalar STRING from a STRING list.
+
+    INPUT_IS_LIST=True: receives the full upstream list in one call.
+    Returns a single string at the clamped index.
+    """
+
+    INPUT_IS_LIST = True
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "items": (
+                    "STRING",
+                    {"forceInput": True},
+                ),
+                "index": (
+                    "INT",
+                    {"default": 0, "min": 0, "max": 10000},
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("STRING", "INT")
+    RETURN_NAMES = ("item", "total")
+    FUNCTION = "pick"
+    CATEGORY = "Oz/Utils"
+
+    def pick(self, items, index):
+        # With INPUT_IS_LIST=True each arg arrives as a list even widgets
+        if isinstance(index, list):
+            idx = index[0] if index else 0
+        else:
+            idx = index
+
+        if items is None:
+            return ("", 0)
+        if not isinstance(items, list):
+            items = [items]
+
+        total = len(items)
+        if total == 0:
+            return ("", 0)
+
+        idx = max(0, min(idx, total - 1))
+        return (items[idx], total)
+
+
+NODE_CLASS_MAPPINGS = {
+    "ozW_StringAtIndex": Oz_StringAtIndex,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ozW_StringAtIndex": "📌 Oz String At Index",
+}