fix: nine review follow-ups for connections & workflow foundation (HEL-619)

1. .form-col border-box — 384px is the outer width (a6 spec)
2. import preview counts all analyzed inputs, matching inline/studio counts
3. SSRF guard also runs on endpoint save (create + patch)
4. schemeless/garbled URL is a 400 format error, not a DNS-classified probe failure
5. ComfyUI health probe timeout 120s → 5s (matches the test probe)
6. workflow delete refuses (409) while pending/running jobs use it; delete errors surfaced in the UI
7. agent_llm_assignments: per-role incremental merge server-side + single-role delta payloads
8. test_shell_tool now portable (interpreter on PATH; PYTHON+approval instead of ffprobe)
9. test_video_continue pauses the queue singleton via monkeypatch (no leak into test_workbench)

Co-authored-by: multica-agent <github@multica.ai>

calliope-backend/src/calliope/comfyui/client.py

@@ -13,6 +13,11 @@ from calliope.comfyui.registry import IMAGE_CLASSES, AUDIO_CLASSES, VIDEO_CLASSE
 
 logger = logging.getLogger("calliope.comfyui")
 
+# Reachability probe budget (HEL-619): matches the connections-page test
+# probe (5s). Without it health() inherits the 120s client default, so a
+# bad endpoint hangs every queued job for two minutes before failing.
+HEALTH_TIMEOUT_SEC = 5.0
+
 
 def _surface_error(prefix: str, resp: httpx.Response) -> RuntimeError:
     """Raise with ComfyUI's own error body instead of an opaque status line.
@@ -41,12 +46,24 @@ def _surface_error(prefix: str, resp: httpx.Response) -> RuntimeError:
                 if not isinstance(node_err, dict):
                     continue
                 errors = node_err.get("errors")
+                node = f"{node_id}（{node_err['class_type']}）" if node_err.get("class_type") else node_id
                 if isinstance(errors, list):
                     for e in errors:
-                        if isinstance(e, dict):
-                            msg = e.get("message") or e.get("details")
-                            if msg:
-                                parts.append(f"节点 {node_id}：{msg}")
+                        if not isinstance(e, dict):
+                            continue
+                        if e.get("type") == "value_not_in_list":
+                            extra = e.get("extra_info") or {}
+                            parts.append(
+                                f"节点 {node}：ComfyUI 上没有「{extra.get('received_value', '?')}」"
+                                f"（{extra.get('input_name', '参数')} 不在可选列表中，"
+                                "多为模型文件未安装）"
+                            )
+                            continue
+                        msg = e.get("message") or e.get("details")
+                        if msg and e.get("details") and e["details"] != msg:
+                            msg = f"{msg}（{e['details']}）"
+                        if msg:
+                            parts.append(f"节点 {node}：{msg}")
         detail = "；".join(parts)
     suffix = f"：{detail}" if detail else ""
     return RuntimeError(f"{prefix}（HTTP {resp.status_code}）{suffix}")
@@ -64,7 +81,9 @@ class ComfyUIClient:
 
     async def health(self) -> bool:
         try:
-            resp = await self._http.get(f"{self.base_url}/system_stats")
+            resp = await self._http.get(
+                f"{self.base_url}/system_stats", timeout=HEALTH_TIMEOUT_SEC
+            )
             return resp.status_code == 200
         except Exception:
             return False
@@ -217,6 +236,37 @@ class ComfyUIClient:
         data = resp.json()
         return data.get(prompt_id)
 
+    async def locate_prompt(self, prompt_id: str) -> tuple[str, int]:
+        """Where ``prompt_id`` sits in ComfyUI's ``/queue``.
+
+        Returns ``("running", 0)``, ``("pending", <prompts ahead>)``,
+        ``("missing", 0)`` when the queue does not list it, or
+        ``("unknown", 0)`` when this server has no ``/queue`` route.
+        """
+        resp = await self._http.get(f"{self.base_url}/queue")
+        if resp.status_code == 404:
+            return "unknown", 0
+        resp.raise_for_status()
+        data = resp.json() if resp.content else {}
+        running = data.get("queue_running") or []
+        pending = data.get("queue_pending") or []
+
+        def pid(item: Any) -> Any:
+            return item[1] if isinstance(item, list) and len(item) > 1 else None
+
+        if any(pid(item) == prompt_id for item in running):
+            return "running", 0
+        mine = next((item for item in pending if pid(item) == prompt_id), None)
+        if mine is None:
+            return "missing", 0
+        ahead = sum(
+            1
+            for item in pending
+            if isinstance(item, list) and item and isinstance(item[0], (int, float))
+            and isinstance(mine[0], (int, float)) and item[0] < mine[0]
+        )
+        return "pending", len(running) + ahead
+
     async def download_image(
         self,
         filename: str,
@@ -226,7 +276,10 @@ class ComfyUIClient:
     ) -> Path:
         params = {"filename": filename, "subfolder": subfolder, "type": folder_type}
         resp = await self._http.get(f"{self.base_url}/view", params=params)
-        resp.raise_for_status()
+        if resp.status_code >= 400:
+            raise _surface_error(f"从 ComfyUI 下载结果文件 {filename} 失败", resp)
+        if not resp.content:
+            raise RuntimeError(f"从 ComfyUI 下载的结果文件 {filename} 是空文件")
         if dest is None:
             dest = settings.assets_dir / "comfy_downloads" / filename
         dest.parent.mkdir(parents=True, exist_ok=True)
@@ -239,16 +292,46 @@ class ComfyUIClient:
         except Exception as exc:
             logger.warning("ComfyUI interrupt failed: %s", exc)
 
-    def extract_outputs(self, history: dict[str, Any]) -> list[dict[str, str]]:
+    # History items carry no explicit media type — infer from the file
+    # extension first, then the history key the node reported under.
+    _VIDEO_EXTS = frozenset({".mp4", ".webm", ".mkv", ".mov", ".gif", ".m4v", ".avi", ".flv"})
+    _IMAGE_EXTS = frozenset({".png", ".jpg", ".jpeg", ".webp", ".bmp", ".tif", ".tiff"})
+
+    @classmethod
+    def _infer_media_kind(cls, filename: str, history_key: str) -> str | None:
+        ext = Path(str(filename)).suffix.lower()
+        if ext in cls._VIDEO_EXTS:
+            return "video"
+        if ext in cls._IMAGE_EXTS:
+            return "image"
+        if history_key in ("gifs", "videos"):
+            return "video"
+        return None
+
+    def extract_outputs(
+        self, history: dict[str, Any], node_kinds: dict[str, str] | None = None
+    ) -> list[dict[str, str]]:
+        """Media items in a finished prompt's history.
+
+        ``node_kinds`` (HEL-638) scopes the harvest to the workflow's
+        confirmed output nodes — {nodeId: image|video} — so results from
+        nodes the user never designated are ignored, and each item carries
+        the node id plus its inferred media kind for mismatch checks.
+        """
         outputs: list[dict[str, str]] = []
-        for _node_id, node_out in (history.get("outputs") or {}).items():
+        for node_id, node_out in (history.get("outputs") or {}).items():
+            if node_kinds is not None and str(node_id) not in node_kinds:
+                continue
             for key in ("images", "gifs", "videos"):
                 for item in node_out.get(key) or []:
+                    filename = item.get("filename", "")
                     outputs.append(
                         {
-                            "filename": item.get("filename", ""),
+                            "filename": filename,
                             "subfolder": item.get("subfolder", ""),
                             "type": item.get("type", "output"),
+                            "node_id": str(node_id),
+                            "media_kind": self._infer_media_kind(filename, key) or "",
                         }
                     )
         return outputs

calliope-backend/src/calliope/comfyui/lint.py

@@ -0,0 +1,126 @@
+"""Structural checks on an imported ComfyUI API workflow.
+
+``error`` findings mean ComfyUI will reject the prompt as exported, so the
+studio blocks generation; ``warning`` findings only explain odd parameters.
+Nothing here repairs a workflow — a broken export has to be re-exported from
+a ComfyUI that has the missing custom nodes installed.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+REEXPORT_HINT = "请在已安装对应自定义节点的 ComfyUI 中打开该工作流，重新导出 API 格式 JSON 后再导入"
+
+# Nodes that cannot run without a model link.
+_NEEDS_MODEL = frozenset(
+    {"KSampler", "KSamplerAdvanced", "BasicGuider", "CFGGuider", "BasicScheduler"}
+)
+
+
+def _title(node_id: str, node: dict[str, Any]) -> str:
+    title = str((node.get("_meta") or {}).get("title") or "").strip()
+    return f"节点 {node_id}「{title}」" if title else f"节点 {node_id}"
+
+
+def workflow_warnings(workflow: dict[str, Any]) -> list[dict[str, str]]:
+    if not isinstance(workflow, dict):
+        return []
+    found: list[dict[str, str]] = []
+    nodes = {str(k): v for k, v in workflow.items() if isinstance(v, dict)}
+
+    untyped = [nid for nid, node in nodes.items() if not str(node.get("class_type") or "").strip()]
+    for nid in untyped:
+        found.append(
+            {
+                "level": "error",
+                "code": "missing_class_type",
+                "node_id": nid,
+                "message": f"{_title(nid, nodes[nid])}缺少节点类型（class_type），"
+                "导出时 ComfyUI 未加载该自定义节点",
+            }
+        )
+
+    consumed: set[str] = set()
+    for nid, node in nodes.items():
+        inputs = node.get("inputs") or {}
+        for name, val in inputs.items():
+            if isinstance(val, list) and len(val) == 2 and isinstance(val[0], (str, int)):
+                src = str(val[0])
+                consumed.add(src)
+                if src not in nodes:
+                    found.append(
+                        {
+                            "level": "error",
+                            "code": "dangling_link",
+                            "node_id": nid,
+                            "message": f"{_title(nid, node)}的输入「{name}」"
+                            f"连到了不存在的节点 {src}",
+                        }
+                    )
+        ct = str(node.get("class_type") or "")
+        if ct in _NEEDS_MODEL and not isinstance(inputs.get("model"), list):
+            found.append(
+                {
+                    "level": "error",
+                    "code": "missing_model_link",
+                    "node_id": nid,
+                    "message": f"{_title(nid, node)}（{ct}）没有连接模型（model），"
+                    "模型加载链路在导出时丢失",
+                }
+            )
+
+    for nid, node in nodes.items():
+        ct = str(node.get("class_type") or "")
+        if ct.startswith("Empty") and "Latent" in ct and nid not in consumed:
+            found.append(
+                {
+                    "level": "warning",
+                    "code": "orphan_latent",
+                    "node_id": nid,
+                    "message": f"{_title(nid, nodes[nid])}没有接到任何节点，"
+                    "它的宽高不会生效，已不在表单中显示",
+                }
+            )
+
+    # HEL-636/638: a workflow without any recognizable output node can never
+    # return a result — block it with a readable reason instead of letting
+    # ComfyUI run blind. Unknown candidates (needs_mapping) don't trigger
+    # this: the user designates them on the import/connections page, and
+    # until then the row stays disabled.
+    from calliope.comfyui.parser import detect_output_nodes
+
+    outputs = detect_output_nodes(workflow)
+    if not any(o.get("kind") in ("image", "video") for o in outputs):
+        unknown = [o for o in outputs if o.get("evidence") == "unknown_node"]
+        if not unknown:
+            found.append(
+                {
+                    "level": "error",
+                    "code": "no_output",
+                    "node_id": "",
+                    "message": "未在图中找到输出节点（SaveImage / 视频合成等），"
+                    "请确认导出的是 API 格式且包含保存节点",
+                }
+            )
+        else:
+            names = "、".join(f"节点 {o['nodeId']}" for o in unknown[:4])
+            found.append(
+                {
+                    "level": "warning",
+                    "code": "unknown_output_node",
+                    "node_id": names,
+                    "message": f"存在无法识别的输出节点（{names}），"
+                    "需人工指定实际输出节点及其媒体类型（图片/视频）后才能生成",
+                }
+            )
+    return found
+
+
+def blocking_problem(workflow: dict[str, Any]) -> str | None:
+    """One Chinese sentence explaining why this workflow cannot be submitted."""
+    errors = [w["message"] for w in workflow_warnings(workflow) if w["level"] == "error"]
+    if not errors:
+        return None
+    shown = "；".join(errors[:4]) + (f"；等 {len(errors)} 处" if len(errors) > 4 else "")
+    return f"该工作流文件不完整，ComfyUI 无法执行：{shown}。{REEXPORT_HINT}。"

calliope-backend/src/calliope/comfyui/output_map.py

@@ -0,0 +1,148 @@
+"""Stored output-node mapping for imported workflows (HEL-638).
+
+Unknown custom output nodes are never auto-typed. The import confirm page
+(or the connections table) stores the user's explicit designation — which
+node ids are the real outputs and each one's media type — in
+``workflows.output_map`` with ``output_map_source='user'``. Everything that
+re-derives schemas (reanalyze, migration, plain field edits) must keep that
+decision; only a fresh explicit payload replaces it.
+
+Rows without unknown candidates carry an ``auto`` map derived from the
+trusted registry/tagged outputs so the generation path always knows which
+history nodes to harvest.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from calliope.comfyui.parser import parse_dynamic_outputs
+from calliope.comfyui.registry import (
+    IMAGE_OUTPUT_CLASSES,
+    NUMBER_CLASSES,
+    TEXT_AREA_CLASSES,
+    VIDEO_OUTPUT_CLASSES,
+)
+
+VALID_OUTPUT_KINDS = ("image", "video")
+
+
+def _wiring_class(class_type: str) -> bool:
+    """Parameter / wiring classes can never be designated as outputs."""
+    return (
+        not class_type
+        or class_type in TEXT_AREA_CLASSES
+        or class_type in NUMBER_CLASSES
+        or class_type.startswith("Empty")
+        or class_type.startswith("Primitive")
+    )
+
+
+def _entry_public(entry: dict[str, Any]) -> dict[str, Any]:
+    out = {
+        "nodeId": str(entry.get("nodeId") or ""),
+        "kind": entry.get("kind"),
+    }
+    if entry.get("label"):
+        out["label"] = entry["label"]
+    if entry.get("class_type"):
+        out["class_type"] = entry["class_type"]
+    return out
+
+
+def auto_output_map(workflow: dict[str, Any]) -> list[dict[str, Any]]:
+    """Trusted outputs only (tagged titles / registry classes)."""
+    if not isinstance(workflow, dict):
+        return []
+    return [
+        _entry_public(o)
+        for o in parse_dynamic_outputs(workflow)
+        if o.get("kind") in VALID_OUTPUT_KINDS
+    ]
+
+
+def needs_user_output_map(workflow: dict[str, Any]) -> bool:
+    """True when the graph has unknown output candidates (HEL-638)."""
+    if not isinstance(workflow, dict):
+        return False
+    return any(
+        o.get("evidence") == "unknown_node" for o in parse_dynamic_outputs(workflow)
+    )
+
+
+def validate_output_map(
+    workflow: dict[str, Any], entries: Any
+) -> list[str]:
+    """Chinese problems with a user-supplied output map; empty = valid."""
+    if not isinstance(entries, list) or not entries:
+        return ["输出节点映射不能为空：请至少指定一个输出节点及其媒体类型"]
+    seen: set[str] = set()
+    problems: list[str] = []
+    for entry in entries:
+        if not isinstance(entry, dict):
+            problems.append("输出节点映射格式有误（应为对象数组）")
+            continue
+        nid = str(entry.get("nodeId") or "")
+        node = workflow.get(nid) if isinstance(workflow, dict) else None
+        if not nid or not isinstance(node, dict):
+            problems.append(f"输出节点 {nid or '?'} 不存在于该工作流中")
+            continue
+        ct = str(node.get("class_type") or "").strip()
+        if not ct:
+            problems.append(f"节点 {nid} 缺少节点类型，不能作为输出节点")
+        elif _wiring_class(ct) and ct not in (IMAGE_OUTPUT_CLASSES | VIDEO_OUTPUT_CLASSES):
+            problems.append(f"节点 {nid}（{ct}）是参数/连线节点，不能作为输出节点")
+        if entry.get("kind") not in VALID_OUTPUT_KINDS:
+            problems.append(f"输出节点 {nid} 的媒体类型必须是图片或视频")
+        if nid in seen:
+            problems.append(f"输出节点 {nid} 重复指定")
+        seen.add(nid)
+    return problems
+
+
+def load_output_map(raw: str | None) -> list[dict[str, Any]]:
+    if not raw:
+        return []
+    try:
+        data = json.loads(raw)
+    except (json.JSONDecodeError, TypeError):
+        return []
+    return data if isinstance(data, list) else []
+
+
+def resolve_output_map(
+    output_map_raw: str | None, source: str | None, workflow: dict[str, Any]
+) -> tuple[list[dict[str, Any]], str | None]:
+    """The map generation harvests, plus whose decision it is.
+
+    A user map wins as long as its node ids still exist in the stored JSON
+    (defensive pruning — PATCH cannot edit the JSON, but keep it safe);
+    otherwise the trusted auto map applies. Empty list back means "not
+    confirmed yet".
+    """
+    if source == "user":
+        entries = [
+            e for e in load_output_map(output_map_raw) if str(e.get("nodeId") or "") in
+            (workflow if isinstance(workflow, dict) else {})
+        ]
+        if entries:
+            return entries, "user"
+        return [], None
+    auto = auto_output_map(workflow)
+    return (auto, "auto") if auto else ([], None)
+
+
+def mapping_problem(
+    workflow: dict[str, Any], output_map_raw: str | None, source: str | None
+) -> str | None:
+    """Chinese reason this workflow's outputs are not confirmed, else None."""
+    if not needs_user_output_map(workflow):
+        return None
+    entries, resolved = resolve_output_map(output_map_raw, source, workflow)
+    if resolved == "user" and entries:
+        return None
+    return (
+        "该工作流含无法识别的自定义输出节点，需在「ComfyUI 连接」页指定"
+        "实际输出节点及其媒体类型（图片/视频）后才能启用或生成"
+    )

calliope-backend/src/calliope/comfyui/parser.py

@@ -2,18 +2,26 @@
 
 from __future__ import annotations
 
+import math
+import re
 from typing import Any
 
 from calliope.comfyui.patcher import FIELD_KEY_SEP, resolve_patch_field
 from calliope.comfyui.registry import (
     AUDIO_CLASSES,
     IMAGE_CLASSES,
+    IMAGE_OUTPUT_CLASSES,
+    IMAGE_URL_CLASSES,
+    NUMBER_CLASSES,
+    TEXT_AREA_CLASSES,
     VIDEO_CLASSES,
+    VIDEO_OUTPUT_CLASSES,
     ComfyOutputKind,
     class_to_input_kind,
     class_to_output_kind,
 )
 from calliope.comfyui.roles import (
+    USAGE_VALUES,
     normalize_input_role,
     normalize_output_role,
     parse_title_tag,
@@ -67,6 +75,28 @@ def parse_dynamic_inputs(workflow: dict[str, Any]) -> list[dict[str, Any]]:
     return results
 
 
+def effective_input_schema(
+    stored: list[dict[str, Any]] | None, workflow: dict[str, Any]
+) -> list[dict[str, Any]]:
+    """The schema a stored workflow exposes now.
+
+    Auto-detected (and empty) schemas are re-derived from the workflow JSON
+    on every read, so parser upgrades reach workflows imported earlier
+    without a re-import. Tagged ``(Input:…)`` schemas are kept as stored.
+    Entries the user corrected on the import confirm page carry
+    ``manual: true`` — their role/label survive re-derivation.
+    """
+    if not stored:
+        return parse_dynamic_inputs(workflow)
+    manual_by_id = {
+        str(e.get("nodeId")): e for e in stored if isinstance(e, dict) and e.get("manual")
+    }
+    if any(isinstance(e, dict) and e.get("auto") for e in stored):
+        fresh = parse_dynamic_inputs(workflow)
+        return [manual_by_id.get(str(e.get("nodeId")), e) for e in fresh]
+    return stored
+
+
 # ---------------------------------------------------------------------------
 # Untagged detection
 # ---------------------------------------------------------------------------
@@ -185,9 +215,15 @@ def _duration_hint(
 
 
 def _entry(
-    key: str, label: str, role: str | None, kind: str, default: Any, required: bool
+    key: str,
+    label: str,
+    role: str | None,
+    kind: str,
+    default: Any,
+    required: bool,
+    **extra: Any,
 ) -> dict[str, Any]:
-    return {
+    entry = {
         "nodeId": key,
         "label": label,
         "role": role,
@@ -196,6 +232,198 @@ def _entry(
         "required": required,
         "auto": True,
     }
+    entry.update({k: v for k, v in extra.items() if v is not None})
+    return entry
+
+
+# ComfyUI's own widget limits (nodes.py / comfy_extras) for the widgets we
+# expose; the studio validates against them before a job is queued. Seeds
+# stop at 2**53-1 (ComfyUI allows 2**64-1): larger values lose precision in
+# the browser's JSON numbers.
+_NUMBER_LIMITS: dict[str, dict[str, Any]] = {
+    "seed": {"min": 0, "max": 2**53 - 1, "step": 1, "integer": True},
+    "steps": {"min": 1, "max": 10000, "step": 1, "integer": True},
+    "cfg": {"min": 0.0, "max": 100.0, "step": 0.1},
+    "denoise": {"min": 0.0, "max": 1.0, "step": 0.01},
+    "width": {"min": 16, "max": 16384, "step": 8, "integer": True},
+    "height": {"min": 16, "max": 16384, "step": 8, "integer": True},
+    "batch": {"min": 1, "max": 4096, "step": 1, "integer": True},
+    "megapixels": {"min": 0.1, "max": 16.0, "step": 0.1},
+}
+
+# Text encoders whose ``resolution`` widget sizes the generated image when an
+# input image is wired (edit mode); in text-to-image it only sizes references.
+_RESOLUTION_ENCODERS: dict[str, dict[str, Any]] = {
+    "TextEncodeQwenImage21": {"min": 0, "max": 4096, "step": 32, "integer": True},
+}
+
+# comfy_extras/nodes_resolution.py — option strings must match exactly.
+RESOLUTION_ASPECT_RATIOS: dict[str, tuple[int, int]] = {
+    "1:1 (Square)": (1, 1),
+    "2:3 (Portrait Photo)": (2, 3),
+    "3:2 (Photo)": (3, 2),
+    "3:4 (Portrait Standard)": (3, 4),
+    "4:3 (Standard)": (4, 3),
+    "9:16 (Portrait Widescreen)": (9, 16),
+    "16:9 (Widescreen)": (16, 9),
+    "21:9 (Ultrawide)": (21, 9),
+}
+
+
+def resolution_selector_size(aspect_ratio: str, megapixels: float, multiple: int) -> tuple[int, int]:
+    """Width/height exactly as ComfyUI's ResolutionSelector computes them."""
+    w_ratio, h_ratio = RESOLUTION_ASPECT_RATIOS[aspect_ratio]
+    scale = math.sqrt(megapixels * 1024 * 1024 / (w_ratio * h_ratio))
+    multiple = max(1, int(multiple))
+    return (
+        round(w_ratio * scale / multiple) * multiple,
+        round(h_ratio * scale / multiple) * multiple,
+    )
+
+
+# ComfyUI Autogrow image inputs a studio form fills as one 1…max list.
+# The workflow wires ``<group>.<prefix>N``; extra images are cloned LoadImage
+# nodes added at patch time (patcher.py). This registry only beautifies known
+# classes (label + real max from /object_info); detection itself is generic —
+# any ``<group>.<prefix>N`` run of image-loader links folds into a group.
+IMAGE_GROUPS: dict[str, dict[str, dict[str, Any]]] = {
+    "MiniMaxH3ReferenceToVideo": {
+        "ref_images": {"prefix": "ref_image_", "max": 9, "label": "参考图"},
+    },
+}
+
+# ``ref_images.ref_image_0`` / ``images.image_1`` style Autogrow input names.
+_GROUP_INPUT_RE = re.compile(
+    r"^(?P<group>[A-Za-z0-9_+-]+)\.(?P<rest>[A-Za-z0-9_+-]+?)(?P<n>\d+)$"
+)
+
+# Consumer input name → (role, label) of the LoadImage wired into it.
+_FRAME_SLOT_ROLES: dict[str, tuple[str, str]] = {
+    "first_frame": ("first_frame", "首帧"),
+    "start_image": ("first_frame", "首帧"),
+    "last_frame": ("last_frame", "尾帧"),
+    "end_image": ("last_frame", "尾帧"),
+}
+
+
+def image_group_spec(class_type: str, group: str) -> dict[str, Any] | None:
+    return IMAGE_GROUPS.get(class_type, {}).get(group)
+
+
+def image_group_prefix(node: dict[str, Any], group: str) -> str | None:
+    """The ``<prefix>`` this node numbers its ``<group>.<prefix>N`` inputs with.
+
+    Known classes read it from the registry; anything else derives it from
+    the node's own wired input names (generic Autogrow detection).
+    """
+    spec = image_group_spec(str(node.get("class_type") or ""), group)
+    if spec:
+        return str(spec["prefix"])
+    head = f"{group}."
+    prefixes = set()
+    for name in (node.get("inputs") or {}):
+        if not name.startswith(head):
+            continue
+        m = _GROUP_INPUT_RE.match(name)
+        if m and m.group("group") == group:
+            prefixes.add(m.group("rest"))
+    if len(prefixes) == 1:
+        return prefixes.pop()
+    return None
+
+
+def image_group_slots(
+    node: dict[str, Any], group: str, prefix: str
+) -> list[tuple[int, str, Any]]:
+    """``[(N, input name, link), …]`` wired into ``<group>.<prefix>N``, by N."""
+    head = f"{group}.{prefix}"
+    out: list[tuple[int, str, Any]] = []
+    for name, val in (node.get("inputs") or {}).items():
+        if name.startswith(head) and name[len(head):].isdigit():
+            out.append((int(name[len(head):]), name, val))
+    return sorted(out)
+
+
+def _detected_group_runs(
+    workflow: dict[str, Any], node: dict[str, Any]
+) -> list[tuple[str, str, list[str]]]:
+    """``[(group, prefix, source LoadImage ids)]`` for generic Autogrow inputs.
+
+    A run qualifies when the numbers are consecutive, every slot links to an
+    image-loader class, and the run either starts at 0 (single-slot Autogrow
+    exports like H3's ``ref_image_0``) or has ≥2 slots. Single runs numbered
+    from 1 (e.g. TextEncodeQwenImage21's ``images.image_1``) stay ordinary
+    image slots.
+    """
+    runs: dict[tuple[str, str], dict[int, Any]] = {}
+    for name, val in (node.get("inputs") or {}).items():
+        m = _GROUP_INPUT_RE.match(name)
+        if not m or not (isinstance(val, list) and len(val) == 2):
+            continue
+        runs.setdefault((m.group("group"), m.group("rest")), {})[int(m.group("n"))] = val
+    out: list[tuple[str, str, list[str]]] = []
+    for (group, prefix), slots in sorted(runs.items()):
+        ns = sorted(slots)
+        if any(b - a != 1 for a, b in zip(ns, ns[1:])):
+            continue
+        if not (ns[0] == 0 or len(ns) >= 2):
+            continue
+        sources: list[str] = []
+        for n in ns:
+            link = slots[n]
+            src = workflow.get(str(link[0]))
+            if not (isinstance(src, dict) and src.get("class_type") in IMAGE_CLASSES):
+                sources = []
+                break
+            sources.append(str(link[0]))
+        if sources:
+            out.append((group, prefix, sources))
+    return out
+
+
+def _image_groups(
+    workflow: dict[str, Any],
+) -> tuple[list[dict[str, Any]], set[str]]:
+    """Group entries for Autogrow reference inputs + the LoadImage ids they absorb."""
+    entries: list[dict[str, Any]] = []
+    absorbed: set[str] = set()
+    for nid, node in sorted(
+        ((str(k), v) for k, v in workflow.items() if isinstance(v, dict)),
+        key=lambda kv: _node_sort_key(kv[0]),
+    ):
+        for group, _prefix, sources in _detected_group_runs(workflow, node):
+            spec = image_group_spec(str(node.get("class_type") or ""), group) or {}
+            absorbed.update(sources)
+            entries.append(
+                _entry(
+                    f"{nid}{FIELD_KEY_SEP}{group}",
+                    str(spec.get("label") or "参考图"),
+                    "reference_image",
+                    "image_list",
+                    None,
+                    True,
+                    min=1,
+                    max=spec.get("max", 9),
+                )
+            )
+    return entries, absorbed
+
+
+def _image_slot(
+    nid: str, workflow: dict[str, Any], consumers: dict[str, list[tuple[str, str]]]
+) -> tuple[str, str] | None:
+    """(role, label) of a LoadImage from what consumes it; None when unwired."""
+    uses = consumers.get(nid, [])
+    if not uses:
+        return None
+    for _cid, name in uses:
+        if name in _FRAME_SLOT_ROLES:
+            return _FRAME_SLOT_ROLES[name]
+    for cid, name in uses:
+        ct = str((workflow.get(cid) or {}).get("class_type") or "")
+        if "TextEncode" in ct and name.startswith("image"):
+            return "image", "输入图"
+    return "image", ""
 
 
 def _key(node_id: str, node: dict[str, Any], field: str) -> str:
@@ -221,6 +449,7 @@ def detect_untagged_inputs(workflow: dict[str, Any]) -> list[dict[str, Any]]:
     )
 
     texts: list[tuple[str, dict[str, Any], str, bool]] = []  # (id, node, field, negative)
+    groups, grouped_images = _image_groups(workflow)
     media: list[dict[str, Any]] = []
     numbers: list[dict[str, Any]] = []
     taken_roles: set[str] = set()
@@ -232,7 +461,12 @@ def detect_untagged_inputs(workflow: dict[str, Any]) -> list[dict[str, Any]]:
         if not _is_scalar(value) or isinstance(value, str):
             return
         taken_roles.add(role)
-        numbers.append(_entry(_key(nid, node, field), label, role, "number", value, False))
+        numbers.append(
+            _entry(
+                _key(nid, node, field), label, role, "number", value, False,
+                **_NUMBER_LIMITS.get(role, {}),
+            )
+        )
 
     for nid, node in nodes:
         ct = str(node.get("class_type") or "")
@@ -241,19 +475,31 @@ def detect_untagged_inputs(workflow: dict[str, Any]) -> list[dict[str, Any]]:
         lowered = title.lower()
 
         if ct in IMAGE_CLASSES or ct in _MASK_IMAGE_CLASSES:
+            if nid in grouped_images:
+                continue
             is_mask = ct in _MASK_IMAGE_CLASSES or "mask" in lowered or "遮罩" in lowered
-            label = title if title and title != ct else ("遮罩" if is_mask else "参考图")
-            if is_mask and "mask" not in label.lower() and "遮罩" not in label:
-                label = f"遮罩 · {label}"
-            has_default = isinstance(inputs.get("image"), str) and bool(inputs.get("image"))
+            slot = _image_slot(nid, workflow, consumers)
+            if is_mask:
+                label = title if title and title != ct else "遮罩"
+                if "mask" not in label.lower() and "遮罩" not in label:
+                    label = f"遮罩 · {label}"
+                has_default = isinstance(inputs.get("image"), str) and bool(inputs.get("image"))
+                media.append(
+                    _entry(_key(nid, node, "image"), label, "mask", "image", None, not has_default)
+                )
+                continue
+            if slot is None:
+                # Nothing consumes it — ComfyUI never runs it, so no upload slot.
+                continue
+            role, label = slot
             media.append(
                 _entry(
                     _key(nid, node, "image"),
-                    label,
-                    "mask" if is_mask else "image",
+                    label or (title if title and title != ct else "参考图"),
+                    role,
                     "image",
                     None,
-                    not has_default,
+                    True,
                 )
             )
             continue
@@ -279,23 +525,72 @@ def detect_untagged_inputs(workflow: dict[str, Any]) -> list[dict[str, Any]]:
                 texts.append((nid, node, neg_field, True))
             elif field:
                 texts.append((nid, node, field, _is_negative(nid, lowered, consumers)))
+            edits_image = any(
+                k.startswith("images.") and isinstance(v, list) for k, v in inputs.items()
+            )
+            if ct in _RESOLUTION_ENCODERS and edits_image and "resolution" not in taken_roles:
+                value = inputs.get("resolution")
+                if _is_scalar(value) and not isinstance(value, str):
+                    taken_roles.add("resolution")
+                    numbers.append(
+                        _entry(
+                            _key(nid, node, "resolution"),
+                            "输出分辨率",
+                            "resolution",
+                            "number",
+                            value,
+                            False,
+                            **_RESOLUTION_ENCODERS[ct],
+                        )
+                    )
             continue
 
         if ct in _SAMPLER_CLASSES:
             add_number(nid, node, "seed" if "seed" in inputs else "noise_seed", "seed", "随机种子")
             add_number(nid, node, "steps", "steps", "采样步数")
             add_number(nid, node, "cfg", "cfg", "CFG")
+            add_number(nid, node, "denoise", "denoise", "降噪强度")
             continue
         if ct == "RandomNoise":
             add_number(nid, node, "noise_seed", "seed", "随机种子")
             continue
         if ct == "BasicScheduler":
             add_number(nid, node, "steps", "steps", "采样步数")
+            add_number(nid, node, "denoise", "denoise", "降噪强度")
+            continue
+        if ct == "ResolutionSelector" and nid in consumers:
+            ratio = inputs.get("aspect_ratio")
+            if (
+                "aspect_ratio" not in taken_roles
+                and isinstance(ratio, str)
+                and ratio in RESOLUTION_ASPECT_RATIOS
+            ):
+                taken_roles.add("aspect_ratio")
+                multiple = inputs.get("multiple")
+                numbers.append(
+                    _entry(
+                        _key(nid, node, "aspect_ratio"),
+                        "画面比例",
+                        "aspect_ratio",
+                        "select",
+                        ratio,
+                        False,
+                        options=list(RESOLUTION_ASPECT_RATIOS),
+                        resolution={
+                            "megapixels": _key(nid, node, "megapixels"),
+                            "multiple": multiple if isinstance(multiple, int) else 8,
+                        },
+                    )
+                )
+                add_number(nid, node, "megapixels", "megapixels", "总像素（百万）")
             continue
         if ct == "CFGGuider":
             add_number(nid, node, "cfg", "cfg", "CFG")
             continue
         if ct.startswith("Empty") and "Latent" in ct:
+            if nid not in consumers:
+                # Orphan latent (Qwen edit sizes from its encoder): editing it changes nothing.
+                continue
             add_number(nid, node, "width", "width", "宽度")
             add_number(nid, node, "height", "height", "高度")
             add_number(nid, node, "batch_size", "batch", "批次数量")
@@ -316,8 +611,16 @@ def detect_untagged_inputs(workflow: dict[str, Any]) -> list[dict[str, Any]]:
                 role = None
             if role:
                 taken_roles.add(role)
+            limits = dict(_NUMBER_LIMITS.get(role or "", {}))
+            if ct in ("PrimitiveInt", "INT"):
+                limits["integer"] = True
+            if role == "duration":
+                limits.setdefault("min", 0.1)
             numbers.append(
-                _entry(_key(nid, node, "value"), label, role, "number", inputs["value"], False)
+                _entry(
+                    _key(nid, node, "value"), label, role, "number", inputs["value"], False,
+                    **limits,
+                )
             )
 
     results: list[dict[str, Any]] = []
@@ -359,6 +662,7 @@ def detect_untagged_inputs(workflow: dict[str, Any]) -> list[dict[str, Any]]:
         )
     results.extend(numbers)
     results.extend(media)
+    results.extend(groups)
     return results
 
 
@@ -393,4 +697,341 @@ def parse_dynamic_outputs(workflow: dict[str, Any]) -> list[dict[str, Any]]:
                 "kind": out_kind,
             }
         )
+    if not results:
+        results = detect_output_nodes(workflow)
     return results
+
+
+# ---------------------------------------------------------------------------
+# Output (sink) detection + five-usage classification (HEL-636)
+# ---------------------------------------------------------------------------
+
+# Nodes whose output another node consumes are wiring, not results. A node
+# nothing consumes is a sink; media sinks are the workflow's outputs.
+_INPUT_ONLY_CLASSES = IMAGE_CLASSES | IMAGE_URL_CLASSES | AUDIO_CLASSES | VIDEO_CLASSES
+# Latent/source shapers (EmptyLatentImage…) are wiring even when nothing
+# consumes them — they never carry results out of the graph.
+_SOURCE_ONLY_CLASSES = _INPUT_ONLY_CLASSES | TEXT_AREA_CLASSES | NUMBER_CLASSES
+
+# Classes that are known-internal tails: standard decode steps and cache
+# cleaners consume media but never emit history outputs, so they can never
+# be output candidates (HEL-638: a graph ending in these has no output).
+_NON_OUTPUT_CLASSES = frozenset(
+    {"VAEDecode", "VAEDecodeTiled", "VAEDecodeAudio", "easy cleanGpuUsed"}
+)
+
+# Widget names save-style custom nodes carry, and link input names that mark
+# "consumes rendered media" — used to flag unknown sinks that need mapping.
+_SAVE_WIDGET_NAMES = frozenset(
+    {"filename_prefix", "filename", "prefix", "path", "output_path", "save_output"}
+)
+_MEDIA_LINK_NAMES = frozenset(
+    {"images", "image", "video", "frames", "latent", "latents", "audio", "audios"}
+)
+
+
+def _sinks(
+    workflow: dict[str, Any], consumers: dict[str, list[tuple[str, str]]]
+) -> list[tuple[str, dict[str, Any]]]:
+    out: list[tuple[str, dict[str, Any]]] = []
+    for nid, node in sorted(
+        ((str(k), v) for k, v in workflow.items() if isinstance(v, dict)),
+        key=lambda kv: _node_sort_key(kv[0]),
+    ):
+        if not consumers.get(nid):
+            out.append((nid, node))
+    return out
+
+
+def _unknown_sink_looks_like_save(node: dict[str, Any], workflow: dict[str, Any]) -> bool:
+    inputs = node.get("inputs") or {}
+    for name, val in inputs.items():
+        if name in _SAVE_WIDGET_NAMES and isinstance(val, (str, int, float, bool)):
+            return True
+        if name in _MEDIA_LINK_NAMES and isinstance(val, list) and len(val) == 2:
+            src = workflow.get(str(val[0]))
+            if isinstance(src, dict) and "decode" in str(src.get("class_type") or "").lower():
+                return True
+    return False
+
+
+def _node_has_save_widget(node: dict[str, Any]) -> bool:
+    """A concrete save widget (filename/prefix/path) — the only signal that
+    counts for unknown nodes that something else consumes; media links from
+    decode steps are meaningless there (every transform has them)."""
+    inputs = node.get("inputs") or {}
+    return any(
+        name in _SAVE_WIDGET_NAMES and isinstance(val, (str, int, float, bool))
+        for name, val in inputs.items()
+    )
+
+
+def _video_semantics(workflow: dict[str, Any]) -> bool:
+    """Auxiliary evidence the graph renders video (frame counts, video nodes)."""
+    for node in workflow.values():
+        if not isinstance(node, dict):
+            continue
+        ct = str(node.get("class_type") or "").lower()
+        if "video" in ct or "animatediff" in ct:
+            return True
+        for name in (node.get("inputs") or {}):
+            if name in _FRAME_INPUTS:
+                return True
+    return False
+
+
+def _suggest_output_kind(class_type: str, videoish: bool) -> str | None:
+    """Best-guess media type for an unknown candidate — UI default only."""
+    lower = class_type.lower()
+    if "video" in lower or "animatediff" in lower:
+        return "video"
+    if "image" in lower or "save" in lower:
+        return "image"
+    return "video" if videoish else None
+
+
+def _unknown_output_entry(
+    nid: str, node: dict[str, Any], workflow: dict[str, Any], videoish: bool
+) -> dict[str, Any]:
+    ct = str(node.get("class_type") or "")
+    return {
+        "nodeId": nid,
+        "label": _title_of(node) or ct,
+        "role": None,
+        # HEL-638: unknown custom nodes are never auto-typed — the user
+        # picks the media type; `suggested_kind` is only a form default.
+        "kind": None,
+        "class_type": ct,
+        "evidence": "unknown_node",
+        "suggested_kind": _suggest_output_kind(ct, videoish),
+    }
+
+
+def detect_output_nodes(workflow: dict[str, Any]) -> list[dict[str, Any]]:
+    """Infer output nodes of an untagged workflow from its sinks.
+
+    Exact registry classes (SaveImage, VHS_VideoCombine…) count whether or
+    not something downstream consumes them (a SaveVideo feeding a
+    cache-cleanup tail is still the output). Every OTHER class at an output
+    position is an *unknown candidate*: kind stays null, the import page
+    asks the user to designate the real output node(s) and their media
+    type, and the workflow stays pending until then (HEL-638). Sinks with
+    no save features only become candidates when the graph has no trusted
+    output at all — next to a real saver they are utility tails.
+    """
+    if not isinstance(workflow, dict):
+        return []
+    consumers = _consumers(workflow)
+    videoish = _video_semantics(workflow)
+    registry_outputs: list[dict[str, Any]] = []
+    candidates: list[dict[str, Any]] = []
+    seen: set[str] = set()
+
+    def _is_wiring(ct: str) -> bool:
+        return (
+            not ct
+            or ct in _SOURCE_ONLY_CLASSES
+            or ct in _NON_OUTPUT_CLASSES
+            or ct.startswith("Empty")
+        )
+
+    # 1) Trusted registry outputs at sink positions.
+    for nid, node in _sinks(workflow, consumers):
+        ct = str(node.get("class_type") or "")
+        if ct in IMAGE_OUTPUT_CLASSES or ct in VIDEO_OUTPUT_CLASSES:
+            registry_outputs.append(
+                {
+                    "nodeId": nid,
+                    "label": _title_of(node) or ct,
+                    "role": None,
+                    "kind": "video" if ct in VIDEO_OUTPUT_CLASSES else "image",
+                    "class_type": ct,
+                    "evidence": "registry",
+                }
+            )
+            seen.add(nid)
+
+    # 2) Registry output classes consumed by other nodes are outputs too.
+    for nid, node in sorted(
+        ((str(k), v) for k, v in workflow.items() if isinstance(v, dict)),
+        key=lambda kv: _node_sort_key(kv[0]),
+    ):
+        ct = str(node.get("class_type") or "")
+        if nid in seen or ct not in (IMAGE_OUTPUT_CLASSES | VIDEO_OUTPUT_CLASSES):
+            continue
+        registry_outputs.append(
+            {
+                "nodeId": nid,
+                "label": _title_of(node) or ct,
+                "role": None,
+                "kind": "video" if ct in VIDEO_OUTPUT_CLASSES else "image",
+                "class_type": ct,
+                "evidence": "registry",
+            }
+        )
+        seen.add(nid)
+
+    # 3) Unknown sink candidates. Save-looking sinks always need mapping;
+    # feature-less sinks only when nothing trusted exists (utility tails
+    # next to a real saver stay invisible).
+    has_trusted = bool(registry_outputs)
+    for nid, node in _sinks(workflow, consumers):
+        ct = str(node.get("class_type") or "")
+        if nid in seen or _is_wiring(ct) or ct in (IMAGE_OUTPUT_CLASSES | VIDEO_OUTPUT_CLASSES):
+            continue
+        if _unknown_sink_looks_like_save(node, workflow) or not has_trusted:
+            candidates.append(_unknown_output_entry(nid, node, workflow, videoish))
+            seen.add(nid)
+
+    # 4) Unknown save-looking nodes that something consumes (a custom saver
+    # feeding a cleanup tail is still an output candidate). Only concrete
+    # save widgets count here — decode-fed media links are ubiquitous among
+    # mid-graph transforms (CreateVideo & co.) and never mark an output.
+    for nid, node in sorted(
+        ((str(k), v) for k, v in workflow.items() if isinstance(v, dict)),
+        key=lambda kv: _node_sort_key(kv[0]),
+    ):
+        ct = str(node.get("class_type") or "")
+        if nid in seen or _is_wiring(ct) or ct in (IMAGE_OUTPUT_CLASSES | VIDEO_OUTPUT_CLASSES):
+            continue
+        if _node_has_save_widget(node):
+            candidates.append(_unknown_output_entry(nid, node, workflow, videoish))
+            seen.add(nid)
+
+    results = registry_outputs + candidates
+    results.sort(key=lambda r: _node_sort_key(r["nodeId"]))
+    return results
+
+
+# Title heuristics the studio form applies to tagged (Input:…) slots; the
+# classifier must judge a workflow the same way the form renders it.
+_TAGGED_FIRST_RE = re.compile(r"first|start|首帧", re.IGNORECASE)
+_TAGGED_LAST_RE = re.compile(r"last|end|尾帧", re.IGNORECASE)
+_TAGGED_MASK_RE = re.compile(r"mask|遮罩", re.IGNORECASE)
+
+
+def _slot_effective_role(entry: dict[str, Any]) -> str | None:
+    """The role the generate form will act on for this schema entry."""
+    kind = str(entry.get("kind") or "")
+    if kind == "image_list":
+        return "reference_image"
+    role = normalize_input_role(entry.get("role"))
+    if entry.get("auto") or kind not in ("image", "image_url"):
+        return role
+    label = str(entry.get("label") or "")
+    if _TAGGED_MASK_RE.search(label):
+        return "mask"
+    if _TAGGED_FIRST_RE.search(label):
+        return "first_frame"
+    if _TAGGED_LAST_RE.search(label):
+        return "last_frame"
+    return role
+
+
+def classify_usage(workflow: dict[str, Any]) -> dict[str, Any]:
+    """Judge a workflow's usage from graph evidence (HEL-636 §2).
+
+    Returns ``usage`` plus everything the import confirm page shows:
+    ``ambiguous`` (needs a human decision), ``needs_mapping`` (unknown
+    output nodes), ``problem`` (Chinese reason when usage is None) and
+    ``evidence`` (output nodes, image/video slots, summary lines). Never
+    looks at file names, model names or fixed node ids.
+    """
+    inputs = parse_dynamic_inputs(workflow) if isinstance(workflow, dict) else []
+    outputs = parse_dynamic_outputs(workflow)
+    media_outputs = [o for o in outputs if o.get("kind") in ("image", "video")]
+    unknown_outputs = [o for o in outputs if o.get("evidence") == "unknown_node"]
+    out_kinds = sorted({o["kind"] for o in media_outputs})
+
+    image_slots: list[dict[str, Any]] = []
+    video_slots: list[dict[str, Any]] = []
+    for entry in inputs:
+        kind = str(entry.get("kind") or "")
+        if kind in ("image", "image_list", "image_url"):
+            image_slots.append(
+                {
+                    "nodeId": entry.get("nodeId"),
+                    "label": entry.get("label"),
+                    "kind": kind,
+                    "role": _slot_effective_role(entry),
+                }
+            )
+        elif kind == "video":
+            video_slots.append(
+                {
+                    "nodeId": entry.get("nodeId"),
+                    "label": entry.get("label"),
+                    "kind": kind,
+                    "role": normalize_input_role(entry.get("role")),
+                }
+            )
+
+    effective = [s["role"] or "image" for s in image_slots if s["role"] != "mask"]
+    bulk = [r for r in effective if r in (None, "image")]
+    has_frame = any(r in ("first_frame", "last_frame") for r in effective)
+    has_ref_group = any(s["kind"] == "image_list" for s in image_slots)
+
+    summary: list[str] = []
+    for o in media_outputs:
+        zh = "图片" if o["kind"] == "image" else "视频"
+        summary.append(f"输出：节点 {o['nodeId']}（{o.get('class_type') or o['label']}）→ {zh}")
+    if unknown_outputs:
+        names = "、".join(
+            f"节点 {o['nodeId']}（{o.get('class_type') or '?'}）" for o in unknown_outputs[:4]
+        )
+        summary.append(f"存在无法识别的输出节点：{names}，需人工指定输出节点及媒体类型")
+    for s in image_slots:
+        if s["role"] != "mask":
+            summary.append(f"图片输入：节点 {s['nodeId']}（{s['label']}）")
+    if video_slots:
+        summary.append("含视频输入槽（本版本不支持参考视频上传）")
+
+    usage: str | None = None
+    ambiguous = False
+    problem: str | None = None
+    if not out_kinds and not unknown_outputs:
+        problem = (
+            "未在图中找到输出节点（SaveImage / 视频合成等），"
+            "请确认导出的是 API 格式且包含保存节点"
+        )
+    elif unknown_outputs:
+        # HEL-638: any unknown custom output node keeps the workflow
+        # pending — no name-based guessing, and picking a usage alone must
+        # not bypass the output-node designation.
+        names = "、".join(
+            f"节点 {o['nodeId']}（{o.get('class_type') or '?'}）" for o in unknown_outputs[:4]
+        )
+        ambiguous = True
+        problem = (
+            f"存在无法识别的输出节点（{names}），"
+            "需人工指定实际输出节点及其媒体类型（图片/视频）后才能保存启用"
+        )
+    elif len(out_kinds) > 1:
+        ambiguous = True
+        problem = "同一工作流同时输出图片和视频，需人工选择主用途"
+    elif len(out_kinds) == 1:
+        if out_kinds[0] == "image":
+            usage = "image2image" if bulk else "text2image"
+        elif has_ref_group or len(bulk) >= 2:
+            usage = "ref2video"
+        elif has_frame and not bulk:
+            usage = "image2video"
+        elif not effective:
+            usage = "text2video"
+        else:
+            ambiguous = True
+            problem = "视频工作流中的单张图片输入无法判定是首帧还是参考图，需人工确认"
+
+    return {
+        "usage": usage,
+        "ambiguous": ambiguous,
+        "needs_mapping": bool(unknown_outputs),
+        "problem": problem,
+        "evidence": {
+            "outputs": outputs,
+            "image_slots": image_slots,
+            "video_slots": video_slots,
+            "summary": summary,
+        },
+        "usable_usage": list(USAGE_VALUES),
+    }

calliope-backend/src/calliope/comfyui/patcher.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import copy
 from typing import Any
 
-from calliope.comfyui.registry import class_to_patch_field
+from calliope.comfyui.registry import IMAGE_CLASSES, class_to_patch_field
 
 # Input keys of the form "<nodeId>@<widget>" target one named widget on a
 # node (auto-detected inputs: KSampler seed/steps/cfg, latent width/height…).
@@ -38,6 +38,70 @@ def resolve_patch_field(node: dict[str, Any]) -> str:
     )
 
 
+def _next_node_id(workflow: dict[str, Any]) -> str:
+    numeric = [int(k) for k in workflow if str(k).isdigit()]
+    return str(max(numeric, default=0) + 1)
+
+
+def apply_image_group(
+    workflow: dict[str, Any], node_id: str, group: str, paths: list[str]
+) -> None:
+    """Rewire an Autogrow image group to exactly ``paths``, in order.
+
+    ``<group>.<prefix>0 … N-1`` each get their own LoadImage: the workflow's
+    existing ones are reused in slot order, extra ones are clones of the
+    first, and slots/loaders left over from the export are removed so no
+    stale image reaches ComfyUI.
+    """
+    from calliope.comfyui.parser import image_group_prefix, image_group_slots
+
+    node = workflow.get(node_id)
+    if not isinstance(node, dict):
+        return
+    prefix = image_group_prefix(node, group)
+    if prefix is None:
+        return
+    label = "参考图"
+    inputs = dict(node.get("inputs") or {})
+    slots = image_group_slots(node, group, prefix)
+    loaders: list[str] = []
+    for _n, name, link in slots:
+        inputs.pop(name, None)
+        if isinstance(link, list) and len(link) == 2:
+            src = workflow.get(str(link[0]))
+            if isinstance(src, dict) and src.get("class_type") in IMAGE_CLASSES:
+                loaders.append(str(link[0]))
+    if not loaders:
+        return
+    template = copy.deepcopy(workflow[loaders[0]])
+
+    still_used: set[str] = set()
+    for nid, other in workflow.items():
+        if nid == node_id or not isinstance(other, dict):
+            continue
+        for val in (other.get("inputs") or {}).values():
+            if isinstance(val, list) and len(val) == 2:
+                still_used.add(str(val[0]))
+    for nid in loaders[len(paths):]:
+        if nid not in still_used and nid not in loaders[: len(paths)]:
+            workflow.pop(nid, None)
+
+    for i, path in enumerate(paths):
+        if i < len(loaders):
+            nid = loaders[i]
+            loader = workflow[nid]
+        else:
+            nid = _next_node_id(workflow)
+            loader = copy.deepcopy(template)
+        loader_inputs = dict(loader.get("inputs") or {})
+        loader_inputs["image"] = path
+        loader["inputs"] = loader_inputs
+        loader["_meta"] = {**(loader.get("_meta") or {}), "title": f"{label} {i + 1}"}
+        workflow[nid] = loader
+        inputs[f"{group}.{prefix}{i}"] = [nid, 0]
+    node["inputs"] = inputs
+
+
 def patch_workflow(
     base: dict[str, Any],
     values_by_node_id: dict[str, Any],
@@ -54,6 +118,15 @@ def patch_workflow(
         if not isinstance(node, dict):
             continue
         inputs = dict(node.get("inputs") or {})
+        if field is not None and field not in inputs and any(
+            k.startswith(f"{field}.") for k in inputs
+        ):
+            paths = [value] if isinstance(value, str) else value
+            if isinstance(paths, list):
+                clean = [p for p in paths if isinstance(p, str) and p.strip()]
+                if clean:
+                    apply_image_group(patched, key, field, clean)
+            continue
         if field is None:
             field = resolve_patch_field(node)
         elif isinstance(inputs.get(field), list):

calliope-backend/src/calliope/comfyui/registry.py

@@ -30,7 +30,8 @@ VIDEO_OUTPUT_CLASSES = frozenset(
     {"VHS_VideoCombine", "SaveVideo", "VideoOutput", "AnimateDiffCombine"}
 )
 IMAGE_OUTPUT_CLASSES = frozenset(
-    {"SaveImage", "PreviewImage", "SaveImageWebsocket", "ETN_SendImageWebSocket"}
+    {"SaveImage", "PreviewImage", "SaveImageWebsocket", "ETN_SendImageWebSocket",
+     "SaveImageAdvanced"}
 )
 
 

calliope-backend/src/calliope/comfyui/roles.py

@@ -30,6 +30,27 @@ OUTPUT_ROLE_ALIASES: dict[str, frozenset[str]] = {
     "video": frozenset({"video", "vid"}),
 }
 
+# The five workflow usages the studio distinguishes (HEL-636). Derived from
+# graph evidence only (output media + consumed image inputs) — never from
+# file names, model names or fixed node ids.
+WorkflowUsage = str
+USAGE_VALUES: tuple[str, ...] = (
+    "text2image",
+    "image2image",
+    "text2video",
+    "image2video",
+    "ref2video",
+)
+
+
+def usage_to_kind(usage: str | None) -> str | None:
+    """Output media kind of a usage (image / video); None when unknown."""
+    if usage in ("text2image", "image2image"):
+        return "image"
+    if usage in ("text2video", "image2video", "ref2video"):
+        return "video"
+    return None
+
 
 def parse_title_tag(title: str) -> tuple[str | None, str | None, str]:
     """Return (kind, role, label) from a Comfy node title.

calliope-backend/src/calliope/comfyui/smart_fill.py

@@ -158,8 +158,12 @@ def smart_fill_inputs(
                         break
 
     if ref_images:
-        for inp, path in zip(ref_image_slots(inputs), ref_images):
-            values[str(inp["nodeId"])] = path
+        group = next((inp for inp in inputs if inp.get("kind") == "image_list"), None)
+        if group is not None:
+            values[str(group["nodeId"])] = list(ref_images[: group.get("max") or len(ref_images)])
+        else:
+            for inp, path in zip(ref_image_slots(inputs), ref_images):
+                values[str(inp["nodeId"])] = path
 
     if ref_videos:
         for inp, path in zip(ref_video_slots(inputs), ref_videos):

calliope-backend/src/calliope/comfyui/validate.py

@@ -0,0 +1,127 @@
+"""Check and coerce studio form values against a workflow's input schema."""
+
+from __future__ import annotations
+
+import math
+from pathlib import Path
+from typing import Any
+
+
+def _fmt(n: Any) -> str:
+    return f"{n:g}" if isinstance(n, float) else str(n)
+
+
+def validate_input_values(
+    schema: list[dict[str, Any]], values: dict[str, Any]
+) -> tuple[dict[str, Any], list[str]]:
+    """Return ``(clean_values, errors)``.
+
+    Numbers are coerced to int/float per the schema entry (``integer``,
+    ``min``/``max``); select values must be one of ``options``. Blank values
+    are dropped so the workflow keeps its own value. Keys not in the schema
+    pass through untouched (other callers patch extra keys, e.g. uploads).
+    Auto-detected required entries (positive prompt, wired image slots,
+    reference-image lists) must be present — tagged workflows mark every
+    input required, and blank ones fall back to the workflow's value.
+    """
+    by_key = {str(e.get("nodeId")): e for e in schema if isinstance(e, dict)}
+    clean: dict[str, Any] = {}
+    errors: list[str] = []
+    for key, raw in (values or {}).items():
+        entry = by_key.get(str(key))
+        if entry is None:
+            clean[key] = raw
+            continue
+        if raw is None or (isinstance(raw, str) and not raw.strip()):
+            continue
+        label = str(entry.get("label") or key)
+        kind = entry.get("kind")
+        if kind == "number":
+            if isinstance(raw, bool):
+                errors.append(f"「{label}」必须是数字")
+                continue
+            try:
+                num = float(raw)
+            except (TypeError, ValueError):
+                errors.append(f"「{label}」必须是数字")
+                continue
+            if not math.isfinite(num):
+                errors.append(f"「{label}」必须是有限数字")
+                continue
+            if entry.get("integer"):
+                if num != int(num):
+                    errors.append(f"「{label}」必须是整数")
+                    continue
+                value: int | float = int(num)
+            else:
+                value = int(num) if isinstance(raw, int) else num
+            lo, hi = entry.get("min"), entry.get("max")
+            if lo is not None and value < lo:
+                errors.append(f"「{label}」不能小于 {_fmt(lo)}")
+                continue
+            if hi is not None and value > hi:
+                errors.append(f"「{label}」不能大于 {_fmt(hi)}")
+                continue
+            clean[key] = value
+        elif kind == "image_list":
+            paths = [raw] if isinstance(raw, str) else raw
+            if not isinstance(paths, list) or not all(isinstance(p, str) for p in paths):
+                errors.append(f"「{label}」的取值格式不对，请重新上传")
+                continue
+            paths = [p for p in paths if p.strip()]
+            hi = entry.get("max")
+            if hi is not None and len(paths) > hi:
+                errors.append(f"{label}最多 {hi} 张（当前 {len(paths)} 张），请删除多余的图片")
+                continue
+            bad = [
+                f"{label} {i}：{msg}"
+                for i, p in enumerate(paths, 1)
+                if (msg := _image_file_problem(p))
+            ]
+            if bad:
+                errors.extend(bad)
+                continue
+            if paths:
+                clean[key] = paths
+        elif kind == "select":
+            options = entry.get("options") or []
+            if options and raw not in options:
+                errors.append(f"「{label}」的取值「{raw}」不在工作流支持的选项中")
+                continue
+            clean[key] = raw
+        else:
+            clean[key] = raw
+    for key, entry in by_key.items():
+        required = entry.get("auto") and entry.get("required")
+        label = entry.get("label") or key
+        if required and entry.get("role") == "prompt":
+            has_fallback = str(entry.get("defaultValue") or "").strip() != ""
+            if key not in clean and not has_fallback:
+                errors.append(f"请填写「{label}」")
+        elif required and entry.get("kind") == "image_list":
+            lo = entry.get("min") or 1
+            if len(clean.get(key) or []) < lo and not any(label in e for e in errors):
+                errors.append(f"需要至少 {lo} 张{label}")
+        elif required and entry.get("kind") == "image" and entry.get("role") != "mask":
+            if key not in clean:
+                errors.append(f"请上传{label}")
+    return clean, errors
+
+
+_IMAGE_EXTS = frozenset({".png", ".jpg", ".jpeg", ".webp"})
+
+
+def _image_file_problem(path: str) -> str | None:
+    """Why ``path`` cannot be a studio reference image (None = fine)."""
+    from calliope import config
+
+    target = Path(path)
+    if target.suffix.lower() not in _IMAGE_EXTS:
+        return "格式不支持，请使用 PNG / JPG / WebP"
+    try:
+        target.resolve().relative_to(config.settings.assets_dir.resolve())
+    except (ValueError, OSError):
+        return "只能使用在本页上传或从生成结果选入的图片"
+    if not target.is_file():
+        return "文件已不存在，请重新上传"
+    return None

calliope-backend/src/calliope/db.py

@@ -121,7 +121,11 @@ CREATE TABLE IF NOT EXISTS workflows (
     description TEXT,
     prompt_profile TEXT NOT NULL DEFAULT 'prose',
     is_enabled INTEGER NOT NULL DEFAULT 1,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    usage TEXT,
+    usage_source TEXT,
+    output_map TEXT,
+    output_map_source TEXT
 );
 
 CREATE TABLE IF NOT EXISTS jobs (
@@ -138,7 +142,9 @@ CREATE TABLE IF NOT EXISTS jobs (
     created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
     started_at TIMESTAMP,
     completed_at TIMESTAMP,
-    retry_count INTEGER NOT NULL DEFAULT 0
+    retry_count INTEGER NOT NULL DEFAULT 0,
+    comfy_prompt_id TEXT,
+    phase TEXT
 );
 
 CREATE TABLE IF NOT EXISTS agent_sessions (
@@ -336,6 +342,74 @@ def _sqlite_connect(path: Path) -> sqlite3.Connection:
     return sqlite3.connect(path)
 
 
+def _backfill_workflow_usage(conn: sqlite3.Connection) -> None:
+    """HEL-636: settle `workflows.usage` for rows that still have none.
+
+    Determinate graphs get ``usage='auto'``; indeterminate ones keep NULL
+    and are disabled (they must be confirmed on the connections page before
+    they can generate). Rows the user already confirmed (usage_source='user')
+    never pass through here again — their usage is set, so the WHERE clause
+    skips them. Old jobs / history / `kind` semantics are untouched.
+    """
+    from calliope.comfyui.parser import classify_usage
+
+    rows = conn.execute(
+        "SELECT id, workflow_json FROM workflows WHERE usage IS NULL OR usage = ''"
+    ).fetchall()
+    for row in rows:  # plain connect — positional access
+        try:
+            workflow = json.loads(row[1])
+        except (json.JSONDecodeError, TypeError):
+            workflow = None
+        judgment = classify_usage(workflow) if isinstance(workflow, dict) else {}
+        if judgment.get("usage"):
+            conn.execute(
+                "UPDATE workflows SET usage = ?, usage_source = 'auto' WHERE id = ?",
+                (judgment["usage"], row[0]),
+            )
+        else:
+            conn.execute(
+                "UPDATE workflows SET is_enabled = 0 WHERE id = ? AND usage IS NULL",
+                (row[0],),
+            )
+
+
+def _backfill_workflow_output_map(conn: sqlite3.Connection) -> None:
+    """HEL-638: settle the output-node mapping for existing rows.
+
+    Rows the user already mapped (output_map_source='user') are never
+    touched. Determinate graphs get the trusted ``auto`` map. Rows whose
+    graph now contains unknown custom output candidates get no auto map and
+    are parked disabled — the usage decision survives, but until the user
+    designates the output nodes the workflow must not generate.
+    """
+    from calliope.comfyui.output_map import auto_output_map, needs_user_output_map
+
+    rows = conn.execute(
+        "SELECT id, workflow_json FROM workflows"
+        " WHERE output_map_source IS NULL OR output_map_source != 'user'"
+    ).fetchall()
+    for row in rows:
+        try:
+            workflow = json.loads(row[1])
+        except (json.JSONDecodeError, TypeError):
+            workflow = None
+        if not isinstance(workflow, dict):
+            continue
+        if needs_user_output_map(workflow):
+            conn.execute(
+                "UPDATE workflows SET output_map = NULL, output_map_source = NULL,"
+                " is_enabled = 0 WHERE id = ?",
+                (row[0],),
+            )
+        else:
+            conn.execute(
+                "UPDATE workflows SET output_map = ?, output_map_source = 'auto'"
+                " WHERE id = ?",
+                (json.dumps(auto_output_map(workflow)), row[0]),
+            )
+
+
 async def migrate_db(db_path: Path) -> None:
     db_path.parent.mkdir(parents=True, exist_ok=True)
     conn = sqlite3.connect(db_path)
@@ -381,6 +455,23 @@ async def migrate_db(db_path: Path) -> None:
         # comfyui_endpoints id). Dangling ids are tolerated — enqueue falls
         # back to the active connection.
         conn.execute("ALTER TABLE workflows ADD COLUMN endpoint_id TEXT")
+    # HEL-636: five-way usage (text2image…ref2video). NULL = pending human
+    # confirmation; `kind` keeps meaning output media for history/paths.
+    if "usage" not in cols:
+        conn.execute("ALTER TABLE workflows ADD COLUMN usage TEXT")
+    if "usage_source" not in cols:
+        conn.execute("ALTER TABLE workflows ADD COLUMN usage_source TEXT")
+    # HEL-638: explicit output-node designation for unknown custom output
+    # nodes ({nodeId, kind} JSON + 'user'|'auto'). Idempotent backfill
+    # below parks unmapped unknown-output rows (disabled) like usage does.
+    if "output_map" not in cols:
+        conn.execute("ALTER TABLE workflows ADD COLUMN output_map TEXT")
+    if "output_map_source" not in cols:
+        conn.execute("ALTER TABLE workflows ADD COLUMN output_map_source TEXT")
+    # Idempotent backfill: pending rows are re-judged on every boot (parser
+    # upgrades can settle them); confirmed rows are never touched.
+    _backfill_workflow_usage(conn)
+    _backfill_workflow_output_map(conn)
     scene_cols = {r[1] for r in conn.execute("PRAGMA table_info(scenes)").fetchall()}
     if "location_id" not in scene_cols:
         conn.execute("ALTER TABLE scenes ADD COLUMN location_id INTEGER")
@@ -420,6 +511,13 @@ async def migrate_db(db_path: Path) -> None:
             WHERE kind = 'video' AND scene_id IS NOT NULL AND clip_id IS NULL
             """
         )
+    # HEL-627: the ComfyUI prompt id a job was accepted under, and where the
+    # job really is (connecting / comfy_queued / comfy_running / saving;
+    # finished = real results saved; dry_run = placeholder, ComfyUI never called).
+    if "comfy_prompt_id" not in job_cols:
+        conn.execute("ALTER TABLE jobs ADD COLUMN comfy_prompt_id TEXT")
+    if "phase" not in job_cols:
+        conn.execute("ALTER TABLE jobs ADD COLUMN phase TEXT")
     # Build Scene's per-scene sessions: origin stamps WHERE a blind session was
     # born ('chat' = user-created in AI Canvas, 'scene' = auto-created by the
     # Build Scene rail). The session list excludes origin='scene' so scene

calliope-backend/src/calliope/models/schemas.py

@@ -198,14 +198,35 @@ class ExpandClipsRequest(BaseModel):
     clip_cap: int | None = None
 
 
+WorkflowUsageKind = Literal[
+    "text2image",
+    "image2image",
+    "text2video",
+    "image2video",
+    "ref2video",
+]
+
+
 class WorkflowCreate(BaseModel):
     name: str = Field(..., min_length=1)
-    kind: Literal["image", "video"] = "image"
+    kind: Literal["image", "video"] | None = None
     workflow_json: dict[str, Any]
     description: str | None = None
     prompt_profile: Literal["prose", "minimax_h3_ref"] | None = None
     # Optional binding to a ComfyUI connection id (settings.comfyui_endpoints).
     endpoint_id: str | None = None
+    # HEL-636: five-way usage. Given by the import confirm page (possibly a
+    # user correction of the auto judgment); when absent it is classified
+    # from the graph, and indeterminate workflows stay pending (disabled).
+    usage: WorkflowUsageKind | None = None
+    usage_source: Literal["auto", "user"] | None = None
+    # Schema corrected on the confirm page (manual role overrides included).
+    input_schema: list[dict[str, Any]] | None = None
+    # HEL-638: explicit output-node designation for unknown custom output
+    # nodes — [{nodeId, kind: image|video}]. Required before a workflow
+    # with unknown outputs can be enabled or generated.
+    output_map: list[dict[str, Any]] | None = None
+    output_map_source: Literal["auto", "user"] | None = None
 
 
 class WorkflowUpdate(BaseModel):
@@ -215,6 +236,13 @@ class WorkflowUpdate(BaseModel):
     prompt_profile: Literal["prose", "minimax_h3_ref"] | None = None
     is_enabled: bool | None = None
     endpoint_id: str | None = None
+    usage: WorkflowUsageKind | None = None
+    usage_source: Literal["auto", "user"] | None = None
+    input_schema: list[dict[str, Any]] | None = None
+    # HEL-638: set/replace the user output mapping; an explicit empty list
+    # resets the workflow to pending confirmation.
+    output_map: list[dict[str, Any]] | None = None
+    output_map_source: Literal["auto", "user"] | None = None
 
 
 class WorkflowAnalyze(BaseModel):

calliope-backend/src/calliope/queue/manager.py

@@ -19,7 +19,8 @@ class QueueManager:
         conn = get_db(config.settings.db_path)
         try:
             cur = conn.execute(
-                "UPDATE jobs SET status = 'pending', started_at = NULL WHERE status = 'running'"
+                "UPDATE jobs SET status = 'pending', started_at = NULL, phase = NULL, "
+                "comfy_prompt_id = NULL WHERE status = 'running'"
             )
             conn.commit()
             return cur.rowcount
@@ -105,6 +106,20 @@ class QueueManager:
         finally:
             conn.close()
 
+    def set_phase(self, job_id: int, phase: str, comfy_prompt_id: str | None = None) -> None:
+        conn = get_db(config.settings.db_path)
+        try:
+            if comfy_prompt_id:
+                conn.execute(
+                    "UPDATE jobs SET phase = ?, comfy_prompt_id = ? WHERE id = ?",
+                    (phase, comfy_prompt_id, job_id),
+                )
+            else:
+                conn.execute("UPDATE jobs SET phase = ? WHERE id = ?", (phase, job_id))
+            conn.commit()
+        finally:
+            conn.close()
+
     def mark_done(self, job_id: int, output_paths: list[str]) -> None:
         conn = get_db(config.settings.db_path)
         try:
@@ -142,7 +157,7 @@ class QueueManager:
             conn.execute(
                 """
                 UPDATE jobs SET status = 'pending', error = NULL, started_at = NULL,
-                completed_at = NULL WHERE id = ?
+                completed_at = NULL, phase = NULL, comfy_prompt_id = NULL WHERE id = ?
                 """,
                 (job_id,),
             )

calliope-backend/src/calliope/queue/worker.py

@@ -8,9 +8,12 @@ from typing import Any
 
 from pathlib import Path as _fs_path
 
+import httpx
+
 from calliope import config
 from calliope.comfyui.client import ComfyUIClient
 from calliope.comfyui.dry_run import write_placeholder_mp4, write_placeholder_png
+from calliope.comfyui.lint import blocking_problem
 from calliope.comfyui.parser import parse_dynamic_inputs
 from calliope.comfyui.patcher import patch_workflow
 from calliope.comfyui.roles import input_has_role
@@ -26,12 +29,22 @@ def _comfy_messages(messages: list[Any]) -> str:
     """Pull the readable part out of ComfyUI's history status messages."""
     parts: list[str] = []
     for msg in messages:
-        if isinstance(msg, (list, tuple)) and len(msg) == 2 and msg[0] == "execution_error":
-            body = msg[1] if isinstance(msg[1], dict) else {}
-            node = body.get("node_type") or body.get("node_id") or "?"
+        if not (isinstance(msg, (list, tuple)) and len(msg) == 2):
+            continue
+        body = msg[1] if isinstance(msg[1], dict) else {}
+        node = body.get("node_type") or body.get("node_id") or "?"
+        if msg[0] == "execution_error":
             reason = body.get("exception_message") or body.get("exception_type") or "未知错误"
             parts.append(f"节点 {node}：{str(reason).strip()}")
-    return "；".join(parts) or str(messages)[:500]
+        elif msg[0] == "execution_interrupted":
+            parts.append(f"任务在节点 {node} 处被中断（在 ComfyUI 端被取消，或 ComfyUI 已重启）")
+    return "；".join(parts) or "ComfyUI 未给出原因"
+
+
+# /queue lookups that must agree before a prompt counts as lost, and /history
+# or /queue request failures in a row before the job gives up.
+_MISSING_POLLS_LIMIT = 3
+_POLL_ERRORS_LIMIT = 5
 
 
 class _CancelledByUser(RuntimeError):
@@ -91,6 +104,7 @@ class QueueWorker:
                         job_payload = json.loads(job["payload_json"] or "{}")
                     except (json.JSONDecodeError, TypeError):
                         job_payload = {}
+                    row = queue_manager.get_job(job["id"]) or {}
                     await event_bus.publish(
                         "job.completed",
                         {
@@ -102,6 +116,9 @@ class QueueWorker:
                             # Source stamp lets the UI attribute sandbox jobs
                             # to their enqueuer without racing the jobs poll.
                             "source": job_payload.get("source"),
+                            "comfy_prompt_id": row.get("comfy_prompt_id"),
+                            # Placeholder output — ComfyUI was never called.
+                            "dry_run": row.get("phase") == "dry_run",
                             "message": f"{self._job_label(job)} · {len(outputs)} file(s)",
                         },
                     )
@@ -167,8 +184,10 @@ class QueueWorker:
         client = ComfyUIClient(base_url, headers=headers)
         try:
             if use_dry:
+                queue_manager.set_phase(job["id"], "dry_run")
                 return await self._dry_run(job, payload)
 
+            queue_manager.set_phase(job["id"], "connecting")
             healthy = await client.health()
             if not healthy:
                 raise RuntimeError(
@@ -177,11 +196,24 @@ class QueueWorker:
                 )
 
             workflow_id = job.get("workflow_id") or payload.get("workflow_id")
-            workflow = self._load_workflow(workflow_id)
-            if not workflow:
+            workflow_row = self._load_workflow_row(workflow_id)
+            if not workflow_row:
                 raise RuntimeError(
                     "找不到该任务使用的工作流（可能已被删除），请重新选择工作流后再生成"
                 )
+            workflow = workflow_row["workflow_json"]
+            broken = blocking_problem(workflow)
+            if broken:
+                raise RuntimeError(broken)
+
+            # HEL-638: harvest only the confirmed output nodes. A workflow
+            # with unknown custom outputs and no user mapping must not run.
+            node_kinds = self._output_node_kinds(workflow_row)
+            if node_kinds is None:
+                raise RuntimeError(
+                    "该工作流含无法识别的自定义输出节点，尚未指定输出节点及媒体类型，"
+                    "请到「ComfyUI 连接」页确认后再生成"
+                )
 
             input_values = payload.get("input_values") or {}
             if payload.get("continue_source") and kind == "video":
@@ -191,21 +223,60 @@ class QueueWorker:
             patched = patch_workflow(workflow, input_values)
             patched = await client.prepare_media_inputs(patched)
             prompt_id = await client.queue_prompt(patched)
+            queue_manager.set_phase(job["id"], "comfy_queued", prompt_id)
+            await event_bus.publish(
+                "job.progress",
+                {
+                    "job_id": job["id"],
+                    "prompt_id": prompt_id,
+                    "phase": "comfy_queued",
+                    "message": f"ComfyUI 已接收任务（ID {prompt_id}）",
+                },
+            )
 
             history = await self._poll_history(client, prompt_id, job["id"])
             if not history:
                 if queue_manager.is_cancelled(job["id"]):
                     raise _CancelledByUser()
                 raise RuntimeError(
-                    "等待 ComfyUI 出结果超时：可在「设置 → 队列」调大超时，或到 ComfyUI 检查该任务"
+                    f"等待 ComfyUI 出结果超时（任务 ID {prompt_id}）：可在「设置 → 队列」调大超时，"
+                    "或到 ComfyUI 检查该任务"
                 )
 
             status = history.get("status") or {}
             if status.get("status_str") == "error" or status.get("completed") is False:
                 messages = status.get("messages") or []
-                raise RuntimeError(f"ComfyUI 执行出错：{_comfy_messages(messages)}")
+                raise RuntimeError(
+                    f"ComfyUI 执行出错（任务 ID {prompt_id}）：{_comfy_messages(messages)}"
+                )
 
-            outputs_meta = client.extract_outputs(history)
+            outputs_meta = client.extract_outputs(history, node_kinds=node_kinds)
+            saved = [m for m in outputs_meta if m.get("type") == "output"]
+            outputs_meta = saved or outputs_meta
+            if not outputs_meta:
+                checked = "、".join(sorted(node_kinds))
+                raise RuntimeError(
+                    f"ComfyUI 显示任务已结束（任务 ID {prompt_id}），但没有返回任何图片或视频，"
+                    "不算生成完成。已按输出映射检查节点：" f"{checked}；"
+                    "请到 ComfyUI 历史中核对该任务，并确认所指定的输出节点正确。"
+                )
+            mismatch = next(
+                (
+                    m
+                    for m in outputs_meta
+                    if m.get("media_kind") and m["media_kind"] != node_kinds.get(m["node_id"])
+                ),
+                None,
+            )
+            if mismatch:
+                want = node_kinds.get(mismatch["node_id"])
+                raise RuntimeError(
+                    f"输出节点 {mismatch['node_id']} 的媒体类型与映射不符"
+                    f"（映射为{'视频' if want == 'video' else '图片'}，"
+                    f"实际返回 {mismatch['filename']}），任务不算生成完成。"
+                    "请到「ComfyUI 连接」页修正该节点的媒体类型。"
+                )
+            queue_manager.set_phase(job["id"], "saving")
             dest_dir = config.settings.assets_dir / str(project_id) / kind
             dest_dir.mkdir(parents=True, exist_ok=True)
             paths: list[str] = []
@@ -221,6 +292,7 @@ class QueueWorker:
                 paths.append(str(dest))
 
             self._apply_outputs_to_entities(job, payload, paths)
+            queue_manager.set_phase(job["id"], "finished")
             return paths
         finally:
             await client.close()
@@ -360,6 +432,9 @@ class QueueWorker:
         # configurable (default 30 min) instead of a hardcoded 600 seconds.
         attempts = None if timeout <= 0 else int(timeout / interval)
         n = 0
+        phase = "comfy_queued"
+        missing = 0
+        errors = 0
         while attempts is None or n < attempts:
             n += 1
             if self._stop.is_set():
@@ -370,17 +445,51 @@ class QueueWorker:
             if queue_manager.is_cancelled(job_id):
                 await client.interrupt()
                 return None
-            history = await client.get_history(prompt_id)
-            if history:
-                return history
-            await asyncio.sleep(interval)
+            try:
+                history = await client.get_history(prompt_id)
+                if history:
+                    return history
+                where, ahead = await client.locate_prompt(prompt_id)
+            except httpx.HTTPError as exc:
+                errors += 1
+                if errors >= _POLL_ERRORS_LIMIT:
+                    raise RuntimeError(
+                        f"连续 {errors} 次无法从 ComfyUI 查询任务状态（任务 ID {prompt_id}）："
+                        f"{exc or type(exc).__name__}"
+                    ) from exc
+                await asyncio.sleep(interval)
+                continue
+            errors = 0
+            if where == "missing":
+                missing += 1
+                if missing >= _MISSING_POLLS_LIMIT:
+                    raise RuntimeError(
+                        f"ComfyUI 的队列和历史里都找不到该任务（任务 ID {prompt_id}），"
+                        "可能 ComfyUI 已重启或任务被清除，没有产出结果"
+                    )
+            else:
+                missing = 0
+            if where == "running":
+                phase = "comfy_running"
+                message = f"ComfyUI 正在执行（任务 ID {prompt_id}）"
+            elif where == "pending":
+                phase = "comfy_queued"
+                message = f"ComfyUI 排队中，前面还有 {ahead} 个任务（任务 ID {prompt_id}）"
+            else:
+                message = f"等待 ComfyUI 返回结果（任务 ID {prompt_id}）"
+            if job_id is not None:
+                queue_manager.set_phase(job_id, phase)
             await event_bus.publish(
                 "job.progress",
                 {
+                    "job_id": job_id,
                     "prompt_id": prompt_id,
-                    "message": f"Waiting on ComfyUI ({prompt_id[:8]}…)",
+                    "phase": phase,
+                    "queue_ahead": ahead if where == "pending" else None,
+                    "message": message,
                 },
             )
+            await asyncio.sleep(interval)
         return None
 
     def _mark_project_completed(self, project_id: int) -> None:
@@ -395,20 +504,45 @@ class QueueWorker:
         finally:
             conn.close()
 
-    def _load_workflow(self, workflow_id: int | None) -> dict[str, Any] | None:
+    def _load_workflow_row(self, workflow_id: int | None) -> dict[str, Any] | None:
         if not workflow_id:
             return None
         conn = get_db(config.settings.db_path)
         try:
             row = conn.execute(
-                "SELECT workflow_json FROM workflows WHERE id = ?", (workflow_id,)
+                "SELECT workflow_json, output_map, output_map_source FROM workflows"
+                " WHERE id = ?",
+                (workflow_id,),
             ).fetchone()
             if not row:
                 return None
-            return json.loads(row["workflow_json"])
+            return {
+                "workflow_json": json.loads(row["workflow_json"]),
+                "output_map": row["output_map"],
+                "output_map_source": row["output_map_source"],
+            }
         finally:
             conn.close()
 
+    @staticmethod
+    def _output_node_kinds(workflow_row: dict[str, Any]) -> dict[str, str] | None:
+        """Confirmed {nodeId: image|video} for this workflow, or None when
+        the outputs are not confirmed (unknown nodes, no user mapping)."""
+        from calliope.comfyui.output_map import mapping_problem, resolve_output_map
+
+        workflow = workflow_row["workflow_json"]
+        problem = mapping_problem(
+            workflow, workflow_row.get("output_map"), workflow_row.get("output_map_source")
+        )
+        if problem:
+            return None
+        entries, _source = resolve_output_map(
+            workflow_row.get("output_map"),
+            workflow_row.get("output_map_source"),
+            workflow,
+        )
+        return {str(e["nodeId"]): str(e["kind"]) for e in entries} or None
+
     def _job_label(self, job: dict[str, Any]) -> str:
         payload = json.loads(job.get("payload_json") or "{}")
         kind = job.get("kind") or "job"

calliope-backend/src/calliope/routers/comfyui.py

@@ -77,8 +77,11 @@ def _parsed_url(base_url: str) -> tuple[str, str]:
     url = (base_url or "").strip()
     if not url:
         raise HTTPException(status_code=400, detail="API 地址不能为空")
-    if "://" not in url:
-        url = f"http://{url}"
+    # HEL-619: the server validates format as strictly as the UI already
+    # does. A schemeless garbled string used to be silently prefixed with
+    # http:// and then reported as a DNS failure; it is a 400 format error.
+    if "://" not in url or any(ch.isspace() for ch in url):
+        raise HTTPException(status_code=400, detail="地址必须是 http:// 或 https:// 开头的有效 URL")
     parsed = urlparse(url)
     if parsed.scheme not in ("http", "https") or not parsed.hostname:
         raise HTTPException(status_code=400, detail="地址必须是 http:// 或 https:// 开头的有效 URL")
@@ -135,7 +138,12 @@ async def list_endpoints() -> dict[str, Any]:
 
 @router.post("/endpoints")
 async def create_endpoint(payload: EndpointIn) -> dict[str, Any]:
-    base_url, _host = _parsed_url(payload.base_url)
+    base_url, host = _parsed_url(payload.base_url)
+    # HEL-619: the same SSRF guard as the connectivity test applies on
+    # save — otherwise a blocked address can be stored and later probed by
+    # the worker path. Unresolvable hosts still pass (resolution happens
+    # again at probe time).
+    _assert_not_ssrf(host)
     incoming = [ep for ep in settings.comfyui_endpoints or []]
     incoming.append(payload.model_dump() | {"base_url": base_url})
     try:
@@ -151,7 +159,8 @@ async def update_endpoint(endpoint_id: str, payload: EndpointPatch) -> dict[str,
     _stored_endpoint(endpoint_id)
     base_url = payload.base_url
     if base_url is not None:
-        base_url, _host = _parsed_url(base_url)
+        base_url, host = _parsed_url(base_url)
+        _assert_not_ssrf(host)  # same save-time guard as create (HEL-619)
     patch = payload.model_dump(exclude_unset=True)
     if base_url is not None:
         patch["base_url"] = base_url

calliope-backend/src/calliope/routers/playground.py

@@ -13,6 +13,10 @@ from pydantic import BaseModel, Field
 
 from calliope import config
 from calliope.agent.prompts import item_reference_prompt
+from calliope.comfyui.lint import blocking_problem
+from calliope.comfyui.output_map import mapping_problem
+from calliope.comfyui.parser import effective_input_schema
+from calliope.comfyui.validate import validate_input_values
 from calliope.db import get_db, row_to_dict
 from calliope.events.bus import event_bus
 from calliope.queue.manager import queue_manager
@@ -332,7 +336,8 @@ async def generate(payload: PlaygroundGenerate) -> dict[str, Any]:
     try:
         pid = ensure_playground_project(conn)
         wf = conn.execute(
-            "SELECT id, kind, is_enabled FROM workflows WHERE id = ?",
+            "SELECT id, kind, is_enabled, workflow_json, input_schema, output_map,"
+            " output_map_source FROM workflows WHERE id = ?",
             (payload.workflow_id,),
         ).fetchone()
         if not wf:
@@ -344,16 +349,33 @@ async def generate(payload: PlaygroundGenerate) -> dict[str, Any]:
                 status_code=400, detail="该工作流已停用，请到「ComfyUI 连接」页启用后再生成"
             )
         kind = wf["kind"]
+        workflow_json = json.loads(wf["workflow_json"])
+        # HEL-638: a workflow with unknown custom output nodes must have a
+        # confirmed output mapping before anything is queued.
+        map_problem = mapping_problem(workflow_json, wf["output_map"], wf["output_map_source"])
+        if map_problem:
+            raise HTTPException(status_code=400, detail=map_problem)
+        schema = effective_input_schema(
+            json.loads(wf["input_schema"]) if wf["input_schema"] else [], workflow_json
+        )
     finally:
         conn.close()
 
+    broken = blocking_problem(workflow_json)
+    if broken:
+        raise HTTPException(status_code=400, detail=broken)
+
+    input_values, problems = validate_input_values(schema, payload.input_values)
+    if problems:
+        raise HTTPException(status_code=400, detail="参数有误：" + "；".join(problems))
+
     job = queue_manager.enqueue(
         project_id=pid,
         kind=kind,
         workflow_id=payload.workflow_id,
         scene_id=None,
         payload={
-            "input_values": payload.input_values,
+            "input_values": input_values,
             "source": payload.source,
             **({"endpoint_id": payload.endpoint_id} if payload.endpoint_id else {}),
         },

calliope-backend/src/calliope/routers/settings.py

@@ -107,7 +107,11 @@ async def update_settings(payload: SettingsUpdate) -> dict[str, Any]:
     if assignments_in is not None:
         settings.ensure_llm_profiles()
         ids = {p["id"] for p in settings.llm_profiles}
-        cleaned: dict[str, str | None] = {}
+        # HEL-619: per-role INCREMENTAL update. Rapid dropdown switches used
+        # to send whole cached snapshots that fully overwrote the map, so a
+        # stale snapshot could wipe a newer choice. Roles absent from the
+        # payload keep their stored value; a role sent as null is cleared.
+        cleaned: dict[str, str | None] = dict(settings.agent_llm_assignments or {})
         for role, pid in assignments_in.items():
             if role not in AGENT_LLM_ROLES:
                 continue

calliope-backend/src/calliope/routers/workflows.py

@@ -5,8 +5,22 @@ from typing import Any
 
 from fastapi import APIRouter, HTTPException
 
-from calliope.comfyui.parser import parse_dynamic_inputs, parse_dynamic_outputs
+from calliope.comfyui.lint import workflow_warnings
+from calliope.comfyui.output_map import (
+    auto_output_map,
+    load_output_map,
+    mapping_problem,
+    needs_user_output_map,
+    validate_output_map,
+)
+from calliope.comfyui.parser import (
+    classify_usage,
+    effective_input_schema,
+    parse_dynamic_inputs,
+    parse_dynamic_outputs,
+)
 from calliope.comfyui.profiles import detect_prompt_profile
+from calliope.comfyui.roles import usage_to_kind
 from calliope.config import settings
 from calliope.db import get_db, row_to_dict
 from calliope.models.schemas import WorkflowAnalyze, WorkflowCreate, WorkflowUpdate
@@ -17,12 +31,19 @@ router = APIRouter()
 def _serialize_workflow(row: Any) -> dict[str, Any]:
     data = row_to_dict(row)
     data["workflow_json"] = json.loads(data["workflow_json"])
-    data["input_schema"] = json.loads(data["input_schema"]) if data.get("input_schema") else []
-    if not data["input_schema"]:
-        # An empty stored schema is re-derived so untagged workflows still expose inputs.
-        data["input_schema"] = parse_dynamic_inputs(data["workflow_json"])
-    data["output_schema"] = json.loads(data["output_schema"]) if data.get("output_schema") else []
+    stored = json.loads(data["input_schema"]) if data.get("input_schema") else []
+    data["input_schema"] = effective_input_schema(stored, data["workflow_json"])
+    # Outputs are pure graph derivation (no manual overrides) — always fresh,
+    # so parser upgrades reach old rows without a re-import.
+    data["output_schema"] = parse_dynamic_outputs(data["workflow_json"])
     data["is_enabled"] = bool(data.get("is_enabled"))
+    data["warnings"] = workflow_warnings(data["workflow_json"])
+    raw_map = data.get("output_map")
+    data["output_map"] = load_output_map(raw_map)
+    # Pending flag: unknown output candidates the user has not mapped yet.
+    data["needs_mapping"] = (
+        mapping_problem(data["workflow_json"], raw_map, data.get("output_map_source")) is not None
+    )
     return data
 
 
@@ -30,19 +51,36 @@ def _serialize_workflow(row: Any) -> dict[str, Any]:
 async def analyze_workflow(payload: WorkflowAnalyze) -> dict[str, Any]:
     inputs = parse_dynamic_inputs(payload.workflow_json)
     outputs = parse_dynamic_outputs(payload.workflow_json)
+    judgment = classify_usage(payload.workflow_json)
     return {
         "inputs": inputs,
         "outputs": outputs,
         "suggested_profile": detect_prompt_profile(payload.workflow_json),
+        "warnings": workflow_warnings(payload.workflow_json),
+        "usage": judgment["usage"],
+        "usage_ambiguous": judgment["ambiguous"],
+        "needs_mapping": judgment["needs_mapping"],
+        "usage_problem": judgment["problem"],
+        "usage_evidence": judgment["evidence"],
+        "usable_usage": judgment["usable_usage"],
     }
 
 
+def _stored_schema(payload_schema: list[dict[str, Any]] | None, workflow: dict[str, Any]) -> str:
+    """Schema to persist: the confirm page's corrected copy, else the auto one."""
+    if payload_schema and all(isinstance(e, dict) for e in payload_schema):
+        return json.dumps(payload_schema)
+    return json.dumps(parse_dynamic_inputs(workflow))
+
+
 @router.post("/{workflow_id}/reanalyze")
 async def reanalyze_workflow(workflow_id: int) -> dict[str, Any]:
-    """Recompute input/output schemas from the stored workflow JSON.
+    """Recompute usage and input/output schemas from the stored workflow JSON.
 
     Workflows imported before a parser upgrade keep stale (often empty)
-    schemas — this refreshes them without re-importing.
+    schemas — this refreshes them without re-importing. A usage or output
+    mapping the user set by hand is never overwritten; only ``auto`` (and
+    pending NULL) rows get the new judgment.
     """
     conn = get_db(settings.db_path)
     try:
@@ -51,11 +89,40 @@ async def reanalyze_workflow(workflow_id: int) -> dict[str, Any]:
             raise HTTPException(status_code=404, detail="Workflow not found")
         data = row_to_dict(row)
         workflow = json.loads(data["workflow_json"])
-        inputs = parse_dynamic_inputs(workflow)
+        judgment = classify_usage(workflow)
+        usage = data["usage"]
+        usage_source = data["usage_source"]
+        if data["usage_source"] != "user" and judgment["usage"]:
+            usage = judgment["usage"]
+            usage_source = "auto"
+        stored = json.loads(data["input_schema"]) if data["input_schema"] else []
+        schema = effective_input_schema(stored, workflow)
         outputs = parse_dynamic_outputs(workflow)
+        if data["output_map_source"] == "user":
+            output_map, output_map_source = data["output_map"], "user"
+        elif needs_user_output_map(workflow):
+            # Unknown output candidates: no auto map, and the row must not
+            # generate until the user designates the output nodes.
+            output_map, output_map_source = None, None
+        else:
+            output_map, output_map_source = json.dumps(auto_output_map(workflow)), "auto"
+        is_enabled = data["is_enabled"]
+        if output_map_source is None or usage is None:
+            is_enabled = 0
         conn.execute(
-            "UPDATE workflows SET input_schema = ?, output_schema = ? WHERE id = ?",
-            (json.dumps(inputs), json.dumps(outputs), workflow_id),
+            "UPDATE workflows SET input_schema = ?, output_schema = ?,"
+            " usage = ?, usage_source = ?, output_map = ?, output_map_source = ?,"
+            " is_enabled = ? WHERE id = ?",
+            (
+                json.dumps(schema),
+                json.dumps(outputs),
+                usage,
+                usage_source,
+                output_map,
+                output_map_source,
+                is_enabled,
+                workflow_id,
+            ),
         )
         conn.commit()
         fresh = conn.execute(
@@ -113,38 +180,77 @@ async def dedupe_workflows() -> dict[str, Any]:
 
 @router.post("")
 async def create_workflow(payload: WorkflowCreate) -> dict[str, Any]:
-    inputs = parse_dynamic_inputs(payload.workflow_json)
-    outputs = parse_dynamic_outputs(payload.workflow_json)
+    judgment = classify_usage(payload.workflow_json)
+    usage = payload.usage or judgment["usage"]
+    usage_source = "user" if payload.usage else "auto"
+    kind = payload.kind or usage_to_kind(usage)
+    if kind is None:
+        # Indeterminate and nothing chosen: classify_output hint keeps old
+        # callers working while the workflow stays pending confirmation.
+        out_kinds = {
+            o.get("kind")
+            for o in parse_dynamic_outputs(payload.workflow_json)
+            if o.get("kind") in ("image", "video")
+        }
+        kind = "video" if out_kinds == {"video"} else "image"
     profile = payload.prompt_profile or detect_prompt_profile(payload.workflow_json)
+    # HEL-638: an explicit user output map wins; otherwise the trusted auto
+    # map. Either way a graph with unknown output candidates is unusable
+    # until the user designates the output nodes.
+    if payload.output_map:
+        problems = validate_output_map(payload.workflow_json, payload.output_map)
+        if problems:
+            raise HTTPException(status_code=422, detail="；".join(problems))
+        output_map = json.dumps(payload.output_map)
+        output_map_source = payload.output_map_source or "user"
+    else:
+        auto_map = auto_output_map(payload.workflow_json)
+        output_map = json.dumps(auto_map) if auto_map else None
+        output_map_source = "auto" if auto_map else None
+    mapping_ok = not needs_user_output_map(payload.workflow_json) or bool(payload.output_map)
     conn = get_db(settings.db_path)
     try:
         # Byte-identical re-imports are the main way the library fills up with
         # same-named clones (the "@" typeahead then shows 20 identical rows).
         existing = conn.execute(
             "SELECT id, name FROM workflows WHERE name = ? AND kind = ? AND workflow_json = ?",
-            (payload.name, payload.kind, json.dumps(payload.workflow_json)),
+            (payload.name, kind, json.dumps(payload.workflow_json)),
         ).fetchone()
         if existing:
             raise HTTPException(
                 status_code=409,
-                detail=f"An identical workflow already exists (id {existing['id']}, “{existing['name']}”).",
+                detail=(
+                    f"An identical workflow already exists (id {existing['id']},"
+                    f" “{existing['name']}”)."
+                ),
             )
+        # Unconfirmed workflows (ambiguous usage / unknown outputs without a
+        # user mapping) are stored but disabled: they must not reach the
+        # generate pages until the user confirms usage AND, for unknown
+        # output nodes, designates the outputs on the connections page.
+        is_enabled = 1 if (usage and mapping_ok) else 0
         cur = conn.execute(
             """
             INSERT INTO workflows (name, kind, workflow_json, input_schema,
                                    output_schema, description, prompt_profile,
-                                   endpoint_id, is_enabled)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1)
+                                   endpoint_id, is_enabled, usage, usage_source,
+                                   output_map, output_map_source)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
             """,
             (
                 payload.name,
-                payload.kind,
+                kind,
                 json.dumps(payload.workflow_json),
-                json.dumps(inputs),
-                json.dumps(outputs),
+                _stored_schema(payload.input_schema, payload.workflow_json),
+                json.dumps(parse_dynamic_outputs(payload.workflow_json)),
                 payload.description,
                 profile,
                 payload.endpoint_id,
+                is_enabled,
+                usage,
+                usage_source,
+                output_map,
+                output_map_source,
             ),
         )
         conn.commit()
@@ -176,9 +282,54 @@ async def update_workflow(workflow_id: int, payload: WorkflowUpdate) -> dict[str
         data = payload.model_dump(exclude_unset=True)
         if "is_enabled" in data and data["is_enabled"] is not None:
             data["is_enabled"] = 1 if data["is_enabled"] else 0
-        # endpoint_id: explicit null clears the binding; other Nones are skips.
-        explicit_null = {"endpoint_id"} & {k for k, v in data.items() if v is None}
+        workflow_json = json.loads(existing["workflow_json"])
+        # HEL-638: output_map payload. A non-empty list validates against the
+        # stored JSON and becomes the user decision; an explicit empty list
+        # resets the row to pending (disabled).
+        if "output_map" in data:
+            if data["output_map"]:
+                problems = validate_output_map(workflow_json, data["output_map"])
+                if problems:
+                    raise HTTPException(status_code=422, detail="；".join(problems))
+                data["output_map"] = json.dumps(data["output_map"])
+                data.setdefault("output_map_source", "user")
+            else:
+                data["output_map"] = None
+                data["output_map_source"] = None
+                data["is_enabled"] = 0
+        if data.get("usage"):
+            # Confirming / correcting the usage is an explicit user decision:
+            # kind (output media) follows the usage. Whether it re-enables is
+            # decided by the gate below — with unknown output nodes the user
+            # must also designate the output nodes (HEL-638).
+            data.setdefault("usage_source", "user")
+            data["kind"] = usage_to_kind(data["usage"]) or existing["kind"]
+        if "input_schema" in data and data["input_schema"] is not None:
+            if not all(isinstance(e, dict) for e in data["input_schema"]):
+                raise HTTPException(status_code=422, detail="input_schema 必须是参数对象数组")
+            data["input_schema"] = json.dumps(data["input_schema"])
+        # endpoint_id: explicit null clears the binding; other Nones are skips
+        # (an output_map reset keeps its explicit NULLs).
+        explicit_null = {"endpoint_id", "output_map", "output_map_source"} & {
+            k for k, v in data.items() if v is None
+        }
         data = {k: v for k, v in data.items() if v is not None or k in explicit_null}
+
+        # Enable gate: usage must be settled and, when the graph carries
+        # unknown custom output nodes, a user output mapping must exist.
+        usage_ok = bool(data.get("usage") or existing["usage"])
+        map_raw = data.get("output_map", existing["output_map"])
+        map_source = data.get("output_map_source", existing["output_map_source"])
+        map_problem = mapping_problem(workflow_json, map_raw, map_source)
+        if data.get("is_enabled"):
+            if not usage_ok:
+                raise HTTPException(status_code=400, detail="请先选择工作流用途，再启用该工作流")
+            if map_problem:
+                raise HTTPException(status_code=400, detail=map_problem)
+        elif (data.get("usage") or data.get("output_map")) and "is_enabled" not in data:
+            # A usage-confirm or output-map-confirm path: enabled only when
+            # both decisions are settled.
+            data["is_enabled"] = 1 if (usage_ok and not map_problem) else 0
         if data:
             fields = ", ".join(f"{k} = :{k}" for k in data)
             data["id"] = workflow_id
@@ -194,10 +345,29 @@ async def update_workflow(workflow_id: int, payload: WorkflowUpdate) -> dict[str
 async def delete_workflow(workflow_id: int) -> dict[str, bool]:
     conn = get_db(settings.db_path)
     try:
-        cur = conn.execute("DELETE FROM workflows WHERE id = ?", (workflow_id,))
-        conn.commit()
-        if cur.rowcount == 0:
+        # HEL-619: refuse to delete while queued/running jobs still use the
+        # workflow — deleting sets their workflow_id NULL and the job dies
+        # with "工作流已被删除" only after the user waits for it.
+        row = conn.execute(
+            "SELECT id FROM workflows WHERE id = ?", (workflow_id,)
+        ).fetchone()
+        if not row:
             raise HTTPException(status_code=404, detail="Workflow not found")
+        pending = conn.execute(
+            "SELECT COUNT(*) AS n FROM jobs"
+            " WHERE workflow_id = ? AND status IN ('pending', 'running')",
+            (workflow_id,),
+        ).fetchone()["n"]
+        if pending:
+            raise HTTPException(
+                status_code=409,
+                detail=(
+                    f"该工作流还有 {pending} 个排队或执行中的任务，"
+                    "请先等任务完成或取消任务，再删除该工作流"
+                ),
+            )
+        conn.execute("DELETE FROM workflows WHERE id = ?", (workflow_id,))
+        conn.commit()
         return {"ok": True}
     finally:
         conn.close()

calliope-backend/tests/conftest.py

@@ -10,6 +10,10 @@ from fastapi.testclient import TestClient
 from calliope.db import migrate_db
 from calliope.main import create_app
 
+# Shared fake-ComfyUI HTTP server (defined in test_studio_generation,
+# reused by the generation / status / unknown-output-mapping suites).
+from tests.test_studio_generation import fake_comfy  # noqa: F401,E402
+
 
 @pytest.fixture
 def client(monkeypatch):

calliope-backend/tests/fixtures/comfy_native/h3_i2v_04_API.json

@@ -0,0 +1,322 @@
+{
+  "1": {
+    "inputs": {
+      "value": "PASTE YOUR PROMPT HERE. For image-to-video describe the motion from the first frame; the frame fixes the look. Use the MiniMax-H3 prompt contract (integrated_multimodal_description / overall_soundscape / non_diegetic_music)."
+    },
+    "class_type": "PrimitiveStringMultiline",
+    "_meta": {
+      "title": "PROMPT (feeds every stage)"
+    }
+  },
+  "92": {
+    "inputs": {
+      "filename_prefix": "video/04_i2v_fl2v_4step_sla",
+      "format": "auto",
+      "format.codec": "auto",
+      "codec": "auto",
+      "video": [
+        "130",
+        0
+      ]
+    },
+    "class_type": "SaveVideo",
+    "_meta": {
+      "title": "REFERENCE 2026-08-29: fused ref-delta bake + SLA 0.9/64, res_multistep/simple/4, shift 12/3, 1152x640, 243 f, seed 42 -> subway_bake_sla_00001_.mp4"
+    }
+  },
+  "115": {
+    "inputs": {
+      "aspect_ratio": "16:9 (Widescreen)",
+      "megapixels": 0.7,
+      "multiple": 32
+    },
+    "class_type": "ResolutionSelector",
+    "_meta": {
+      "title": "ResolutionSelector"
+    }
+  },
+  "116": {
+    "inputs": {
+      "expression": "a"
+    },
+    "class_type": "ComfyMathExpression",
+    "_meta": {
+      "title": "ComfyMathExpression"
+    }
+  },
+  "119": {
+    "inputs": {
+      "vae_name": "minimax_h3_video_vae_int8_convrot.safetensors"
+    },
+    "class_type": "VAELoader",
+    "_meta": {
+      "title": "VAELoader"
+    }
+  },
+  "120": {
+    "inputs": {
+      "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+    },
+    "class_type": "VAELoader",
+    "_meta": {
+      "title": "VAELoader"
+    }
+  },
+  "121": {
+    "inputs": {
+      "samples": [
+        "125",
+        0
+      ],
+      "vae": [
+        "120",
+        0
+      ]
+    },
+    "class_type": "VAEDecodeAudio",
+    "_meta": {
+      "title": "VAEDecodeAudio"
+    }
+  },
+  "122": {
+    "inputs": {
+      "samples": [
+        "125",
+        0
+      ],
+      "vae": [
+        "119",
+        0
+      ]
+    },
+    "class_type": "VAEDecode",
+    "_meta": {
+      "title": "VAEDecode"
+    }
+  },
+  "124": {
+    "inputs": {
+      "scheduler": "simple",
+      "steps": 4,
+      "denoise": 1,
+      "model": [
+        "142",
+        0
+      ]
+    },
+    "class_type": "BasicScheduler",
+    "_meta": {
+      "title": "BasicScheduler"
+    }
+  },
+  "125": {
+    "inputs": {
+      "noise": [
+        "129",
+        0
+      ],
+      "guider": [
+        "126",
+        0
+      ],
+      "sampler": [
+        "135",
+        0
+      ],
+      "sigmas": [
+        "124",
+        0
+      ],
+      "latent_image": [
+        "131",
+        1
+      ]
+    },
+    "class_type": "SamplerCustomAdvanced",
+    "_meta": {
+      "title": "SamplerCustomAdvanced"
+    }
+  },
+  "126": {
+    "inputs": {
+      "model": [
+        "142",
+        0
+      ],
+      "conditioning": [
+        "131",
+        0
+      ]
+    },
+    "class_type": "BasicGuider",
+    "_meta": {
+      "title": "BasicGuider"
+    }
+  },
+  "127": {
+    "inputs": {
+      "unet_name": "minimax_h3_fused_refdelta_r1024_turbo8_mystic07_int8_convrot.safetensors",
+      "weight_dtype": "default"
+    },
+    "class_type": "UNETLoader",
+    "_meta": {
+      "title": "UNETLoader"
+    }
+  },
+  "128": {
+    "inputs": {
+      "clip_name": "qwen3vl_32b_heretic_minimax_h3_nvfp4.safetensors",
+      "type": "minimax",
+      "device": "default"
+    },
+    "class_type": "CLIPLoader",
+    "_meta": {
+      "title": "CLIPLoader"
+    }
+  },
+  "129": {
+    "inputs": {
+      "noise_seed": 42
+    },
+    "class_type": "RandomNoise",
+    "_meta": {
+      "title": "RandomNoise"
+    }
+  },
+  "130": {
+    "inputs": {
+      "fps": 24,
+      "bit_depth": 8,
+      "color_space": "sRGB",
+      "codec": "none",
+      "images": [
+        "122",
+        0
+      ],
+      "audio": [
+        "121",
+        0
+      ]
+    },
+    "class_type": "CreateVideo",
+    "_meta": {
+      "title": "CreateVideo"
+    }
+  },
+  "131": {
+    "inputs": {
+      "prompt": [
+        "1",
+        0
+      ],
+      "width": [
+        "115",
+        0
+      ],
+      "height": [
+        "115",
+        1
+      ],
+      "length": [
+        "132",
+        1
+      ],
+      "clip": [
+        "128",
+        0
+      ],
+      "vae": [
+        "119",
+        0
+      ],
+      "first_frame": [
+        "901",
+        0
+      ]
+    },
+    "class_type": "MiniMaxH3ImageToVideo",
+    "_meta": {
+      "title": "MiniMaxH3ImageToVideo"
+    }
+  },
+  "132": {
+    "inputs": {
+      "expression": "max(5, round(a * 24)) + (5 - (max(5, round(a * 24)) % 17)) % 17",
+      "values.a": [
+        "133",
+        0
+      ]
+    },
+    "class_type": "ComfyMathExpression",
+    "_meta": {
+      "title": "ComfyMathExpression"
+    }
+  },
+  "133": {
+    "inputs": {
+      "value": 10
+    },
+    "class_type": "PrimitiveFloat",
+    "_meta": {
+      "title": "PrimitiveFloat"
+    }
+  },
+  "135": {
+    "inputs": {
+      "sampler_name": "res_multistep"
+    },
+    "class_type": "KSamplerSelect",
+    "_meta": {
+      "title": "KSamplerSelect"
+    }
+  },
+  "142": {
+    "inputs": {
+      "shift_video": 12,
+      "shift_audio": 3,
+      "model": [
+        "900",
+        0
+      ]
+    },
+    "class_type": "MiniMaxH3SigmaShift",
+    "_meta": {
+      "title": "MiniMaxH3SigmaShift"
+    }
+  },
+  "900": {
+    "inputs": {
+      "sparsity_ratio": 0.9,
+      "block_size": "64",
+      "min_seq_len": 8192,
+      "dense_last_steps": 0,
+      "protect_audio": true,
+      "enabled": true,
+      "dense_steps": "1",
+      "dense_backend": "comfy_kitchen",
+      "disable_fp16_accum": true,
+      "stabilize_motion": false,
+      "reference_protection": "Off",
+      "tail_correction": false,
+      "use_int8_qk": true,
+      "engine": "comfy_kitchen",
+      "model": [
+        "127",
+        0
+      ]
+    },
+    "class_type": "H3SLAAttention",
+    "_meta": {
+      "title": "H3 SLA Attention 0.9/64 (their graph)"
+    }
+  },
+  "901": {
+    "inputs": {
+      "image": "first_frame.png"
+    },
+    "class_type": "LoadImage",
+    "_meta": {
+      "title": "FIRST FRAME (add a second LoadImage into last_frame for FL2V)"
+    }
+  }
+}

calliope-backend/tests/fixtures/comfy_native/h3_ref2va_05_API.json

@@ -0,0 +1,327 @@
+{
+  "1": {
+    "inputs": {
+      "value": "PASTE YOUR PROMPT HERE, in the reference contract:\nsubject_definitions:\n<Subject 1> is the person in <Picture 1>; their face, hair and clothing follow <Picture 1>.\n\nsummary:\n[reference generation] one continuous shot of <Subject 1> doing X, appearance taken from <Picture 1>.\n\nretention_analysis:\n<Subject 1> is fully preserved from <Picture 1>.\n\ndetailed_description:\n[Shot 1] ... camera, action, timing ...\n\noverall_soundscape: ...\n\nnon_diegetic_music: N/A"
+    },
+    "class_type": "PrimitiveStringMultiline",
+    "_meta": {
+      "title": "PROMPT (feeds every stage)"
+    }
+  },
+  "92": {
+    "inputs": {
+      "filename_prefix": "video/05_ref2va_4step_sla",
+      "format": "auto",
+      "format.codec": "auto",
+      "codec": "auto",
+      "video": [
+        "130",
+        0
+      ]
+    },
+    "class_type": "SaveVideo",
+    "_meta": {
+      "title": "REFERENCE 2026-08-29: fused ref-delta bake + SLA 0.9/64, res_multistep/simple/4, shift 12/3, 1152x640, 243 f, seed 42 -> subway_bake_sla_00001_.mp4"
+    }
+  },
+  "115": {
+    "inputs": {
+      "aspect_ratio": "16:9 (Widescreen)",
+      "megapixels": 0.7,
+      "multiple": 32
+    },
+    "class_type": "ResolutionSelector",
+    "_meta": {
+      "title": "ResolutionSelector"
+    }
+  },
+  "116": {
+    "inputs": {
+      "expression": "a"
+    },
+    "class_type": "ComfyMathExpression",
+    "_meta": {
+      "title": "ComfyMathExpression"
+    }
+  },
+  "119": {
+    "inputs": {
+      "vae_name": "minimax_h3_video_vae_int8_convrot.safetensors"
+    },
+    "class_type": "VAELoader",
+    "_meta": {
+      "title": "VAELoader"
+    }
+  },
+  "120": {
+    "inputs": {
+      "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+    },
+    "class_type": "VAELoader",
+    "_meta": {
+      "title": "VAELoader"
+    }
+  },
+  "121": {
+    "inputs": {
+      "samples": [
+        "125",
+        0
+      ],
+      "vae": [
+        "120",
+        0
+      ]
+    },
+    "class_type": "VAEDecodeAudio",
+    "_meta": {
+      "title": "VAEDecodeAudio"
+    }
+  },
+  "122": {
+    "inputs": {
+      "samples": [
+        "125",
+        0
+      ],
+      "vae": [
+        "119",
+        0
+      ]
+    },
+    "class_type": "VAEDecode",
+    "_meta": {
+      "title": "VAEDecode"
+    }
+  },
+  "124": {
+    "inputs": {
+      "scheduler": "simple",
+      "steps": 4,
+      "denoise": 1,
+      "model": [
+        "142",
+        0
+      ]
+    },
+    "class_type": "BasicScheduler",
+    "_meta": {
+      "title": "BasicScheduler"
+    }
+  },
+  "125": {
+    "inputs": {
+      "noise": [
+        "129",
+        0
+      ],
+      "guider": [
+        "126",
+        0
+      ],
+      "sampler": [
+        "135",
+        0
+      ],
+      "sigmas": [
+        "124",
+        0
+      ],
+      "latent_image": [
+        "131",
+        1
+      ]
+    },
+    "class_type": "SamplerCustomAdvanced",
+    "_meta": {
+      "title": "SamplerCustomAdvanced"
+    }
+  },
+  "126": {
+    "inputs": {
+      "model": [
+        "142",
+        0
+      ],
+      "conditioning": [
+        "131",
+        0
+      ]
+    },
+    "class_type": "BasicGuider",
+    "_meta": {
+      "title": "BasicGuider"
+    }
+  },
+  "127": {
+    "inputs": {
+      "unet_name": "minimax_h3_fused_refdelta_r1024_turbo8_mystic07_int8_convrot.safetensors",
+      "weight_dtype": "default"
+    },
+    "class_type": "UNETLoader",
+    "_meta": {
+      "title": "UNETLoader"
+    }
+  },
+  "128": {
+    "inputs": {
+      "clip_name": "qwen3vl_32b_heretic_minimax_h3_nvfp4.safetensors",
+      "type": "minimax",
+      "device": "default"
+    },
+    "class_type": "CLIPLoader",
+    "_meta": {
+      "title": "CLIPLoader"
+    }
+  },
+  "129": {
+    "inputs": {
+      "noise_seed": 42
+    },
+    "class_type": "RandomNoise",
+    "_meta": {
+      "title": "RandomNoise"
+    }
+  },
+  "130": {
+    "inputs": {
+      "fps": 24,
+      "bit_depth": 8,
+      "color_space": "sRGB",
+      "codec": "none",
+      "images": [
+        "122",
+        0
+      ],
+      "audio": [
+        "121",
+        0
+      ]
+    },
+    "class_type": "CreateVideo",
+    "_meta": {
+      "title": "CreateVideo"
+    }
+  },
+  "131": {
+    "inputs": {
+      "prompt": [
+        "1",
+        0
+      ],
+      "width": [
+        "115",
+        0
+      ],
+      "height": [
+        "115",
+        1
+      ],
+      "length": [
+        "132",
+        1
+      ],
+      "ref_image_size": "match",
+      "clip": [
+        "128",
+        0
+      ],
+      "vae": [
+        "119",
+        0
+      ],
+      "audio_vae": [
+        "120",
+        0
+      ],
+      "ref_images.ref_image_0": [
+        "901",
+        0
+      ]
+    },
+    "class_type": "MiniMaxH3ReferenceToVideo",
+    "_meta": {
+      "title": "MiniMaxH3ReferenceToVideo"
+    }
+  },
+  "132": {
+    "inputs": {
+      "expression": "max(5, round(a * 24)) + (5 - (max(5, round(a * 24)) % 17)) % 17",
+      "values.a": [
+        "133",
+        0
+      ]
+    },
+    "class_type": "ComfyMathExpression",
+    "_meta": {
+      "title": "ComfyMathExpression"
+    }
+  },
+  "133": {
+    "inputs": {
+      "value": 10
+    },
+    "class_type": "PrimitiveFloat",
+    "_meta": {
+      "title": "PrimitiveFloat"
+    }
+  },
+  "135": {
+    "inputs": {
+      "sampler_name": "res_multistep"
+    },
+    "class_type": "KSamplerSelect",
+    "_meta": {
+      "title": "KSamplerSelect"
+    }
+  },
+  "142": {
+    "inputs": {
+      "shift_video": 12,
+      "shift_audio": 3,
+      "model": [
+        "900",
+        0
+      ]
+    },
+    "class_type": "MiniMaxH3SigmaShift",
+    "_meta": {
+      "title": "MiniMaxH3SigmaShift"
+    }
+  },
+  "900": {
+    "inputs": {
+      "sparsity_ratio": 0.9,
+      "block_size": "64",
+      "min_seq_len": 8192,
+      "dense_last_steps": 0,
+      "protect_audio": true,
+      "enabled": true,
+      "dense_steps": "1",
+      "dense_backend": "comfy_kitchen",
+      "disable_fp16_accum": true,
+      "stabilize_motion": false,
+      "reference_protection": "Off",
+      "tail_correction": false,
+      "use_int8_qk": true,
+      "engine": "comfy_kitchen",
+      "model": [
+        "127",
+        0
+      ]
+    },
+    "class_type": "H3SLAAttention",
+    "_meta": {
+      "title": "H3 SLA Attention 0.9/64 (their graph)"
+    }
+  },
+  "901": {
+    "inputs": {
+      "image": "reference_1.png"
+    },
+    "class_type": "LoadImage",
+    "_meta": {
+      "title": "REFERENCE IMAGE 1 (<Picture 1>); the node grows more image / video / audio slots"
+    }
+  }
+}

calliope-backend/tests/fixtures/comfy_native/qwen21_edit_sage_API.json

@@ -0,0 +1,136 @@
+{
+  "1": {
+    "inputs": {
+      "UNKNOWN": "qwen-image-2.1-Q4_K_M.gguf"
+    },
+    "_meta": {
+      "title": "Unet Loader (GGUF)"
+    }
+  },
+  "2": {
+    "inputs": {
+      "clip_name": "qwen3vl_8b_int8_convrot.safetensors",
+      "type": "qwen_image",
+      "device": "default"
+    },
+    "class_type": "CLIPLoader",
+    "_meta": {
+      "title": "加载CLIP"
+    }
+  },
+  "3": {
+    "inputs": {
+      "vae_name": "qwen_image_2.1_vae_bf16.safetensors"
+    },
+    "class_type": "VAELoader",
+    "_meta": {
+      "title": "加载VAE"
+    }
+  },
+  "4": {
+    "inputs": {
+      "prompt": "参考角色五官，重新生成图片：高细节皮肤质感",
+      "negative_prompt": "模糊，低质量，文字乱码，变形",
+      "resolution": 1024,
+      "clip": [
+        "2",
+        0
+      ],
+      "images.image_1": [
+        "10",
+        0
+      ],
+      "vae": [
+        "3",
+        0
+      ]
+    },
+    "class_type": "TextEncodeQwenImage21",
+    "_meta": {
+      "title": "Text Encode Qwen Image 2.1"
+    }
+  },
+  "5": {
+    "inputs": {
+      "width": 1024,
+      "height": 1024,
+      "batch_size": 1
+    },
+    "class_type": "EmptyLatentImage",
+    "_meta": {
+      "title": "空Latent图像"
+    }
+  },
+  "6": {
+    "inputs": {
+      "seed": 278835418249884,
+      "steps": 25,
+      "cfg": 1,
+      "sampler_name": "euler",
+      "scheduler": "simple",
+      "denoise": 1,
+      "positive": [
+        "4",
+        0
+      ],
+      "negative": [
+        "4",
+        1
+      ],
+      "latent_image": [
+        "4",
+        2
+      ]
+    },
+    "class_type": "KSampler",
+    "_meta": {
+      "title": "K采样器"
+    }
+  },
+  "7": {
+    "inputs": {
+      "samples": [
+        "6",
+        0
+      ],
+      "vae": [
+        "3",
+        0
+      ]
+    },
+    "class_type": "VAEDecode",
+    "_meta": {
+      "title": "VAE解码"
+    }
+  },
+  "8": {
+    "inputs": {
+      "filename_prefix": "qwen_image",
+      "images": [
+        "7",
+        0
+      ]
+    },
+    "class_type": "SaveImage",
+    "_meta": {
+      "title": "保存图像"
+    }
+  },
+  "9": {
+    "inputs": {
+      "UNKNOWN": "auto"
+    },
+    "_meta": {
+      "title": "Patch Sage Attention KJ"
+    }
+  },
+  "10": {
+    "inputs": {
+      "image": "3f24a075cd7b4118829be1b222ca1ab9.png"
+    },
+    "class_type": "LoadImage",
+    "_meta": {
+      "title": "加载图像"
+    }
+  }
+}

calliope-backend/tests/test_comfyui_endpoints.py

@@ -374,6 +374,61 @@ def test_comfy_test_requires_url(client):
     assert r.status_code == 400
 
 
+def test_schemeless_url_is_format_error_everywhere(client):
+    """HEL-619: a schemeless/garbled address is a 400 format error on every
+    entry point (probe + save), not a silent http:// prefix that later
+    surfaces as a DNS-classified probe failure."""
+    prev = _snapshot_settings()
+    try:
+        for url in ("192.168.0.1:8188", "http:192.168.0.1", "ht!tp://x", "http://a b.test/"):
+            r = client.post(
+                "/api/comfyui/endpoints/test", json={"base_url": url, "timeout_sec": 2}
+            )
+            assert r.status_code == 400, url
+            assert "http://" in r.json()["detail"] or "https://" in r.json()["detail"]
+            r = client.post(
+                "/api/comfyui/endpoints", json={"name": "无协议", "base_url": url}
+            )
+            assert r.status_code == 400, url
+            assert "无协议" not in [ep.get("name") for ep in settings.comfyui_endpoints or []]
+    finally:
+        for key, value in prev.items():
+            setattr(settings, key, value)
+
+
+def test_save_endpoint_runs_ssrf_guard(client):
+    """HEL-619: the SSRF guard applies on save (create + edit), not only on
+    the connectivity probe; loopback stays allowed."""
+    prev = _snapshot_settings()
+    try:
+        _clear_endpoints()
+        r = client.post(
+            "/api/comfyui/endpoints",
+            json={"name": "元数据", "base_url": "http://169.254.169.254/latest"},
+        )
+        assert r.status_code == 400
+        assert "禁止" in r.json()["detail"]
+
+        r = client.post(
+            "/api/comfyui/endpoints",
+            json={"name": "本机", "base_url": "http://127.0.0.1:8188"},
+        )
+        assert r.status_code == 200
+        eid = r.json()["endpoints"][-1]["id"]
+
+        r = client.patch(
+            f"/api/comfyui/endpoints/{eid}",
+            json={"base_url": "http://169.254.169.254/latest"},
+        )
+        assert r.status_code == 400
+        # the stored endpoint is untouched
+        stored = next(ep for ep in settings.comfyui_endpoints if ep["id"] == eid)
+        assert stored["base_url"] == "http://127.0.0.1:8188"
+    finally:
+        for key, value in prev.items():
+            setattr(settings, key, value)
+
+
 # ----------------------------------------------------------------------
 # workflow binding + job snapshots
 # ----------------------------------------------------------------------
@@ -381,10 +436,21 @@ def test_comfy_test_requires_url(client):
 
 def _import_workflow(client, name="H3 视频", kind="video", endpoint_id=None):
     wf_json = {
+        "4": {
+            "class_type": "CheckpointLoaderSimple",
+            "inputs": {"ckpt_name": "model.safetensors"},
+        },
         "6": {
             "class_type": "CLIPTextEncode",
             "inputs": {"text": "placeholder prompt", "clip": ["4", 1]},
         },
+        # HEL-636: a workflow needs a recognizable output node to classify a
+        # usage and stay enabled; without it generation is refused.
+        "9": {
+            "class_type": "VHS_VideoCombine",
+            "inputs": {"images": ["6", 0]},
+            "_meta": {"title": "Video Output (Output:video)"},
+        },
     }
     payload = {"name": name, "kind": kind, "workflow_json": wf_json}
     if endpoint_id is not None:
@@ -531,6 +597,41 @@ def test_queue_enqueue_stamps_all_paths(client):
             setattr(settings, key, value)
 
 
+def test_workflow_delete_blocked_while_jobs_pending(client):
+    """HEL-619: deleting a workflow with pending/running jobs is refused
+    with 409 instead of silently nulling the jobs' workflow_id."""
+    from calliope.db import get_db
+    from calliope.queue.manager import queue_manager
+
+    wf = _import_workflow(client).json()
+    project = client.post(
+        "/api/projects", json={"title": "删除保护测试", "idea": "x"}
+    ).json()
+    # Pause the lifespan-started worker so the pending job STAYS pending.
+    queue_manager.paused = True
+    try:
+        queue_manager.enqueue(
+            project_id=project["id"], kind="video", workflow_id=wf["id"], payload={}
+        )
+
+        r = client.delete(f"/api/workflows/{wf['id']}")
+        assert r.status_code == 409
+        assert "排队" in r.json()["detail"]
+    finally:
+        queue_manager.paused = False
+
+    # job finished → deletion allowed again
+    conn = get_db(settings.db_path)
+    try:
+        conn.execute("UPDATE jobs SET status = 'done' WHERE project_id = ?", (project["id"],))
+        conn.commit()
+    finally:
+        conn.close()
+    r = client.delete(f"/api/workflows/{wf['id']}")
+    assert r.status_code == 200
+    assert r.json() == {"ok": True}
+
+
 def test_settings_public_dict_masks_endpoint_tokens(client):
     prev = _snapshot_settings()
     try:

calliope-backend/tests/test_image_input_workflows.py

@@ -0,0 +1,477 @@
+"""HEL-633: the three image-input workflows the user supplied — Qwen Image 2.1
+图片编辑, MiniMax H3 首帧图生视频 (04) and H3 参考图生视频 (05, 1–9 refs).
+
+Slots come from real wiring, every picked image is uploaded to ComfyUI and
+lands in the node input it belongs to (in order, nothing stale), and a
+broken export is refused before anything is queued."""
+
+from __future__ import annotations
+
+import json
+import re
+import threading
+from http.server import ThreadingHTTPServer
+from pathlib import Path
+
+import pytest
+
+from calliope.comfyui.lint import blocking_problem, workflow_warnings
+from calliope.comfyui.parser import detect_untagged_inputs, parse_dynamic_inputs
+from calliope.comfyui.patcher import patch_workflow
+from calliope.comfyui.smart_fill import smart_fill_inputs
+from calliope.comfyui.validate import validate_input_values
+from calliope.config import settings
+from tests.test_studio_generation import (
+    PNG_1PX,
+    _FakeComfyHandler,
+    _import_workflow,
+    _real_run,
+    _wait_done,
+)
+
+FIXTURES = Path(__file__).parent / "fixtures" / "comfy_native"
+I2V = "h3_i2v_04_API.json"  # 04_i2v_fl2v_4step_sla (1).json
+REF = "h3_ref2va_05_API.json"  # 05_ref2va_4step_sla (1).json
+QWEN_EDIT = "qwen21_edit_sage_API.json"  # qwen-image-2.1-图片编辑-sage加速.json
+EXAMPLES = Path(__file__).resolve().parents[2] / "example_ComfyUI_workflows"
+
+REF_KEY = "131@ref_images"
+
+
+def _load(name: str) -> dict:
+    return json.loads((FIXTURES / name).read_text(encoding="utf-8"))
+
+
+def _by_node(inputs: list[dict]) -> dict[str, dict]:
+    return {i["nodeId"]: i for i in inputs}
+
+
+def _ref_links(wf: dict, node_id: str = "131") -> list[tuple[str, str]]:
+    """[(input name, LoadImage image value), …] in slot order."""
+    inputs = wf[node_id]["inputs"]
+    names = sorted(
+        (k for k in inputs if k.startswith("ref_images.ref_image_")),
+        key=lambda k: int(k.rsplit("_", 1)[1]),
+    )
+    return [(k, wf[inputs[k][0]]["inputs"]["image"]) for k in names]
+
+
+# ---------------------------------------------------------------------------
+# Slot detection
+# ---------------------------------------------------------------------------
+
+
+def test_i2v_exposes_one_required_first_frame_and_no_last_frame():
+    inputs = parse_dynamic_inputs(_load(I2V))
+    media = [i for i in inputs if i["kind"] in ("image", "image_list", "video", "audio")]
+    assert media == [
+        {
+            "nodeId": "901",
+            "label": "首帧",
+            "role": "first_frame",
+            "kind": "image",
+            "defaultValue": None,
+            "required": True,
+            "auto": True,
+        }
+    ]
+    # the title comment about FL2V is not a slot
+    assert not any(i.get("role") == "last_frame" for i in inputs)
+
+
+def test_ref2v_exposes_one_group_of_one_to_nine_reference_images():
+    inputs = parse_dynamic_inputs(_load(REF))
+    media = [i for i in inputs if i["kind"] in ("image", "image_list", "video", "audio")]
+    assert len(media) == 1
+    group = media[0]
+    assert group["nodeId"] == REF_KEY
+    assert group["kind"] == "image_list"
+    assert group["role"] == "reference_image"
+    assert group["label"] == "参考图"
+    assert (group["min"], group["max"], group["required"]) == (1, 9, True)
+    # the parameters HEL-627 wired stay exposed
+    by_node = _by_node(inputs)
+    for key in ("1", "115@aspect_ratio", "115@megapixels", "124@steps", "124@denoise",
+                "129@noise_seed", "133"):
+        assert key in by_node, key
+    assert not any(i["kind"] == "video" for i in inputs)
+
+
+def test_example_five_ref_workflow_folds_into_the_same_group():
+    # The repo example is (Input:…)-tagged and keeps its tagged slots; stripped
+    # of tags (as a plain ComfyUI export) its five loaders become one group.
+    wf = json.loads((EXAMPLES / "video_minimax_h3_r2v_5ref_API.json").read_text(encoding="utf-8"))
+    inputs = detect_untagged_inputs(wf)
+    groups = [i for i in inputs if i["kind"] == "image_list"]
+    assert [g["nodeId"] for g in groups] == ["178@ref_images"]
+    # its five LoadImages are the group, not five separate slots
+    assert not any(i["kind"] == "image" for i in inputs if i.get("role") != "mask")
+
+
+def test_qwen_edit_exposes_input_image_real_resolution_and_hides_orphan_latent():
+    inputs = parse_dynamic_inputs(_load(QWEN_EDIT))
+    by_node = _by_node(inputs)
+    img = by_node["10"]
+    assert (img["kind"], img["role"], img["label"]) == ("image", "image", "输入图")
+    assert img["required"] is True
+    res = by_node["4@resolution"]
+    assert (res["role"], res["defaultValue"], res["min"], res["max"], res["step"]) == (
+        "resolution", 1024, 0, 4096, 32,
+    )
+    assert by_node["4@prompt"]["role"] == "prompt"
+    assert by_node["4@negative_prompt"]["role"] == "negative"
+    for key in ("6@seed", "6@steps", "6@cfg", "6@denoise"):
+        assert key in by_node
+    # EmptyLatentImage #5 feeds nothing — its width/height would do nothing
+    assert not any(i["nodeId"].startswith("5@") for i in inputs)
+
+
+def test_unwired_load_image_gets_no_slot():
+    wf = _load(I2V)
+    wf["950"] = {
+        "class_type": "LoadImage",
+        "inputs": {"image": "last.png"},
+        "_meta": {"title": "LAST"},
+    }
+    assert "950" not in _by_node(parse_dynamic_inputs(wf))
+
+
+# ---------------------------------------------------------------------------
+# Broken exports
+# ---------------------------------------------------------------------------
+
+
+def test_broken_qwen_export_is_flagged_and_blocked():
+    warnings = workflow_warnings(_load(QWEN_EDIT))
+    errors = {(w["code"], w["node_id"]) for w in warnings if w["level"] == "error"}
+    assert errors == {
+        ("missing_class_type", "1"),
+        ("missing_class_type", "9"),
+        ("missing_model_link", "6"),
+    }
+    assert ("orphan_latent", "5") in {(w["code"], w["node_id"]) for w in warnings}
+    msg = blocking_problem(_load(QWEN_EDIT))
+    assert msg and "Unet Loader (GGUF)" in msg and "重新导出" in msg
+
+
+def test_h3_workflows_are_clean():
+    assert workflow_warnings(_load(I2V)) == []
+    assert workflow_warnings(_load(REF)) == []
+
+
+# ---------------------------------------------------------------------------
+# Patching 1 / 4 / 9 reference images
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize("count", [1, 4, 9])
+def test_patch_wires_each_reference_image_in_order(count):
+    base = _load(REF)
+    paths = [f"/assets/uploads/ref-{i}.png" for i in range(1, count + 1)]
+    wf = patch_workflow(base, {REF_KEY: paths})
+    links = _ref_links(wf)
+    assert links == [(f"ref_images.ref_image_{i}", p) for i, p in enumerate(paths)]
+    # every loader is a real, distinct LoadImage feeding node 131
+    loader_ids = [wf["131"]["inputs"][name][0] for name, _ in links]
+    assert len(set(loader_ids)) == count
+    assert all(wf[n]["class_type"] == "LoadImage" for n in loader_ids)
+    assert loader_ids[0] == "901"
+    # the base workflow is untouched
+    assert _ref_links(base) == [("ref_images.ref_image_0", "reference_1.png")]
+
+
+def test_patch_shrinking_removes_stale_slots_and_loaders():
+    nine = patch_workflow(_load(REF), {REF_KEY: [f"/u/{i}.png" for i in range(9)]})
+    two = patch_workflow(nine, {REF_KEY: ["/u/b.png", "/u/a.png"]})
+    assert _ref_links(two) == [
+        ("ref_images.ref_image_0", "/u/b.png"),
+        ("ref_images.ref_image_1", "/u/a.png"),
+    ]
+    load_images = [n for n, v in two.items() if v.get("class_type") == "LoadImage"]
+    assert len(load_images) == 2
+    assert not any("/u/8.png" in json.dumps(v) for v in two.values())
+
+
+def test_single_slot_values_patch_first_frame_and_qwen_input():
+    i2v = patch_workflow(_load(I2V), {"901": "/assets/uploads/first.png"})
+    assert i2v["901"]["inputs"]["image"] == "/assets/uploads/first.png"
+    assert i2v["131"]["inputs"]["first_frame"] == ["901", 0]
+    qwen = patch_workflow(_load(QWEN_EDIT), {"10": "/assets/uploads/in.png", "4@resolution": 1536})
+    assert qwen["10"]["inputs"]["image"] == "/assets/uploads/in.png"
+    assert qwen["4"]["inputs"]["resolution"] == 1536
+
+
+def test_legacy_job_values_keyed_by_load_image_still_patch():
+    """Jobs queued before HEL-633 carry the LoadImage id, not the group key."""
+    wf = patch_workflow(_load(REF), {"901": "/assets/uploads/old.png"})
+    assert _ref_links(wf) == [("ref_images.ref_image_0", "/assets/uploads/old.png")]
+
+
+def test_smart_fill_hands_reference_list_to_the_group():
+    inputs = parse_dynamic_inputs(_load(REF))
+    refs = [f"/r/{i}.png" for i in range(12)]
+    values = smart_fill_inputs(inputs, prompt="p", ref_images=refs)
+    assert values[REF_KEY] == refs[:9]
+
+
+# ---------------------------------------------------------------------------
+# Validation
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def uploads_dir(client):
+    d = settings.assets_dir / "uploads"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def _pngs(d: Path, n: int) -> list[str]:
+    out = []
+    for i in range(n):
+        p = d / f"ref{i + 1}.png"
+        p.write_bytes(PNG_1PX)
+        out.append(str(p))
+    return out
+
+
+def test_validate_reference_count_limits(uploads_dir):
+    schema = parse_dynamic_inputs(_load(REF))
+    base = {"1": "prompt"}
+    for n in (1, 4, 9):
+        clean, errs = validate_input_values(schema, {**base, REF_KEY: _pngs(uploads_dir, n)})
+        assert errs == [] and len(clean[REF_KEY]) == n
+    _, errs = validate_input_values(schema, {**base, REF_KEY: _pngs(uploads_dir, 10)})
+    assert errs == ["参考图最多 9 张（当前 10 张），请删除多余的图片"]
+    _, errs = validate_input_values(schema, base)
+    assert errs == ["需要至少 1 张参考图"]
+    _, errs = validate_input_values(schema, {**base, REF_KEY: []})
+    assert errs == ["需要至少 1 张参考图"]
+
+
+def test_validate_rejects_bad_reference_files(uploads_dir):
+    schema = parse_dynamic_inputs(_load(REF))
+    gif = uploads_dir / "anim.gif"
+    gif.write_bytes(b"GIF89a")
+    ok = _pngs(uploads_dir, 1)[0]
+    _, errs = validate_input_values(schema, {"1": "p", REF_KEY: [ok, str(gif)]})
+    assert errs == ["参考图 2：格式不支持，请使用 PNG / JPG / WebP"]
+    _, errs = validate_input_values(schema, {"1": "p", REF_KEY: ["/etc/passwd.png"]})
+    assert errs == ["参考图 1：只能使用在本页上传或从生成结果选入的图片"]
+    _, errs = validate_input_values(schema, {"1": "p", REF_KEY: [str(uploads_dir / "gone.png")]})
+    assert errs == ["参考图 1：文件已不存在，请重新上传"]
+
+
+def test_validate_requires_first_frame_and_input_image():
+    _, errs = validate_input_values(parse_dynamic_inputs(_load(I2V)), {"1": "p"})
+    assert errs == ["请上传首帧"]
+    _, errs = validate_input_values(parse_dynamic_inputs(_load(QWEN_EDIT)), {"4@prompt": "p"})
+    assert errs == ["请上传输入图"]
+
+
+# ---------------------------------------------------------------------------
+# Full chain against a fake ComfyUI
+# ---------------------------------------------------------------------------
+
+
+class _NamedUploadHandler(_FakeComfyHandler):
+    """/upload/image answers with the uploaded file's own name, like ComfyUI."""
+
+    def do_POST(self):  # noqa: N802 — BaseHTTPRequestHandler hook name
+        if self.path != "/upload/image":
+            super().do_POST()
+            return
+        length = int(self.headers.get("Content-Length") or 0)
+        body = self.rfile.read(length) if length else b""
+        self.server.requests.append(self.path)
+        self.server.uploads.append(body)
+        m = re.search(rb'filename="([^"]+)"', body)
+        name = m.group(1).decode() if m else "x.png"
+        self.server.upload_names.append(name)
+        self._json(200, {"name": name, "subfolder": "calliope", "type": "input"})
+
+
+@pytest.fixture
+def named_comfy():
+    server = ThreadingHTTPServer(("127.0.0.1", 0), _NamedUploadHandler)
+    server.requests = []
+    server.prompts = []
+    server.uploads = []
+    server.upload_names = []
+    server.history = {}
+    server.fail_prompt = False
+    server.out_name = "ref2v_00001_.mp4"
+    server.outputs_key = "images"
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        yield server
+    finally:
+        server.shutdown()
+        server.server_close()
+
+
+def _upload(client, name: str) -> str:
+    r = client.post("/api/playground/uploads", files={"file": (name, PNG_1PX, "image/png")})
+    assert r.status_code == 200, r.text
+    return r.json()["path"]
+
+
+def _generate(client, wf_id: int, values: dict, source: str = "studio-video"):
+    return client.post(
+        "/api/playground/generate",
+        json={
+            "workflow_id": wf_id,
+            "input_values": values,
+            "source": source,
+            "endpoint_id": settings.comfyui_active_id,
+        },
+    )
+
+
+@pytest.mark.parametrize("count", [1, 4, 9])
+def test_ref2v_chain_uploads_every_image_and_wires_it_in_order(client, named_comfy, count):
+    with _real_run(client, named_comfy):
+        wf_id = _import_workflow(client, "H3 参考生视频", "video", _load(REF))
+        paths = [_upload(client, f"角色{i}.png") for i in range(1, count + 1)]
+        r = _generate(
+            client,
+            wf_id,
+            {"1": "<Subject 1> 走进雨夜码头", REF_KEY: paths, "124@steps": 4, "133": 2},
+        )
+        assert r.status_code == 200, r.text
+        job = _wait_done(client, r.json()["job"]["id"])
+        assert job["status"] == "done", job.get("error")
+        assert job["payload"]["input_values"][REF_KEY] == paths
+
+    assert len(named_comfy.prompts) == 1
+    prompt = named_comfy.prompts[0]["prompt"]
+    expected = [f"calliope/{Path(p).name}" for p in paths]
+    assert [img for _k, img in _ref_links(prompt)] == expected
+    assert named_comfy.upload_names == [Path(p).name for p in paths]
+    assert prompt["1"]["inputs"]["value"] == "<Subject 1> 走进雨夜码头"
+    assert prompt["124"]["inputs"]["steps"] == 4
+    assert prompt["133"]["inputs"]["value"] == 2
+    # no leftover default reference and no unconsumed LoadImage
+    assert "reference_1.png" not in json.dumps(prompt)
+    loaders = {n for n, v in prompt.items() if v["class_type"] == "LoadImage"}
+    wired = {v[0] for k, v in prompt["131"]["inputs"].items() if k.startswith("ref_images.")}
+    assert loaders == wired
+
+
+def test_ref2v_replace_and_delete_leave_no_stale_image(client, named_comfy):
+    with _real_run(client, named_comfy):
+        wf_id = _import_workflow(client, "H3 参考生视频", "video", _load(REF))
+        a, b, c = (_upload(client, n) for n in ("a.png", "b.png", "c.png"))
+        r = _generate(client, wf_id, {"1": "x", REF_KEY: [a, b, c]})
+        assert _wait_done(client, r.json()["job"]["id"])["status"] == "done"
+        # user replaced #2 with d and deleted #3
+        d = _upload(client, "d.png")
+        r = _generate(client, wf_id, {"1": "x", REF_KEY: [a, d]})
+        assert _wait_done(client, r.json()["job"]["id"])["status"] == "done"
+    second = named_comfy.prompts[1]["prompt"]
+    assert [img for _k, img in _ref_links(second)] == [
+        f"calliope/{Path(a).name}",
+        f"calliope/{Path(d).name}",
+    ]
+    dumped = json.dumps(second)
+    assert Path(b).name not in dumped and Path(c).name not in dumped
+
+
+def test_ref2v_ten_images_rejected_before_queue(client, named_comfy):
+    with _real_run(client, named_comfy):
+        wf_id = _import_workflow(client, "H3 参考生视频", "video", _load(REF))
+        paths = [_upload(client, f"r{i}.png") for i in range(10)]
+        r = _generate(client, wf_id, {"1": "x", REF_KEY: paths})
+        assert r.status_code == 400
+        assert "参考图最多 9 张" in r.json()["detail"]
+        r = _generate(client, wf_id, {"1": "x"})
+        assert r.status_code == 400
+        assert "需要至少 1 张参考图" in r.json()["detail"]
+    assert named_comfy.prompts == [] and named_comfy.upload_names == []
+
+
+def test_i2v_chain_uploads_first_frame(client, named_comfy):
+    with _real_run(client, named_comfy):
+        wf_id = _import_workflow(client, "H3 图生视频", "video", _load(I2V))
+        r = _generate(client, wf_id, {"1": "镜头缓慢推近"})
+        assert r.status_code == 400 and "请上传首帧" in r.json()["detail"]
+        first = _upload(client, "首帧.png")
+        r = _generate(client, wf_id, {"1": "镜头缓慢推近", "901": first, "124@denoise": 0.8})
+        assert r.status_code == 200, r.text
+        assert _wait_done(client, r.json()["job"]["id"])["status"] == "done"
+    prompt = named_comfy.prompts[0]["prompt"]
+    assert prompt["901"]["inputs"]["image"] == f"calliope/{Path(first).name}"
+    assert prompt["131"]["inputs"]["first_frame"] == ["901", 0]
+    assert prompt["124"]["inputs"]["denoise"] == 0.8
+
+
+def test_broken_qwen_import_warns_and_generation_is_refused(client, named_comfy):
+    with _real_run(client, named_comfy):
+        analyzed = client.post("/api/workflows/analyze", json={"workflow_json": _load(QWEN_EDIT)})
+        assert analyzed.status_code == 200
+        codes = {w["code"] for w in analyzed.json()["warnings"]}
+        assert {"missing_class_type", "missing_model_link", "orphan_latent"} <= codes
+        # importing is allowed (the user may fix it later) …
+        wf_id = _import_workflow(client, "Qwen 图片编辑", "image", _load(QWEN_EDIT))
+        listed = next(w for w in client.get("/api/workflows").json() if w["id"] == wf_id)
+        assert any(w["level"] == "error" for w in listed["warnings"])
+        # … but it never reaches ComfyUI and never shows as done
+        img = _upload(client, "门面.png")
+        r = _generate(client, wf_id, {"4@prompt": "换招牌", "10": img}, source="studio-image")
+        assert r.status_code == 400
+        assert "重新导出" in r.json()["detail"]
+        assert client.get("/api/playground/jobs").json() == []
+    assert named_comfy.prompts == [] and named_comfy.upload_names == []
+
+
+def test_repaired_qwen_export_runs_with_its_input_image(client, named_comfy):
+    wf = _load(QWEN_EDIT)
+    wf["1"] = {
+        "class_type": "UNETLoader",
+        "inputs": {
+            "unet_name": "qwen_image_2.1_int8_convrot.safetensors",
+            "weight_dtype": "default",
+        },
+    }
+    del wf["9"]
+    wf["6"]["inputs"]["model"] = ["1", 0]
+    with _real_run(client, named_comfy):
+        named_comfy.out_name = "qwen_image_00001_.png"
+        wf_id = _import_workflow(client, "Qwen 图片编辑（修复版）", "image", wf)
+        img = _upload(client, "门面.png")
+        r = _generate(
+            client, wf_id, {"4@prompt": "换招牌", "10": img, "4@resolution": 1536, "6@steps": 20},
+            source="studio-image",
+        )
+        assert r.status_code == 200, r.text
+        job = _wait_done(client, r.json()["job"]["id"])
+        assert job["status"] == "done" and job["output_paths"]
+    prompt = named_comfy.prompts[0]["prompt"]
+    assert prompt["10"]["inputs"]["image"] == f"calliope/{Path(img).name}"
+    assert prompt["4"]["inputs"]["images.image_1"] == ["10", 0]
+    assert prompt["4"]["inputs"]["resolution"] == 1536
+    assert prompt["6"]["inputs"]["steps"] == 20
+
+
+def test_worker_refuses_broken_workflow_from_other_callers(client, named_comfy):
+    """Workbench/agent jobs skip the playground check — the worker still stops them."""
+    from calliope.db import get_db
+    from calliope.queue.manager import queue_manager
+    from calliope.routers.playground import ensure_playground_project
+
+    with _real_run(client, named_comfy):
+        wf_id = _import_workflow(client, "Qwen 图片编辑", "image", _load(QWEN_EDIT))
+        conn = get_db(settings.db_path)
+        try:
+            pid = ensure_playground_project(conn)
+        finally:
+            conn.close()
+        job = queue_manager.enqueue(
+            project_id=pid, kind="image", workflow_id=wf_id, scene_id=None,
+            payload={"input_values": {"4@prompt": "x"}, "source": "playground"},
+        )
+        done = _wait_done(client, job["id"])
+    assert done["status"] == "failed"
+    assert "重新导出" in (done["error"] or "")
+    assert named_comfy.prompts == []

calliope-backend/tests/test_llm_profiles.py

@@ -216,6 +216,18 @@ def test_settings_accepts_agent_llm_assignments(client):
         # Unknown role keys are dropped, known roles stored (incl. explicit None)
         assert body["agent_llm_assignments"] == {"video": a_id, "story": None}
 
+        # HEL-619: updates are per-role incremental — a partial payload must
+        # not wipe roles it does not mention (rapid-switch race).
+        r = client.post(
+            "/api/settings",
+            json={"agent_llm_assignments": {"main": a_id}},
+        )
+        assert r.status_code == 200
+        body = r.json()
+        assert body["agent_llm_assignments"]["main"] == a_id
+        assert body["agent_llm_assignments"]["video"] == a_id
+        assert body["agent_llm_assignments"]["story"] is None
+
         r = client.post(
             "/api/settings",
             json={"agent_llm_assignments": {"video": "no-such-profile"}},

calliope-backend/tests/test_real_workflow_status.py

@@ -0,0 +1,411 @@
+"""HEL-627: the two workflows the user runs (Qwen Image 2.1 文生图 and
+MiniMax H3 reference 文生视频) expose every widget they really have, the
+values land in the /prompt payload, and a job is only "done" once ComfyUI
+returned real files — empty, failed, lost and placeholder runs never are."""
+
+from __future__ import annotations
+
+import json
+import threading
+import time
+from http.server import ThreadingHTTPServer
+from pathlib import Path
+
+import pytest
+
+from calliope.comfyui.parser import (
+    RESOLUTION_ASPECT_RATIOS,
+    effective_input_schema,
+    parse_dynamic_inputs,
+    resolution_selector_size,
+)
+from calliope.comfyui.validate import validate_input_values
+from calliope.config import settings
+from calliope.db import get_db
+from tests.test_studio_generation import (
+    _FakeComfyHandler,
+    _import_workflow,
+    _real_run,
+)
+
+FIXTURES = Path(__file__).parent / "fixtures" / "comfy_native"
+T2I = "wen_sheng_tu_API.json"  # image_qwen_image_2_1_t2i (2).json
+T2V = "wen_sheng_shipin_API.json"  # 01_reference_4step_sla (1).json
+
+
+def _load(name: str) -> dict:
+    return json.loads((FIXTURES / name).read_text(encoding="utf-8"))
+
+
+def _by_role(inputs: list[dict]) -> dict[str, dict]:
+    return {i["role"]: i for i in inputs if i.get("role")}
+
+
+class _StatusHandler(_FakeComfyHandler):
+    """Fake ComfyUI with /queue and scriptable history outcomes."""
+
+    def do_GET(self):
+        srv = self.server
+        if self.path == "/queue":
+            if srv.queue_mode is None:
+                self._json(404, {"error": "not found"})
+                return
+            self.server.requests.append(self.path)
+            items = [[i, pid, {}, {}, []] for i, pid in enumerate(srv.history)]
+            if srv.queue_mode == "running":
+                self._json(200, {"queue_running": items, "queue_pending": []})
+            elif srv.queue_mode == "pending":
+                blocker = [[-1, "someone-else", {}, {}, []]]
+                self._json(200, {"queue_running": blocker, "queue_pending": items})
+            else:
+                self._json(200, {"queue_running": [], "queue_pending": []})
+            return
+        if self.path.startswith("/history/"):
+            if srv.lose_history or srv.hidden_history_polls > 0:
+                srv.hidden_history_polls = max(0, srv.hidden_history_polls - 1)
+                self.server.requests.append(self.path)
+                self._json(200, {})
+                return
+        super().do_GET()
+
+    def do_POST(self):
+        super().do_POST()
+        if self.path == "/prompt" and self.server.history_patch:
+            for entry in self.server.history.values():
+                entry.update(self.server.history_patch)
+
+
+@pytest.fixture
+def status_comfy():
+    server = ThreadingHTTPServer(("127.0.0.1", 0), _StatusHandler)
+    server.requests = []
+    server.prompts = []
+    server.uploads = []
+    server.history = {}
+    server.fail_prompt = False
+    server.out_name = "out-1.png"
+    server.outputs_key = "images"
+    server.queue_mode = None
+    server.lose_history = False
+    server.hidden_history_polls = 0
+    server.history_patch = None
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        yield server
+    finally:
+        server.shutdown()
+        server.server_close()
+
+
+def _wait_final(client, job_id: int, timeout: float = 25.0) -> dict:
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        for j in client.get("/api/playground/jobs").json():
+            if j["id"] == job_id and j["status"] in ("done", "failed"):
+                return j
+        time.sleep(0.2)
+    raise AssertionError(f"job {job_id} did not finish")
+
+
+def _generate(client, wf_id: int, values: dict, source: str = "studio-image"):
+    return client.post(
+        "/api/playground/generate",
+        json={
+            "workflow_id": wf_id,
+            "input_values": values,
+            "source": source,
+            "endpoint_id": settings.comfyui_active_id,
+        },
+    )
+
+
+# ---------------------------------------------------------------------------
+# Parameter detection on the two real workflows
+# ---------------------------------------------------------------------------
+
+
+def test_real_t2i_exposes_ratio_megapixels_steps_denoise():
+    roles = _by_role(parse_dynamic_inputs(_load(T2I)))
+    assert set(roles) == {
+        "prompt", "negative", "aspect_ratio", "megapixels", "batch",
+        "seed", "steps", "cfg", "denoise",
+    }
+    ratio = roles["aspect_ratio"]
+    assert ratio["nodeId"] == "13@aspect_ratio"
+    assert ratio["kind"] == "select"
+    assert ratio["defaultValue"] == "1:1 (Square)"
+    assert ratio["options"] == list(RESOLUTION_ASPECT_RATIOS)
+    assert ratio["resolution"] == {"megapixels": "13@megapixels", "multiple": 8}
+    assert roles["megapixels"]["defaultValue"] == 1
+    assert roles["steps"]["nodeId"] == "459:458@steps"
+    assert roles["steps"]["defaultValue"] == 25 and roles["steps"]["integer"] is True
+    assert roles["denoise"]["nodeId"] == "459:458@denoise"
+    assert (roles["denoise"]["min"], roles["denoise"]["max"]) == (0.0, 1.0)
+    # Width/height are wired from ResolutionSelector; they are not faked as
+    # free inputs, and the encoder's reference-image `resolution` is not exposed.
+    assert "width" not in roles and "height" not in roles
+    assert all("resolution" not in i["nodeId"] for i in parse_dynamic_inputs(_load(T2I)))
+
+
+def test_real_t2v_exposes_ratio_steps_denoise_seed_duration():
+    inputs = parse_dynamic_inputs(_load(T2V))
+    roles = _by_role(inputs)
+    assert set(roles) == {
+        "prompt", "aspect_ratio", "megapixels", "steps", "denoise", "seed", "duration",
+    }
+    assert roles["aspect_ratio"]["defaultValue"] == "16:9 (Widescreen)"
+    assert roles["aspect_ratio"]["resolution"]["multiple"] == 32
+    assert roles["megapixels"]["defaultValue"] == 0.7
+    assert roles["steps"]["nodeId"] == "124@steps" and roles["steps"]["defaultValue"] == 4
+    assert roles["seed"]["nodeId"] == "129@noise_seed"
+    assert roles["duration"]["nodeId"] == "133" and roles["duration"]["defaultValue"] == 10
+    # BasicGuider has no CFG; the frame expression hard-codes 24 fps, so no fps field.
+    assert "cfg" not in roles and "fps" not in roles
+
+
+def test_resolution_matches_comfyui_resolution_selector():
+    # The H3 workflow's own title documents 1152x640 for 16:9 · 0.7 MP · ×32.
+    assert resolution_selector_size("16:9 (Widescreen)", 0.7, 32) == (1152, 640)
+    assert resolution_selector_size("1:1 (Square)", 1, 8) == (1024, 1024)
+    assert resolution_selector_size("9:16 (Portrait Widescreen)", 1, 8) == (768, 1368)
+
+
+def test_validation_rejects_bad_values_in_chinese():
+    schema = parse_dynamic_inputs(_load(T2I))
+    clean, errors = validate_input_values(
+        schema,
+        {
+            "459:452@prompt": "猫",
+            "13@aspect_ratio": "5:4",
+            "459:458@steps": 12.5,
+            "459:458@denoise": 1.5,
+            "13@megapixels": "abc",
+        },
+    )
+    assert any("画面比例" in e and "5:4" in e for e in errors)
+    assert any("采样步数" in e and "整数" in e for e in errors)
+    assert any("降噪强度" in e and "不能大于 1" in e for e in errors)
+    assert any("总像素" in e and "数字" in e for e in errors)
+    clean, errors = validate_input_values(schema, {"459:458@steps": "30", "13@megapixels": 2})
+    assert errors == []  # an omitted prompt falls back to the workflow's own text
+    assert clean["459:458@steps"] == 30 and isinstance(clean["459:458@steps"], int)
+
+    blank = [dict(e, defaultValue="") if e.get("role") == "prompt" else e for e in schema]
+    _, errors = validate_input_values(blank, {"459:452@prompt": "  "})
+    assert errors == ["请填写「正向提示词」"]
+
+
+def test_stale_auto_schema_is_refreshed_without_reimport(client):
+    wf = _load(T2I)
+    stale = [
+        {"nodeId": "459:452@prompt", "label": "正向提示词", "role": "prompt",
+         "kind": "textarea", "defaultValue": "x", "required": True, "auto": True},
+    ]
+    conn = get_db(settings.db_path)
+    try:
+        cur = conn.execute(
+            "INSERT INTO workflows"
+            " (name, kind, workflow_json, input_schema, output_schema, is_enabled)"
+            " VALUES (?, 'image', ?, ?, '[]', 1)",
+            ("旧导入·Qwen2.1", json.dumps(wf), json.dumps(stale)),
+        )
+        conn.commit()
+        wf_id = cur.lastrowid
+    finally:
+        conn.close()
+    roles = _by_role(client.get(f"/api/workflows/{wf_id}").json()["input_schema"])
+    assert {"aspect_ratio", "megapixels", "steps", "denoise"} <= set(roles)
+
+
+def test_tagged_schema_is_kept_as_stored():
+    stored = [{"nodeId": "6", "label": "P", "role": "prompt", "kind": "textarea",
+               "required": True}]
+    assert effective_input_schema(stored, _load(T2I)) == stored
+
+
+# ---------------------------------------------------------------------------
+# Submit payload + job status against a fake ComfyUI
+# ---------------------------------------------------------------------------
+
+
+def test_t2i_values_reach_the_prompt_payload(client, status_comfy):
+    with _real_run(client, status_comfy):
+        wf_id = _import_workflow(client, "真实·Qwen2.1(参数)", "image", _load(T2I))
+        r = _generate(
+            client,
+            wf_id,
+            {
+                "459:452@prompt": "雨夜霓虹街道",
+                "459:452@negative_prompt": "模糊",
+                "13@aspect_ratio": "16:9 (Widescreen)",
+                "13@megapixels": 2,
+                "459:458@steps": "30",
+                "459:458@cfg": 2.5,
+                "459:458@denoise": 0.8,
+                "459:458@seed": 7,
+            },
+        )
+        assert r.status_code == 200, r.text
+        job = _wait_final(client, r.json()["job"]["id"])
+        assert job["status"] == "done", job.get("error")
+        queued = status_comfy.prompts[-1]["prompt"]
+        assert queued["13"]["inputs"]["aspect_ratio"] == "16:9 (Widescreen)"
+        assert queued["13"]["inputs"]["megapixels"] == 2
+        assert queued["459:458"]["inputs"]["steps"] == 30
+        assert queued["459:458"]["inputs"]["cfg"] == 2.5
+        assert queued["459:458"]["inputs"]["denoise"] == 0.8
+        assert queued["459:458"]["inputs"]["seed"] == 7
+        assert queued["459:452"]["inputs"]["prompt"] == "雨夜霓虹街道"
+        # Wiring intact: the latent still takes its size from the selector.
+        assert queued["459:456"]["inputs"]["width"] == ["13", 0]
+        assert queued["459:456"]["inputs"]["height"] == ["13", 1]
+        assert job["comfy_prompt_id"] in status_comfy.history
+        assert job["phase"] == "finished"
+        assert job["output_paths"] and Path(job["output_paths"][0]).stat().st_size > 0
+
+
+def test_t2v_values_reach_the_prompt_payload(client, status_comfy):
+    status_comfy.outputs_key = "images"  # SaveVideo reports under "images" + animated
+    status_comfy.out_name = "clip.mp4"
+    with _real_run(client, status_comfy):
+        wf_id = _import_workflow(client, "真实·H3 参考生视频", "video", _load(T2V))
+        r = _generate(
+            client,
+            wf_id,
+            {
+                "1": "地铁车厢里的长镜头",
+                "115@aspect_ratio": "9:16 (Portrait Widescreen)",
+                "115@megapixels": 0.5,
+                "124@steps": 6,
+                "124@denoise": 1,
+                "129@noise_seed": 1234,
+                "133": 5,
+            },
+            source="studio-video",
+        )
+        assert r.status_code == 200, r.text
+        job = _wait_final(client, r.json()["job"]["id"])
+        assert job["status"] == "done", job.get("error")
+        queued = status_comfy.prompts[-1]["prompt"]
+        assert queued["1"]["inputs"]["value"] == "地铁车厢里的长镜头"
+        assert queued["115"]["inputs"]["aspect_ratio"] == "9:16 (Portrait Widescreen)"
+        assert queued["115"]["inputs"]["megapixels"] == 0.5
+        assert queued["124"]["inputs"]["steps"] == 6
+        assert queued["129"]["inputs"]["noise_seed"] == 1234
+        assert queued["133"]["inputs"]["value"] == 5
+        assert queued["132"]["inputs"]["values.a"] == ["133", 0]
+
+
+def test_invalid_values_are_rejected_before_queueing(client, status_comfy):
+    with _real_run(client, status_comfy):
+        wf_id = _import_workflow(client, "真实·Qwen2.1(校验)", "image", _load(T2I))
+        r = _generate(client, wf_id, {"459:452@prompt": "猫", "459:458@steps": 0})
+        assert r.status_code == 400
+        assert "采样步数" in r.json()["detail"] and "不能小于 1" in r.json()["detail"]
+        r = _generate(client, wf_id, {"459:452@prompt": "猫", "13@megapixels": 99})
+        assert r.status_code == 400 and "总像素" in r.json()["detail"]
+        assert "/prompt" not in status_comfy.requests
+
+
+def test_empty_outputs_never_count_as_done(client, status_comfy):
+    status_comfy.history_patch = {"outputs": {}}
+    with _real_run(client, status_comfy):
+        wf_id = _import_workflow(client, "真实·Qwen2.1(空结果)", "image", _load(T2I))
+        job = _wait_final(client, _generate(client, wf_id, {"459:452@prompt": "猫"}).json()["job"]["id"])
+        assert job["status"] == "failed"
+        assert "没有返回任何图片或视频" in job["error"]
+        assert job["comfy_prompt_id"] and job["comfy_prompt_id"] in job["error"]
+        assert job["output_paths"] == []
+
+
+def test_comfy_execution_error_is_failed_with_reason(client, status_comfy):
+    status_comfy.history_patch = {
+        "status": {
+            "status_str": "error",
+            "completed": False,
+            "messages": [
+                ["execution_start", {}],
+                ["execution_error", {"node_type": "UNETLoader",
+                                     "exception_message": "模型文件不存在"}],
+            ],
+        },
+        "outputs": {},
+    }
+    with _real_run(client, status_comfy):
+        wf_id = _import_workflow(client, "真实·Qwen2.1(执行错)", "image", _load(T2I))
+        job = _wait_final(client, _generate(client, wf_id, {"459:452@prompt": "猫"}).json()["job"]["id"])
+        assert job["status"] == "failed"
+        assert "ComfyUI 执行出错" in job["error"] and "UNETLoader" in job["error"]
+        assert "模型文件不存在" in job["error"]
+
+
+def test_prompt_lost_from_queue_and_history_fails(client, status_comfy):
+    status_comfy.lose_history = True
+    status_comfy.queue_mode = "missing"
+    with _real_run(client, status_comfy):
+        wf_id = _import_workflow(client, "真实·Qwen2.1(丢失)", "image", _load(T2I))
+        job = _wait_final(client, _generate(client, wf_id, {"459:452@prompt": "猫"}).json()["job"]["id"])
+        assert job["status"] == "failed"
+        assert "队列和历史里都找不到该任务" in job["error"]
+
+
+def test_running_then_finished_reports_real_phase(client, status_comfy):
+    status_comfy.queue_mode = "running"
+    status_comfy.hidden_history_polls = 3
+    with _real_run(client, status_comfy):
+        wf_id = _import_workflow(client, "真实·Qwen2.1(执行中)", "image", _load(T2I))
+        job_id = _generate(client, wf_id, {"459:452@prompt": "猫"}).json()["job"]["id"]
+        seen: set[str] = set()
+        deadline = time.time() + 20
+        while time.time() < deadline:
+            row = next(j for j in client.get("/api/playground/jobs").json() if j["id"] == job_id)
+            if row.get("phase"):
+                seen.add(row["phase"])
+            if row["status"] in ("done", "failed"):
+                break
+            time.sleep(0.1)
+        assert row["status"] == "done", row.get("error")
+        assert "comfy_running" in seen
+        assert "/queue" in status_comfy.requests
+
+
+def test_missing_model_rejection_names_the_file():
+    """Body captured from the user's ComfyUI 0.37.4 when Qwen 2.1 models are absent."""
+    import httpx
+
+    from calliope.comfyui.client import _surface_error
+
+    body = {
+        "error": {"type": "prompt_outputs_failed_validation"},
+        "node_errors": {
+            "459:451": {
+                "errors": [{
+                    "type": "value_not_in_list",
+                    "message": "Value not in list",
+                    "details": "unet_name: 'qwen_image_2.1_int8_convrot.safetensors' not in [...]",
+                    "extra_info": {
+                        "input_name": "unet_name",
+                        "received_value": "qwen_image_2.1_int8_convrot.safetensors",
+                    },
+                }],
+                "class_type": "UNETLoader",
+            }
+        },
+    }
+    msg = str(_surface_error("ComfyUI 拒绝执行该工作流", httpx.Response(400, json=body)))
+    assert "节点 459:451（UNETLoader）" in msg
+    assert "qwen_image_2.1_int8_convrot.safetensors" in msg and "模型文件未安装" in msg
+
+
+def test_dry_run_result_is_marked_placeholder(client):
+    wf_id = _import_workflow(client, "真实·Qwen2.1(dry)", "image", _load(T2I))
+    prev = settings.dry_run
+    settings.dry_run = True
+    try:
+        job = _wait_final(client, _generate(client, wf_id, {"459:452@prompt": "猫"}).json()["job"]["id"])
+    finally:
+        settings.dry_run = prev
+    assert job["status"] == "done"
+    assert job["phase"] == "dry_run"
+    assert job["comfy_prompt_id"] is None

calliope-backend/tests/test_shell_tool.py

@@ -13,6 +13,7 @@ The shell is default-OFF; every guard branch here is a security contract:
 from __future__ import annotations
 
 import asyncio
+import os
 import sys
 from pathlib import Path
 
@@ -25,6 +26,23 @@ from calliope.agent.harness.registry import ToolContext
 PYTHON = Path(sys.executable).stem  # bare name ("python") — the tool refuses paths
 
 
+@pytest.fixture(autouse=True, scope="module")
+def _interpreter_on_path():
+    """Make the bare interpreter name resolvable via PATH (HEL-619).
+
+    The guard resolves the command with ``shutil.which`` against PATH —
+    running pytest as ``path/to/.venv/bin/python -m pytest`` (or on a box
+    with no ``python`` alias) leaves the stem unresolvable and every
+    exec-path test fails for environmental reasons only. Prepending the
+    interpreter's own bin dir (restored afterwards) pins the lookup to the
+    interpreter actually running the suite, on every OS.
+    """
+    prev = os.environ.get("PATH", "")
+    os.environ["PATH"] = f"{Path(sys.executable).parent}{os.pathsep}{prev}"
+    yield
+    os.environ["PATH"] = prev
+
+
 @pytest.fixture(autouse=True, scope="module")
 def _never_touch_real_db():
     """Redirect data_dir before ANY write in this module (repo test rule)."""
@@ -210,12 +228,19 @@ def test_structured_shell_approval_allows(enabled):
 
 
 def test_cwd_outside_workspace_denied(enabled):
+    """Guard denial tests use PYTHON + a structured approval card (not
+    ffprobe): the interpreter resolves on every machine, and the card
+    clears the approval gate so the LATER containment check is what fires
+    (HEL-619 — ffprobe-absent boxes used to fail these for environmental
+    reasons)."""
     registry, _ = build_harness()
+    sid = _session()
+    _answer_card(sid, "Yes, run it")
     out = asyncio.run(
         registry.execute(
-            _ctx(),
+            ToolContext(session_id=sid, project_id=None),
             "run_command",
-            {"command": "ffprobe", "cwd": str(Path(settings_data_dir_home()))},
+            {"command": PYTHON, "cwd": str(settings_data_dir_home())},
         )
     )
     assert out["reason_code"] == "guard_shell_outside_workspace"
@@ -230,11 +255,13 @@ def test_sensitive_arg_denied(enabled, tmp_path):
     registry, _ = build_harness()
     secret = tmp_path / "calliope_config.json"
     secret.write_text("{}", encoding="utf-8")
+    sid = _session()
+    _answer_card(sid, "Yes, run it")
     out = asyncio.run(
         registry.execute(
-            _ctx(),
+            ToolContext(session_id=sid, project_id=None),
             "run_command",
-            {"command": "ffprobe", "args": [str(secret)]},
+            {"command": PYTHON, "args": ["-c", "print('x')", str(secret)]},
         )
     )
     assert out["reason_code"] == "guard_shell_denied_path"
@@ -244,11 +271,13 @@ def test_db_arg_denied(enabled, tmp_path):
     registry, _ = build_harness()
     db = tmp_path / "calliope.db"
     db.write_bytes(b"")
+    sid = _session()
+    _answer_card(sid, "Yes, run it")
     out = asyncio.run(
         registry.execute(
-            _ctx(),
+            ToolContext(session_id=sid, project_id=None),
             "run_command",
-            {"command": "ffprobe", "args": [str(db)]},
+            {"command": PYTHON, "args": ["-c", "print('x')", str(db)]},
         )
     )
     assert out["reason_code"] == "guard_shell_denied_path"
@@ -256,11 +285,13 @@ def test_db_arg_denied(enabled, tmp_path):
 
 def test_env_file_arg_denied(enabled):
     registry, _ = build_harness()
+    sid = _session()
+    _answer_card(sid, "Yes, run it")
     out = asyncio.run(
         registry.execute(
-            _ctx(),
+            ToolContext(session_id=sid, project_id=None),
             "run_command",
-            {"command": "ffprobe", "args": ["--", ".env"]},
+            {"command": PYTHON, "args": ["-c", "print('x')", "--", ".env"]},
         )
     )
     assert out["reason_code"] == "guard_shell_denied_path"
@@ -270,11 +301,13 @@ def test_outside_absolute_arg_denied(enabled, tmp_path):
     registry, _ = build_harness()
     outside = tmp_path / "movie.mp4"
     outside.write_bytes(b"00")
+    sid = _session()
+    _answer_card(sid, "Yes, run it")
     out = asyncio.run(
         registry.execute(
-            _ctx(),
+            ToolContext(session_id=sid, project_id=None),
             "run_command",
-            {"command": "ffprobe", "args": [str(outside)]},
+            {"command": PYTHON, "args": ["-c", "print('x')", str(outside)]},
         )
     )
     assert out["reason_code"] == "guard_shell_outside_workspace"
@@ -287,16 +320,22 @@ def test_inside_asset_arg_allowed(enabled):
     registry, _ = build_harness()
     ref = settings.assets_dir / "ref.mp4"
     ref.write_bytes(b"00")
+    sid = _session()
+    _answer_card(sid, "Yes, run it")
     out = asyncio.run(
         registry.execute(
-            _ctx(),
+            ToolContext(session_id=sid, project_id=None),
             "run_command",
-            {"command": "ffprobe", "args": ["-v", "error", str(ref)]},
+            {
+                # The asset path is a real argv entry the guard must allow
+                # (and the interpreter actually reads it).
+                "command": PYTHON,
+                "args": ["-c", "import sys; print(open(sys.argv[1]).read())", str(ref)],
+            },
         )
     )
-    # Not a real mp4 — ffprobe fails, but the GUARD must not have denied it.
-    assert out.get("reason_code") is None
-    assert out.get("exit_code") != 0 or out.get("ok") is False or out["ok"] is True
+    assert out["ok"] is True, out
+    assert "00" in out["stdout"]
 
 
 def test_workspace_relative_cwd_allowed(enabled, tmp_path):

calliope-backend/tests/test_studio_generation.py

@@ -25,9 +25,19 @@ PNG_1PX = bytes.fromhex(
 
 
 class _FakeComfyHandler(BaseHTTPRequestHandler):
-    """Minimal ComfyUI: /system_stats, /prompt, /history/{id}, /view, /upload/image."""
+    """Minimal ComfyUI: /system_stats, /prompt, /history/{id}, /view, /upload/image.
+
+    History outputs are keyed by the prompt's real output node id (what
+    ComfyUI does); a known output class that is absent falls back to
+    ``server.forced_output_node`` (default "9"). Scripted tests can pin
+    ``server.forced_output_node`` or drop entries via ``server.drop_outputs``.
+    """
 
     server_version = "FakeComfy/1.0"
+    KNOWN_OUTPUT_CLASSES = {
+        "SaveImage", "PreviewImage", "SaveImageAdvanced", "SaveImageWebsocket",
+        "SaveVideo", "VideoOutput", "VHS_VideoCombine", "AnimateDiffCombine",
+    }
 
     def do_GET(self):
         self.server.requests.append(self.path)
@@ -64,11 +74,13 @@ class _FakeComfyHandler(BaseHTTPRequestHandler):
             prompt_id = uuid.uuid4().hex
             outputs_key = self.server.outputs_key
             out_entry = {
-                outputs_key: [{"filename": self.server.out_name, "subfolder": "", "type": "output"}]
+                outputs_key: [
+                    {"filename": self.server.out_name, "subfolder": "", "type": "output"}
+                ]
             }
             self.server.history[prompt_id] = {
                 "status": {"status_str": "success", "completed": True},
-                "outputs": {"9": out_entry},
+                "outputs": {self._output_node(body): out_entry},
                 "prompt": [],
             }
             self.server.prompts.append(json.loads(body.decode("utf-8") or "{}"))
@@ -80,6 +92,19 @@ class _FakeComfyHandler(BaseHTTPRequestHandler):
             return
         self._json(404, {"error": "not found"})
 
+    def _output_node(self, body: bytes) -> str:
+        forced = getattr(self.server, "forced_output_node", None)
+        if forced:
+            return forced
+        try:
+            prompt = json.loads(body.decode("utf-8") or "{}").get("prompt") or {}
+        except json.JSONDecodeError:
+            prompt = {}
+        for nid, node in prompt.items():
+            if isinstance(node, dict) and node.get("class_type") in self.KNOWN_OUTPUT_CLASSES:
+                return str(nid)
+        return "9"
+
     def _json(self, status: int, payload: dict) -> None:
         data = json.dumps(payload).encode("utf-8")
         self.send_response(status)
@@ -109,6 +134,7 @@ def fake_comfy():
     server.fail_prompt = False
     server.out_name = "out-1.png"
     server.outputs_key = "images"
+    server.forced_output_node = None
     thread = threading.Thread(target=server.serve_forever, daemon=True)
     thread.start()
     try:

calliope-backend/tests/test_unknown_output_mapping.py

@@ -0,0 +1,371 @@
+"""HEL-638: unknown custom output nodes close the loop — no name-based
+auto-typing, feature-less sinks become mappable candidates, a usage choice
+alone never bypasses the output designation, and generation harvests (and
+checks) exactly the nodes the user mapped.
+
+Two brand-new class names drive the cases:
+
+* ``NebulaGlaxVideoVault`` — screams "video" in its name and carries a
+  filename_prefix; before HEL-638 the fuzzy name match auto-typed it video
+  and enabled the workflow.
+* ``QuarkMuffinDisplay`` — no save widget, no media link name; before
+  HEL-638 such a graph only reported ``no_output`` with no way to map.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from calliope.config import settings
+from calliope.db import get_db, migrate_db
+from tests.test_studio_generation import _real_run, _wait_done
+
+FIXTURES = Path(__file__).parent / "fixtures" / "comfy_native"
+
+
+def _vault_workflow() -> dict:
+    return {
+        "1": {"class_type": "PrimitiveStringMultiline", "inputs": {"value": "p"}},
+        "7": {
+            "class_type": "GlaxSamplerNode",
+            "inputs": {"prompt": ["1", 0], "length": 121},
+        },
+        "12": {
+            "class_type": "NebulaGlaxVideoVault",
+            "inputs": {"filename_prefix": "anim", "frames": ["7", 0]},
+        },
+    }
+
+
+def _muffin_workflow() -> dict:
+    return {
+        "1": {"class_type": "PrimitiveStringMultiline", "inputs": {"value": "p"}},
+        "7": {
+            "class_type": "GlaxSamplerNode",
+            "inputs": {"prompt": ["1", 0], "length": 121},
+        },
+        "15": {"class_type": "QuarkMuffinDisplay", "inputs": {"payload": ["7", 0]}},
+    }
+
+
+def _analyze(client, wf: dict) -> dict:
+    r = client.post("/api/workflows/analyze", json={"workflow_json": wf})
+    assert r.status_code == 200, r.text
+    return r.json()
+
+
+# ---------------------------------------------------------------------------
+# 1. Unknown outputs stay pending — names never decide (gap 1)
+# ---------------------------------------------------------------------------
+
+
+def test_video_semantic_unknown_node_is_never_auto_typed(client):
+    body = _analyze(client, _vault_workflow())
+    entry = next(o for o in body["usage_evidence"]["outputs"] if o["nodeId"] == "12")
+    assert entry["evidence"] == "unknown_node"
+    assert entry["kind"] is None  # the user picks the media type
+    assert entry["suggested_kind"] == "video"  # only a form default
+    assert body["needs_mapping"] is True
+    assert body["usage"] is None and body["usage_ambiguous"] is True
+    assert "指定实际输出节点" in body["usage_problem"]
+    codes = {(w["level"], w["code"]) for w in body["warnings"]}
+    assert ("warning", "unknown_output_node") in codes
+    assert ("error", "no_output") not in codes
+
+
+def test_choosing_a_usage_alone_does_not_bypass_output_mapping(client):
+    """create/PATCH with a usage but no output map keeps the row disabled."""
+    r = client.post(
+        "/api/workflows",
+        json={"name": "未知·视频语义", "workflow_json": _vault_workflow(),
+              "usage": "text2video", "usage_source": "user"},
+    )
+    assert r.status_code == 200, r.text
+    wf = r.json()
+    assert wf["usage"] == "text2video" and wf["usage_source"] == "user"
+    assert wf["is_enabled"] is False  # usage set, outputs still unconfirmed
+    assert wf["needs_mapping"] is True and not wf["output_map"]
+
+    gen = client.post(
+        "/api/playground/generate",
+        json={"workflow_id": wf["id"], "input_values": {"1": "x"}},
+    )
+    assert gen.status_code == 400
+
+    # forcing the switch on is refused with the mapping reason
+    r = client.patch(f"/api/workflows/{wf['id']}", json={"is_enabled": True})
+    assert r.status_code == 400
+    assert "指定" in r.json()["detail"] and "输出节点" in r.json()["detail"]
+
+
+# ---------------------------------------------------------------------------
+# 2. Feature-less unknown sinks become mappable candidates (gap 2)
+# ---------------------------------------------------------------------------
+
+
+def test_featureless_unknown_node_is_a_candidate_not_a_hard_error(client):
+    body = _analyze(client, _muffin_workflow())
+    entry = next(o for o in body["usage_evidence"]["outputs"] if o["nodeId"] == "15")
+    assert entry["evidence"] == "unknown_node" and entry["kind"] is None
+    assert body["needs_mapping"] is True
+    codes = {(w["level"], w["code"]) for w in body["warnings"]}
+    assert ("warning", "unknown_output_node") in codes
+    assert ("error", "no_output") not in codes
+
+
+def test_truly_outputless_graph_still_reports_the_chinese_error(client):
+    wf = {
+        "1": {"class_type": "CLIPTextEncode", "inputs": {"text": "p"}},
+        "2": {"class_type": "VAEDecode", "inputs": {"samples": ["1", 0]}},
+    }
+    body = _analyze(client, wf)
+    assert body["usage"] is None and body["needs_mapping"] is False
+    assert "未在图中找到输出节点" in body["usage_problem"]
+
+
+# ---------------------------------------------------------------------------
+# 3. Manual mapping → enable → scoped generation (fake ComfyUI round trip)
+# ---------------------------------------------------------------------------
+
+
+def test_manual_mapping_enables_and_extracts_from_the_mapped_node(client, fake_comfy):
+    fake_comfy.outputs_key = "gifs"
+    fake_comfy.out_name = "clip.mp4"
+    fake_comfy.forced_output_node = "12"  # the mapped node reports results
+    with _real_run(client, fake_comfy):
+        r = client.post(
+            "/api/workflows",
+            json={
+                "name": "映射·视频库",
+                "workflow_json": _vault_workflow(),
+                "usage": "text2video",
+                "usage_source": "user",
+                "output_map": [{"nodeId": "12", "kind": "video"}],
+                "output_map_source": "user",
+            },
+        )
+        assert r.status_code == 200, r.text
+        wf = r.json()
+        assert wf["is_enabled"] is True
+        assert wf["output_map"] == [{"nodeId": "12", "kind": "video"}]
+        assert wf["output_map_source"] == "user"
+
+        r = client.post(
+            "/api/playground/generate",
+            json={"workflow_id": wf["id"], "input_values": {"1": "星空延时"},
+                  "source": "studio-video"},
+        )
+        assert r.status_code == 200, r.text
+        job = _wait_done(client, r.json()["job"]["id"])
+        assert job["status"] == "done", job.get("error")
+        assert job["output_paths"][0].endswith(".mp4")
+
+
+def test_mapped_node_returning_nothing_fails_for_real(client, fake_comfy):
+    """Results that only land on an unmapped node are NOT a completion."""
+    fake_comfy.forced_output_node = "7"  # something else reports results
+    with _real_run(client, fake_comfy):
+        r = client.post(
+            "/api/workflows",
+            json={
+                "name": "映射·空手而归",
+                "workflow_json": _muffin_workflow(),
+                "usage": "text2image",
+                "usage_source": "user",
+                "output_map": [{"nodeId": "15", "kind": "image"}],
+            },
+        )
+        assert r.status_code == 200 and r.json()["is_enabled"] is True
+        r = client.post(
+            "/api/playground/generate",
+            json={"workflow_id": r.json()["id"], "input_values": {"1": "x"}},
+        )
+        assert r.status_code == 200, r.text
+        job = _wait_done(client, r.json()["job"]["id"])
+        assert job["status"] == "failed"
+        assert "没有返回任何图片或视频" in job["error"]
+        assert "15" in job["error"]  # names the node it waited on
+        assert job["output_paths"] == []
+
+
+def test_media_type_mismatch_fails_for_real(client, fake_comfy):
+    """A video mapping that only yields a png is a real failure."""
+    fake_comfy.outputs_key = "images"
+    fake_comfy.out_name = "still.png"
+    fake_comfy.forced_output_node = "12"
+    with _real_run(client, fake_comfy):
+        r = client.post(
+            "/api/workflows",
+            json={
+                "name": "映射·类型不符",
+                "workflow_json": _vault_workflow(),
+                "usage": "text2video",
+                "usage_source": "user",
+                "output_map": [{"nodeId": "12", "kind": "video"}],
+            },
+        )
+        wid = r.json()["id"]
+        r = client.post(
+            "/api/playground/generate",
+            json={"workflow_id": wid, "input_values": {"1": "x"}},
+        )
+        job = _wait_done(client, r.json()["job"]["id"])
+        assert job["status"] == "failed"
+        assert "媒体类型与映射不符" in job["error"]
+        assert job["output_paths"] == []
+
+
+# ---------------------------------------------------------------------------
+# 4. Bad / cancelled mappings
+# ---------------------------------------------------------------------------
+
+
+def test_invalid_mappings_are_rejected_in_chinese(client):
+    r = client.post(
+        "/api/workflows",
+        json={"name": "坏映射", "workflow_json": _vault_workflow(),
+              "usage": "text2video",
+              "output_map": [{"nodeId": "999", "kind": "video"}]},
+    )
+    assert r.status_code == 422 and "不存在" in r.json()["detail"]
+
+    r = client.post(
+        "/api/workflows",
+        json={"name": "坏映射2", "workflow_json": _vault_workflow(),
+              "usage": "text2video",
+              "output_map": [{"nodeId": "12", "kind": "audio"}]},
+    )
+    assert r.status_code == 422 and "媒体类型" in r.json()["detail"]
+
+    # a prompt/parameter node can never be an output
+    r = client.post(
+        "/api/workflows",
+        json={"name": "坏映射3", "workflow_json": _vault_workflow(),
+              "usage": "text2video",
+              "output_map": [{"nodeId": "1", "kind": "video"}]},
+    )
+    assert r.status_code == 422 and "不能作为输出节点" in r.json()["detail"]
+
+    wid = client.post(
+        "/api/workflows",
+        json={"name": "先好后坏", "workflow_json": _vault_workflow(),
+              "usage": "text2video",
+              "output_map": [{"nodeId": "12", "kind": "video"}]},
+    ).json()["id"]
+    r = client.patch(
+        f"/api/workflows/{wid}", json={"output_map": [{"nodeId": "42", "kind": "image"}]}
+    )
+    assert r.status_code == 422 and "不存在" in r.json()["detail"]
+
+
+def test_clearing_the_mapping_resets_to_pending(client):
+    wid = client.post(
+        "/api/workflows",
+        json={"name": "映射后清空", "workflow_json": _vault_workflow(),
+              "usage": "text2video",
+              "output_map": [{"nodeId": "12", "kind": "video"}]},
+    ).json()["id"]
+    wf = client.get(f"/api/workflows/{wid}").json()
+    assert wf["is_enabled"] is True
+
+    r = client.patch(f"/api/workflows/{wid}", json={"output_map": []})
+    assert r.status_code == 200
+    wf = r.json()
+    assert wf["is_enabled"] is False and not wf["output_map"]
+    assert wf["usage"] == "text2video"  # the usage decision survives
+    gen = client.post(
+        "/api/playground/generate",
+        json={"workflow_id": wid, "input_values": {"1": "x"}},
+    )
+    assert gen.status_code == 400
+
+
+# ---------------------------------------------------------------------------
+# 5. Saved mappings survive reanalyze / field edits / migration
+# ---------------------------------------------------------------------------
+
+
+def test_saved_mapping_survives_reanalyze_and_field_edits(client):
+    r = client.post(
+        "/api/workflows",
+        json={"name": "重分析·保映射", "workflow_json": _vault_workflow(),
+              "usage": "text2video",
+              "output_map": [{"nodeId": "12", "kind": "video"}]},
+    )
+    wid = r.json()["id"]
+
+    r = client.patch(f"/api/workflows/{wid}", json={"name": "改名不影响映射",
+                                                    "description": "编辑其他字段"})
+    wf = r.json()
+    assert wf["output_map"] == [{"nodeId": "12", "kind": "video"}]
+    assert wf["output_map_source"] == "user" and wf["is_enabled"] is True
+
+    r = client.post(f"/api/workflows/{wid}/reanalyze")
+    assert r.status_code == 200
+    wf = r.json()
+    assert wf["output_map"] == [{"nodeId": "12", "kind": "video"}]
+    assert wf["output_map_source"] == "user"
+    assert wf["usage"] == "text2video" and wf["usage_source"] == "user"
+    assert wf["is_enabled"] is True
+
+
+def test_sql_forced_enabled_row_without_mapping_is_blocked(client):
+    """Backend-direct generation on an unconfirmed row is refused."""
+    wid = client.post(
+        "/api/workflows",
+        json={"name": "强开", "workflow_json": _vault_workflow(),
+              "usage": "text2video"},
+    ).json()["id"]
+    conn = get_db(settings.db_path)
+    try:
+        conn.execute("UPDATE workflows SET is_enabled = 1 WHERE id = ?", (wid,))
+        conn.commit()
+    finally:
+        conn.close()
+    gen = client.post(
+        "/api/playground/generate",
+        json={"workflow_id": wid, "input_values": {"1": "x"}},
+    )
+    assert gen.status_code == 400
+    assert "输出节点" in gen.json()["detail"]
+
+
+def test_migration_parks_unknown_output_rows_and_keeps_trusted_ones(client):
+    import asyncio
+
+    conn = get_db(settings.db_path)
+    try:
+        # Pre-HEL-638 shape: user confirmed a usage on an unknown-output
+        # graph and the old PATCH re-enabled it.
+        conn.execute(
+            "INSERT INTO workflows (name, kind, workflow_json, input_schema,"
+            " output_schema, is_enabled, usage, usage_source)"
+            " VALUES (?, 'video', ?, '[]', '[]', 1, 'text2video', 'user')",
+            ("存量·未知输出", json.dumps(_vault_workflow())),
+        )
+        conn.commit()
+    finally:
+        conn.close()
+
+    asyncio.run(migrate_db(settings.db_path))  # idempotent re-run
+
+    wfs = {w["name"]: w for w in client.get("/api/workflows").json()}
+    parked = wfs["存量·未知输出"]
+    assert parked["is_enabled"] is False
+    assert parked["usage"] == "text2video"  # decision preserved
+    assert not parked["output_map"] and parked["needs_mapping"] is True
+
+    # A trusted five-type import keeps working untouched.
+    r = client.post(
+        "/api/workflows",
+        json={"name": "存量·可信", "kind": "image",
+              "workflow_json": json.loads(
+                  (FIXTURES / "qwen_image_t2i_API.json").read_text(encoding="utf-8")
+              )},
+    )
+    assert r.status_code == 200
+    trusted = next(w for w in client.get("/api/workflows").json() if w["id"] == r.json()["id"])
+    assert trusted["is_enabled"] is True
+    assert trusted["output_map_source"] == "auto"
+    assert any(e["nodeId"] == "60" and e["kind"] == "image" for e in trusted["output_map"])

calliope-backend/tests/test_untagged_workflows.py

@@ -58,8 +58,9 @@ def test_native_qwen_edit_detects_image_and_mask_slots():
     assert set(media) == {"78", "95"}
     assert media["95"]["role"] == "mask"
     assert "mask" in media["95"]["label"].lower() or "遮罩" in media["95"]["label"]
-    # the workflow's own image names stay valid, so the slots are optional
-    assert not media["78"]["required"] and not media["95"]["required"]
+    # HEL-633: a wired input image must be uploaded (the export's own file name
+    # rarely exists on the target ComfyUI); the mask stays optional
+    assert media["78"]["required"] and not media["95"]["required"]
 
 
 def test_untagged_h3_video_detects_prompt_duration_seed():

calliope-backend/tests/test_usage_classifier.py

@@ -0,0 +1,308 @@
+"""HEL-636 A1–A6: the five-usage classifier judges from graph evidence only.
+
+Every case feeds real (or minimally mutated) ComfyUI API exports — never a
+file name, model name or fixed node id — and asserts the usage, the media
+slots it implies, and the failure paths for ambiguous / unknown graphs.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from calliope.comfyui.lint import blocking_problem, workflow_warnings
+from calliope.comfyui.parser import (
+    classify_usage,
+    detect_untagged_inputs,
+    parse_dynamic_inputs,
+    parse_dynamic_outputs,
+)
+from calliope.comfyui.patcher import patch_workflow
+
+FIXTURES = Path(__file__).parent / "fixtures" / "comfy_native"
+EXAMPLES = Path(__file__).resolve().parents[2] / "example_ComfyUI_workflows"
+
+
+def _load(path: Path) -> dict:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _rename_everything(wf: dict, id_shift: int = 7) -> dict:
+    """Change every node id, title and widget value the classifier must not
+    depend on (model file names / prompt texts)."""
+    def new_id(nid: str) -> str:
+        return f"x{int(nid) * id_shift + 3}" if nid.isdigit() else "x" + nid.replace(":", "_")
+
+    out: dict = {}
+    for nid, node in wf.items():
+        out[new_id(nid)] = json.loads(json.dumps(node))
+    for node in out.values():
+        for val in (node.get("inputs") or {}).values():
+            if isinstance(val, list) and len(val) == 2 and str(val[0]).isdigit():
+                val[0] = new_id(str(val[0]))
+        if node.get("_meta", {}).get("title"):
+            node["_meta"]["title"] = f"改·{node['_meta']['title']}"
+        for key, val in list((node.get("inputs") or {}).items()):
+            if isinstance(val, str) and val.endswith((".safetensors", ".gguf")):
+                node["inputs"][key] = "另一个模型_" + val
+    return out
+
+
+def _media(inputs: list[dict]) -> list[dict]:
+    return [
+        i
+        for i in inputs
+        if i["kind"] in ("image", "image_list", "video", "audio")
+    ]
+
+
+# ---------------------------------------------------------------------------
+# A1 / A2 / A3: the three real shapes, plus id/title/model renames
+# ---------------------------------------------------------------------------
+
+
+def test_a1_native_t2i_is_text2image_and_form_has_no_image_slot():
+    wf = _load(FIXTURES / "qwen_image_t2i_API.json")
+    c = classify_usage(wf)
+    assert c["usage"] == "text2image"
+    assert c["ambiguous"] is False and c["needs_mapping"] is False
+    assert _media(parse_dynamic_inputs(wf)) == []
+    outs = parse_dynamic_outputs(wf)
+    assert [(o["nodeId"], o["kind"]) for o in outs] == [("60", "image")]
+
+
+def test_a2_qwen_edit_variant_with_new_ids_titles_and_model_stays_image2image():
+    wf = _rename_everything(_load(FIXTURES / "qwen_image_edit_mask_API.json"))
+    c = classify_usage(wf)
+    assert c["usage"] == "image2image"
+    inputs = parse_dynamic_inputs(wf)
+    img = [i for i in _media(inputs) if i.get("role") == "image"]
+    assert len(img) == 1 and img[0]["required"] is True
+    mask = [i for i in _media(inputs) if i.get("role") == "mask"]
+    assert len(mask) == 1  # mask never counts as an input image
+
+
+def test_a3_i2v_variant_renamed_still_image2video_first_frame_only():
+    wf = _rename_everything(_load(FIXTURES / "h3_i2v_04_API.json"))
+    c = classify_usage(wf)
+    assert c["usage"] == "image2video"
+    media = _media(parse_dynamic_inputs(wf))
+    assert [i.get("role") for i in media] == ["first_frame"]
+    # A3: no first/last pair → the pair validation must not fire
+    assert blocking_problem(wf) is None
+
+
+def test_a4_ref2va_variant_with_renamed_class_and_prefix_still_groups():
+    wf = _rename_everything(_load(FIXTURES / "h3_ref2va_05_API.json"))
+    for node in wf.values():
+        if node.get("class_type") == "MiniMaxH3ReferenceToVideo":
+            node["class_type"] = "MyFancyRefToVideo"
+            inputs = node["inputs"]
+            for k in list(inputs):
+                if k.startswith("ref_images.ref_image_"):
+                    inputs[k.replace("ref_images.ref_image_", "refs.pic_")] = inputs.pop(k)
+    c = classify_usage(wf)
+    assert c["usage"] == "ref2video"
+    groups = [i for i in detect_untagged_inputs(wf) if i["kind"] == "image_list"]
+    assert len(groups) == 1
+    g = groups[0]
+    assert g["role"] == "reference_image" and (g["min"], g["max"]) == (1, 9)
+    # patch rewires the renamed group in order and refuses a 10th image
+    key = g["nodeId"]
+    node_id = key.split("@")[0]
+    patched = patch_workflow(wf, {key: [f"/u/{i}.png" for i in range(4)]})
+    names = sorted(
+        (k for k in patched[node_id]["inputs"] if k.startswith("refs.pic_")),
+        key=lambda k: int(k.rsplit("_", 1)[-1]) if k.rsplit("_", 1)[-1].isdigit() else int(k[-1]),
+    )
+    assert names == [f"refs.pic_{i}" for i in range(4)]
+    from calliope.comfyui.validate import validate_input_values
+
+    _c, errs = validate_input_values(
+        detect_untagged_inputs(wf), {key: [f"/u/{i}.png" for i in range(10)]}
+    )
+    assert any("最多 9 张" in e for e in errs)
+
+
+def test_qwen_single_numbered_encoder_input_is_not_mistaken_for_a_group():
+    """TextEncodeQwenImage21's ``images.image_1`` stays an ordinary input slot."""
+    inputs = parse_dynamic_inputs(_load(FIXTURES / "qwen21_edit_sage_API.json"))
+    assert not any(i["kind"] == "image_list" for i in inputs)
+    assert any(i.get("role") == "image" for i in inputs)
+
+
+# ---------------------------------------------------------------------------
+# Judgment table rows from the real example library
+# ---------------------------------------------------------------------------
+
+
+def test_all_real_exports_classify():
+    expect = {
+        "qwen_image_t2i_API.json": "text2image",
+        "qwen_image_edit_mask_API.json": "image2image",
+        "qwen21_edit_sage_API.json": "image2image",
+        "h3_i2v_04_API.json": "image2video",
+        "h3_ref2va_05_API.json": "ref2video",
+        "minimax_h3_t2v_untagged_API.json": "text2video",
+        "wen_sheng_tu_API.json": "text2image",
+        "wen_sheng_shipin_API.json": "text2video",
+    }
+    for name, usage in expect.items():
+        assert classify_usage(_load(FIXTURES / name))["usage"] == usage, name
+    examples = {
+        "Krea2_t2i_20260818_API.json": "text2image",
+        "krea2_T2I_CharSheetV1_API.json": "text2image",
+        "minimax_h3-Turbo_Text2Video_20260813_API.json": "text2video",
+        "minimax_h3-Turbo_Image2Video_20260813_API.json": "text2video",
+        "MiniMax-H3-Turbo-R2V-Extend-2Refs1Vid_API.json": "ref2video",
+        "video_minimax_h3_r2v_2ref_API.json": "ref2video",
+        "video_minimax_h3_r2v_3ref_API.json": "ref2video",
+        "video_minimax_h3_r2v_4ref_API.json": "ref2video",
+        "video_minimax_h3_r2v_5ref_API.json": "ref2video",
+    }
+    for name, usage in examples.items():
+        assert classify_usage(_load(EXAMPLES / name))["usage"] == usage, name
+
+
+def test_r2v_extend_reports_its_video_input_slot():
+    wf = _load(EXAMPLES / "MiniMax-H3-Turbo-R2V-Extend-2Refs1Vid_API.json")
+    c = classify_usage(wf)
+    assert c["usage"] == "ref2video"
+    assert c["evidence"]["video_slots"], "the reference-video slot must be reported"
+    assert any("视频输入槽" in line for line in c["evidence"]["summary"])
+
+
+# ---------------------------------------------------------------------------
+# A5: ambiguity — single loose image into a video graph; multi-output graph
+# ---------------------------------------------------------------------------
+
+
+def _load_image(nid: str) -> dict:
+    return {
+        "class_type": "LoadImage",
+        "inputs": {"image": "x.png"},
+        "_meta": {"title": f"图 {nid}"},
+    }
+
+
+def test_single_loose_image_with_video_output_is_ambiguous():
+    wf = {
+        "1": {"class_type": "PrimitiveStringMultiline", "inputs": {"value": "p"}},
+        "5": {"class_type": "LoadImage", "inputs": {"image": "x.png"}},
+        "7": {
+            "class_type": "SomeVideoSampler",
+            "inputs": {"prompt": ["1", 0], "image": ["5", 0]},
+        },
+        "9": {"class_type": "SaveVideo", "inputs": {"images": ["7", 0]}},
+    }
+    c = classify_usage(wf)
+    assert c["usage"] is None and c["ambiguous"] is True
+    assert "首帧还是参考图" in c["problem"]
+
+
+def test_first_frame_role_decides_image2video_without_ambiguity():
+    wf = {
+        "1": {"class_type": "PrimitiveStringMultiline", "inputs": {"value": "p"}},
+        "5": {"class_type": "LoadImage", "inputs": {"image": "x.png"}},
+        "7": {
+            "class_type": "SomeVideoSampler",
+            "inputs": {"prompt": ["1", 0], "first_frame": ["5", 0]},
+        },
+        "9": {"class_type": "SaveVideo", "inputs": {"images": ["7", 0]}},
+    }
+    assert classify_usage(wf)["usage"] == "image2video"
+
+
+def test_same_graph_both_image_and_video_outputs_is_ambiguous():
+    wf = {
+        "1": {"class_type": "PrimitiveStringMultiline", "inputs": {"value": "p"}},
+        "5": {"class_type": "LoadImage", "inputs": {"image": "x.png"}},
+        "7": {
+            "class_type": "SomeVideoSampler",
+            "inputs": {"prompt": ["1", 0], "image": ["5", 0]},
+        },
+        "9": {"class_type": "SaveVideo", "inputs": {"images": ["7", 0]}},
+        "10": {"class_type": "SaveImage", "inputs": {"images": ["7", 1]}},
+    }
+    c = classify_usage(wf)
+    assert c["usage"] is None and c["ambiguous"] is True
+    assert "同时输出图片和视频" in c["problem"]
+
+
+def test_two_reference_images_into_a_custom_node_become_a_group_ref2video():
+    wf = {
+        "1": {"class_type": "PrimitiveStringMultiline", "inputs": {"value": "p"}},
+        "5": {"class_type": "LoadImage", "inputs": {"image": "a.png"}},
+        "6": {"class_type": "LoadImage", "inputs": {"image": "b.png"}},
+        "7": {
+            "class_type": "GenericRefToVideo",
+            "inputs": {
+                "prompt": ["1", 0],
+                "refs.pic_1": ["5", 0],
+                "refs.pic_2": ["6", 0],
+            },
+        },
+        "9": {"class_type": "SaveVideo", "inputs": {"images": ["7", 0]}},
+    }
+    c = classify_usage(wf)
+    assert c["usage"] == "ref2video"
+    groups = [i for i in detect_untagged_inputs(wf) if i["kind"] == "image_list"]
+    assert [g["nodeId"] for g in groups] == ["7@refs"]
+
+
+# ---------------------------------------------------------------------------
+# A6: failure paths — no output, unknown custom output nodes
+# ---------------------------------------------------------------------------
+
+
+def test_no_output_graph_reports_chinese_error_and_blocks():
+    wf = {
+        "1": {"class_type": "CLIPTextEncode", "inputs": {"text": "p"}},
+        "2": {"class_type": "VAEDecode", "inputs": {"samples": ["1", 0]}},
+    }
+    c = classify_usage(wf)
+    assert c["usage"] is None and c["ambiguous"] is False
+    assert "未在图中找到输出节点" in c["problem"]
+    assert blocking_problem(wf) and "未在图中找到输出节点" in blocking_problem(wf)
+
+
+def test_unknown_custom_save_node_needs_mapping_and_keeps_a_runnable_path():
+    wf = {
+        "1": {"class_type": "PrimitiveStringMultiline", "inputs": {"value": "p"}},
+        "7": {
+            "class_type": "MyCloudExporter",
+            "inputs": {"filename_prefix": "out", "render": ["8", 0]},
+        },
+        "8": {"class_type": "VAEDecode", "inputs": {"samples": ["1", 0]}},
+    }
+    c = classify_usage(wf)
+    assert c["needs_mapping"] is True
+    assert c["usage"] is None and "无法识别" in (c["problem"] or "")
+    # unknown savers are a warning (user maps them at import), not a block —
+    # once the user confirms the usage the job can still run and results are
+    # pulled from ComfyUI history's images/gifs/videos keys.
+    codes = {(w["level"], w["code"]) for w in workflow_warnings(wf)}
+    assert ("warning", "unknown_output_node") in codes
+    assert ("error", "no_output") not in codes
+
+
+def test_utility_sink_tail_is_not_an_output_and_does_not_break_detection():
+    """VideoCombine feeding a cache-cleanup tail still counts as the output."""
+    wf = _load(FIXTURES / "minimax_h3_t2v_untagged_API.json")
+    wf["9999"] = {
+        "class_type": "easy cleanGpuUsed",
+        "inputs": {"anything": ["5978", 0]},
+    }
+    c = classify_usage(wf)
+    assert c["usage"] == "text2video"
+    assert c["needs_mapping"] is False
+    assert workflow_warnings(wf) == []
+
+
+def test_evidence_lists_output_nodes_and_slots():
+    wf = _load(FIXTURES / "h3_ref2va_05_API.json")
+    c = classify_usage(wf)
+    ev = c["evidence"]
+    assert any(o["nodeId"] == "92" and o["kind"] == "video" for o in ev["outputs"])
+    assert any(s["kind"] == "image_list" for s in ev["image_slots"])
+    assert any("输出" in line for line in ev["summary"])

calliope-backend/tests/test_video_continue.py

@@ -26,6 +26,15 @@ VIDEO_WORKFLOW = {
         "inputs": {"file": ""},
         "_meta": {"title": "Previous Clip (Input:video)"},
     },
+    "30": {
+        "class_type": "VHS_VideoCombine",
+        "inputs": {"images": ["40", 0]},
+        "_meta": {"title": "Video Output (Output:video)"},
+    },
+    "40": {
+        "class_type": "VAEDecode",
+        "inputs": {"samples": ["10", 0]},
+    },
 }
 
 # Same but the video slot is missing entirely — must be rejected at enqueue.
@@ -35,6 +44,15 @@ NO_VIDEO_WORKFLOW = {
         "inputs": {"text": ""},
         "_meta": {"title": "Main Prompt (Input:prompt)"},
     },
+    "30": {
+        "class_type": "VHS_VideoCombine",
+        "inputs": {"images": ["40", 0]},
+        "_meta": {"title": "Video Output (Output:video)"},
+    },
+    "40": {
+        "class_type": "VAEDecode",
+        "inputs": {"samples": ["10", 0]},
+    },
 }
 
 
@@ -250,12 +268,14 @@ def _scene_ids(pid: int) -> list[int]:
 
 
 async def _fake_history(_client, _prompt_id, *_args):
-    """A successful ComfyUI history with one video output named out.mp4.
-    Extra positional args (job_id) are accepted for the cancel-check wiring."""
+    """A successful ComfyUI history with one video output named out.mp4,
+    reported under the workflow's real output node (30 = the tagged
+    VHS_VideoCombine). Extra positional args (job_id) are accepted for the
+    cancel-check wiring."""
     return {
         "status": {"status_str": "success", "completed": True},
         "outputs": {
-            "99": {"videos": [{"filename": "out.mp4", "subfolder": "", "type": "output"}]}
+            "30": {"videos": [{"filename": "out.mp4", "subfolder": "", "type": "output"}]}
         },
     }
 
@@ -269,7 +289,11 @@ def _stub_comfy(monkeypatch, captured: dict) -> list[str]:
     prepare_media_inputs handed it; download_image writes out.mp4. Returns
     the list that collects uploaded local paths.
     """
-    queue_manager.paused = True
+    # monkeypatch (not bare assignment): queue_manager is a process-level
+    # singleton — a bare `paused = True` leaks into every later test and
+    # stalls e.g. test_workbench's worker (HEL-619). monkeypatch restores
+    # the previous value at teardown.
+    monkeypatch.setattr(queue_manager, "paused", True)
     uploads: list[str] = []
 
     async def fake_upload_video(self, path, subfolder="calliope"):

calliope-backend/tests/test_workflow_import_confirm.py

@@ -0,0 +1,235 @@
+"""HEL-636: the two-step import closes the loop — analyze → confirm → save,
+user corrections stick (reanalyze never overwrites them), pending workflows
+cannot generate, and legacy rows migrate losslessly."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from calliope.config import settings
+from calliope.db import get_db, migrate_db
+
+FIXTURES = Path(__file__).parent / "fixtures" / "comfy_native"
+
+
+def _load(name: str) -> dict:
+    return json.loads((FIXTURES / name).read_text(encoding="utf-8"))
+
+
+AMBIGUOUS = {
+    "1": {"class_type": "PrimitiveStringMultiline", "inputs": {"value": "p"}},
+    "5": {"class_type": "LoadImage", "inputs": {"image": "x.png"}},
+    "7": {
+        "class_type": "SomeVideoSampler",
+        "inputs": {"prompt": ["1", 0], "image": ["5", 0]},
+    },
+    "9": {"class_type": "SaveVideo", "inputs": {"images": ["7", 0]}},
+}
+
+
+def test_analyze_returns_usage_evidence_and_problem(client):
+    wf = _load("qwen_image_t2i_API.json")
+    r = client.post("/api/workflows/analyze", json={"workflow_json": wf})
+    assert r.status_code == 200
+    body = r.json()
+    assert body["usage"] == "text2image"
+    assert body["usage_ambiguous"] is False and body["needs_mapping"] is False
+    assert any(o["kind"] == "image" for o in body["usage_evidence"]["outputs"])
+    assert body["usable_usage"] == [
+        "text2image", "image2image", "text2video", "image2video", "ref2video",
+    ]
+
+    r = client.post("/api/workflows/analyze", json={"workflow_json": AMBIGUOUS})
+    body = r.json()
+    assert body["usage"] is None and body["usage_ambiguous"] is True
+    assert "首帧还是参考图" in body["usage_problem"]
+    assert body["usage_evidence"]["image_slots"][0]["nodeId"] == "5"
+
+    bare = {"1": {"class_type": "Note", "inputs": {}}}
+    r = client.post("/api/workflows/analyze", json={"workflow_json": bare})
+    body = r.json()
+    assert "未在图中找到输出节点" in body["usage_problem"]
+
+
+def test_create_stores_auto_usage_and_kind(client):
+    r = client.post(
+        "/api/workflows",
+        json={"name": "自动·文生图", "workflow_json": _load("qwen_image_t2i_API.json")},
+    )
+    assert r.status_code == 200, r.text
+    wf = r.json()
+    assert wf["usage"] == "text2image" and wf["usage_source"] == "auto"
+    assert wf["kind"] == "image" and wf["is_enabled"] is True
+
+    r = client.post(
+        "/api/workflows",
+        json={"name": "自动·参考生视频", "workflow_json": _load("h3_ref2va_05_API.json")},
+    )
+    wf = r.json()
+    assert wf["usage"] == "ref2video" and wf["kind"] == "video"
+
+
+def test_ambiguous_import_stays_pending_and_cannot_generate(client):
+    r = client.post("/api/workflows", json={"name": "歧义", "workflow_json": AMBIGUOUS})
+    assert r.status_code == 200
+    wf = r.json()
+    assert wf["usage"] is None and wf["is_enabled"] is False
+
+    gen = client.post(
+        "/api/playground/generate",
+        json={"workflow_id": wf["id"], "input_values": {"1": "x"}},
+    )
+    assert gen.status_code == 400
+    assert "已停用" in gen.json()["detail"]
+    assert client.get("/api/playground/jobs").json() == []
+
+
+def test_confirm_page_correction_roundtrip(client):
+    """analyze → user picks usage + fixes the slot role → create carries both."""
+    analyzed = client.post("/api/workflows/analyze", json={"workflow_json": AMBIGUOUS}).json()
+    assert analyzed["usage"] is None
+
+    slot = analyzed["usage_evidence"]["image_slots"][0]
+    schema = [
+        {**i, "role": "first_frame", "manual": True} if i["nodeId"] == slot["nodeId"] else i
+        for i in analyzed["inputs"]
+    ]
+    r = client.post(
+        "/api/workflows",
+        json={
+            "name": "确认·图生视频",
+            "workflow_json": AMBIGUOUS,
+            "usage": "image2video",
+            "usage_source": "user",
+            "input_schema": schema,
+        },
+    )
+    assert r.status_code == 200, r.text
+    wf = r.json()
+    assert wf["usage"] == "image2video" and wf["usage_source"] == "user"
+    assert wf["kind"] == "video" and wf["is_enabled"] is True
+    # the manual role sticks on read (and through re-derivation)
+    entry = next(i for i in wf["input_schema"] if i["nodeId"] == slot["nodeId"])
+    assert entry["role"] == "first_frame"
+
+    # reanalyze refreshes the auto schema but never the user's usage
+    r = client.post(f"/api/workflows/{wf['id']}/reanalyze")
+    assert r.status_code == 200
+    fresh = r.json()
+    assert fresh["usage"] == "image2video" and fresh["usage_source"] == "user"
+    entry = next(i for i in fresh["input_schema"] if i["nodeId"] == slot["nodeId"])
+    assert entry["role"] == "first_frame" and entry.get("manual") is True
+
+
+def test_patch_usage_confirms_pending_workflow(client):
+    r = client.post("/api/workflows", json={"name": "待确认", "workflow_json": AMBIGUOUS})
+    wid = r.json()["id"]
+    assert r.json()["is_enabled"] is False
+
+    r = client.patch(f"/api/workflows/{wid}", json={"usage": "ref2video"})
+    assert r.status_code == 200
+    wf = r.json()
+    assert wf["usage"] == "ref2video" and wf["usage_source"] == "user"
+    assert wf["kind"] == "video" and wf["is_enabled"] is True
+
+    listed = next(w for w in client.get("/api/workflows").json() if w["id"] == wid)
+    assert listed["usage"] == "ref2video"
+
+
+def test_reanalyze_upgrades_auto_usage_only(client):
+    r = client.post(
+        "/api/workflows",
+        json={"name": "重分析", "workflow_json": _load("qwen_image_t2i_API.json")},
+    )
+    wid = r.json()["id"]
+    r = client.patch(f"/api/workflows/{wid}", json={"usage": "image2image", "usage_source": "user"})
+    assert r.json()["usage"] == "image2image"
+
+    r = client.post(f"/api/workflows/{wid}/reanalyze")
+    assert r.json()["usage"] == "image2image"  # user decision survives
+    assert r.json()["usage_source"] == "user"
+
+
+def test_legacy_kind_only_callers_still_work(client):
+    """Old clients post kind without usage — determinate graphs classify, the
+    row is enabled and generation proceeds as before."""
+    r = client.post(
+        "/api/workflows",
+        json={"name": "旧调用", "kind": "image", "workflow_json": _load("qwen_image_t2i_API.json")},
+    )
+    assert r.status_code == 200
+    wf = r.json()
+    assert wf["usage"] == "text2image" and wf["is_enabled"] is True
+
+
+def test_migration_backfills_usage_and_keeps_history(client):
+    """A8: pre-HEL-636 rows (direct SQL, no usage) settle on re-migration;
+    determinate ones gain usage, ambiguous ones are parked disabled, and
+    existing jobs/history stay readable with their original kind."""
+    pid = client.post("/api/projects", json={"title": "存量项目", "idea": "x"}).json()["id"]
+    conn = get_db(settings.db_path)
+    try:
+        conn.execute(
+            "INSERT INTO workflows (name, kind, workflow_json, input_schema,"
+            " output_schema, is_enabled) VALUES (?, 'image', ?, '[]', '[]', 1)",
+            ("存量·文生图", json.dumps(_load("qwen_image_t2i_API.json"))),
+        )
+        conn.execute(
+            "INSERT INTO workflows (name, kind, workflow_json, input_schema,"
+            " output_schema, is_enabled) VALUES (?, 'video', ?, '[]', '[]', 1)",
+            ("存量·歧义", json.dumps(AMBIGUOUS)),
+        )
+        conn.execute(
+            "INSERT INTO jobs (project_id, kind, workflow_id, status, payload_json,"
+            " output_paths_json) VALUES (?, 'image', NULL, 'done', '{}', ?)",
+            (pid, json.dumps(["/old/result.png"])),
+        )
+        conn.commit()
+    finally:
+        conn.close()
+
+    import asyncio
+
+    asyncio.run(migrate_db(settings.db_path))  # idempotent re-run
+
+    wfs = {w["name"]: w for w in client.get("/api/workflows").json()}
+    assert wfs["存量·文生图"]["usage"] == "text2image"
+    assert wfs["存量·文生图"]["is_enabled"] is True
+    assert wfs["存量·歧义"]["usage"] is None
+    assert wfs["存量·歧义"]["is_enabled"] is False
+    assert wfs["存量·歧义"]["kind"] == "video"  # old kind semantics untouched
+
+    jobs = client.get(f"/api/jobs?project_id={pid}").json()
+    assert any(
+        j["status"] == "done" and j["kind"] == "image" and j["output_paths"] == ["/old/result.png"]
+        for j in jobs
+    )
+
+    # a third run changes nothing (idempotent)
+    asyncio.run(migrate_db(settings.db_path))
+    wfs2 = {w["name"]: w for w in client.get("/api/workflows").json()}
+    assert wfs2["存量·文生图"]["usage"] == "text2image"
+    assert wfs2["存量·歧义"]["usage"] is None
+
+
+def test_broken_qwen_import_stays_blocked_but_recorded(client):
+    """The damaged Qwen export classifies fine (image2image); its structural
+    lint errors still refuse generation — a broken file case, not a usage case."""
+    wf_json = _load("qwen21_edit_sage_API.json")
+    r = client.post(
+        "/api/workflows/analyze", json={"workflow_json": wf_json}
+    )
+    assert r.json()["usage"] == "image2image"
+    r = client.post(
+        "/api/workflows", json={"name": "损坏·Qwen", "kind": "image", "workflow_json": wf_json}
+    )
+    assert r.status_code == 200
+    wf = r.json()
+    assert wf["usage"] == "image2image" and wf["is_enabled"] is True
+    assert any(w["level"] == "error" for w in wf["warnings"])
+    gen = client.post(
+        "/api/playground/generate",
+        json={"workflow_id": wf["id"], "input_values": {"4@prompt": "x"}},
+    )
+    assert gen.status_code == 400 and "重新导出" in gen.json()["detail"]

calliope-web/src/lib/api.ts

@@ -133,8 +133,11 @@ import type {
   SceneVideoSettings,
   Clip,
   Workflow,
+  WorkflowUsage,
+  WorkflowAnalyzeResult,
   ComfyDynamicInput,
   ComfyDynamicOutput,
+  WorkflowOutputMapEntry,
 } from "./comfy/types";
 export type {
   Job,
@@ -142,8 +145,11 @@ export type {
   SceneVideoSettings,
   Clip,
   Workflow,
+  WorkflowUsage,
+  WorkflowAnalyzeResult,
   ComfyDynamicInput,
   ComfyDynamicOutput,
+  WorkflowOutputMapEntry,
 };
 
 async function api<T>(path: string, init?: RequestInit): Promise<T> {
@@ -453,11 +459,7 @@ export const comfy = {
 export const workflows = {
   list: () => api<Workflow[]>("/api/workflows"),
   analyze: (workflow_json: Record<string, unknown>) =>
-    api<{
-      inputs: ComfyDynamicInput[];
-      outputs: ComfyDynamicOutput[];
-      suggested_profile?: string;
-    }>("/api/workflows/analyze", {
+    api<WorkflowAnalyzeResult>("/api/workflows/analyze", {
       method: "POST",
       body: JSON.stringify({ workflow_json }),
     }),
@@ -465,8 +467,13 @@ export const workflows = {
     api<Workflow>(`/api/workflows/${id}/reanalyze`, { method: "POST" }),
   create: (payload: {
     name: string;
-    kind: "image" | "video";
     workflow_json: Record<string, unknown>;
+    kind?: "image" | "video";
+    usage?: WorkflowUsage;
+    usage_source?: "auto" | "user";
+    input_schema?: ComfyDynamicInput[];
+    output_map?: WorkflowOutputMapEntry[];
+    output_map_source?: "auto" | "user";
     description?: string;
     prompt_profile?: string;
     endpoint_id?: string | null;
@@ -484,6 +491,11 @@ export const workflows = {
       description: string;
       prompt_profile: string;
       endpoint_id: string | null;
+      usage: WorkflowUsage;
+      usage_source: "auto" | "user";
+      input_schema: ComfyDynamicInput[];
+      output_map: WorkflowOutputMapEntry[];
+      output_map_source: "auto" | "user";
     }>,
   ) =>
     api<Workflow>(`/api/workflows/${id}`, {

calliope-web/src/lib/comfy/imageFile.ts

@@ -0,0 +1,26 @@
+import { t } from '$lib/i18n.svelte';
+
+/** Studio image slots (ref-upload-spec §3): PNG / JPG / WebP, ≤ 20MB each. */
+export const IMAGE_SLOT_ACCEPT = '.png,.jpg,.jpeg,.webp,image/png,image/jpeg,image/webp';
+export const IMAGE_SLOT_MAX_BYTES = 20 * 1024 * 1024;
+const IMAGE_EXTS = ['.png', '.jpg', '.jpeg', '.webp'];
+
+/** Why this file cannot fill an image slot (null = fine). */
+export function imageFileProblem(file: { name: string; size: number }): string | null {
+	const dot = file.name.lastIndexOf('.');
+	const ext = dot >= 0 ? file.name.slice(dot).toLowerCase() : '';
+	if (!IMAGE_EXTS.includes(ext)) return t('studio.errImageFormat', { name: file.name });
+	if (file.size > IMAGE_SLOT_MAX_BYTES) return t('studio.errImageSize', { name: file.name });
+	return null;
+}
+
+export function formatBytes(bytes: number): string {
+	if (bytes >= 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+	return `${Math.max(1, Math.round(bytes / 1024))} KB`;
+}
+
+/** Display name of an uploaded path (strips the uuid8- prefix the upload endpoint writes). */
+export function uploadBaseName(p: string): string {
+	const raw = p.split(/[/\\]/).pop() ?? p;
+	return /^[0-9a-f]{8}-/.test(raw) ? raw.slice(9) : raw;
+}

calliope-web/src/lib/comfy/promptInput.ts

@@ -44,6 +44,7 @@ export function compactInputValues(
 	for (const [k, v] of Object.entries(values)) {
 		if (v === null || v === undefined) continue;
 		if (typeof v === 'string' && !v.trim()) continue;
+		if (Array.isArray(v) && !v.length) continue;
 		out[k] = v;
 	}
 	return out;

calliope-web/src/lib/comfy/resolution.ts

@@ -0,0 +1,41 @@
+/**
+ * ComfyUI ResolutionSelector (comfy_extras/nodes_resolution.py) — same
+ * ratios and rounding, so the size shown is the size ComfyUI renders.
+ */
+const RATIOS: Record<string, [number, number]> = {
+	'1:1 (Square)': [1, 1],
+	'2:3 (Portrait Photo)': [2, 3],
+	'3:2 (Photo)': [3, 2],
+	'3:4 (Portrait Standard)': [3, 4],
+	'4:3 (Standard)': [4, 3],
+	'9:16 (Portrait Widescreen)': [9, 16],
+	'16:9 (Widescreen)': [16, 9],
+	'21:9 (Ultrawide)': [21, 9],
+};
+
+/** Python's round(): halves go to the even neighbour. */
+function roundHalfEven(x: number): number {
+	const f = Math.floor(x);
+	const diff = x - f;
+	if (diff > 0.5) return f + 1;
+	if (diff < 0.5) return f;
+	return f % 2 === 0 ? f : f + 1;
+}
+
+export function resolutionSelectorSize(
+	aspectRatio: string,
+	megapixels: number,
+	multiple: number,
+): { width: number; height: number } | null {
+	const ratio = RATIOS[aspectRatio];
+	if (!ratio || !Number.isFinite(megapixels) || megapixels <= 0) return null;
+	const [w, h] = ratio;
+	const m = Math.max(1, Math.floor(multiple) || 8);
+	const scale = Math.sqrt((megapixels * 1024 * 1024) / (w * h));
+	return { width: roundHalfEven((w * scale) / m) * m, height: roundHalfEven((h * scale) / m) * m };
+}
+
+/** "16:9 (Widescreen)" → "16:9". */
+export function ratioShort(option: string): string {
+	return option.split(' ')[0] ?? option;
+}

calliope-web/src/lib/comfy/types.ts

@@ -1,6 +1,24 @@
-export type ComfyInputKind = 'text' | 'textarea' | 'number' | 'image' | 'image_url' | 'audio' | 'video';
+export type ComfyInputKind =
+	| 'text'
+	| 'textarea'
+	| 'number'
+	| 'select'
+	| 'image'
+	| 'image_url'
+	| 'audio'
+	| 'video'
+	/** Ordered list of images for one Autogrow input (e.g. H3 ref_images, min…max). */
+	| 'image_list';
 export type ComfyOutputKind = 'image' | 'video' | 'other';
 
+/** Structural finding on an imported workflow; `error` blocks generation. */
+export interface WorkflowWarning {
+	level: 'error' | 'warning';
+	code: string;
+	node_id: string;
+	message: string;
+}
+
 export interface ComfyDynamicInput {
 	nodeId: string;
 	label: string;
@@ -11,14 +29,78 @@ export interface ComfyDynamicInput {
 	required: boolean;
 	/** Inferred from node classes/wiring — the workflow carries no (Input) tags. */
 	auto?: boolean;
+	/** ComfyUI widget limits (number kind). */
+	min?: number;
+	max?: number;
+	step?: number;
+	integer?: boolean;
+	/** Allowed values (select kind). */
+	options?: string[];
+	/** On a ResolutionSelector aspect_ratio entry: its megapixels key and rounding multiple. */
+	resolution?: { megapixels: string; multiple: number };
 }
 
 export interface ComfyDynamicOutput {
 	nodeId: string;
 	label: string;
-	/** Role from title tag, e.g. (Output:image) → "image". */
+	/** Role from title tag, e.g. (Output:image). */
 	role?: string | null;
-	kind: ComfyOutputKind;
+	/** Null while an unknown custom node awaits the user's media-type pick. */
+	kind: ComfyOutputKind | null;
+	/** Untagged detection: node class + which rule typed it. */
+	class_type?: string;
+	evidence?: 'registry' | 'class_name_match' | 'unknown_node';
+	/** Form default for unknown candidates — never auto-applied. */
+	suggested_kind?: 'image' | 'video' | null;
+}
+
+/** One entry of a workflow's confirmed output mapping (HEL-638). */
+export interface WorkflowOutputMapEntry {
+	nodeId: string;
+	kind: 'image' | 'video';
+	label?: string;
+	class_type?: string;
+}
+
+/** The five workflow usages the studio distinguishes (HEL-636). */
+export type WorkflowUsage =
+	| 'text2image'
+	| 'image2image'
+	| 'text2video'
+	| 'image2video'
+	| 'ref2video';
+
+export const WORKFLOW_USAGES: WorkflowUsage[] = [
+	'text2image',
+	'image2image',
+	'text2video',
+	'image2video',
+	'ref2video',
+];
+
+/** Which usages each generate page serves. */
+export const USAGE_BY_KIND: Record<'image' | 'video', WorkflowUsage[]> = {
+	image: ['text2image', 'image2image'],
+	video: ['text2video', 'image2video', 'ref2video'],
+};
+
+/** Result of POST /api/workflows/analyze (import confirm step 1). */
+export interface WorkflowAnalyzeResult {
+	inputs: ComfyDynamicInput[];
+	outputs: ComfyDynamicOutput[];
+	suggested_profile?: string;
+	warnings?: WorkflowWarning[];
+	usage: WorkflowUsage | null;
+	usage_ambiguous: boolean;
+	needs_mapping: boolean;
+	usage_problem: string | null;
+	usage_evidence: {
+		outputs: ComfyDynamicOutput[];
+		image_slots: Array<{ nodeId: string; label: string; kind: string; role: string | null }>;
+		video_slots: Array<{ nodeId: string; label: string; kind: string; role: string | null }>;
+		summary: string[];
+	};
+	usable_usage: WorkflowUsage[];
 }
 
 export interface WorkflowNode {
@@ -31,6 +113,9 @@ export interface Workflow {
 	id: number;
 	name: string;
 	kind: 'image' | 'video';
+	/** Five-way usage (HEL-636); null = pending human confirmation. */
+	usage?: WorkflowUsage | null;
+	usage_source?: 'auto' | 'user' | null;
 	workflow_json: Record<string, WorkflowNode>;
 	input_schema: ComfyDynamicInput[];
 	output_schema: ComfyDynamicOutput[];
@@ -39,6 +124,12 @@ export interface Workflow {
 	is_enabled: boolean;
 	/** Bound ComfyUI connection id (settings.comfyui_endpoints); null = active. */
 	endpoint_id?: string | null;
+	warnings?: WorkflowWarning[];
+	/** HEL-638: confirmed output mapping ({nodeId, kind}); null/empty = pending. */
+	output_map?: WorkflowOutputMapEntry[] | null;
+	output_map_source?: 'auto' | 'user' | null;
+	/** True when the graph has unknown output nodes needing designation. */
+	needs_mapping?: boolean;
 }
 
 export interface Job {
@@ -57,6 +148,10 @@ export interface Job {
 	started_at: string | null;
 	completed_at: string | null;
 	retry_count: number;
+	/** Prompt id ComfyUI accepted this job under (null until /prompt succeeds). */
+	comfy_prompt_id?: string | null;
+	/** connecting · comfy_queued · comfy_running · saving · finished · dry_run */
+	phase?: string | null;
 }
 
 export interface SceneVideoSettings {

calliope-web/src/lib/components/ComfyDynamicForm.svelte

@@ -260,6 +260,18 @@
 						oninput={(e) => setNumberValue(inp.nodeId, e.currentTarget.value)}
 						onblur={() => markTouched(inp.nodeId)}
 					/>
+				{:else if inp.kind === 'select'}
+					<select
+						{id}
+						class:invalid={errored}
+						value={current || String(inp.defaultValue ?? '')}
+						onchange={(e) => setValue(inp.nodeId, e.currentTarget.value)}
+						onblur={() => markTouched(inp.nodeId)}
+					>
+						{#each inp.options ?? [] as opt (opt)}
+							<option value={opt}>{opt}</option>
+						{/each}
+					</select>
 				{:else if allowUpload && isUploadKind(inp.kind)}
 					{@const uploadingName = uploading[inp.nodeId]}
 					{@const isUpload = !!current && !assetOptions.some((o) => o.path === current)}

calliope-web/src/lib/components/OmniComposer.svelte

@@ -346,6 +346,16 @@
 								value={values[nodeId] ?? ctrl.input.defaultValue ?? ''}
 								oninput={(e) => setValue(nodeId, Number(e.currentTarget.value) || 0)}
 							/>
+						{:else if ctrl.input.kind === 'select'}
+							<select
+								class="adv-input"
+								value={String(values[nodeId] ?? ctrl.input.defaultValue ?? '')}
+								onchange={(e) => setValue(nodeId, e.currentTarget.value)}
+							>
+								{#each ctrl.input.options ?? [] as opt (opt)}
+									<option value={opt}>{opt}</option>
+								{/each}
+							</select>
 						{:else}
 							<input
 								class="adv-input"

calliope-web/src/lib/components/studio/MediaSlot.svelte

@@ -2,22 +2,31 @@
 	import Icon from '$lib/components/ui/Icon.svelte';
 	import Spinner from '$lib/components/ui/Spinner.svelte';
 	import { assetUrl } from '$lib/api';
+	import { IMAGE_SLOT_ACCEPT, formatBytes, uploadBaseName } from '$lib/comfy/imageFile';
 	import { t } from '$lib/i18n.svelte';
 
 	/**
-	 * A-style media upload slot (spec-v2 §5 上传槽): empty = 1.5px dashed
-	 * border + "click or drop", drag-hover = amber dashed, filled = solid
-	 * border + thumbnail + mono name + ✕, error = red border + red reason.
+	 * A-style media upload slot (spec-v2 §5 上传槽, ref-upload-spec §2):
+	 * empty = 1.5px dashed border + "click or drop" + format line, drag-hover
+	 * = amber dashed, filled = solid border + thumb + name + size + 替换 + ✕,
+	 * error = red border + red reason.
 	 */
 	interface Props {
 		label: string;
-		/** Extra hint under the label, e.g. 可从生图结果送入. */
+		/** Hint on the right of the label, e.g. 必填 · 1 张 / 可从生图结果送入. */
 		hint?: string;
+		required?: boolean;
 		/** Current value: a server-side path ('' = empty). */
 		value: string;
 		kind: 'image' | 'video' | 'audio';
 		/** Thumb aspect: wide = 16:9 (first/last frame slots). */
 		aspect?: 'square' | 'wide';
+		/** Empty-state main line (defaults to 点击或拖入). */
+		emptyText?: string;
+		/** Empty-state mono line, e.g. accepted formats and size limit. */
+		emptySub?: string;
+		/** Byte size of the current file when known. */
+		size?: number;
 		uploading?: boolean;
 		uploadName?: string;
 		error?: string;
@@ -31,9 +40,13 @@
 	let {
 		label,
 		hint,
+		required = false,
 		value,
 		kind,
 		aspect = 'square',
+		emptyText,
+		emptySub,
+		size,
 		uploading = false,
 		uploadName,
 		error,
@@ -46,21 +59,24 @@
 	let fileInput = $state<HTMLInputElement | null>(null);
 	let dragDepth = $state(0);
 	let broken = $state(false);
+	let dims = $state('');
 	$effect(() => {
 		void value;
 		broken = false;
+		dims = '';
 	});
 
+	const meta = $derived([dims, size != null ? formatBytes(size) : ''].filter(Boolean).join(' · '));
+
 	function accept(): string {
 		if (kind === 'video') return 'video/*,.mp4,.webm,.mov,.mkv';
 		if (kind === 'audio') return 'audio/*';
-		return 'image/*';
+		return IMAGE_SLOT_ACCEPT;
 	}
 
-	function baseName(p: string): string {
-		const raw = p.split(/[/\\]/).pop() ?? p;
-		// strip uuid8- prefix the upload endpoint writes
-		return /^[0-9a-f]{8}-/.test(raw) ? raw.slice(9) : raw;
+	function noteDims(e: Event) {
+		const img = e.currentTarget as HTMLImageElement;
+		if (img.naturalWidth) dims = `${img.naturalWidth}×${img.naturalHeight}`;
 	}
 
 	function pick() {
@@ -80,7 +96,7 @@
 
 <div class="media-slot" class:wide={aspect === 'wide'}>
 	<div class="slot-label">
-		<span class="lbl">{label}</span>
+		<span class="lbl">{label}{#if required}<em>*</em>{/if}</span>
 		{#if hint}<span class="slot-hint">{hint}</span>{/if}
 	</div>
 
@@ -100,8 +116,10 @@
 	{#if value && !broken}
 		<div class="slot-filled" class:invalid={!!error}>
 			<div class="slot-thumb">
-				{#if kind === 'image'}
-					<img src={assetUrl(value)} alt={label} onerror={() => (broken = true)} />
+				{#if uploading}
+					<Spinner size="sm" />
+				{:else if kind === 'image'}
+					<img src={assetUrl(value)} alt={label} onload={noteDims} onerror={() => (broken = true)} />
 				{:else if kind === 'video'}
 					<video src={assetUrl(value)} preload="metadata" muted></video>
 					<span class="kind-badge" aria-hidden="true"><Icon name="film" size={12} /></span>
@@ -110,22 +128,29 @@
 				{/if}
 			</div>
 			<div class="slot-meta">
-				<span class="mono name" title={baseName(value)}>{baseName(value)}</span>
-				<div class="slot-actions">
-					{#if allowFromResults && onFromResults}
-						<button type="button" class="mini-link" onclick={onFromResults}>
-							{t('studio.slotFromResults')}
-						</button>
-					{/if}
-					<button
-						type="button"
-						class="slot-clear"
-						aria-label={t('studio.deleteBtn')}
-						onclick={onClear}
-					>
-						<Icon name="close" size={13} />
+				<span class="name" title={uploading ? uploadName : uploadBaseName(value)}>
+					{uploading ? uploadName : uploadBaseName(value)}
+				</span>
+				{#if meta && !uploading}<span class="mono dims">{meta}</span>{/if}
+			</div>
+			<div class="slot-actions">
+				{#if allowFromResults && onFromResults}
+					<button type="button" class="mini-link" onclick={onFromResults}>
+						{t('studio.slotFromResultsShort')}
 					</button>
-				</div>
+				{/if}
+				<button type="button" class="mini-link" disabled={uploading} onclick={pick}>
+					{t('studio.refReplace')}
+				</button>
+				<button
+					type="button"
+					class="slot-clear"
+					aria-label={t('studio.deleteBtn')}
+					disabled={uploading}
+					onclick={onClear}
+				>
+					<Icon name="close" size={12} />
+				</button>
 			</div>
 		</div>
 	{:else}
@@ -151,7 +176,8 @@
 				<span class="pick-text">{uploadName ?? t('studio.slotPick')}</span>
 			{:else}
 				<Icon name={kind === 'video' ? 'film' : kind === 'audio' ? 'music' : 'image'} size={16} />
-				<span class="pick-text">{t('studio.slotPick')}</span>
+				<span class="pick-text">{emptyText ?? t('studio.slotPick')}</span>
+				{#if emptySub}<span class="pick-sub mono">{emptySub}</span>{/if}
 			{/if}
 		</button>
 		{#if allowFromResults && onFromResults}
@@ -181,6 +207,11 @@
 		font-weight: 600;
 		color: var(--text-2);
 	}
+	.lbl em {
+		color: var(--error);
+		font-style: normal;
+		margin-left: 2px;
+	}
 	.slot-hint {
 		font-size: 10.5px;
 		color: var(--text-3);
@@ -234,7 +265,12 @@
 		opacity: 0.7;
 	}
 	.pick-text {
+		font-size: 12.5px;
+		color: var(--text-2);
+	}
+	.pick-sub {
 		font-size: 11px;
+		color: var(--text-3);
 	}
 	.from-results-link {
 		align-self: flex-end;
@@ -251,18 +287,21 @@
 	}
 	.slot-filled {
 		display: flex;
-		flex-direction: column;
-		gap: 6px;
+		align-items: center;
+		gap: 10px;
 		border: 1px solid var(--border-strong);
 		border-radius: 8px;
 		background: var(--surface-2);
 		padding: 8px;
 	}
 	.slot-filled.invalid {
-		border-color: rgba(229, 72, 77, 0.65);
+		border-color: var(--error);
 	}
 	.slot-thumb {
-		border-radius: 7px;
+		width: 56px;
+		height: 56px;
+		flex-shrink: 0;
+		border-radius: 6px;
 		overflow: hidden;
 		background: var(--bg);
 		border: 1px solid var(--border);
@@ -271,39 +310,39 @@
 		justify-content: center;
 		position: relative;
 	}
+	.media-slot.wide .slot-thumb {
+		width: 88px;
+		height: 50px;
+	}
 	.slot-thumb img,
 	.slot-thumb video {
 		display: block;
 		width: 100%;
-		max-height: 140px;
-		object-fit: cover;
-	}
-	.media-slot.wide .slot-thumb {
-		aspect-ratio: 16 / 9;
-	}
-	.media-slot.wide .slot-thumb img,
-	.media-slot.wide .slot-thumb video {
-		max-height: none;
 		height: 100%;
+		object-fit: cover;
 	}
 	.slot-thumb .kind-badge {
 		color: var(--text-3);
 	}
 	.slot-meta {
+		flex: 1;
 		display: flex;
-		align-items: center;
-		gap: 8px;
+		flex-direction: column;
+		gap: 3px;
 		min-width: 0;
 	}
 	.name {
-		flex: 1;
-		min-width: 0;
-		font-size: 10.5px;
-		color: var(--text-3);
+		font-size: 12.5px;
+		color: var(--text);
 		overflow: hidden;
 		text-overflow: ellipsis;
 		white-space: nowrap;
 	}
+	.dims {
+		font-size: 10.5px;
+		color: var(--text-3);
+		white-space: nowrap;
+	}
 	.slot-actions {
 		display: inline-flex;
 		align-items: center;
@@ -315,12 +354,17 @@
 		border: none;
 		padding: 0;
 		font-family: inherit;
-		font-size: 10.5px;
-		color: var(--accent);
+		font-size: 11.5px;
+		color: var(--text-2);
+		text-decoration: underline;
 		cursor: pointer;
 	}
-	.mini-link:hover {
-		text-decoration: underline;
+	.mini-link:hover:not(:disabled) {
+		color: var(--accent);
+	}
+	.mini-link:disabled {
+		opacity: 0.5;
+		cursor: default;
 	}
 	.slot-clear {
 		display: inline-flex;
@@ -330,7 +374,7 @@
 		height: 22px;
 		border: none;
 		border-radius: 6px;
-		background: transparent;
+		background: var(--surface-3);
 		color: var(--text-3);
 		cursor: pointer;
 	}

calliope-web/src/lib/components/studio/RefImageGrid.svelte

@@ -0,0 +1,446 @@
+<script lang="ts">
+	import Icon from '$lib/components/ui/Icon.svelte';
+	import Spinner from '$lib/components/ui/Spinner.svelte';
+	import { assetUrl } from '$lib/api';
+	import { IMAGE_SLOT_ACCEPT, formatBytes, uploadBaseName } from '$lib/comfy/imageFile';
+	import { t } from '$lib/i18n.svelte';
+
+	/**
+	 * Reference-image grid (ref-upload-spec §2 `.refgrid`): numbered cells
+	 * 参考图 1…N in the order they reach the workflow, each with replace and
+	 * ✕; a dashed add cell while below `max`; rejected files show as error
+	 * cells that take no place in the list.
+	 */
+	interface Reject {
+		name: string;
+		message: string;
+	}
+	interface Props {
+		label: string;
+		paths: string[];
+		max: number;
+		/** Byte sizes of files uploaded in this session, by server path. */
+		sizes?: Record<string, number>;
+		/** Name of the file being uploaded (add or replace), if any. */
+		uploadingName?: string;
+		/** Index being replaced while uploading (-1 = adding). */
+		uploadingIndex?: number;
+		rejects?: Reject[];
+		error?: string;
+		allowFromResults?: boolean;
+		onAdd: (files: File[]) => void;
+		onReplace: (index: number, file: File) => void;
+		onRemove: (index: number) => void;
+		onDismissReject: (index: number) => void;
+		onFromResults?: () => void;
+	}
+
+	let {
+		label,
+		paths,
+		max,
+		sizes = {},
+		uploadingName,
+		uploadingIndex = -1,
+		rejects = [],
+		error,
+		allowFromResults = false,
+		onAdd,
+		onReplace,
+		onRemove,
+		onDismissReject,
+		onFromResults,
+	}: Props = $props();
+
+	let addInput = $state<HTMLInputElement | null>(null);
+	let replaceInput = $state<HTMLInputElement | null>(null);
+	let replaceIndex = $state(-1);
+	let dragDepth = $state(0);
+	let dims = $state<Record<string, string>>({});
+
+	const uploading = $derived(!!uploadingName);
+	const remaining = $derived(Math.max(0, max - paths.length));
+
+	function pickAdd() {
+		if (uploading || !addInput) return;
+		addInput.value = '';
+		addInput.click();
+	}
+
+	function pickReplace(i: number) {
+		if (uploading || !replaceInput) return;
+		replaceIndex = i;
+		replaceInput.value = '';
+		replaceInput.click();
+	}
+
+	function onDrop(e: DragEvent) {
+		e.preventDefault();
+		dragDepth = 0;
+		if (uploading) return;
+		const files = Array.from(e.dataTransfer?.files ?? []);
+		if (files.length) onAdd(files);
+	}
+
+	function noteDims(path: string, e: Event) {
+		const img = e.currentTarget as HTMLImageElement;
+		if (img.naturalWidth) dims = { ...dims, [path]: `${img.naturalWidth}×${img.naturalHeight}` };
+	}
+
+	function metaOf(path: string): string {
+		return [dims[path], sizes[path] != null ? formatBytes(sizes[path]) : null].filter(Boolean).join(' · ');
+	}
+</script>
+
+<div class="refgrid-field">
+	<div class="slot-label">
+		<span class="lbl">{label}<em>*</em></span>
+		<span class="slot-hint">{t('studio.refHint', { n: paths.length, max })}</span>
+	</div>
+
+	<input
+		bind:this={addInput}
+		type="file"
+		class="sr-file"
+		tabindex="-1"
+		aria-hidden="true"
+		accept={IMAGE_SLOT_ACCEPT}
+		multiple
+		onchange={(e) => {
+			const files = Array.from(e.currentTarget.files ?? []);
+			if (files.length) onAdd(files);
+		}}
+	/>
+	<input
+		bind:this={replaceInput}
+		type="file"
+		class="sr-file"
+		tabindex="-1"
+		aria-hidden="true"
+		accept={IMAGE_SLOT_ACCEPT}
+		onchange={(e) => {
+			const f = e.currentTarget.files?.[0];
+			if (f && replaceIndex >= 0) onReplace(replaceIndex, f);
+		}}
+	/>
+
+	<div class="refgrid">
+		{#each paths as path, i (path + i)}
+			<div class="ref-cell" class:busy={uploadingIndex === i}>
+				<button
+					type="button"
+					class="ref-thumb"
+					title={t('studio.refReplace')}
+					onclick={() => pickReplace(i)}
+				>
+					<img src={assetUrl(path)} alt={t('studio.slotRefN', { n: i + 1 })} onload={(e) => noteDims(path, e)} />
+					<span class="ref-no mono">{i + 1}</span>
+					{#if uploadingIndex === i}
+						<span class="ref-busy"><Spinner size="sm" /></span>
+					{/if}
+				</button>
+				<button
+					type="button"
+					class="ref-x"
+					aria-label={t('studio.refRemove', { n: i + 1 })}
+					onclick={() => onRemove(i)}
+				>
+					<Icon name="close" size={11} />
+				</button>
+				<span class="ref-name" title={uploadBaseName(path)}>{uploadBaseName(path)}</span>
+				<span class="ref-meta mono">
+					{metaOf(path)}
+					<button type="button" class="mini-link" onclick={() => pickReplace(i)}>{t('studio.refReplace')}</button>
+				</span>
+			</div>
+		{/each}
+
+		{#each rejects as rej, i (rej.name + i)}
+			<div class="ref-cell rejected" role="alert">
+				<div class="ref-thumb error">
+					<Icon name="close" size={16} />
+					<span class="mono">{t('studio.refRejectedShort')}</span>
+				</div>
+				<button
+					type="button"
+					class="ref-x"
+					aria-label={t('studio.deleteBtn')}
+					onclick={() => onDismissReject(i)}
+				>
+					<Icon name="close" size={11} />
+				</button>
+				<span class="ref-name err" title={rej.name}>{rej.name}</span>
+			</div>
+		{/each}
+
+		{#if remaining > 0}
+			<button
+				type="button"
+				class="ref-add"
+				class:drag={dragDepth > 0}
+				class:invalid={!!error}
+				disabled={uploading}
+				aria-busy={uploading || undefined}
+				onclick={pickAdd}
+				ondragenter={(e) => {
+					e.preventDefault();
+					dragDepth += 1;
+				}}
+				ondragleave={() => (dragDepth = Math.max(0, dragDepth - 1))}
+				ondragover={(e) => e.preventDefault()}
+				ondrop={onDrop}
+			>
+				{#if uploading && uploadingIndex < 0}
+					<Spinner size="sm" />
+					<span class="add-main">{uploadingName}</span>
+				{:else}
+					<Icon name="plus" size={16} />
+					<span class="add-main">{t('studio.refAdd')}</span>
+					<span class="add-sub mono">{t('studio.refAddSub', { n: remaining, max })}</span>
+				{/if}
+			</button>
+		{/if}
+	</div>
+
+	{#if allowFromResults && onFromResults && remaining > 0}
+		<button type="button" class="from-results-link" onclick={onFromResults}>
+			{t('studio.slotFromResults')}
+		</button>
+	{/if}
+	{#if remaining === 0}
+		<span class="full-note">{t('studio.refFull', { max })}</span>
+	{/if}
+	{#each rejects as rej, i (rej.name + i)}
+		<span class="slot-error">{rej.message}</span>
+	{/each}
+	{#if error?.trim()}<span class="slot-error" role="alert">{error}</span>{/if}
+</div>
+
+<style>
+	.refgrid-field {
+		display: flex;
+		flex-direction: column;
+		gap: 6px;
+		min-width: 0;
+	}
+	.slot-label {
+		display: flex;
+		align-items: baseline;
+		justify-content: space-between;
+		gap: 8px;
+	}
+	.lbl {
+		font-size: 12px;
+		font-weight: 600;
+		color: var(--text-2);
+	}
+	.lbl em {
+		color: var(--error);
+		font-style: normal;
+		margin-left: 2px;
+	}
+	.slot-hint {
+		font-size: 10.5px;
+		color: var(--text-3);
+		white-space: nowrap;
+	}
+	.sr-file {
+		position: absolute;
+		width: 1px;
+		height: 1px;
+		overflow: hidden;
+		clip: rect(0 0 0 0);
+		white-space: nowrap;
+		border: 0;
+	}
+	.refgrid {
+		display: grid;
+		grid-template-columns: repeat(3, minmax(0, 1fr));
+		gap: 8px;
+	}
+	.ref-cell {
+		position: relative;
+		display: flex;
+		flex-direction: column;
+		gap: 3px;
+		min-width: 0;
+		padding: 5px;
+		border: 1px solid var(--border-strong);
+		border-radius: 8px;
+		background: var(--surface-2);
+	}
+	.ref-cell.rejected {
+		border-color: var(--error);
+	}
+	.ref-thumb {
+		position: relative;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		aspect-ratio: 1;
+		padding: 0;
+		border: 1px solid var(--border);
+		border-radius: 6px;
+		overflow: hidden;
+		background: var(--bg);
+		cursor: pointer;
+	}
+	.ref-thumb img {
+		width: 100%;
+		height: 100%;
+		object-fit: cover;
+		display: block;
+	}
+	.ref-thumb.error {
+		flex-direction: column;
+		gap: 4px;
+		cursor: default;
+		color: var(--error);
+		font-size: 10px;
+	}
+	.ref-no {
+		position: absolute;
+		left: 4px;
+		top: 4px;
+		min-width: 16px;
+		padding: 0 4px;
+		border-radius: 4px;
+		background: rgba(0, 0, 0, 0.62);
+		color: var(--text);
+		font-size: 10px;
+		line-height: 16px;
+		text-align: center;
+	}
+	.ref-busy {
+		position: absolute;
+		inset: 0;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		background: rgba(0, 0, 0, 0.5);
+	}
+	.ref-x {
+		position: absolute;
+		top: 9px;
+		right: 9px;
+		display: inline-flex;
+		align-items: center;
+		justify-content: center;
+		width: 18px;
+		height: 18px;
+		padding: 0;
+		border: none;
+		border-radius: 5px;
+		background: rgba(0, 0, 0, 0.62);
+		color: var(--text);
+		cursor: pointer;
+	}
+	.ref-x:hover {
+		color: var(--error);
+	}
+	.ref-name {
+		font-size: 11px;
+		color: var(--text);
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
+	.ref-name.err {
+		color: var(--error);
+	}
+	.ref-meta {
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		gap: 4px;
+		font-size: 9.5px;
+		color: var(--text-3);
+		white-space: nowrap;
+		overflow: hidden;
+	}
+	.mini-link {
+		background: none;
+		border: none;
+		padding: 0;
+		font-family: inherit;
+		font-size: 10.5px;
+		color: var(--text-2);
+		text-decoration: underline;
+		cursor: pointer;
+		flex-shrink: 0;
+	}
+	.mini-link:hover {
+		color: var(--accent);
+	}
+	.ref-add {
+		display: flex;
+		flex-direction: column;
+		align-items: center;
+		justify-content: center;
+		gap: 4px;
+		min-height: 110px;
+		padding: 8px 4px;
+		border: 1.5px dashed var(--border-strong);
+		border-radius: 8px;
+		background: var(--surface-2);
+		color: var(--text-3);
+		font-family: inherit;
+		cursor: pointer;
+		transition:
+			border-color 150ms,
+			color 150ms;
+	}
+	.ref-add:hover:not(:disabled) {
+		color: var(--text-2);
+	}
+	.ref-add.drag {
+		border-color: var(--accent);
+		color: var(--accent);
+	}
+	.ref-add.invalid {
+		border-color: var(--error);
+	}
+	.ref-add:disabled {
+		cursor: default;
+		opacity: 0.7;
+	}
+	.add-main {
+		font-size: 12px;
+		color: var(--text-2);
+		text-align: center;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		max-width: 100%;
+	}
+	.add-sub {
+		font-size: 10px;
+		text-align: center;
+	}
+	.from-results-link {
+		align-self: flex-end;
+		background: none;
+		border: none;
+		padding: 0;
+		font-family: inherit;
+		font-size: 11px;
+		color: var(--accent);
+		cursor: pointer;
+	}
+	.from-results-link:hover {
+		text-decoration: underline;
+	}
+	.full-note {
+		font-size: 11px;
+		color: var(--text-3);
+	}
+	.slot-error {
+		font-size: 11.5px;
+		color: var(--error);
+		line-height: 1.5;
+	}
+	@media (max-width: 1023px) {
+		.refgrid {
+			grid-template-columns: repeat(auto-fill, minmax(120px, 1fr));
+		}
+	}
+</style>

calliope-web/src/lib/i18n/de.ts

@@ -1398,6 +1398,54 @@ export const de: Dict = {
 	'conn.wfJsonInvalid': 'Kein gültiges API-Format-JSON (erwartet: Objekt aus Knoten-ID → {{…class_type…}})',
 	'conn.wfJsonPh': 'ComfyUI-API-JSON hier einfügen oder rechts eine Datei wählen',
 	'conn.wfDeleted': 'Workflow gelöscht',
+	'conn.wfImportedBroken': 'Imported, but the workflow file is incomplete and must be re-exported before generating: {detail}',
+	'conn.wfBrokenBadge': 'Incomplete file — cannot generate',
+	// --- Five usages & import confirmation (HEL-636) ---
+	'usage.text2image': 'Text → Image',
+	'usage.image2image': 'Image → Image',
+	'usage.text2video': 'Text → Video',
+	'usage.image2video': 'Image → Video',
+	'usage.ref2video': 'Reference → Video',
+	'usage.pending': 'Usage pending',
+	'wfRole.image': 'Input image',
+	'wfRole.first_frame': 'First frame',
+	'wfRole.last_frame': 'Last frame',
+	'wfRole.reference_image': 'Reference',
+	'wfRole.mask': 'Mask',
+	'conn.wfImportAction': 'Import workflow',
+	'conn.wfConfirmTitle': 'Confirm detection',
+	'conn.wfStepAnalyze': 'Paste & analyze',
+	'conn.wfStepConfirm': 'Confirm & save',
+	'conn.wfChooseFile': 'Choose file',
+	'conn.wfAnalyze': 'Analyze',
+	'conn.wfAnalyzing': 'Analyzing…',
+	'conn.wfConfirmHint': 'Review the evidence, output nodes and image slots; correct the usage or slot roles before saving.',
+	'conn.wfUsageLabel': 'Usage',
+	'conn.wfUsageAuto': 'Auto-detected: {usage}',
+	'conn.wfUsageNeedPick': 'Pick manually',
+	'conn.wfPickUsage': 'Choose a usage first',
+	'conn.wfSlotsLabel': 'Image slots',
+	'conn.wfSlotsHint': 'Roles are inferred from wiring; override them (input image / first / last frame / reference / mask) and the manual choice sticks.',
+	'conn.wfBack': 'Back',
+	'conn.wfConfirmSave': 'Confirm & save',
+	'conn.wfImportedWithUsage': 'Saved as “{usage}” with {n} fillable parameters',
+	'conn.wfPendingCount': '{n} pending',
+	'conn.wfConfirmed': 'Usage confirmed: {usage} — the workflow can generate now',
+	'conn.wfSourceUser': 'Usage set manually; re-analysis will not overwrite it',
+	'conn.wfSourceAuto': 'Usage auto-detected',
+	'conn.wfDisabledBadge': 'Disabled',
+	'conn.wfConfirmAria': 'Confirm workflow usage',
+	'conn.wfOutputLabel': 'Ausgabeknoten',
+	'conn.wfOutputNeedPick': 'Unbekannte benutzerdefinierte Ausgabeknoten — bitte zuordnen',
+	'conn.wfOutputHint': 'Markieren Sie die Knoten, die tatsächlich Ergebnisse liefern, und wählen Sie je den Medientyp; die Generierung sammelt Bilder/Videos nur aus diesen Knoten.',
+	'conn.wfOutputPick': 'Mindestens einen Ausgabeknoten markieren',
+	'conn.wfOutputKindAria': 'Medientyp des Ausgabeknotens',
+	'conn.wfOutputPendingBadge': 'Ausgabe offen',
+	'conn.wfOutputNeedMap': 'Dieser Workflow enthält nicht erkannte Ausgabeknoten; ordnen Sie sie samt Medientyp zu, um ihn zu aktivieren',
+	'conn.wfOutputApply': 'Ausgabezuordnung speichern',
+	'conn.wfMapCancel': 'Abbrechen',
+	'conn.wfOutputApplied': 'Ausgabezuordnung gespeichert: Knoten {nodes}',
+	'conn.wfOutputCleared': 'Ausgabezuordnung gelöscht — der Workflow ist wieder ausstehend',
 	'conn.missingMaterial': 'Ein dediziertes Qwen Image 2.1-Workflow-JSON fehlt noch im Repo: aus ComfyUI exportieren und hier importieren — der generische Importweg steht bereit.',
 
 	// --- Eigenständige Bild-/Videogenerierung (a3/a4, HEL-612) ---
@@ -1499,6 +1547,34 @@ export const de: Dict = {
 	'studio.wfNoParamsNote': 'Dieser Workflow hat keine ausfüllbaren Parameter und läuft mit eingebautem Prompt und Einstellungen. Um sie hier auszufüllen, Knotentitel in ComfyUI mit (Input:prompt) usw. markieren und neu importieren.',
 	'studio.wfAutoParamsNote': 'Keine (Input:…)-Titelmarken – {n} Parameter anhand der Knotentypen erkannt; leere Felder behalten die Workflow-Werte.',
 	'studio.promptNotDeclared': 'Dieser Workflow hat keinen Prompt-Knoten',
+	'studio.modeImageEdit': 'Image edit',
+	'studio.modeImageToVideo': 'Image to video',
+	'studio.modeRefToVideo': 'Reference to video',
+	'studio.slotInput': 'Input image',
+	'studio.slotHintOne': 'Required · 1 image',
+	'studio.slotEmptyInput': 'Click or drop the input image',
+	'studio.slotEmptyFirst': 'Click or drop the first frame',
+	'studio.slotEmptySub': 'PNG / JPG / WebP · ≤ 20MB each',
+	'studio.slotFromResultsShort': 'From results',
+	'studio.errImageFormat': '"{name}" is not supported — use PNG / JPG / WebP; this file will not be used',
+	'studio.errImageSize': '"{name}" is larger than 20MB — compress it and upload again',
+	'studio.errNeedInputImage': 'Image edit needs an input image',
+	'studio.errNeedFirstFrame': 'Image to video needs a first frame',
+	'studio.errNeedRef': 'Reference to video needs at least 1 reference image',
+	'studio.errRefMax': 'At most {max} reference images: {n} selected, these {k} were not added',
+	'studio.refHint': 'Required · 1–{max} · {n} selected',
+	'studio.refAdd': 'Add reference image',
+	'studio.refAddSub': '{n} more · max {max}',
+	'studio.refReplace': 'Replace',
+	'studio.refRemove': 'Remove reference {n}',
+	'studio.refRejectedShort': 'Not added',
+	'studio.refFull': 'Limit of {max} reached — remove one to add another',
+	'studio.refStrip': 'Reference images ({n} used)',
+	'studio.resolutionLabel': 'Output resolution',
+	'studio.resolutionHint': 'About {v}×{v} px, keeps the input aspect; 0 = original size',
+	'studio.wfBrokenTitle': 'This workflow file is incomplete — ComfyUI cannot run it, generation is blocked',
+	'studio.wfBrokenHint': 'Re-export the API-format JSON from a ComfyUI that has the custom nodes installed, then import it again under ComfyUI connections.',
+	'studio.errWfBroken': 'Workflow file is incomplete — re-export it before generating',
 	'studio.cancelToast': 'Abbruch angefordert',
 	'studio.deleteBtn': 'Löschen',
 	'studio.delTitle': 'Aufgabeneintrag löschen',
@@ -1761,4 +1837,39 @@ export const de: Dict = {
 	'home.errScriptShort': 'Drehbuch zu kurz — prüfe den eingefügten Text (mind. 30 Zeichen)',
 	'home.stageProgress': 'Fünf-Phasen-Fortschritt',
 	'tasks.sourceWorkbench': 'Kreativ-Fluss',
+	'jobst.idSuffix': ' · ComfyUI-Prompt-ID {id}',
+	'jobst.done': 'Fertig',
+	'jobst.doneDetail': 'ComfyUI ist fertig, Ergebnisse gespeichert',
+	'jobst.dryRun': 'Platzhalter',
+	'jobst.dryRunDetail': 'Nur Platzhalter: Dry-run ist aktiv, ComfyUI wurde nicht aufgerufen',
+	'jobst.noOutput': 'Keine Ausgabe',
+	'jobst.noOutputDetail': 'Der Job endete ohne Ergebnisdatei – keine fertige Generierung',
+	'jobst.queued': 'Wartet',
+	'jobst.queuedDetail': 'Wartet in der Workbench-Warteschlange auf ComfyUI',
+	'jobst.connecting': 'Verbinde',
+	'jobst.connectingDetail': 'Verbinde mit ComfyUI und lade Eingaben hoch',
+	'jobst.comfyQueued': 'Angenommen',
+	'jobst.comfyQueuedDetail': 'ComfyUI hat den Job angenommen und eingereiht',
+	'jobst.comfyQueuedAhead': 'ComfyUI hat den Job angenommen – {n} davor in der Warteschlange',
+	'jobst.comfyRunning': 'Läuft',
+	'jobst.comfyRunningDetail': 'ComfyUI führt den Job aus',
+	'jobst.saving': 'Speichert',
+	'jobst.savingDetail': 'ComfyUI hat Ergebnisse geliefert, lade herunter',
+	'jobst.failed': 'Fehlgeschlagen',
+	'jobst.cancelled': 'Abgebrochen',
+	'studio.ratioLabel': 'Seitenverhältnis',
+	'studio.megapixelsLabel': 'Megapixel',
+	'studio.outputSize': 'Ausgabe {w} × {h}',
+	'studio.denoiseLabel': 'Entrauschen',
+	'studio.errNumber': '„{label}“ muss eine Zahl sein',
+	'studio.errInteger': '„{label}“ muss eine ganze Zahl sein',
+	'studio.errMin': '„{label}“ muss mindestens {v} sein',
+	'studio.errMax': '„{label}“ darf höchstens {v} sein',
+	'studio.errOption': '„{label}“ ist keine Option des Workflows',
+	'studio.reuseParams': 'Einstellungen übernehmen',
+	'studio.reusedToast': 'Einstellungen dieses Jobs übernommen – anpassen und neu generieren',
+	'studio.reuseMissingWf': 'Der Workflow dieses Jobs existiert nicht mehr',
+	'studio.doneToast': 'Fertig: {n} Datei(en) (ComfyUI-Prompt-ID {id})',
+	'studio.dryRunToast': 'Nur Platzhalter: Dry-run ist aktiv, ComfyUI wurde nicht aufgerufen',
+	'studio.dryRunNote': 'Dry-run ist aktiv: Generieren schreibt nur Platzhalter und ruft ComfyUI nie auf. In den Einstellungen abschalten.',
 };

calliope-web/src/lib/i18n/en.ts

@@ -1398,6 +1398,54 @@ export const en = {
 	'conn.wfJsonInvalid': 'Not valid API-format JSON (expected an object of node id to class_type)',
 	'conn.wfJsonPh': 'Paste the ComfyUI API-format JSON here, or pick a file',
 	'conn.wfDeleted': 'Workflow deleted',
+	'conn.wfImportedBroken': 'Imported, but the workflow file is incomplete and must be re-exported before generating: {detail}',
+	'conn.wfBrokenBadge': 'Incomplete file — cannot generate',
+	// --- Five usages & import confirmation (HEL-636) ---
+	'usage.text2image': 'Text → Image',
+	'usage.image2image': 'Image → Image',
+	'usage.text2video': 'Text → Video',
+	'usage.image2video': 'Image → Video',
+	'usage.ref2video': 'Reference → Video',
+	'usage.pending': 'Usage pending',
+	'wfRole.image': 'Input image',
+	'wfRole.first_frame': 'First frame',
+	'wfRole.last_frame': 'Last frame',
+	'wfRole.reference_image': 'Reference',
+	'wfRole.mask': 'Mask',
+	'conn.wfImportAction': 'Import workflow',
+	'conn.wfConfirmTitle': 'Confirm detection',
+	'conn.wfStepAnalyze': 'Paste & analyze',
+	'conn.wfStepConfirm': 'Confirm & save',
+	'conn.wfChooseFile': 'Choose file',
+	'conn.wfAnalyze': 'Analyze',
+	'conn.wfAnalyzing': 'Analyzing…',
+	'conn.wfConfirmHint': 'Review the evidence, output nodes and image slots; correct the usage or slot roles before saving.',
+	'conn.wfUsageLabel': 'Usage',
+	'conn.wfUsageAuto': 'Auto-detected: {usage}',
+	'conn.wfUsageNeedPick': 'Pick manually',
+	'conn.wfPickUsage': 'Choose a usage first',
+	'conn.wfSlotsLabel': 'Image slots',
+	'conn.wfSlotsHint': 'Roles are inferred from wiring; override them (input image / first / last frame / reference / mask) and the manual choice sticks.',
+	'conn.wfBack': 'Back',
+	'conn.wfConfirmSave': 'Confirm & save',
+	'conn.wfImportedWithUsage': 'Saved as “{usage}” with {n} fillable parameters',
+	'conn.wfPendingCount': '{n} pending',
+	'conn.wfConfirmed': 'Usage confirmed: {usage} — the workflow can generate now',
+	'conn.wfSourceUser': 'Usage set manually; re-analysis will not overwrite it',
+	'conn.wfSourceAuto': 'Usage auto-detected',
+	'conn.wfDisabledBadge': 'Disabled',
+	'conn.wfConfirmAria': 'Confirm workflow usage',
+	'conn.wfOutputLabel': 'Output nodes',
+	'conn.wfOutputNeedPick': 'Unrecognized custom output nodes — designate them',
+	'conn.wfOutputHint': 'Check the nodes that actually produce results and pick each one’s media type; generation harvests images/videos only from these nodes.',
+	'conn.wfOutputPick': 'Check at least one output node',
+	'conn.wfOutputKindAria': 'Output node media type',
+	'conn.wfOutputPendingBadge': 'Outputs unset',
+	'conn.wfOutputNeedMap': 'This workflow has unrecognized output nodes; designate them and their media type to enable it',
+	'conn.wfOutputApply': 'Save output mapping',
+	'conn.wfMapCancel': 'Cancel',
+	'conn.wfOutputApplied': 'Output mapping saved: node {nodes}',
+	'conn.wfOutputCleared': 'Output mapping cleared — the workflow is pending again',
 	'conn.missingMaterial': 'A dedicated Qwen Image 2.1 workflow JSON is not in the repo yet: export it from ComfyUI and import it here — the generic import path is ready.',
 	// --- Standalone image / video generation (a3/a4, HEL-612) ---
 	'studio.image.title': 'Image',
@@ -1498,6 +1546,34 @@ export const en = {
 	'studio.wfNoParamsNote': 'This workflow has no fillable parameters and will run with its built-in prompt and settings. To fill them here, tag node titles with (Input:prompt) etc. in ComfyUI and re-import.',
 	'studio.wfAutoParamsNote': 'No (Input:…) title tags found — {n} parameters were detected from node types; blank fields keep the workflow values.',
 	'studio.promptNotDeclared': 'This workflow has no prompt node — nothing to fill',
+	'studio.modeImageEdit': 'Image edit',
+	'studio.modeImageToVideo': 'Image to video',
+	'studio.modeRefToVideo': 'Reference to video',
+	'studio.slotInput': 'Input image',
+	'studio.slotHintOne': 'Required · 1 image',
+	'studio.slotEmptyInput': 'Click or drop the input image',
+	'studio.slotEmptyFirst': 'Click or drop the first frame',
+	'studio.slotEmptySub': 'PNG / JPG / WebP · ≤ 20MB each',
+	'studio.slotFromResultsShort': 'From results',
+	'studio.errImageFormat': '"{name}" is not supported — use PNG / JPG / WebP; this file will not be used',
+	'studio.errImageSize': '"{name}" is larger than 20MB — compress it and upload again',
+	'studio.errNeedInputImage': 'Image edit needs an input image',
+	'studio.errNeedFirstFrame': 'Image to video needs a first frame',
+	'studio.errNeedRef': 'Reference to video needs at least 1 reference image',
+	'studio.errRefMax': 'At most {max} reference images: {n} selected, these {k} were not added',
+	'studio.refHint': 'Required · 1–{max} · {n} selected',
+	'studio.refAdd': 'Add reference image',
+	'studio.refAddSub': '{n} more · max {max}',
+	'studio.refReplace': 'Replace',
+	'studio.refRemove': 'Remove reference {n}',
+	'studio.refRejectedShort': 'Not added',
+	'studio.refFull': 'Limit of {max} reached — remove one to add another',
+	'studio.refStrip': 'Reference images ({n} used)',
+	'studio.resolutionLabel': 'Output resolution',
+	'studio.resolutionHint': 'About {v}×{v} px, keeps the input aspect; 0 = original size',
+	'studio.wfBrokenTitle': 'This workflow file is incomplete — ComfyUI cannot run it, generation is blocked',
+	'studio.wfBrokenHint': 'Re-export the API-format JSON from a ComfyUI that has the custom nodes installed, then import it again under ComfyUI connections.',
+	'studio.errWfBroken': 'Workflow file is incomplete — re-export it before generating',
 	'studio.cancelToast': 'Cancel requested',
 	'studio.deleteBtn': 'Delete',
 	'studio.delTitle': 'Delete task record',
@@ -1760,6 +1836,41 @@ export const en = {
 	'home.errScriptShort': 'The script looks too short — check the paste is complete (min 30 characters)',
 	'home.stageProgress': 'Five-stage progress',
 	'tasks.sourceWorkbench': 'Creation flow',
+	'jobst.idSuffix': ' · ComfyUI prompt ID {id}',
+	'jobst.done': 'Done',
+	'jobst.doneDetail': 'ComfyUI finished and the results are saved',
+	'jobst.dryRun': 'Placeholder',
+	'jobst.dryRunDetail': 'Placeholder only: Dry-run is on, ComfyUI was not called',
+	'jobst.noOutput': 'No output',
+	'jobst.noOutputDetail': 'The job ended without any result file — not a finished generation',
+	'jobst.queued': 'Queued',
+	'jobst.queuedDetail': 'Waiting in the workbench queue to be sent to ComfyUI',
+	'jobst.connecting': 'Connecting',
+	'jobst.connectingDetail': 'Connecting to ComfyUI and uploading inputs',
+	'jobst.comfyQueued': 'Accepted',
+	'jobst.comfyQueuedDetail': 'ComfyUI accepted the job and queued it',
+	'jobst.comfyQueuedAhead': 'ComfyUI accepted the job — {n} ahead in its queue',
+	'jobst.comfyRunning': 'Running',
+	'jobst.comfyRunningDetail': 'ComfyUI is running the job',
+	'jobst.saving': 'Saving',
+	'jobst.savingDetail': 'ComfyUI returned results, downloading them',
+	'jobst.failed': 'Failed',
+	'jobst.cancelled': 'Cancelled',
+	'studio.ratioLabel': 'Aspect ratio',
+	'studio.megapixelsLabel': 'Megapixels',
+	'studio.outputSize': 'Output {w} × {h}',
+	'studio.denoiseLabel': 'Denoise',
+	'studio.errNumber': '“{label}” must be a number',
+	'studio.errInteger': '“{label}” must be a whole number',
+	'studio.errMin': '“{label}” must be at least {v}',
+	'studio.errMax': '“{label}” must be at most {v}',
+	'studio.errOption': '“{label}” is not one of the workflow\'s options',
+	'studio.reuseParams': 'Reuse settings',
+	'studio.reusedToast': 'Settings from this job are filled in — adjust and generate again',
+	'studio.reuseMissingWf': 'The workflow this job used no longer exists',
+	'studio.doneToast': 'Done: {n} file(s) (ComfyUI prompt ID {id})',
+	'studio.dryRunToast': 'Placeholder only: Dry-run is on, ComfyUI was not called',
+	'studio.dryRunNote': 'Dry-run is on: Generate only writes placeholder files and never calls ComfyUI. Turn it off in Settings.',
 };
 
 export type Dict = typeof en;

calliope-web/src/lib/i18n/es.ts

@@ -1398,6 +1398,54 @@ export const es: Dict = {
 	'conn.wfJsonInvalid': 'JSON no válido en formato API (se esperaba un objeto id de nodo → {{…class_type…}})',
 	'conn.wfJsonPh': 'Pega aquí el JSON en formato API de ComfyUI o elige un archivo',
 	'conn.wfDeleted': 'Flujo eliminado',
+	'conn.wfImportedBroken': 'Imported, but the workflow file is incomplete and must be re-exported before generating: {detail}',
+	'conn.wfBrokenBadge': 'Incomplete file — cannot generate',
+	// --- Five usages & import confirmation (HEL-636) ---
+	'usage.text2image': 'Text → Image',
+	'usage.image2image': 'Image → Image',
+	'usage.text2video': 'Text → Video',
+	'usage.image2video': 'Image → Video',
+	'usage.ref2video': 'Reference → Video',
+	'usage.pending': 'Usage pending',
+	'wfRole.image': 'Input image',
+	'wfRole.first_frame': 'First frame',
+	'wfRole.last_frame': 'Last frame',
+	'wfRole.reference_image': 'Reference',
+	'wfRole.mask': 'Mask',
+	'conn.wfImportAction': 'Import workflow',
+	'conn.wfConfirmTitle': 'Confirm detection',
+	'conn.wfStepAnalyze': 'Paste & analyze',
+	'conn.wfStepConfirm': 'Confirm & save',
+	'conn.wfChooseFile': 'Choose file',
+	'conn.wfAnalyze': 'Analyze',
+	'conn.wfAnalyzing': 'Analyzing…',
+	'conn.wfConfirmHint': 'Review the evidence, output nodes and image slots; correct the usage or slot roles before saving.',
+	'conn.wfUsageLabel': 'Usage',
+	'conn.wfUsageAuto': 'Auto-detected: {usage}',
+	'conn.wfUsageNeedPick': 'Pick manually',
+	'conn.wfPickUsage': 'Choose a usage first',
+	'conn.wfSlotsLabel': 'Image slots',
+	'conn.wfSlotsHint': 'Roles are inferred from wiring; override them (input image / first / last frame / reference / mask) and the manual choice sticks.',
+	'conn.wfBack': 'Back',
+	'conn.wfConfirmSave': 'Confirm & save',
+	'conn.wfImportedWithUsage': 'Saved as “{usage}” with {n} fillable parameters',
+	'conn.wfPendingCount': '{n} pending',
+	'conn.wfConfirmed': 'Usage confirmed: {usage} — the workflow can generate now',
+	'conn.wfSourceUser': 'Usage set manually; re-analysis will not overwrite it',
+	'conn.wfSourceAuto': 'Usage auto-detected',
+	'conn.wfDisabledBadge': 'Disabled',
+	'conn.wfConfirmAria': 'Confirm workflow usage',
+	'conn.wfOutputLabel': 'Nodos de salida',
+	'conn.wfOutputNeedPick': 'Nodos de salida personalizados no reconocidos: asígnalos',
+	'conn.wfOutputHint': 'Marca los nodos que realmente producen resultados y elige el tipo de medio de cada uno; la generación solo extrae imágenes/vídeos de estos nodos.',
+	'conn.wfOutputPick': 'Marca al menos un nodo de salida',
+	'conn.wfOutputKindAria': 'Tipo de medio del nodo de salida',
+	'conn.wfOutputPendingBadge': 'Salida pendiente',
+	'conn.wfOutputNeedMap': 'Este flujo tiene nodos de salida no reconocidos; asígnalos y su tipo de medio para activarlo',
+	'conn.wfOutputApply': 'Guardar mapeo de salida',
+	'conn.wfMapCancel': 'Cancelar',
+	'conn.wfOutputApplied': 'Mapeo de salida guardado: nodo {nodes}',
+	'conn.wfOutputCleared': 'Mapeo de salida borrado: el flujo vuelve a estar pendiente',
 	'conn.missingMaterial': 'Aún falta en el repo un JSON dedicado de Qwen Image 2.1: expórtalo desde ComfyUI e impórtalo aquí; la vía genérica ya está lista.',
 
 	// --- Generación independiente de imagen / vídeo (a3/a4, HEL-612) ---
@@ -1499,6 +1547,34 @@ export const es: Dict = {
 	'studio.wfNoParamsNote': 'Este flujo no tiene parámetros rellenables y se ejecutará con su prompt y ajustes internos. Para rellenarlos aquí, etiqueta los títulos de nodo con (Input:prompt) etc. en ComfyUI y vuelve a importar.',
 	'studio.wfAutoParamsNote': 'Sin etiquetas (Input:…): se detectaron {n} parámetros por tipo de nodo; los campos vacíos conservan los valores del flujo.',
 	'studio.promptNotDeclared': 'Este flujo no tiene nodo de prompt',
+	'studio.modeImageEdit': 'Image edit',
+	'studio.modeImageToVideo': 'Image to video',
+	'studio.modeRefToVideo': 'Reference to video',
+	'studio.slotInput': 'Input image',
+	'studio.slotHintOne': 'Required · 1 image',
+	'studio.slotEmptyInput': 'Click or drop the input image',
+	'studio.slotEmptyFirst': 'Click or drop the first frame',
+	'studio.slotEmptySub': 'PNG / JPG / WebP · ≤ 20MB each',
+	'studio.slotFromResultsShort': 'From results',
+	'studio.errImageFormat': '"{name}" is not supported — use PNG / JPG / WebP; this file will not be used',
+	'studio.errImageSize': '"{name}" is larger than 20MB — compress it and upload again',
+	'studio.errNeedInputImage': 'Image edit needs an input image',
+	'studio.errNeedFirstFrame': 'Image to video needs a first frame',
+	'studio.errNeedRef': 'Reference to video needs at least 1 reference image',
+	'studio.errRefMax': 'At most {max} reference images: {n} selected, these {k} were not added',
+	'studio.refHint': 'Required · 1–{max} · {n} selected',
+	'studio.refAdd': 'Add reference image',
+	'studio.refAddSub': '{n} more · max {max}',
+	'studio.refReplace': 'Replace',
+	'studio.refRemove': 'Remove reference {n}',
+	'studio.refRejectedShort': 'Not added',
+	'studio.refFull': 'Limit of {max} reached — remove one to add another',
+	'studio.refStrip': 'Reference images ({n} used)',
+	'studio.resolutionLabel': 'Output resolution',
+	'studio.resolutionHint': 'About {v}×{v} px, keeps the input aspect; 0 = original size',
+	'studio.wfBrokenTitle': 'This workflow file is incomplete — ComfyUI cannot run it, generation is blocked',
+	'studio.wfBrokenHint': 'Re-export the API-format JSON from a ComfyUI that has the custom nodes installed, then import it again under ComfyUI connections.',
+	'studio.errWfBroken': 'Workflow file is incomplete — re-export it before generating',
 	'studio.cancelToast': 'Cancelación solicitada',
 	'studio.deleteBtn': 'Eliminar',
 	'studio.delTitle': 'Eliminar registro de tarea',
@@ -1761,4 +1837,39 @@ export const es: Dict = {
 	'home.errScriptShort': 'El guion es demasiado corto — revisa el pegado (mín. 30 caracteres)',
 	'home.stageProgress': 'Progreso de cinco etapas',
 	'tasks.sourceWorkbench': 'Flujo de creación',
+	'jobst.idSuffix': ' · ID de prompt de ComfyUI {id}',
+	'jobst.done': 'Listo',
+	'jobst.doneDetail': 'ComfyUI terminó y los resultados se guardaron',
+	'jobst.dryRun': 'Marcador',
+	'jobst.dryRunDetail': 'Solo marcador: Dry-run activo, no se llamó a ComfyUI',
+	'jobst.noOutput': 'Sin salida',
+	'jobst.noOutputDetail': 'El trabajo terminó sin archivos de resultado: no cuenta como generado',
+	'jobst.queued': 'En cola',
+	'jobst.queuedDetail': 'Esperando en la cola del taller para enviarse a ComfyUI',
+	'jobst.connecting': 'Conectando',
+	'jobst.connectingDetail': 'Conectando con ComfyUI y subiendo entradas',
+	'jobst.comfyQueued': 'Aceptado',
+	'jobst.comfyQueuedDetail': 'ComfyUI aceptó el trabajo y lo puso en cola',
+	'jobst.comfyQueuedAhead': 'ComfyUI aceptó el trabajo: {n} por delante en su cola',
+	'jobst.comfyRunning': 'Ejecutando',
+	'jobst.comfyRunningDetail': 'ComfyUI está ejecutando el trabajo',
+	'jobst.saving': 'Guardando',
+	'jobst.savingDetail': 'ComfyUI devolvió resultados, descargándolos',
+	'jobst.failed': 'Fallido',
+	'jobst.cancelled': 'Cancelado',
+	'studio.ratioLabel': 'Relación de aspecto',
+	'studio.megapixelsLabel': 'Megapíxeles',
+	'studio.outputSize': 'Salida {w} × {h}',
+	'studio.denoiseLabel': 'Eliminación de ruido',
+	'studio.errNumber': '«{label}» debe ser un número',
+	'studio.errInteger': '«{label}» debe ser un número entero',
+	'studio.errMin': '«{label}» debe ser al menos {v}',
+	'studio.errMax': '«{label}» debe ser como máximo {v}',
+	'studio.errOption': '«{label}» no es una opción del flujo',
+	'studio.reuseParams': 'Reutilizar ajustes',
+	'studio.reusedToast': 'Ajustes de este trabajo aplicados: modifícalos y genera de nuevo',
+	'studio.reuseMissingWf': 'El flujo que usó este trabajo ya no existe',
+	'studio.doneToast': 'Listo: {n} archivo(s) (ID de prompt de ComfyUI {id})',
+	'studio.dryRunToast': 'Solo marcador: Dry-run activo, no se llamó a ComfyUI',
+	'studio.dryRunNote': 'Dry-run activo: Generar solo escribe marcadores y nunca llama a ComfyUI. Desactívalo en Ajustes.',
 };

calliope-web/src/lib/i18n/fr.ts

@@ -1398,6 +1398,54 @@ export const fr: Dict = {
 	'conn.wfJsonInvalid': 'JSON invalide au format API (attendu : objet id de nœud → {{…class_type…}})',
 	'conn.wfJsonPh': 'Collez ici le JSON format API ComfyUI ou choisissez un fichier',
 	'conn.wfDeleted': 'Workflow supprimé',
+	'conn.wfImportedBroken': 'Imported, but the workflow file is incomplete and must be re-exported before generating: {detail}',
+	'conn.wfBrokenBadge': 'Incomplete file — cannot generate',
+	// --- Five usages & import confirmation (HEL-636) ---
+	'usage.text2image': 'Text → Image',
+	'usage.image2image': 'Image → Image',
+	'usage.text2video': 'Text → Video',
+	'usage.image2video': 'Image → Video',
+	'usage.ref2video': 'Reference → Video',
+	'usage.pending': 'Usage pending',
+	'wfRole.image': 'Input image',
+	'wfRole.first_frame': 'First frame',
+	'wfRole.last_frame': 'Last frame',
+	'wfRole.reference_image': 'Reference',
+	'wfRole.mask': 'Mask',
+	'conn.wfImportAction': 'Import workflow',
+	'conn.wfConfirmTitle': 'Confirm detection',
+	'conn.wfStepAnalyze': 'Paste & analyze',
+	'conn.wfStepConfirm': 'Confirm & save',
+	'conn.wfChooseFile': 'Choose file',
+	'conn.wfAnalyze': 'Analyze',
+	'conn.wfAnalyzing': 'Analyzing…',
+	'conn.wfConfirmHint': 'Review the evidence, output nodes and image slots; correct the usage or slot roles before saving.',
+	'conn.wfUsageLabel': 'Usage',
+	'conn.wfUsageAuto': 'Auto-detected: {usage}',
+	'conn.wfUsageNeedPick': 'Pick manually',
+	'conn.wfPickUsage': 'Choose a usage first',
+	'conn.wfSlotsLabel': 'Image slots',
+	'conn.wfSlotsHint': 'Roles are inferred from wiring; override them (input image / first / last frame / reference / mask) and the manual choice sticks.',
+	'conn.wfBack': 'Back',
+	'conn.wfConfirmSave': 'Confirm & save',
+	'conn.wfImportedWithUsage': 'Saved as “{usage}” with {n} fillable parameters',
+	'conn.wfPendingCount': '{n} pending',
+	'conn.wfConfirmed': 'Usage confirmed: {usage} — the workflow can generate now',
+	'conn.wfSourceUser': 'Usage set manually; re-analysis will not overwrite it',
+	'conn.wfSourceAuto': 'Usage auto-detected',
+	'conn.wfDisabledBadge': 'Disabled',
+	'conn.wfConfirmAria': 'Confirm workflow usage',
+	'conn.wfOutputLabel': 'Nœuds de sortie',
+	'conn.wfOutputNeedPick': 'Nœuds de sortie personnalisés non reconnus — à désigner',
+	'conn.wfOutputHint': 'Cochez les nœuds qui produisent réellement les résultats et choisissez leur type de média ; la génération ne collecte les images/vidéos que sur ces nœuds.',
+	'conn.wfOutputPick': 'Cochez au moins un nœud de sortie',
+	'conn.wfOutputKindAria': 'Type de média du nœud de sortie',
+	'conn.wfOutputPendingBadge': 'Sortie à définir',
+	'conn.wfOutputNeedMap': 'Ce workflow contient des nœuds de sortie non reconnus ; désignez-les avec leur type de média pour l’activer',
+	'conn.wfOutputApply': 'Enregistrer le mapping de sortie',
+	'conn.wfMapCancel': 'Annuler',
+	'conn.wfOutputApplied': 'Mapping de sortie enregistré : nœud {nodes}',
+	'conn.wfOutputCleared': 'Mapping de sortie effacé — le workflow est de nouveau en attente',
 	'conn.missingMaterial': 'Un JSON de workflow Qwen Image 2.1 dédié manque encore au dépôt : exportez-le depuis ComfyUI et importez-le ici — le chemin d\'import générique est prêt.',
 
 	// --- Génération indépendante image / vidéo (a3/a4, HEL-612) ---
@@ -1499,6 +1547,34 @@ export const fr: Dict = {
 	'studio.wfNoParamsNote': 'Ce workflow n\'a aucun paramètre à remplir et sera exécuté avec son prompt et ses réglages intégrés. Pour les remplir ici, ajoutez (Input:prompt) etc. aux titres de nœuds dans ComfyUI puis réimportez.',
 	'studio.wfAutoParamsNote': 'Aucune balise (Input:…) : {n} paramètres détectés par type de nœud ; les champs vides gardent les valeurs du workflow.',
 	'studio.promptNotDeclared': 'Ce workflow n\'a pas de nœud de prompt',
+	'studio.modeImageEdit': 'Image edit',
+	'studio.modeImageToVideo': 'Image to video',
+	'studio.modeRefToVideo': 'Reference to video',
+	'studio.slotInput': 'Input image',
+	'studio.slotHintOne': 'Required · 1 image',
+	'studio.slotEmptyInput': 'Click or drop the input image',
+	'studio.slotEmptyFirst': 'Click or drop the first frame',
+	'studio.slotEmptySub': 'PNG / JPG / WebP · ≤ 20MB each',
+	'studio.slotFromResultsShort': 'From results',
+	'studio.errImageFormat': '"{name}" is not supported — use PNG / JPG / WebP; this file will not be used',
+	'studio.errImageSize': '"{name}" is larger than 20MB — compress it and upload again',
+	'studio.errNeedInputImage': 'Image edit needs an input image',
+	'studio.errNeedFirstFrame': 'Image to video needs a first frame',
+	'studio.errNeedRef': 'Reference to video needs at least 1 reference image',
+	'studio.errRefMax': 'At most {max} reference images: {n} selected, these {k} were not added',
+	'studio.refHint': 'Required · 1–{max} · {n} selected',
+	'studio.refAdd': 'Add reference image',
+	'studio.refAddSub': '{n} more · max {max}',
+	'studio.refReplace': 'Replace',
+	'studio.refRemove': 'Remove reference {n}',
+	'studio.refRejectedShort': 'Not added',
+	'studio.refFull': 'Limit of {max} reached — remove one to add another',
+	'studio.refStrip': 'Reference images ({n} used)',
+	'studio.resolutionLabel': 'Output resolution',
+	'studio.resolutionHint': 'About {v}×{v} px, keeps the input aspect; 0 = original size',
+	'studio.wfBrokenTitle': 'This workflow file is incomplete — ComfyUI cannot run it, generation is blocked',
+	'studio.wfBrokenHint': 'Re-export the API-format JSON from a ComfyUI that has the custom nodes installed, then import it again under ComfyUI connections.',
+	'studio.errWfBroken': 'Workflow file is incomplete — re-export it before generating',
 	'studio.cancelToast': 'Annulation demandée',
 	'studio.deleteBtn': 'Supprimer',
 	'studio.delTitle': 'Supprimer la tâche',
@@ -1761,4 +1837,39 @@ export const fr: Dict = {
 	'home.errScriptShort': 'Scénario trop court — vérifiez le collage (30 caractères min.)',
 	'home.stageProgress': 'Progression en cinq étapes',
 	'tasks.sourceWorkbench': 'Flux de création',
+	'jobst.idSuffix': ' · ID de prompt ComfyUI {id}',
+	'jobst.done': 'Terminé',
+	'jobst.doneDetail': 'ComfyUI a terminé, résultats enregistrés',
+	'jobst.dryRun': 'Substitut',
+	'jobst.dryRunDetail': 'Substitut uniquement : Dry-run actif, ComfyUI n\'a pas été appelé',
+	'jobst.noOutput': 'Aucune sortie',
+	'jobst.noOutputDetail': 'La tâche s\'est terminée sans fichier de résultat : pas une génération',
+	'jobst.queued': 'En attente',
+	'jobst.queuedDetail': 'En attente dans la file de l\'atelier avant envoi à ComfyUI',
+	'jobst.connecting': 'Connexion',
+	'jobst.connectingDetail': 'Connexion à ComfyUI et envoi des entrées',
+	'jobst.comfyQueued': 'Acceptée',
+	'jobst.comfyQueuedDetail': 'ComfyUI a accepté la tâche et l\'a mise en file',
+	'jobst.comfyQueuedAhead': 'ComfyUI a accepté la tâche — {n} devant dans sa file',
+	'jobst.comfyRunning': 'En cours',
+	'jobst.comfyRunningDetail': 'ComfyUI exécute la tâche',
+	'jobst.saving': 'Enregistrement',
+	'jobst.savingDetail': 'ComfyUI a renvoyé des résultats, téléchargement',
+	'jobst.failed': 'Échec',
+	'jobst.cancelled': 'Annulée',
+	'studio.ratioLabel': 'Format d\'image',
+	'studio.megapixelsLabel': 'Mégapixels',
+	'studio.outputSize': 'Sortie {w} × {h}',
+	'studio.denoiseLabel': 'Débruitage',
+	'studio.errNumber': '« {label} » doit être un nombre',
+	'studio.errInteger': '« {label} » doit être un entier',
+	'studio.errMin': '« {label} » doit valoir au moins {v}',
+	'studio.errMax': '« {label} » doit valoir au plus {v}',
+	'studio.errOption': '« {label} » n\'est pas une option du workflow',
+	'studio.reuseParams': 'Réutiliser les réglages',
+	'studio.reusedToast': 'Réglages de cette tâche repris : ajustez puis relancez',
+	'studio.reuseMissingWf': 'Le workflow de cette tâche n\'existe plus',
+	'studio.doneToast': 'Terminé : {n} fichier(s) (ID de prompt ComfyUI {id})',
+	'studio.dryRunToast': 'Substitut uniquement : Dry-run actif, ComfyUI n\'a pas été appelé',
+	'studio.dryRunNote': 'Dry-run actif : Générer n\'écrit que des substituts et n\'appelle jamais ComfyUI. Désactivez-le dans Réglages.',
 };

calliope-web/src/lib/i18n/ja.ts

@@ -1398,6 +1398,54 @@ export const ja: Dict = {
 	'conn.wfJsonInvalid': '有効な API 形式 JSON ではありません（ノード ID → {{…class_type…}} のオブジェクトが必要）',
 	'conn.wfJsonPh': 'ここに ComfyUI の API 形式 JSON を貼り付けるか、右のボタンでファイルを選択',
 	'conn.wfDeleted': 'ワークフローを削除しました',
+	'conn.wfImportedBroken': 'Imported, but the workflow file is incomplete and must be re-exported before generating: {detail}',
+	'conn.wfBrokenBadge': 'Incomplete file — cannot generate',
+	// --- Five usages & import confirmation (HEL-636) ---
+	'usage.text2image': 'Text → Image',
+	'usage.image2image': 'Image → Image',
+	'usage.text2video': 'Text → Video',
+	'usage.image2video': 'Image → Video',
+	'usage.ref2video': 'Reference → Video',
+	'usage.pending': 'Usage pending',
+	'wfRole.image': 'Input image',
+	'wfRole.first_frame': 'First frame',
+	'wfRole.last_frame': 'Last frame',
+	'wfRole.reference_image': 'Reference',
+	'wfRole.mask': 'Mask',
+	'conn.wfImportAction': 'Import workflow',
+	'conn.wfConfirmTitle': 'Confirm detection',
+	'conn.wfStepAnalyze': 'Paste & analyze',
+	'conn.wfStepConfirm': 'Confirm & save',
+	'conn.wfChooseFile': 'Choose file',
+	'conn.wfAnalyze': 'Analyze',
+	'conn.wfAnalyzing': 'Analyzing…',
+	'conn.wfConfirmHint': 'Review the evidence, output nodes and image slots; correct the usage or slot roles before saving.',
+	'conn.wfUsageLabel': 'Usage',
+	'conn.wfUsageAuto': 'Auto-detected: {usage}',
+	'conn.wfUsageNeedPick': 'Pick manually',
+	'conn.wfPickUsage': 'Choose a usage first',
+	'conn.wfSlotsLabel': 'Image slots',
+	'conn.wfSlotsHint': 'Roles are inferred from wiring; override them (input image / first / last frame / reference / mask) and the manual choice sticks.',
+	'conn.wfBack': 'Back',
+	'conn.wfConfirmSave': 'Confirm & save',
+	'conn.wfImportedWithUsage': 'Saved as “{usage}” with {n} fillable parameters',
+	'conn.wfPendingCount': '{n} pending',
+	'conn.wfConfirmed': 'Usage confirmed: {usage} — the workflow can generate now',
+	'conn.wfSourceUser': 'Usage set manually; re-analysis will not overwrite it',
+	'conn.wfSourceAuto': 'Usage auto-detected',
+	'conn.wfDisabledBadge': 'Disabled',
+	'conn.wfConfirmAria': 'Confirm workflow usage',
+	'conn.wfOutputLabel': '出力ノード',
+	'conn.wfOutputNeedPick': '認識できないカスタム出力ノードがあります。手動で指定してください',
+	'conn.wfOutputHint': '実際に結果を出すノードにチェックし、それぞれのメディア種別を選んでください。生成時にこれらのノードからのみ画像/動画を取り出します。',
+	'conn.wfOutputPick': '出力ノードを1つ以上チェックしてください',
+	'conn.wfOutputKindAria': '出力ノードのメディア種別',
+	'conn.wfOutputPendingBadge': '出力未指定',
+	'conn.wfOutputNeedMap': '認識できない出力ノードを含みます。ノードとメディア種別を指定すると有効化できます',
+	'conn.wfOutputApply': '出力マッピングを保存',
+	'conn.wfMapCancel': 'キャンセル',
+	'conn.wfOutputApplied': '出力マッピングを保存しました：ノード {nodes}',
+	'conn.wfOutputCleared': '出力マッピングを解除しました。ワークフローは保留に戻ります',
 	'conn.missingMaterial': 'Qwen Image 2.1 専用のワークフロー JSON はまだリポジトリにありません。ComfyUI から書き出してここで取り込んでください。汎用の取り込み経路は用意済みです。',
 
 	// --- 独立画像/動画生成（a3/a4、HEL-612）---
@@ -1499,6 +1547,34 @@ export const ja: Dict = {
 	'studio.wfNoParamsNote': 'このワークフローには記入可能なパラメータがなく、内蔵のプロンプトと設定で実行されます。ここで記入するには ComfyUI でノードタイトルに (Input:prompt) などを付けて再度取り込んでください。',
 	'studio.wfAutoParamsNote': '(Input:…) タグがないため、ノード種別から {n} 件のパラメータを自動検出しました。空欄はワークフローの値を使います。',
 	'studio.promptNotDeclared': 'このワークフローにはプロンプトノードがありません',
+	'studio.modeImageEdit': 'Image edit',
+	'studio.modeImageToVideo': 'Image to video',
+	'studio.modeRefToVideo': 'Reference to video',
+	'studio.slotInput': 'Input image',
+	'studio.slotHintOne': 'Required · 1 image',
+	'studio.slotEmptyInput': 'Click or drop the input image',
+	'studio.slotEmptyFirst': 'Click or drop the first frame',
+	'studio.slotEmptySub': 'PNG / JPG / WebP · ≤ 20MB each',
+	'studio.slotFromResultsShort': 'From results',
+	'studio.errImageFormat': '"{name}" is not supported — use PNG / JPG / WebP; this file will not be used',
+	'studio.errImageSize': '"{name}" is larger than 20MB — compress it and upload again',
+	'studio.errNeedInputImage': 'Image edit needs an input image',
+	'studio.errNeedFirstFrame': 'Image to video needs a first frame',
+	'studio.errNeedRef': 'Reference to video needs at least 1 reference image',
+	'studio.errRefMax': 'At most {max} reference images: {n} selected, these {k} were not added',
+	'studio.refHint': 'Required · 1–{max} · {n} selected',
+	'studio.refAdd': 'Add reference image',
+	'studio.refAddSub': '{n} more · max {max}',
+	'studio.refReplace': 'Replace',
+	'studio.refRemove': 'Remove reference {n}',
+	'studio.refRejectedShort': 'Not added',
+	'studio.refFull': 'Limit of {max} reached — remove one to add another',
+	'studio.refStrip': 'Reference images ({n} used)',
+	'studio.resolutionLabel': 'Output resolution',
+	'studio.resolutionHint': 'About {v}×{v} px, keeps the input aspect; 0 = original size',
+	'studio.wfBrokenTitle': 'This workflow file is incomplete — ComfyUI cannot run it, generation is blocked',
+	'studio.wfBrokenHint': 'Re-export the API-format JSON from a ComfyUI that has the custom nodes installed, then import it again under ComfyUI connections.',
+	'studio.errWfBroken': 'Workflow file is incomplete — re-export it before generating',
 	'studio.cancelToast': 'キャンセルを要求しました',
 	'studio.deleteBtn': '削除',
 	'studio.delTitle': 'タスク記録を削除',
@@ -1761,4 +1837,39 @@ export const ja: Dict = {
 	'home.errScriptShort': '脚本が短すぎます。貼り付けが完全か確認してください（30 文字以上）',
 	'home.stageProgress': '五段階の進捗',
 	'tasks.sourceWorkbench': '制作フロー',
+	'jobst.idSuffix': ' · ComfyUI プロンプト ID {id}',
+	'jobst.done': '完了',
+	'jobst.doneDetail': 'ComfyUI の実行が完了し、結果を保存しました',
+	'jobst.dryRun': 'プレースホルダー',
+	'jobst.dryRunDetail': 'プレースホルダーのみ：Dry-run が有効で ComfyUI は呼び出されていません',
+	'jobst.noOutput': '出力なし',
+	'jobst.noOutputDetail': '結果ファイルなしで終了しました（生成完了ではありません）',
+	'jobst.queued': '待機中',
+	'jobst.queuedDetail': 'ワークベンチのキューで ComfyUI への送信を待っています',
+	'jobst.connecting': '接続中',
+	'jobst.connectingDetail': 'ComfyUI に接続して素材をアップロードしています',
+	'jobst.comfyQueued': '受付済み',
+	'jobst.comfyQueuedDetail': 'ComfyUI が受け付け、実行待ちです',
+	'jobst.comfyQueuedAhead': 'ComfyUI が受け付けました。前に {n} 件あります',
+	'jobst.comfyRunning': '実行中',
+	'jobst.comfyRunningDetail': 'ComfyUI が実行中です',
+	'jobst.saving': '保存中',
+	'jobst.savingDetail': 'ComfyUI の結果をダウンロードしています',
+	'jobst.failed': '失敗',
+	'jobst.cancelled': 'キャンセル済み',
+	'studio.ratioLabel': 'アスペクト比',
+	'studio.megapixelsLabel': '総画素数（MP）',
+	'studio.outputSize': '出力 {w} × {h}',
+	'studio.denoiseLabel': 'ノイズ除去',
+	'studio.errNumber': '「{label}」は数値で入力してください',
+	'studio.errInteger': '「{label}」は整数で入力してください',
+	'studio.errMin': '「{label}」は {v} 以上にしてください',
+	'studio.errMax': '「{label}」は {v} 以下にしてください',
+	'studio.errOption': '「{label}」はワークフローの選択肢にありません',
+	'studio.reuseParams': '設定を再利用',
+	'studio.reusedToast': 'このジョブの設定を反映しました。調整して再生成できます',
+	'studio.reuseMissingWf': 'このジョブのワークフローはもう存在しません',
+	'studio.doneToast': '完了：{n} ファイル（ComfyUI プロンプト ID {id}）',
+	'studio.dryRunToast': 'プレースホルダーのみ：Dry-run が有効で ComfyUI は呼び出されていません',
+	'studio.dryRunNote': 'Dry-run が有効です：生成はプレースホルダーを書き出すだけで ComfyUI を呼び出しません。設定でオフにできます。',
 };

calliope-web/src/lib/i18n/ko.ts

@@ -1398,6 +1398,54 @@ export const ko: Dict = {
 	'conn.wfJsonInvalid': '유효한 API 형식 JSON이 아닙니다(노드 ID → {{…class_type…}} 객체 필요)',
 	'conn.wfJsonPh': '여기에 ComfyUI API 형식 JSON을 붙여넣거나 오른쪽 버튼으로 파일을 선택하세요',
 	'conn.wfDeleted': '워크플로가 삭제되었습니다',
+	'conn.wfImportedBroken': 'Imported, but the workflow file is incomplete and must be re-exported before generating: {detail}',
+	'conn.wfBrokenBadge': 'Incomplete file — cannot generate',
+	// --- Five usages & import confirmation (HEL-636) ---
+	'usage.text2image': 'Text → Image',
+	'usage.image2image': 'Image → Image',
+	'usage.text2video': 'Text → Video',
+	'usage.image2video': 'Image → Video',
+	'usage.ref2video': 'Reference → Video',
+	'usage.pending': 'Usage pending',
+	'wfRole.image': 'Input image',
+	'wfRole.first_frame': 'First frame',
+	'wfRole.last_frame': 'Last frame',
+	'wfRole.reference_image': 'Reference',
+	'wfRole.mask': 'Mask',
+	'conn.wfImportAction': 'Import workflow',
+	'conn.wfConfirmTitle': 'Confirm detection',
+	'conn.wfStepAnalyze': 'Paste & analyze',
+	'conn.wfStepConfirm': 'Confirm & save',
+	'conn.wfChooseFile': 'Choose file',
+	'conn.wfAnalyze': 'Analyze',
+	'conn.wfAnalyzing': 'Analyzing…',
+	'conn.wfConfirmHint': 'Review the evidence, output nodes and image slots; correct the usage or slot roles before saving.',
+	'conn.wfUsageLabel': 'Usage',
+	'conn.wfUsageAuto': 'Auto-detected: {usage}',
+	'conn.wfUsageNeedPick': 'Pick manually',
+	'conn.wfPickUsage': 'Choose a usage first',
+	'conn.wfSlotsLabel': 'Image slots',
+	'conn.wfSlotsHint': 'Roles are inferred from wiring; override them (input image / first / last frame / reference / mask) and the manual choice sticks.',
+	'conn.wfBack': 'Back',
+	'conn.wfConfirmSave': 'Confirm & save',
+	'conn.wfImportedWithUsage': 'Saved as “{usage}” with {n} fillable parameters',
+	'conn.wfPendingCount': '{n} pending',
+	'conn.wfConfirmed': 'Usage confirmed: {usage} — the workflow can generate now',
+	'conn.wfSourceUser': 'Usage set manually; re-analysis will not overwrite it',
+	'conn.wfSourceAuto': 'Usage auto-detected',
+	'conn.wfDisabledBadge': 'Disabled',
+	'conn.wfConfirmAria': 'Confirm workflow usage',
+	'conn.wfOutputLabel': '출력 노드',
+	'conn.wfOutputNeedPick': '인식할 수 없는 사용자 지정 출력 노드가 있습니다. 직접 지정하세요',
+	'conn.wfOutputHint': '실제 결과를 내는 노드를 체크하고 각각의 미디어 유형을 선택하세요. 생성 시 이 노드에서만 이미지/동영상을 수집합니다.',
+	'conn.wfOutputPick': '출력 노드를 하나 이상 체크하세요',
+	'conn.wfOutputKindAria': '출력 노드 미디어 유형',
+	'conn.wfOutputPendingBadge': '출력 미지정',
+	'conn.wfOutputNeedMap': '인식할 수 없는 출력 노드가 포함되어 있습니다. 노드와 미디어 유형을 지정하면 활성화됩니다',
+	'conn.wfOutputApply': '출력 매핑 저장',
+	'conn.wfMapCancel': '취소',
+	'conn.wfOutputApplied': '출력 매핑 저장됨: 노드 {nodes}',
+	'conn.wfOutputCleared': '출력 매핑이 삭제되었습니다. 워크플로가 다시 대기 상태가 됩니다',
 	'conn.missingMaterial': 'Qwen Image 2.1 전용 워크플로 JSON이 아직 저장소에 없습니다. ComfyUI에서 내보내 여기서 가져오세요. 범용 가져오기 경로는 준비되어 있습니다.',
 
 	// --- 독립 이미지/비디오 생성 (a3/a4, HEL-612) ---
@@ -1499,6 +1547,34 @@ export const ko: Dict = {
 	'studio.wfNoParamsNote': '이 워크플로에는 채울 매개변수가 없어 내장 프롬프트와 설정으로 실행됩니다. 여기서 입력하려면 ComfyUI에서 노드 제목에 (Input:prompt) 등을 붙인 뒤 다시 가져오세요.',
 	'studio.wfAutoParamsNote': '(Input:…) 제목 태그가 없어 노드 유형으로 매개변수 {n}개를 자동 감지했습니다. 빈 칸은 워크플로 값을 유지합니다.',
 	'studio.promptNotDeclared': '이 워크플로에는 프롬프트 노드가 없습니다',
+	'studio.modeImageEdit': 'Image edit',
+	'studio.modeImageToVideo': 'Image to video',
+	'studio.modeRefToVideo': 'Reference to video',
+	'studio.slotInput': 'Input image',
+	'studio.slotHintOne': 'Required · 1 image',
+	'studio.slotEmptyInput': 'Click or drop the input image',
+	'studio.slotEmptyFirst': 'Click or drop the first frame',
+	'studio.slotEmptySub': 'PNG / JPG / WebP · ≤ 20MB each',
+	'studio.slotFromResultsShort': 'From results',
+	'studio.errImageFormat': '"{name}" is not supported — use PNG / JPG / WebP; this file will not be used',
+	'studio.errImageSize': '"{name}" is larger than 20MB — compress it and upload again',
+	'studio.errNeedInputImage': 'Image edit needs an input image',
+	'studio.errNeedFirstFrame': 'Image to video needs a first frame',
+	'studio.errNeedRef': 'Reference to video needs at least 1 reference image',
+	'studio.errRefMax': 'At most {max} reference images: {n} selected, these {k} were not added',
+	'studio.refHint': 'Required · 1–{max} · {n} selected',
+	'studio.refAdd': 'Add reference image',
+	'studio.refAddSub': '{n} more · max {max}',
+	'studio.refReplace': 'Replace',
+	'studio.refRemove': 'Remove reference {n}',
+	'studio.refRejectedShort': 'Not added',
+	'studio.refFull': 'Limit of {max} reached — remove one to add another',
+	'studio.refStrip': 'Reference images ({n} used)',
+	'studio.resolutionLabel': 'Output resolution',
+	'studio.resolutionHint': 'About {v}×{v} px, keeps the input aspect; 0 = original size',
+	'studio.wfBrokenTitle': 'This workflow file is incomplete — ComfyUI cannot run it, generation is blocked',
+	'studio.wfBrokenHint': 'Re-export the API-format JSON from a ComfyUI that has the custom nodes installed, then import it again under ComfyUI connections.',
+	'studio.errWfBroken': 'Workflow file is incomplete — re-export it before generating',
 	'studio.cancelToast': '취소를 요청했습니다',
 	'studio.deleteBtn': '삭제',
 	'studio.delTitle': '작업 기록 삭제',
@@ -1761,4 +1837,39 @@ export const ko: Dict = {
 	'home.errScriptShort': '대본이 너무 짧습니다. 붙여넣기가 완전한지 확인하세요(30자 이상)',
 	'home.stageProgress': '5단계 진행',
 	'tasks.sourceWorkbench': '제작 흐름',
+	'jobst.idSuffix': ' · ComfyUI 프롬프트 ID {id}',
+	'jobst.done': '완료',
+	'jobst.doneDetail': 'ComfyUI 실행이 끝나 결과를 저장했습니다',
+	'jobst.dryRun': '자리표시자',
+	'jobst.dryRunDetail': '자리표시자만: Dry-run이 켜져 있어 ComfyUI를 호출하지 않았습니다',
+	'jobst.noOutput': '출력 없음',
+	'jobst.noOutputDetail': '결과 파일 없이 끝났습니다 — 생성 완료가 아닙니다',
+	'jobst.queued': '대기 중',
+	'jobst.queuedDetail': '워크벤치 대기열에서 ComfyUI 전송을 기다리는 중',
+	'jobst.connecting': '연결 중',
+	'jobst.connectingDetail': 'ComfyUI에 연결하고 입력을 업로드하는 중',
+	'jobst.comfyQueued': '접수됨',
+	'jobst.comfyQueuedDetail': 'ComfyUI가 작업을 접수해 대기열에 넣었습니다',
+	'jobst.comfyQueuedAhead': 'ComfyUI가 접수함 — 앞에 {n}개 대기',
+	'jobst.comfyRunning': '실행 중',
+	'jobst.comfyRunningDetail': 'ComfyUI가 실행 중입니다',
+	'jobst.saving': '저장 중',
+	'jobst.savingDetail': 'ComfyUI 결과를 내려받는 중',
+	'jobst.failed': '실패',
+	'jobst.cancelled': '취소됨',
+	'studio.ratioLabel': '화면 비율',
+	'studio.megapixelsLabel': '메가픽셀',
+	'studio.outputSize': '출력 {w} × {h}',
+	'studio.denoiseLabel': '디노이즈',
+	'studio.errNumber': '‘{label}’은(는) 숫자여야 합니다',
+	'studio.errInteger': '‘{label}’은(는) 정수여야 합니다',
+	'studio.errMin': '‘{label}’은(는) {v} 이상이어야 합니다',
+	'studio.errMax': '‘{label}’은(는) {v} 이하여야 합니다',
+	'studio.errOption': '‘{label}’ 값이 워크플로 옵션에 없습니다',
+	'studio.reuseParams': '설정 재사용',
+	'studio.reusedToast': '이 작업의 설정을 채웠습니다. 수정 후 다시 생성하세요',
+	'studio.reuseMissingWf': '이 작업의 워크플로가 더 이상 없습니다',
+	'studio.doneToast': '완료: 파일 {n}개 (ComfyUI 프롬프트 ID {id})',
+	'studio.dryRunToast': '자리표시자만: Dry-run이 켜져 있어 ComfyUI를 호출하지 않았습니다',
+	'studio.dryRunNote': 'Dry-run이 켜져 있습니다: 생성은 자리표시자만 쓰고 ComfyUI를 호출하지 않습니다. 설정에서 끌 수 있습니다.',
 };

calliope-web/src/lib/i18n/zh.ts

@@ -1379,7 +1379,7 @@ export const zh: Dict = {
 	'conn.noticeStrong': '连通性以服务器为准：',
 	'conn.noticeBody': '地址在浏览器能打开不代表生成可用；测试与生成请求都由运行影工坊的服务器发起。令牌仅存服务端。',
 	'conn.wfTitle': '工作流库',
-	'conn.wfHint': '导入 ComfyUI 的 API 格式 JSON，分类为图片 / 视频，并绑定到某个连接',
+	'conn.wfHint': '导入 ComfyUI 的 API 格式 JSON，自动判定五类用途，并绑定到某个连接',
 	'conn.wfEmpty': '还没有导入工作流。在 ComfyUI 里启用开发者模式，用「导出（API 格式）」得到 JSON 后粘贴导入。',
 	'conn.wfCount': '{n} 个工作流 · {m} 图片 · {k} 视频',
 	'conn.wfKindImage': '图片',
@@ -1391,14 +1391,62 @@ export const zh: Dict = {
 	'conn.wfImporting': '导入中…',
 	'conn.wfNodes': '{n} 个节点',
 	'conn.wfImportedN': '工作流已导入，识别到 {n} 个可填参数',
-	'conn.wfImportedNoParams': '工作流已导入，但没有识别到可填参数：生成时将按工作流内置设置运行',
-	'conn.wfImportFailed': '导入失败：{detail}',
-	'conn.wfImportTitle': '导入 ComfyUI 工作流（API 格式 JSON）',
-	'conn.wfImportHint': '粘贴或选择文件；名称必填，分类决定它出现在生图还是生视频窗口。',
-	'conn.wfJsonInvalid': '不是有效的 API 格式 JSON（应为节点 id 到 class_type 的对象）',
-	'conn.wfJsonPh': '在此粘贴 ComfyUI 导出的 API 格式 JSON，或点右侧按钮选择文件',
-	'conn.wfDeleted': '工作流已删除',
-	'conn.missingMaterial': 'Qwen Image 2.1 的专用工作流 JSON 仓库中暂缺：请从 ComfyUI 导出后在此导入，通用导入通道已就绪。',
+ 	'conn.wfImportedNoParams': '工作流已导入，但没有识别到可填参数：生成时将按工作流内置设置运行',
+ 	'conn.wfImportFailed': '导入失败：{detail}',
+ 	'conn.wfImportTitle': '导入 ComfyUI 工作流（API 格式 JSON）',
+ 	'conn.wfImportHint': '粘贴或选择文件并点「分析」；系统按输出节点和图片槽位判定五类用途，确认后保存。',
+ 	'conn.wfJsonInvalid': '不是有效的 API 格式 JSON（应为节点 id 到 class_type 的对象）',
+ 	'conn.wfJsonPh': '在此粘贴 ComfyUI 导出的 API 格式 JSON，或点右侧按钮选择文件',
+ 	'conn.wfDeleted': '工作流已删除',
+ 	'conn.wfImportedBroken': '已导入，但工作流文件不完整，生成前需重新导出：{detail}',
+ 	'conn.wfBrokenBadge': '文件不完整，无法生成',
+	// --- 五类用途与导入确认（HEL-636）---
+	'usage.text2image': '文生图',
+	'usage.image2image': '图生图',
+	'usage.text2video': '文生视频',
+	'usage.image2video': '图生视频',
+	'usage.ref2video': '参考图生视频',
+	'usage.pending': '用途待确认',
+	'wfRole.image': '输入图',
+	'wfRole.first_frame': '首帧',
+	'wfRole.last_frame': '尾帧',
+	'wfRole.reference_image': '参考图',
+	'wfRole.mask': '遮罩',
+	'conn.wfImportAction': '导入工作流',
+	'conn.wfConfirmTitle': '确认识别结果',
+	'conn.wfStepAnalyze': '粘贴分析',
+	'conn.wfStepConfirm': '确认保存',
+	'conn.wfChooseFile': '选择文件',
+	'conn.wfAnalyze': '分析',
+	'conn.wfAnalyzing': '分析中…',
+	'conn.wfConfirmHint': '核对判定依据、输出节点与图片槽位；用途或槽位不对可在此纠正后再保存。',
+	'conn.wfUsageLabel': '用途',
+	'conn.wfUsageAuto': '自动判定：{usage}',
+	'conn.wfUsageNeedPick': '需人工选择',
+	'conn.wfPickUsage': '请先选择工作流用途',
+	'conn.wfSlotsLabel': '图片槽位',
+	'conn.wfSlotsHint': '槽位角色按连线推断；不符时可改为输入图 / 首帧 / 尾帧 / 参考图 / 遮罩，保存后以人工选择为准。',
+	'conn.wfBack': '上一步',
+	'conn.wfConfirmSave': '确认保存',
+	'conn.wfImportedWithUsage': '已保存为「{usage}」，识别到 {n} 个可填参数',
+	'conn.wfPendingCount': '{n} 个待确认',
+	'conn.wfConfirmed': '已确认用途：{usage}，工作流已可生成',
+	'conn.wfSourceUser': '用途为人工确认，重新分析不会覆盖',
+	'conn.wfSourceAuto': '用途为自动判定',
+	'conn.wfDisabledBadge': '已停用',
+	'conn.wfConfirmAria': '确认工作流用途',
+	'conn.wfOutputLabel': '输出节点',
+	'conn.wfOutputNeedPick': '存在无法识别的自定义输出节点，需人工指定',
+	'conn.wfOutputHint': '勾选实际产生结果的节点，并为每个节点选择媒体类型；生成时只从这些节点提取图片/视频。',
+	'conn.wfOutputPick': '请至少勾选一个输出节点',
+	'conn.wfOutputKindAria': '输出节点媒体类型',
+	'conn.wfOutputPendingBadge': '待指定输出',
+	'conn.wfOutputNeedMap': '该工作流含无法识别的输出节点，指定输出节点及媒体类型后才能启用',
+	'conn.wfOutputApply': '保存输出映射',
+	'conn.wfMapCancel': '取消',
+	'conn.wfOutputApplied': '已保存输出映射：节点 {nodes}',
+	'conn.wfOutputCleared': '已清除输出映射，工作流回到待确认状态',
+ 	'conn.missingMaterial': 'Qwen Image 2.1 的专用工作流 JSON 仓库中暂缺：请从 ComfyUI 导出后在此导入，通用导入通道已就绪。',
 	// --- 独立生图 / 生视频（a3/a4，HEL-612）---
 	'studio.image.title': '生图',
 	'studio.image.subtitle': '用已导入的图片工作流生成图片 · 连接与队列和「ComfyUI 连接」共用',
@@ -1498,6 +1546,35 @@ export const zh: Dict = {
 	'studio.wfNoParamsNote': '该工作流没有可填写的参数，将按工作流内置的提示词和设置直接生成。如需在这里填写，请在 ComfyUI 中把节点标题加上 (Input:prompt) 等标记后重新导入。',
 	'studio.wfAutoParamsNote': '工作流未使用 (Input:…) 标题标记，已按节点类型自动识别出 {n} 个参数；留空的项沿用工作流原值。',
 	'studio.promptNotDeclared': '该工作流没有提示词节点，无需填写',
+	// --- 图片输入工作流（HEL-633，ref-upload-spec）---
+	'studio.modeImageEdit': '图片编辑',
+	'studio.modeImageToVideo': '图生视频',
+	'studio.modeRefToVideo': '参考生视频',
+	'studio.slotInput': '输入图',
+	'studio.slotHintOne': '必填 · 1 张',
+	'studio.slotEmptyInput': '点击或拖入输入图',
+	'studio.slotEmptyFirst': '点击或拖入首帧图',
+	'studio.slotEmptySub': 'PNG / JPG / WebP · 单张 ≤ 20MB',
+	'studio.slotFromResultsShort': '从结果选',
+	'studio.errImageFormat': '「{name}」格式不支持，请使用 PNG / JPG / WebP；该文件不会参与生成',
+	'studio.errImageSize': '「{name}」超过 20MB，请压缩后再传',
+	'studio.errNeedInputImage': '图片编辑需要上传输入图',
+	'studio.errNeedFirstFrame': '图生视频需要上传首帧图',
+	'studio.errNeedRef': '参考生视频需要至少 1 张参考图',
+	'studio.errRefMax': '参考图最多 {max} 张：已选 {n} 张，本次的 {k} 张未添加',
+	'studio.refHint': '必填 · 1–{max} 张 · 已选 {n}',
+	'studio.refAdd': '添加参考图',
+	'studio.refAddSub': '还可加 {n} 张 · 上限 {max}',
+	'studio.refReplace': '替换',
+	'studio.refRemove': '移除参考图 {n}',
+	'studio.refRejectedShort': '未添加',
+	'studio.refFull': '已达上限 {max} 张，移除后才能再添加',
+	'studio.refStrip': '参考图（{n} 张参与生成）',
+	'studio.resolutionLabel': '输出分辨率',
+	'studio.resolutionHint': '约 {v}×{v} 像素，按输入图比例；0 = 保持原尺寸',
+	'studio.wfBrokenTitle': '该工作流文件不完整，ComfyUI 无法执行，已禁止生成',
+	'studio.wfBrokenHint': '请在已安装对应自定义节点的 ComfyUI 中重新导出 API 格式 JSON，再到「ComfyUI 连接」重新导入。',
+	'studio.errWfBroken': '工作流文件不完整，需重新导出后才能生成',
 	'studio.cancelToast': '已发送取消请求',
 	'studio.deleteBtn': '删除',
 	'studio.delTitle': '删除任务记录',
@@ -1760,4 +1837,39 @@ export const zh: Dict = {
 	'home.errScriptShort': '剧本内容太短，请检查粘贴是否完整（至少 30 字）',
 	'home.stageProgress': '五段进度',
 	'tasks.sourceWorkbench': '创作流程',
+	'jobst.idSuffix': ' · ComfyUI 任务 ID {id}',
+	'jobst.done': '完成',
+	'jobst.doneDetail': 'ComfyUI 已执行完成，结果已保存',
+	'jobst.dryRun': '占位结果',
+	'jobst.dryRunDetail': '占位结果：当前开启了 Dry-run，没有调用 ComfyUI，不是真实生成',
+	'jobst.noOutput': '无产出',
+	'jobst.noOutputDetail': '任务结束但没有任何结果文件，不算生成完成',
+	'jobst.queued': '排队中',
+	'jobst.queuedDetail': '在工作台队列中等待提交到 ComfyUI',
+	'jobst.connecting': '连接中',
+	'jobst.connectingDetail': '正在连接 ComfyUI 并上传素材',
+	'jobst.comfyQueued': '已接收',
+	'jobst.comfyQueuedDetail': 'ComfyUI 已接收，排队等待执行',
+	'jobst.comfyQueuedAhead': 'ComfyUI 已接收，前面还有 {n} 个任务',
+	'jobst.comfyRunning': '执行中',
+	'jobst.comfyRunningDetail': 'ComfyUI 正在执行',
+	'jobst.saving': '保存中',
+	'jobst.savingDetail': 'ComfyUI 已出结果，正在下载保存',
+	'jobst.failed': '失败',
+	'jobst.cancelled': '已取消',
+	'studio.ratioLabel': '画面比例',
+	'studio.megapixelsLabel': '总像素（百万）',
+	'studio.outputSize': '输出 {w} × {h}',
+	'studio.denoiseLabel': '降噪',
+	'studio.errNumber': '「{label}」必须是数字',
+	'studio.errInteger': '「{label}」必须是整数',
+	'studio.errMin': '「{label}」不能小于 {v}',
+	'studio.errMax': '「{label}」不能大于 {v}',
+	'studio.errOption': '「{label}」的取值不在工作流支持的选项中',
+	'studio.reuseParams': '复用参数',
+	'studio.reusedToast': '已回填该任务的参数，可修改后重新生成',
+	'studio.reuseMissingWf': '该任务使用的工作流已不存在，无法回填',
+	'studio.doneToast': '生成完成：{n} 个文件（ComfyUI 任务 ID {id}）',
+	'studio.dryRunToast': '占位完成：当前开启了 Dry-run，没有调用 ComfyUI，结果不是真实生成',
+	'studio.dryRunNote': '已开启 Dry-run：点生成只会写占位文件，不会调用 ComfyUI。可在「设置」中关闭。',
 };

calliope-web/src/lib/jobProgress.ts

@@ -8,14 +8,14 @@ import { t } from './i18n.svelte';
  * Backend reality (see calliope-backend/src/calliope/queue/worker.py):
  * - `job.created`   { job_id, kind, ... }
  * - `job.started`   { job_id, kind, message }          ← message = job label
- * - `job.progress`  { prompt_id, message }             ← NO job_id, NO percent
+ * - `job.progress`  { job_id, prompt_id, phase, queue_ahead, message }  ← NO percent
  * - `job.completed` { job_id, outputs, message }
  * - `job.failed`    { job_id, error, message }
  * - `job.deleted`   { job_id }
  *
- * Because progress ticks carry neither a job id nor a percent, the store:
- * 1. Attributes a tick to the currently running job (tracked from job.started;
- *    explicit `job_id` wins if a future backend sends one).
+ * Because progress ticks carry no percent (and ticks without a job id exist), the store:
+ * 1. Attributes a tick to its `job_id`, else to the currently running job
+ *    (tracked from job.started).
  * 2. Honors a numeric payload field (`progress` / `percent` / `value`, 0–1 or
  *    0–100) when present, otherwise synthesizes an asymptotic value that
  *    approaches TICK_CAP but never reaches it — only job.completed sets 100.
@@ -32,6 +32,10 @@ export type JobProgressEntry = {
 	progress: number;
 	/** Latest human-readable status line from the worker. */
 	message?: string;
+	/** Worker phase from job.progress (comfy_queued / comfy_running …). */
+	phase?: string;
+	/** Prompts ahead of this one in ComfyUI's own queue (comfy_queued only). */
+	queueAhead?: number | null;
 	/** True once the job reached a terminal state (done/failed). */
 	final: boolean;
 	/** Terminal status when final: 'done' | 'failed'. */
@@ -115,6 +119,8 @@ class JobProgressStore {
 				this.map.set(id, {
 					progress,
 					message: str(d.message) || prev?.message,
+					phase: str(d.phase) || prev?.phase,
+					queueAhead: d.queue_ahead === undefined ? prev?.queueAhead : num(d.queue_ahead),
 					final: false,
 					updatedAt: Date.now(),
 				});
@@ -151,9 +157,8 @@ class JobProgressStore {
 	}
 
 	/**
-	 * Today's job.progress payload is {prompt_id, message} with no job id.
-	 * Attribute the tick to the only running job, else the most recently
-	 * started one. Explicit job_id wins when a backend sends it.
+	 * Explicit job_id wins; a tick without one goes to the only running job,
+	 * else the most recently started one.
 	 */
 	private resolveJobId(d: Record<string, unknown>): number | null {
 		const explicit = num(d.job_id);

calliope-web/src/lib/jobStatus.ts

@@ -0,0 +1,53 @@
+import type { Job } from './comfy/types';
+import { progressFor } from './jobProgress';
+import { t } from './i18n.svelte';
+
+export type JobStatusTone = 'ok' | 'run' | 'queue' | 'fail';
+
+export interface JobStatusInfo {
+	tone: JobStatusTone;
+	/** Short label for status columns. */
+	label: string;
+	/** Full sentence for the task card / tooltip. */
+	detail: string;
+}
+
+/**
+ * What a generation job really is — "done" only when ComfyUI returned files.
+ * A dry-run placeholder or a done row without outputs never reads as done.
+ */
+export function jobStatusInfo(job: Job): JobStatusInfo {
+	const live = progressFor(job.id);
+	const phase = live?.phase ?? job.phase ?? null;
+	const idSuffix = job.comfy_prompt_id ? t('jobst.idSuffix', { id: job.comfy_prompt_id }) : '';
+	switch (job.status) {
+		case 'done':
+			if (phase === 'dry_run')
+				return { tone: 'queue', label: t('jobst.dryRun'), detail: t('jobst.dryRunDetail') };
+			if (!(job.output_paths?.length ?? 0))
+				return { tone: 'fail', label: t('jobst.noOutput'), detail: t('jobst.noOutputDetail') };
+			return { tone: 'ok', label: t('jobst.done'), detail: t('jobst.doneDetail') + idSuffix };
+		case 'pending':
+			return { tone: 'queue', label: t('jobst.queued'), detail: t('jobst.queuedDetail') };
+		case 'running':
+			if (phase === 'comfy_queued') {
+				const ahead = live?.queueAhead;
+				const detail =
+					ahead != null && ahead > 0
+						? t('jobst.comfyQueuedAhead', { n: ahead })
+						: t('jobst.comfyQueuedDetail');
+				return { tone: 'queue', label: t('jobst.comfyQueued'), detail: detail + idSuffix };
+			}
+			if (phase === 'comfy_running')
+				return { tone: 'run', label: t('jobst.comfyRunning'), detail: t('jobst.comfyRunningDetail') + idSuffix };
+			if (phase === 'saving')
+				return { tone: 'run', label: t('jobst.saving'), detail: t('jobst.savingDetail') + idSuffix };
+			return { tone: 'run', label: t('jobst.connecting'), detail: t('jobst.connectingDetail') };
+		default:
+			return {
+				tone: 'fail',
+				label: job.error === 'cancelled' ? t('jobst.cancelled') : t('jobst.failed'),
+				detail: job.error ?? t('jobst.failed'),
+			};
+	}
+}

calliope-web/src/routes/agents/+page.svelte

@@ -18,7 +18,6 @@
 		type NamedAgent,
 		type SkillAdminEntry,
 		type SkillVersion,
-		type Settings,
 		canvasApi,
 	} from '$lib/api';
 	import { AGENT_TASK_PROMPTS, AGENT_TASK_TITLE_KEYS, isAgentTaskKind } from '$lib/agentTasks';
@@ -378,10 +377,10 @@
 		},
 	});
 
-	function setAgentModel(s: Settings, role: string, value: string) {
-		const merged: Record<string, string | null> = { ...(s.agent_llm_assignments ?? {}) };
-		merged[role] = value === '' ? null : value;
-		$assignMutation.mutate(merged);
+	function setAgentModel(role: string, value: string) {
+		// Single-role delta only (HEL-619): the whole-snapshot replay races
+		// concurrent switches; the server merges per role.
+		$assignMutation.mutate({ [role]: value === '' ? null : value });
 	}
 
 	// ─────────────────────────────────────────────────────────────────────
@@ -718,7 +717,7 @@
 										<select
 											class="a-select"
 											value={s.agent_llm_assignments?.[activeAgent.llm_role] ?? ''}
-											onchange={(e) => setAgentModel(s, activeAgent.llm_role, e.currentTarget.value)}
+											onchange={(e) => setAgentModel(activeAgent.llm_role, e.currentTarget.value)}
 										>
 											<option value="">{t('agentsPage.modelDefault')}</option>
 											{#each s.llm_profiles as p (p.id)}

calliope-web/src/routes/models/+page.svelte

@@ -420,10 +420,11 @@
 		},
 	});
 
-	function setAssignment(s: Settings, role: string, value: string) {
-		const merged: Record<string, string | null> = { ...(s.agent_llm_assignments ?? {}) };
-		merged[role] = value === '' ? null : value;
-		$assignMutation.mutate(merged);
+	function setAssignment(role: string, value: string) {
+		// Single-role delta only (HEL-619): replaying the whole cached
+		// snapshot races concurrent dropdown switches — an older snapshot
+		// could overwrite a newer choice. The server merges per role.
+		$assignMutation.mutate({ [role]: value === '' ? null : value });
 	}
 
 	// ------------------------------------------------------------------
@@ -630,7 +631,7 @@
 									<select
 										class="a-select"
 										value={s.agent_llm_assignments?.[agent.role] ?? ''}
-										onchange={(e) => setAssignment(s, agent.role, e.currentTarget.value)}
+										onchange={(e) => setAssignment(agent.role, e.currentTarget.value)}
 									>
 										<option value="">{t('models.agentDefault')}</option>
 										{#each profiles as p (p.id)}
@@ -1195,6 +1196,9 @@
 		padding: 18px 20px 20px;
 		position: sticky;
 		top: 24px;
+		/* 384px must be the OUTER width per the a6 spec — without
+		   border-box padding+border inflate it to 426px (HEL-619). */
+		box-sizing: border-box;
 	}
 	.form-idle {
 		display: flex;

calliope-web/src/routes/tasks/+page.svelte

@@ -14,7 +14,8 @@
 	} from '$lib/api';
 	import { connectEvents } from '$lib/events';
 	import { parseDbTs } from '$lib/dbtime';
-	import { handleJobEvent, progressFor } from '$lib/jobProgress';
+	import { handleJobEvent } from '$lib/jobProgress';
+	import { jobStatusInfo } from '$lib/jobStatus';
 	import { toast } from '$lib/toast';
 	import { t } from '$lib/i18n.svelte';
 	import { isStandaloneJob, jobSourceLabel } from '$lib/jobLabels';
@@ -75,18 +76,6 @@
 		return `${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
 	}
 
-	function stInfo(job: Job): { cls: string; label: string; mono?: boolean } {
-		switch (job.status) {
-			case 'done':
-				return { cls: 'ok', label: t('tasks.done') };
-			case 'running':
-				return { cls: 'run', label: `${Math.round(progressFor(job.id)?.progress ?? 3)}%`, mono: true };
-			case 'pending':
-				return { cls: 'queue', label: t('tasks.queued') };
-			default:
-				return { cls: 'fail', label: t('tasks.failed') };
-		}
-	}
 
 	let busyId = $state<number | null>(null);
 	async function retry(job: Job) {
@@ -164,7 +153,7 @@
 		{:else}
 			<div class="task-table">
 				{#each shown as job (job.id)}
-					{@const st = stInfo(job)}
+					{@const st = jobStatusInfo(job)}
 					<div class="trow" class:failed={job.status === 'failed'}>
 						<span class="tkind {job.kind}">
 							<Icon name={job.kind === 'image' ? 'image' : 'film'} size={14} />
@@ -188,6 +177,8 @@
 							</div>
 							{#if job.status === 'failed' && job.error}
 								<div class="terror">{job.error}</div>
+							{:else if st.tone === 'fail' || (job.status === 'done' && job.phase === 'dry_run')}
+								<div class="terror">{st.detail}</div>
 							{/if}
 						</div>
 						<div class="tout">
@@ -205,7 +196,7 @@
 								</div>
 							{/if}
 						</div>
-						<span class="tst {st.cls}" class:mono={st.mono}>{st.label}</span>
+						<span class="tst {st.tone}" title={st.detail}>{st.label}</span>
 						<span class="tactions">
 							{#if job.status === 'failed'}
 								<button type="button" class="link-accent" disabled={busyId === job.id} onclick={() => retry(job)}>