feat(workflows): manual output-node mapping for unknown custom outputs (HEL-638)

Unknown custom output nodes are never auto-typed by class-name semantics;
they stay pending until the user designates the real output node(s) and
media type. Picking a usage alone no longer enables a workflow, reanalyze/
migration/field edits never overwrite a user mapping, generation harvests
only the mapped nodes from ComfyUI history, and media-type mismatches or
missing node results fail for real instead of faking completion.

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

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

@@ -41,15 +41,27 @@ 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 {node_id}: {msg}")
-        detail = "; ".join(parts)
-    suffix = f": {detail}" if detail else ""
-    return RuntimeError(f"{prefix} ({resp.status_code}){suffix}")
+                        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}")
 
 
 class ComfyUIClient:
@@ -75,7 +87,7 @@ class ComfyUIClient:
         form = {"overwrite": "true", "subfolder": subfolder}
         resp = await self._http.post(f"{self.base_url}/upload/image", files=files, data=form)
         if resp.status_code >= 400:
-            raise _surface_error("ComfyUI image upload failed", resp)
+            raise _surface_error("图片上传到 ComfyUI 失败", resp)
         result = resp.json()
         name = result.get("name", path.name)
         sub = result.get("subfolder") or subfolder
@@ -95,7 +107,7 @@ class ComfyUIClient:
             form["subfolder"] = subfolder
         resp = await self._http.post(f"{self.base_url}/upload/image", files=files, data=form)
         if resp.status_code >= 400:
-            raise _surface_error("ComfyUI audio upload failed", resp)
+            raise _surface_error("音频上传到 ComfyUI 失败", resp)
         result = resp.json()
         name = result.get("name", path.name)
         sub = result.get("subfolder") or subfolder
@@ -108,7 +120,7 @@ class ComfyUIClient:
         form = {"overwrite": "true", "subfolder": subfolder, "type": "input"}
         resp = await self._http.post(f"{self.base_url}/upload/image", files=files, data=form)
         if resp.status_code >= 400:
-            raise _surface_error("ComfyUI video upload failed", resp)
+            raise _surface_error("视频上传到 ComfyUI 失败", resp)
         result = resp.json()
         name = result.get("name", path.name)
         sub = result.get("subfolder") or subfolder
@@ -202,11 +214,13 @@ class ComfyUIClient:
         payload = {"prompt": workflow, "client_id": self.client_id}
         resp = await self._http.post(f"{self.base_url}/prompt", json=payload)
         if resp.status_code >= 400:
-            raise _surface_error("ComfyUI rejected the workflow", resp)
+            raise _surface_error(
+                "ComfyUI 拒绝执行该工作流（常见原因：缺少模型/自定义节点，或参数不合法）", resp
+            )
         data = resp.json()
         prompt_id = data.get("prompt_id")
         if not prompt_id:
-            raise RuntimeError(f"ComfyUI /prompt missing prompt_id: {data}")
+            raise RuntimeError(f"ComfyUI 返回异常：/prompt 响应缺少 prompt_id（{str(data)[:200]}）")
         return prompt_id
 
     async def get_history(self, prompt_id: str) -> dict[str, Any] | None:
@@ -215,6 +229,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,
@@ -224,7 +269,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)
@@ -237,16 +285,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

@@ -1,17 +1,27 @@
 """Parse ComfyUI API-format workflows for (Input[:role]) / (Output[:role]) titled nodes."""
+
 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 (
-    ComfyOutputKind,
-    IMAGE_CLASSES,
     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,
@@ -36,6 +46,12 @@ def extract_default_value(node: dict[str, Any]) -> str | int | float | None:
 
 
 def parse_dynamic_inputs(workflow: dict[str, Any]) -> list[dict[str, Any]]:
+    """Tagged ``(Input:role)`` nodes; untagged workflows fall back to detection.
+
+    A workflow exported straight from ComfyUI carries default node titles
+    ("CLIP Text Encode (Positive Prompt)", "KSampler", …) and no tags at all —
+    without the fallback it would expose nothing to fill in.
+    """
     results: list[dict[str, Any]] = []
     for node_id, node in workflow.items():
         if not isinstance(node, dict):
@@ -54,9 +70,610 @@ def parse_dynamic_inputs(workflow: dict[str, Any]) -> list[dict[str, Any]]:
                 "required": True,
             }
         )
+    if not results:
+        results = detect_untagged_inputs(workflow)
     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
+# ---------------------------------------------------------------------------
+
+_MASK_IMAGE_CLASSES = frozenset({"LoadImageMask"})
+_STRING_PRIMITIVES = frozenset({"PrimitiveString", "PrimitiveStringMultiline"})
+_NUMBER_PRIMITIVES = frozenset({"PrimitiveInt", "PrimitiveFloat", "INT", "FLOAT"})
+_SAMPLER_CLASSES = frozenset({"KSampler", "KSamplerAdvanced"})
+_NEGATIVE_WORDS = ("negative", "负面", "反向", "反面")
+_SYSTEM_WORDS = ("system", "系统")
+_PROMPT_WORDS = ("prompt", "positive", "提示", "正向")
+_NEGATIVE_TEXT_FIELDS = ("negative_prompt", "negative_text", "negative")
+
+# Title keyword → (role, Chinese label) for untagged numeric primitives.
+_NUMBER_TITLE_ROLES: tuple[tuple[tuple[str, ...], str, str], ...] = (
+    (("duration", "seconds", "second", "时长", "秒"), "duration", "时长（秒）"),
+    (("fps", "frame rate", "framerate", "帧率"), "fps", "帧率"),
+    (("seed", "种子"), "seed", "随机种子"),
+    (("width", "宽度"), "width", "宽度"),
+    (("height", "高度"), "height", "高度"),
+    (("steps", "步数"), "steps", "采样步数"),
+    (("cfg",), "cfg", "CFG"),
+)
+
+
+def _is_scalar(value: Any) -> bool:
+    return isinstance(value, (str, int, float)) and not isinstance(value, bool)
+
+
+def _title_of(node: dict[str, Any]) -> str:
+    return str((node.get("_meta") or {}).get("title") or "").strip()
+
+
+def _node_sort_key(node_id: str) -> tuple:
+    return tuple(
+        (0, int(p)) if p.isdigit() else (1, p)
+        for p in str(node_id).replace(FIELD_KEY_SEP, ":").split(":")
+    )
+
+
+def _consumers(workflow: dict[str, Any]) -> dict[str, list[tuple[str, str]]]:
+    """source nodeId → [(consumer nodeId, consumer input name), …]."""
+    out: dict[str, list[tuple[str, str]]] = {}
+    for nid, node in workflow.items():
+        if not isinstance(node, dict):
+            continue
+        for name, val in (node.get("inputs") or {}).items():
+            if isinstance(val, list) and len(val) == 2 and isinstance(val[0], (str, int)):
+                out.setdefault(str(val[0]), []).append((str(nid), str(name)))
+    return out
+
+
+def _feeds_negative(
+    node_id: str, consumers: dict[str, list[tuple[str, str]]], depth: int = 4
+) -> bool:
+    """True when this node's output reaches a sampler/guider ``negative`` input
+    and never a ``positive`` one.
+
+    A text encoder wired into both (one conditioning reused for positive and
+    negative) is treated as the positive prompt; only a negative-sounding
+    title makes it negative (see ``_is_negative``).
+    """
+    frontier = [node_id]
+    seen = {node_id}
+    negative = False
+    for _ in range(depth):
+        nxt: list[str] = []
+        for nid in frontier:
+            for cid, name in consumers.get(nid, []):
+                if name == "positive":
+                    return False
+                if name == "negative":
+                    negative = True
+                    continue
+                if cid not in seen:
+                    seen.add(cid)
+                    nxt.append(cid)
+        frontier = nxt
+    return negative
+
+
+_FRAME_INPUTS = frozenset({"length", "num_frames", "frames", "video_length", "frame_count"})
+_SECONDS_INPUTS = frozenset({"duration", "seconds", "duration_seconds"})
+_EXPRESSION_HINTS = ("expression", "math")
+
+
+def _duration_hint(
+    node_id: str,
+    workflow: dict[str, Any],
+    consumers: dict[str, list[tuple[str, str]]],
+    depth: int = 3,
+) -> str | None:
+    """How an untitled number feeds the video length downstream.
+
+    ``"seconds"`` — it reaches a seconds input, or a frame-count input only
+    after passing through a math/expression node (seconds × fps → frames);
+    ``"frames"`` — it is wired straight into a frame-count input.
+    """
+    frontier = [(node_id, False)]
+    seen = {node_id}
+    for _ in range(depth):
+        nxt: list[tuple[str, bool]] = []
+        for nid, via_expr in frontier:
+            for cid, name in consumers.get(nid, []):
+                if name in _SECONDS_INPUTS:
+                    return "seconds"
+                if name in _FRAME_INPUTS:
+                    return "seconds" if via_expr else "frames"
+                if cid in seen:
+                    continue
+                seen.add(cid)
+                ct = str((workflow.get(cid) or {}).get("class_type") or "").lower()
+                nxt.append((cid, via_expr or any(h in ct for h in _EXPRESSION_HINTS)))
+        frontier = nxt
+    return None
+
+
+def _entry(
+    key: str,
+    label: str,
+    role: str | None,
+    kind: str,
+    default: Any,
+    required: bool,
+    **extra: Any,
+) -> dict[str, Any]:
+    entry = {
+        "nodeId": key,
+        "label": label,
+        "role": role,
+        "kind": kind,
+        "defaultValue": default if _is_scalar(default) else None,
+        "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:
+    """Plain nodeId when that already patches ``field``; else ``nodeId@field``."""
+    return (
+        str(node_id) if resolve_patch_field(node) == field else f"{node_id}{FIELD_KEY_SEP}{field}"
+    )
+
+
+def detect_untagged_inputs(workflow: dict[str, Any]) -> list[dict[str, Any]]:
+    """Infer fillable inputs from node classes and wiring of an untagged workflow.
+
+    Only scalar widgets are exposed (linked inputs are wiring, not values).
+    The positive prompt is the only required field; everything else keeps the
+    workflow's own value when left blank.
+    """
+    if not isinstance(workflow, dict):
+        return []
+    consumers = _consumers(workflow)
+    nodes = sorted(
+        ((str(k), v) for k, v in workflow.items() if isinstance(v, dict)),
+        key=lambda kv: _node_sort_key(kv[0]),
+    )
+
+    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()
+
+    def add_number(nid: str, node: dict[str, Any], field: str, role: str, label: str) -> None:
+        if role in taken_roles:
+            return
+        value = (node.get("inputs") or {}).get(field)
+        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,
+                **_NUMBER_LIMITS.get(role, {}),
+            )
+        )
+
+    for nid, node in nodes:
+        ct = str(node.get("class_type") or "")
+        inputs = node.get("inputs") or {}
+        title = _title_of(node)
+        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
+            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 or (title if title and title != ct else "参考图"),
+                    role,
+                    "image",
+                    None,
+                    True,
+                )
+            )
+            continue
+        if ct in VIDEO_CLASSES or ct in AUDIO_CLASSES:
+            kind = "video" if ct in VIDEO_CLASSES else "audio"
+            field = resolve_patch_field(node)
+            has_default = isinstance(inputs.get(field), str) and bool(inputs.get(field))
+            media.append(_entry(str(nid), title or ct, kind, kind, None, not has_default))
+            continue
+
+        if ct in _STRING_PRIMITIVES and isinstance(inputs.get("value"), str):
+            texts.append((nid, node, "value", _is_negative(nid, lowered, consumers)))
+            continue
+        if ct == "CLIPTextEncode" or "TextEncode" in ct:
+            field = next((f for f in ("text", "prompt") if isinstance(inputs.get(f), str)), None)
+            neg_field = next(
+                (f for f in _NEGATIVE_TEXT_FIELDS if isinstance(inputs.get(f), str)), None
+            )
+            if field and neg_field:
+                # One encoder carrying both prompts (TextEncodeQwenImage21…):
+                # its outputs feed positive *and* negative, so wiring says nothing.
+                texts.append((nid, node, field, False))
+                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", "批次数量")
+            continue
+        if ct in _NUMBER_PRIMITIVES and _is_scalar(inputs.get("value")):
+            role, label = None, title if title and title != ct else f"{ct} #{nid}"
+            for words, r, zh in _NUMBER_TITLE_ROLES:
+                if any(w in lowered for w in words):
+                    role, label = r, (title if title and title != ct else zh)
+                    break
+            if role is None and (not title or title == ct):
+                hint = _duration_hint(nid, workflow, consumers)
+                if hint == "seconds":
+                    role, label = "duration", "时长（秒）"
+                elif hint == "frames":
+                    label = "视频帧数"
+            if role and role in taken_roles:
+                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,
+                    **limits,
+                )
+            )
+
+    results: list[dict[str, Any]] = []
+    positives = [t for t in texts if not t[3]]
+    negatives = [t for t in texts if t[3]]
+
+    def rank(t: tuple[str, dict[str, Any], str, bool]) -> tuple[int, int]:
+        title = _title_of(t[1]).lower()
+        system = any(w in title for w in _SYSTEM_WORDS)
+        named = any(w in title for w in _PROMPT_WORDS)
+        return (1 if system else 0, 0 if named else 1)
+
+    positives.sort(key=rank)
+    for i, (nid, node, field, _neg) in enumerate(positives):
+        title = _title_of(node)
+        if i == 0:
+            results.append(
+                _entry(
+                    _key(nid, node, field),
+                    "正向提示词",
+                    "prompt",
+                    "textarea",
+                    node["inputs"][field],
+                    True,
+                )
+            )
+        else:
+            label = title if title and title != node.get("class_type") else f"文本 #{nid}"
+            results.append(
+                _entry(
+                    _key(nid, node, field), label, None, "textarea", node["inputs"][field], False
+                )
+            )
+    for i, (nid, node, field, _neg) in enumerate(negatives):
+        role = "negative" if i == 0 else None
+        label = "反向提示词" if i == 0 else (_title_of(node) or f"文本 #{nid}")
+        results.append(
+            _entry(_key(nid, node, field), label, role, "textarea", node["inputs"][field], False)
+        )
+    results.extend(numbers)
+    results.extend(media)
+    results.extend(groups)
+    return results
+
+
+def _is_negative(
+    node_id: str, lowered_title: str, consumers: dict[str, list[tuple[str, str]]]
+) -> bool:
+    if any(w in lowered_title for w in _NEGATIVE_WORDS):
+        return True
+    return _feeds_negative(node_id, consumers)
+
+
 def parse_dynamic_outputs(workflow: dict[str, Any]) -> list[dict[str, Any]]:
     results: list[dict[str, Any]] = []
     for node_id, node in workflow.items():
@@ -80,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

@@ -1,10 +1,15 @@
 """Patch user values into ComfyUI API-format workflow by nodeId."""
+
 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…).
+FIELD_KEY_SEP = "@"
 
 
 def _resolve_field(field: str, inputs: dict[str, Any]) -> str:
@@ -26,6 +31,77 @@ def _resolve_field(field: str, inputs: dict[str, Any]) -> str:
     return field
 
 
+def resolve_patch_field(node: dict[str, Any]) -> str:
+    """The widget a plain nodeId key writes to on this node."""
+    return _resolve_field(
+        class_to_patch_field(node.get("class_type", "")), dict(node.get("inputs") or {})
+    )
+
+
+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],
@@ -35,11 +111,27 @@ def patch_workflow(
         if value is None:
             continue
         key = str(node_id)
+        field: str | None = None
+        if key not in patched and FIELD_KEY_SEP in key:
+            key, field = key.rsplit(FIELD_KEY_SEP, 1)
         node = patched.get(key)
         if not isinstance(node, dict):
             continue
         inputs = dict(node.get("inputs") or {})
-        field = _resolve_field(class_to_patch_field(node.get("class_type", "")), inputs)
+        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):
+            # Linked input ([src_id, slot]) — never overwrite the wiring.
+            continue
         inputs[field] = value
         node["inputs"] = inputs
         patched[key] = node

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

@@ -20,7 +20,7 @@ TEXT_AREA_CLASSES = frozenset(
 NUMBER_CLASSES = frozenset(
     {"INT", "FLOAT", "PrimitiveInt", "PrimitiveFloat", "KSampler", "KSamplerAdvanced"}
 )
-IMAGE_CLASSES = frozenset({"LoadImage", "ImageLoader", "ETN_LoadImageBase64"})
+IMAGE_CLASSES = frozenset({"LoadImage", "LoadImageMask", "ImageLoader", "ETN_LoadImageBase64"})
 IMAGE_URL_CLASSES = frozenset({"Load Image From Url (mtb)"})
 AUDIO_CLASSES = frozenset({"LoadAudio", "VHS_LoadAudio"})
 # Stock LoadVideo uses the `file` widget; VHS uses `video`.
@@ -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

@@ -13,6 +13,13 @@ def _find_by_role(inputs: list[dict[str, Any]], *roles: str) -> dict[str, Any] |
     return None
 
 
+def _node_sort_key(node_id: object) -> tuple:
+    """Numeric order for "12", subgraph "171:154" and field keys "3@seed"."""
+    return tuple(
+        (0, int(p)) if p.isdigit() else (1, p) for p in str(node_id).replace("@", ":").split(":")
+    )
+
+
 def _find_all_by_role(inputs: list[dict[str, Any]], *roles: str) -> list[dict[str, Any]]:
     """All inputs matching any of the roles, sorted by numeric node id.
 
@@ -21,7 +28,7 @@ def _find_all_by_role(inputs: list[dict[str, Any]], *roles: str) -> list[dict[st
     in this order and it defines ``<Subject N>`` numbering in the prompt.
     """
     matches = [inp for inp in inputs if input_has_role(inp, *roles)]
-    return sorted(matches, key=lambda i: int(i["nodeId"]))
+    return sorted(matches, key=lambda i: _node_sort_key(i["nodeId"]))
 
 
 def ref_image_slots(inputs: list[dict[str, Any]]) -> list[dict[str, Any]]:
@@ -151,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
@@ -22,6 +25,28 @@ from calliope.queue.manager import queue_manager
 logger = logging.getLogger("calliope.worker")
 
 
+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 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()}")
+        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):
     """The job row was flipped to 'cancelled' out-of-band (Stop button).
     The row already carries the terminal state; the loop must not overwrite
@@ -79,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",
                         {
@@ -90,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)",
                         },
                     )
@@ -155,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(
@@ -165,9 +196,24 @@ class QueueWorker:
                 )
 
             workflow_id = job.get("workflow_id") or payload.get("workflow_id")
-            workflow = self._load_workflow(workflow_id)
-            if not workflow:
-                raise RuntimeError("No workflow found for job")
+            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":
@@ -177,19 +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("Timed out waiting for ComfyUI history")
+                raise RuntimeError(
+                    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 error: {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] = []
@@ -205,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()
@@ -344,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():
@@ -354,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:
@@ -379,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/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,24 +336,46 @@ 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:
-            raise HTTPException(status_code=404, detail="Workflow not found")
+            raise HTTPException(
+                status_code=404, detail="工作流不存在（可能已被删除），请刷新页面后重新选择"
+            )
         if not wf["is_enabled"]:
-            raise HTTPException(status_code=400, detail="Workflow is disabled")
+            raise HTTPException(
+                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/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,9 +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 []
-    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
 
 
@@ -27,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:
@@ -48,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(
@@ -110,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()
@@ -173,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

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/minimax_h3_t2v_untagged_API.json

@@ -0,0 +1,808 @@
+{
+ "115": {
+  "inputs": {
+   "aspect_ratio": "9:16 (Portrait Widescreen)",
+   "megapixels": 0.6,
+   "multiple": 32
+  },
+  "class_type": "ResolutionSelector",
+  "_meta": {
+   "title": "Resolution Selector"
+  }
+ },
+ "207": {
+  "inputs": {
+   "vae_name": "minimax-h3\\minimax_h3_video_vae_fp16.safetensors"
+  },
+  "class_type": "VAELoader",
+  "_meta": {
+   "title": "Load VAE"
+  }
+ },
+ "208": {
+  "inputs": {
+   "vae_name": "minimax-h3\\minimax_h3_audio_vae_fp32.safetensors"
+  },
+  "class_type": "VAELoader",
+  "_meta": {
+   "title": "Load VAE"
+  }
+ },
+ "209": {
+  "inputs": {
+   "samples": [
+    "213",
+    0
+   ],
+   "vae": [
+    "208",
+    0
+   ]
+  },
+  "class_type": "VAEDecodeAudio",
+  "_meta": {
+   "title": "VAE Decode Audio"
+  }
+ },
+ "210": {
+  "inputs": {
+   "samples": [
+    "213",
+    0
+   ],
+   "vae": [
+    "207",
+    0
+   ]
+  },
+  "class_type": "VAEDecode",
+  "_meta": {
+   "title": "VAE Decode"
+  }
+ },
+ "211": {
+  "inputs": {
+   "sampler_name": "euler"
+  },
+  "class_type": "KSamplerSelect",
+  "_meta": {
+   "title": "KSamplerSelect"
+  }
+ },
+ "212": {
+  "inputs": {
+   "scheduler": "beta",
+   "steps": 6,
+   "denoise": 1,
+   "model": [
+    "6007",
+    0
+   ]
+  },
+  "class_type": "BasicScheduler",
+  "_meta": {
+   "title": "BasicScheduler"
+  }
+ },
+ "213": {
+  "inputs": {
+   "noise": [
+    "217",
+    0
+   ],
+   "guider": [
+    "214",
+    0
+   ],
+   "sampler": [
+    "211",
+    0
+   ],
+   "sigmas": [
+    "212",
+    0
+   ],
+   "latent_image": [
+    "219",
+    1
+   ]
+  },
+  "class_type": "SamplerCustomAdvanced",
+  "_meta": {
+   "title": "SamplerCustomAdvanced"
+  }
+ },
+ "214": {
+  "inputs": {
+   "model": [
+    "6007",
+    0
+   ],
+   "conditioning": [
+    "219",
+    0
+   ]
+  },
+  "class_type": "BasicGuider",
+  "_meta": {
+   "title": "Basic Guider"
+  }
+ },
+ "215": {
+  "inputs": {
+   "unet_name": "minimax-h3\\minimax_h3_fl2va_int8_convrot.safetensors",
+   "weight_dtype": "default"
+  },
+  "class_type": "UNETLoader",
+  "_meta": {
+   "title": "Load Diffusion Model"
+  }
+ },
+ "216": {
+  "inputs": {
+   "clip_name": "minimax-h3\\qwen3vl_32b_minimax_h3_int8_convrot.comfy.safetensors",
+   "type": "minimax",
+   "device": "default"
+  },
+  "class_type": "CLIPLoader",
+  "_meta": {
+   "title": "Load CLIP"
+  }
+ },
+ "217": {
+  "inputs": {
+   "noise_seed": 42
+  },
+  "class_type": "RandomNoise",
+  "_meta": {
+   "title": "RandomNoise"
+  }
+ },
+ "219": {
+  "inputs": {
+   "prompt": [
+    "6005",
+    0
+   ],
+   "width": [
+    "115",
+    0
+   ],
+   "height": [
+    "115",
+    1
+   ],
+   "length": [
+    "220",
+    1
+   ],
+   "clip": [
+    "6010",
+    1
+   ],
+   "vae": [
+    "207",
+    0
+   ]
+  },
+  "class_type": "MiniMaxH3ImageToVideo",
+  "_meta": {
+   "title": "MiniMax H3 Image to Video"
+  }
+ },
+ "220": {
+  "inputs": {
+   "expression": "max(5, round(a * 24)) + (5 - (max(5, round(a * 24)) % 17)) % 17",
+   "values.a": [
+    "221",
+    0
+   ]
+  },
+  "class_type": "ComfyMathExpression",
+  "_meta": {
+   "title": "Math Expression"
+  }
+ },
+ "221": {
+  "inputs": {
+   "value": 10
+  },
+  "class_type": "PrimitiveFloat",
+  "_meta": {
+   "title": "Seconds"
+  }
+ },
+ "223": {
+  "inputs": {
+   "sage_attention": "auto",
+   "allow_compile": false,
+   "model": [
+    "6020",
+    0
+   ]
+  },
+  "class_type": "PathchSageAttentionKJ",
+  "_meta": {
+   "title": "Patch Sage Attention KJ"
+  }
+ },
+ "5970": {
+  "inputs": {
+   "model_name": "film_net_fp16.safetensors"
+  },
+  "class_type": "FrameInterpolationModelLoader",
+  "_meta": {
+   "title": "Load Frame Interpolation Model"
+  }
+ },
+ "5971": {
+  "inputs": {
+   "multiplier": 2,
+   "interp_model": [
+    "5970",
+    0
+   ],
+   "images": [
+    "5976",
+    0
+   ]
+  },
+  "class_type": "FrameInterpolate",
+  "_meta": {
+   "title": "Run Frame Interpolation Model"
+  }
+ },
+ "5974": {
+  "inputs": {
+   "expression": "a*2",
+   "a": [
+    "5986",
+    0
+   ]
+  },
+  "class_type": "MathExpression|pysssss",
+  "_meta": {
+   "title": "Math Expression 🐍"
+  }
+ },
+ "5975": {
+  "inputs": {
+   "resize_type": "scale by multiplier",
+   "resize_type.scale": 1.5,
+   "quality": "ULTRA",
+   "images": [
+    "5971",
+    0
+   ]
+  },
+  "class_type": "RTXVideoSuperResolution",
+  "_meta": {
+   "title": "RTX Video Super Resolution Pro"
+  }
+ },
+ "5976": {
+  "inputs": {
+   "anything": [
+    "5977",
+    0
+   ]
+  },
+  "class_type": "easy clearCacheAll",
+  "_meta": {
+   "title": "Clear Cache All"
+  }
+ },
+ "5977": {
+  "inputs": {
+   "anything": [
+    "6063:5538",
+    0
+   ]
+  },
+  "class_type": "easy cleanGpuUsed",
+  "_meta": {
+   "title": "Clean VRAM Used"
+  }
+ },
+ "5978": {
+  "inputs": {
+   "frame_rate": [
+    "5974",
+    1
+   ],
+   "loop_count": 0,
+   "filename_prefix": "minimax-h3/vid-vfi",
+   "format": "video/h264-mp4",
+   "pix_fmt": "yuv420p",
+   "crf": 19,
+   "save_metadata": true,
+   "trim_to_audio": false,
+   "pingpong": false,
+   "save_output": true,
+   "images": [
+    "5975",
+    0
+   ],
+   "audio": [
+    "6063:4848",
+    0
+   ]
+  },
+  "class_type": "VHS_VideoCombine",
+  "_meta": {
+   "title": "Video Output 2"
+  }
+ },
+ "5986": {
+  "inputs": {
+   "value": 24
+  },
+  "class_type": "PrimitiveFloat",
+  "_meta": {
+   "title": "PrimitiveFloat"
+  }
+ },
+ "6005": {
+  "inputs": {
+   "value": "integrated_multimodal_description: [Shot 1] Cinematic, live-action, shot on iPhone, a vertical selfie frame from a phone held at arm's length above eye level. A young woman in her mid-twenties with sun-kissed tan skin and loose wavy chestnut brown hair, wearing a white cropped t-shirt with a gold pendant necklace, looks directly into the phone lens, her face filling the centre of frame. Warm golden hour sunlight hits the right side of her face from a low sun behind the trees, casting a soft amber glow across her skin. Behind her, a city park is blurred into soft green and gold bokeh — trees, dappled light, a hot pink sunset sky bleeding through the leaves. The camera holds static in selfie framing. The young woman's lips move as she speaks with a bright, energetic voice with a slight North American accent (S1): <d>[English] Oh my god, you guys, it is actually perfect out here right now.</d> Her mouth closes after the last word, then she breaks into a wide grin, teeth showing, the skin at the corners of her eyes crinkling. She tilts her head slightly to the right, the grin fading to a soft expression as her lips move and she speaks again, her voice warmer (S1): <d>[English] Like, I didn't want to leave.</d> Her mouth closes. She presses her lips together, then points her index finger at the camera and speaks with a playful tone, her lips forming each word (S1): <d>[English] So I'm not.</d> Her mouth closes, and the wide grin returns. With her free left hand she pushes the windblown hair behind her ear, her gold bracelet sliding down her wrist. She raises her free hand in a quick peace sign next to her cheek, her smile widening, and laughs — a short, genuine laugh, her mouth opening, shoulders shaking once, her eyes squeezing shut for a beat, then opening again. She drops the peace sign and brings the phone slightly closer, her face growing larger in frame, the grin settling into a warm smile. The camera pushes in with small amplitude at slow speed as the phone draws closer.\n\noverall_soundscape: A warm breeze carries birdsong and the distant hum of a city at golden hour. The woman's laugh is clear and close to the phone mic — short, genuine, with a slight exhale. Loose hair rustles as she tucks it behind her ear, and the gold bracelet lightly clinks against itself on her wrist.\n\nnon_diegetic_music: N/A"
+  },
+  "class_type": "PrimitiveStringMultiline",
+  "_meta": {
+   "title": "Text Prompt"
+  }
+ },
+ "6006": {
+  "inputs": {
+   "lora_name": "minimax-h3\\minimax_h3_fl2v_turbo_4step_v1.1_768p_comfyui_bf16.safetensors",
+   "strength_model": 0.6,
+   "model": [
+    "215",
+    0
+   ]
+  },
+  "class_type": "LoraLoaderModelOnly",
+  "_meta": {
+   "title": "Load LoRA"
+  }
+ },
+ "6007": {
+  "inputs": {
+   "shift_video": 12,
+   "shift_audio": 3,
+   "model": [
+    "223",
+    0
+   ]
+  },
+  "class_type": "MiniMaxH3SigmaShift",
+  "_meta": {
+   "title": "ModelSamplingMiniMaxH3"
+  }
+ },
+ "6010": {
+  "inputs": {
+   "PowerLoraLoaderHeaderWidget": {
+    "type": "PowerLoraLoaderHeaderWidget"
+   },
+   "lora_1": {
+    "on": true,
+    "lora": "minimax-h3\\h3-realism-people-t2v-i2v-r2v(r34l1sm).safetensors",
+    "strength": 1
+   },
+   "➕ Add Lora": "",
+   "model": [
+    "6006",
+    0
+   ],
+   "clip": [
+    "216",
+    0
+   ]
+  },
+  "class_type": "Power Lora Loader (rgthree)",
+  "_meta": {
+   "title": "Power Lora Loader (rgthree)"
+  }
+ },
+ "6020": {
+  "inputs": {
+   "tau": 1.2,
+   "start_percent": 0.2,
+   "end_percent": 0.9,
+   "min_tokens": 4096,
+   "int8_qk": false,
+   "sink_conditioning": "exact_kv",
+   "morton": false,
+   "morton_curve": "3d",
+   "verbose": false,
+   "model": [
+    "6010",
+    0
+   ]
+  },
+  "class_type": "SolAttnPatch",
+  "_meta": {
+   "title": "Patch Sol-Attn"
+  }
+ },
+ "6059": {
+  "inputs": {
+   "anything": [
+    "6060",
+    0
+   ]
+  },
+  "class_type": "easy clearCacheAll",
+  "_meta": {
+   "title": "Clear Cache All"
+  }
+ },
+ "6060": {
+  "inputs": {
+   "anything": [
+    "210",
+    0
+   ]
+  },
+  "class_type": "easy cleanGpuUsed",
+  "_meta": {
+   "title": "Clean VRAM Used"
+  }
+ },
+ "6062:5570": {
+  "inputs": {
+   "vae_name": "ltx-2.5\\ltx-2.5-audio-vae-bf16.safetensors"
+  },
+  "class_type": "VAELoader",
+  "_meta": {
+   "title": "Load VAE - Audio"
+  }
+ },
+ "6062:5571": {
+  "inputs": {
+   "vae_name": "ltx-2.5\\ltx-2.5-video-vae-bf16.safetensors"
+  },
+  "class_type": "VAELoader",
+  "_meta": {
+   "title": "Load VAE - Video"
+  }
+ },
+ "6062:5569": {
+  "inputs": {
+   "unet_name": "ltx-2.5\\ltx-2.5-22b-distilled-transformer-comfy-int8-convrot.safetensors",
+   "weight_dtype": "default"
+  },
+  "class_type": "UNETLoader",
+  "_meta": {
+   "title": "Load Diffusion Model"
+  }
+ },
+ "6062:5577": {
+  "inputs": {
+   "model_name": "ltx-2.5\\ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors"
+  },
+  "class_type": "LatentUpscaleModelLoader",
+  "_meta": {
+   "title": "Load Latent Upscale Model"
+  }
+ },
+ "6062:5574": {
+  "inputs": {
+   "clip_name": "gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors",
+   "type": "ltxv",
+   "device": "default"
+  },
+  "class_type": "CLIPLoader",
+  "_meta": {
+   "title": "Load CLIP - Text Encoder"
+  }
+ },
+ "6065:2612": {
+  "inputs": {
+   "text": "",
+   "clip": [
+    "6062:5574",
+    0
+   ]
+  },
+  "class_type": "CLIPTextEncode",
+  "_meta": {
+   "title": "CLIP Text Encode (Negative Prompt)"
+  }
+ },
+ "6065:2483": {
+  "inputs": {
+   "text": [
+    "6005",
+    0
+   ],
+   "clip": [
+    "6062:5574",
+    0
+   ]
+  },
+  "class_type": "CLIPTextEncode",
+  "_meta": {
+   "title": "CLIP Text Encode (Positive Prompt)"
+  }
+ },
+ "6065:1241": {
+  "inputs": {
+   "frame_rate": [
+    "5986",
+    0
+   ],
+   "positive": [
+    "6065:2483",
+    0
+   ],
+   "negative": [
+    "6065:2612",
+    0
+   ]
+  },
+  "class_type": "LTXVConditioning",
+  "_meta": {
+   "title": "LTXVConditioning"
+  }
+ },
+ "6061:4985": {
+  "inputs": {
+   "sigmas": "0.85, 0.7250, 0.4219, 0.0"
+  },
+  "class_type": "ManualSigmas",
+  "_meta": {
+   "title": "ManualSigmas"
+  }
+ },
+ "6061:4976": {
+  "inputs": {
+   "sampler_name": "euler"
+  },
+  "class_type": "KSamplerSelect",
+  "_meta": {
+   "title": "KSamplerSelect"
+  }
+ },
+ "6061:4964": {
+  "inputs": {
+   "cfg": 1,
+   "model": [
+    "6062:5569",
+    0
+   ],
+   "positive": [
+    "6065:1241",
+    0
+   ],
+   "negative": [
+    "6065:1241",
+    1
+   ]
+  },
+  "class_type": "CFGGuider",
+  "_meta": {
+   "title": "CFG Guider"
+  }
+ },
+ "6061:4967": {
+  "inputs": {
+   "noise_seed": 42
+  },
+  "class_type": "RandomNoise",
+  "_meta": {
+   "title": "RandomNoise"
+  }
+ },
+ "6061:4973": {
+  "inputs": {
+   "av_latent": [
+    "6061:4971",
+    0
+   ]
+  },
+  "class_type": "LTXVSeparateAVLatent",
+  "_meta": {
+   "title": "LTXVSeparateAVLatent"
+  }
+ },
+ "6061:4971": {
+  "inputs": {
+   "noise": [
+    "6061:4967",
+    0
+   ],
+   "guider": [
+    "6061:4964",
+    0
+   ],
+   "sampler": [
+    "6061:4976",
+    0
+   ],
+   "sigmas": [
+    "6061:4985",
+    0
+   ],
+   "latent_image": [
+    "6061:4969",
+    0
+   ]
+  },
+  "class_type": "SamplerCustomAdvanced",
+  "_meta": {
+   "title": "SamplerCustomAdvanced"
+  }
+ },
+ "6061:4969": {
+  "inputs": {
+   "video_latent": [
+    "6061:4970",
+    0
+   ],
+   "audio_latent": [
+    "6061:6074",
+    0
+   ]
+  },
+  "class_type": "LTXVConcatAVLatent",
+  "_meta": {
+   "title": "LTXVConcatAVLatent"
+  }
+ },
+ "6061:6072": {
+  "inputs": {
+   "value": 0,
+   "width": [
+    "6061:6073",
+    0
+   ],
+   "height": [
+    "6061:6073",
+    1
+   ]
+  },
+  "class_type": "SolidMask",
+  "_meta": {
+   "title": "Create Solid Mask"
+  }
+ },
+ "6061:4975": {
+  "inputs": {
+   "samples": [
+    "6061:6070",
+    0
+   ],
+   "upscale_model": [
+    "6062:5577",
+    0
+   ],
+   "vae": [
+    "6062:5571",
+    0
+   ]
+  },
+  "class_type": "LTXVLatentUpsampler",
+  "_meta": {
+   "title": "LTXVLatentUpsampler"
+  }
+ },
+ "6061:6070": {
+  "inputs": {
+   "pixels": [
+    "6059",
+    0
+   ],
+   "vae": [
+    "6062:5571",
+    0
+   ]
+  },
+  "class_type": "VAEEncode",
+  "_meta": {
+   "title": "VAE Encode"
+  }
+ },
+ "6061:4970": {
+  "inputs": {
+   "strength": 1,
+   "bypass": true,
+   "vae": [
+    "6062:5571",
+    0
+   ],
+   "image": [
+    "6059",
+    0
+   ],
+   "latent": [
+    "6061:4975",
+    0
+   ]
+  },
+  "class_type": "LTXVImgToVideoInplace",
+  "_meta": {
+   "title": "LTXVImgToVideoInplace"
+  }
+ },
+ "6061:6074": {
+  "inputs": {
+   "samples": [
+    "6061:6075",
+    0
+   ],
+   "mask": [
+    "6061:6072",
+    0
+   ]
+  },
+  "class_type": "SetLatentNoiseMask",
+  "_meta": {
+   "title": "Set Latent Noise Mask"
+  }
+ },
+ "6061:6073": {
+  "inputs": {
+   "image": [
+    "6059",
+    0
+   ]
+  },
+  "class_type": "GetImageSize",
+  "_meta": {
+   "title": "Get Image Size"
+  }
+ },
+ "6061:6075": {
+  "inputs": {
+   "audio": [
+    "209",
+    0
+   ],
+   "audio_vae": [
+    "6062:5570",
+    0
+   ]
+  },
+  "class_type": "LTXVAudioVAEEncode",
+  "_meta": {
+   "title": "LTXV Audio VAE Encode"
+  }
+ },
+ "6063:5538": {
+  "inputs": {
+   "tile_size": 512,
+   "overlap": 64,
+   "temporal_size": 128,
+   "temporal_overlap": 32,
+   "samples": [
+    "6061:4973",
+    0
+   ],
+   "vae": [
+    "6062:5571",
+    0
+   ]
+  },
+  "class_type": "VAEDecodeTiled",
+  "_meta": {
+   "title": "VAE Decode (Tiled)"
+  }
+ },
+ "6063:4848": {
+  "inputs": {
+   "samples": [
+    "6061:4973",
+    1
+   ],
+   "audio_vae": [
+    "6062:5570",
+    0
+   ]
+  },
+  "class_type": "LTXVAudioVAEDecode",
+  "_meta": {
+   "title": "LTXV Audio VAE Decode"
+  }
+ }
+}

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/fixtures/comfy_native/qwen_image_edit_mask_API.json

@@ -0,0 +1,126 @@
+{
+  "3": {
+    "inputs": {
+      "seed": 761215360232465,
+      "steps": 20,
+      "cfg": 2.5,
+      "sampler_name": "euler",
+      "scheduler": "simple",
+      "denoise": 1,
+      "model": ["75", 0],
+      "positive": ["76", 0],
+      "negative": ["77", 0],
+      "latent_image": ["90", 0]
+    },
+    "class_type": "KSampler",
+    "_meta": { "title": "KSampler" }
+  },
+  "8": {
+    "inputs": {
+      "samples": ["3", 0],
+      "vae": ["39", 0]
+    },
+    "class_type": "VAEDecode",
+    "_meta": { "title": "VAE Decode" }
+  },
+  "37": {
+    "inputs": {
+      "unet_name": "qwen_image_edit_2509_fp8_e4m3fn.safetensors",
+      "weight_dtype": "default"
+    },
+    "class_type": "UNETLoader",
+    "_meta": { "title": "Load Diffusion Model" }
+  },
+  "38": {
+    "inputs": {
+      "clip_name": "qwen_2.5_vl_7b_fp8_scaled.safetensors",
+      "type": "qwen_image",
+      "device": "default"
+    },
+    "class_type": "CLIPLoader",
+    "_meta": { "title": "Load CLIP" }
+  },
+  "39": {
+    "inputs": {
+      "vae_name": "qwen_image_vae.safetensors"
+    },
+    "class_type": "VAELoader",
+    "_meta": { "title": "Load VAE" }
+  },
+  "60": {
+    "inputs": {
+      "filename_prefix": "ComfyUI",
+      "images": ["8", 0]
+    },
+    "class_type": "SaveImage",
+    "_meta": { "title": "Save Image" }
+  },
+  "75": {
+    "inputs": {
+      "shift": 3,
+      "model": ["37", 0]
+    },
+    "class_type": "ModelSamplingAuraFlow",
+    "_meta": { "title": "ModelSamplingAuraFlow" }
+  },
+  "76": {
+    "inputs": {
+      "prompt": "把背景换成夜晚的城市街道",
+      "clip": ["38", 0],
+      "vae": ["39", 0],
+      "image1": ["93", 0]
+    },
+    "class_type": "TextEncodeQwenImageEditPlus",
+    "_meta": { "title": "TextEncodeQwenImageEditPlus" }
+  },
+  "77": {
+    "inputs": {
+      "prompt": "",
+      "clip": ["38", 0],
+      "vae": ["39", 0],
+      "image1": ["93", 0]
+    },
+    "class_type": "TextEncodeQwenImageEditPlus",
+    "_meta": { "title": "TextEncodeQwenImageEditPlus" }
+  },
+  "78": {
+    "inputs": {
+      "image": "example.png"
+    },
+    "class_type": "LoadImage",
+    "_meta": { "title": "Load Image" }
+  },
+  "88": {
+    "inputs": {
+      "pixels": ["93", 0],
+      "vae": ["39", 0]
+    },
+    "class_type": "VAEEncode",
+    "_meta": { "title": "VAE Encode" }
+  },
+  "90": {
+    "inputs": {
+      "samples": ["88", 0],
+      "mask": ["95", 0]
+    },
+    "class_type": "SetLatentNoiseMask",
+    "_meta": { "title": "Set Latent Noise Mask" }
+  },
+  "93": {
+    "inputs": {
+      "upscale_method": "lanczos",
+      "megapixels": 1,
+      "image": ["78", 0]
+    },
+    "class_type": "ImageScaleToTotalPixels",
+    "_meta": { "title": "Scale Image to Total Pixels" }
+  },
+  "95": {
+    "inputs": {
+      "image": "mask.png",
+      "channel": "alpha"
+    },
+    "class_type": "LoadImageMask",
+    "_meta": { "title": "Load Image (as Mask)" }
+  }
+}

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

@@ -0,0 +1,91 @@
+{
+  "3": {
+    "inputs": {
+      "seed": 1125488487853216,
+      "steps": 20,
+      "cfg": 2.5,
+      "sampler_name": "euler",
+      "scheduler": "simple",
+      "denoise": 1,
+      "model": ["66", 0],
+      "positive": ["6", 0],
+      "negative": ["7", 0],
+      "latent_image": ["58", 0]
+    },
+    "class_type": "KSampler",
+    "_meta": { "title": "KSampler" }
+  },
+  "6": {
+    "inputs": {
+      "text": "一只橘猫坐在窗台上，午后阳光，电影感",
+      "clip": ["38", 0]
+    },
+    "class_type": "CLIPTextEncode",
+    "_meta": { "title": "CLIP Text Encode (Positive Prompt)" }
+  },
+  "7": {
+    "inputs": {
+      "text": "",
+      "clip": ["38", 0]
+    },
+    "class_type": "CLIPTextEncode",
+    "_meta": { "title": "CLIP Text Encode (Negative Prompt)" }
+  },
+  "8": {
+    "inputs": {
+      "samples": ["3", 0],
+      "vae": ["39", 0]
+    },
+    "class_type": "VAEDecode",
+    "_meta": { "title": "VAE Decode" }
+  },
+  "37": {
+    "inputs": {
+      "unet_name": "qwen_image_fp8_e4m3fn.safetensors",
+      "weight_dtype": "default"
+    },
+    "class_type": "UNETLoader",
+    "_meta": { "title": "Load Diffusion Model" }
+  },
+  "38": {
+    "inputs": {
+      "clip_name": "qwen_2.5_vl_7b_fp8_scaled.safetensors",
+      "type": "qwen_image",
+      "device": "default"
+    },
+    "class_type": "CLIPLoader",
+    "_meta": { "title": "Load CLIP" }
+  },
+  "39": {
+    "inputs": {
+      "vae_name": "qwen_image_vae.safetensors"
+    },
+    "class_type": "VAELoader",
+    "_meta": { "title": "Load VAE" }
+  },
+  "58": {
+    "inputs": {
+      "width": 1328,
+      "height": 1328,
+      "batch_size": 1
+    },
+    "class_type": "EmptySD3LatentImage",
+    "_meta": { "title": "EmptySD3LatentImage" }
+  },
+  "60": {
+    "inputs": {
+      "filename_prefix": "ComfyUI",
+      "images": ["8", 0]
+    },
+    "class_type": "SaveImage",
+    "_meta": { "title": "Save Image" }
+  },
+  "66": {
+    "inputs": {
+      "shift": 3.1,
+      "model": ["37", 0]
+    },
+    "class_type": "ModelSamplingAuraFlow",
+    "_meta": { "title": "ModelSamplingAuraFlow" }
+  }
+}

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

@@ -0,0 +1,301 @@
+{
+  "1": {
+    "inputs": {
+      "value": "PASTE YOUR PROMPT HERE. Use the MiniMax-H3 prompt contract (integrated_multimodal_description / overall_soundscape / non_diegetic_music). The previews in this repo were made with a ten-shot subway prompt posted by a community member; it is not redistributed here."
+    },
+    "class_type": "PrimitiveStringMultiline",
+    "_meta": {
+      "title": "PROMPT (feeds every stage)"
+    }
+  },
+  "92": {
+    "inputs": {
+      "filename_prefix": "video/01_reference_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
+      ]
+    },
+    "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,
+      "model": [
+        "127",
+        0
+      ]
+    },
+    "class_type": "H3SLAAttention",
+    "_meta": {
+      "title": "H3 SLA Attention 0.9/64 (their graph)"
+    }
+  }
+}

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

@@ -0,0 +1,137 @@
+{
+  "13": {
+    "inputs": {
+      "aspect_ratio": "1:1 (Square)",
+      "megapixels": 1,
+      "multiple": 8
+    },
+    "class_type": "ResolutionSelector",
+    "_meta": {
+      "title": "分辨率选择器"
+    }
+  },
+  "461": {
+    "inputs": {
+      "filename_prefix": "Qwen_image_2.1",
+      "format": "png",
+      "format.bit_depth": "8-bit",
+      "format.input_color_space": "sRGB",
+      "images": [
+        "459:457",
+        0
+      ]
+    },
+    "class_type": "SaveImageAdvanced",
+    "_meta": {
+      "title": "保存图像（高级）"
+    }
+  },
+  "459:451": {
+    "inputs": {
+      "unet_name": "qwen_image_2.1_int8_convrot.safetensors",
+      "weight_dtype": "default"
+    },
+    "class_type": "UNETLoader",
+    "_meta": {
+      "title": "UNet加载器"
+    }
+  },
+  "459:452": {
+    "inputs": {
+      "prompt": "Greyscale fashion editorial portrait of an avant-garde woman tilted upwards in profile, captured with striking high-contrast chiaroscuro lighting. She wears oversized, thick-rimmed circular black sunglasses with matte dark lenses, concealing her upward gaze. Her attire merges high couture with tactical abstraction: a high-necked structural dress tailored from heavyweight fabric featuring a disrupted optical camouflage pattern—interlocking oversized polka dots, pixelated stippling, and organic contour blotches in stark monochrome that mimic military disruptive patterns in a refined runway style. Around her shoulders, asymmetric pleated webbing and tailored cargo straps are integrated seamlessly into the garment’s architecture. In her gloved hand, she clutches a structured matte-leather geometric handbag accented with subtle tactical buckles, utility stitching, and dark brushed-metal hardware. Her skin texture is rendered with hyper-detailed clarity, sculpted by intense, razor-sharp studio key light and deep graphite shadows. The striking background is a vivid mixed-media graphic collage, composed of flat vibrant lime green planes, stark black and white overlapping circles, segmented semi-circles with bold zebra striping, dense micro-halftone dot matrices, and vector topographic contour lines. The clash between monochromatic disruptive camo elements on her clothing and the saturated, retro-futuristic pop-art backdrop creates an intense visual dissonance, emphasizing sharp silhouettes, paper cut-out edges, dynamic compositional balance, and clean graphic novel textures. Absolutely no text, no typography, no letters, no words, no numbers, no logos, no watermark, no captions, pure imagery only.",
+      "negative_prompt": "",
+      "resolution": 1024,
+      "clip": [
+        "459:453",
+        0
+      ]
+    },
+    "class_type": "TextEncodeQwenImage21",
+    "_meta": {
+      "title": "Text Encode Qwen Image 2.1"
+    }
+  },
+  "459:453": {
+    "inputs": {
+      "clip_name": "qwen3vl_8b_int8_convrot.safetensors",
+      "type": "qwen_image",
+      "device": "default"
+    },
+    "class_type": "CLIPLoader",
+    "_meta": {
+      "title": "加载CLIP"
+    }
+  },
+  "459:454": {
+    "inputs": {
+      "vae_name": "qwen_image_2.1_vae_bf16.safetensors"
+    },
+    "class_type": "VAELoader",
+    "_meta": {
+      "title": "加载VAE"
+    }
+  },
+  "459:456": {
+    "inputs": {
+      "width": [
+        "13",
+        0
+      ],
+      "height": [
+        "13",
+        1
+      ],
+      "batch_size": 1
+    },
+    "class_type": "EmptyLatentImage",
+    "_meta": {
+      "title": "空Latent图像"
+    }
+  },
+  "459:457": {
+    "inputs": {
+      "samples": [
+        "459:458",
+        0
+      ],
+      "vae": [
+        "459:454",
+        0
+      ]
+    },
+    "class_type": "VAEDecode",
+    "_meta": {
+      "title": "VAE解码"
+    }
+  },
+  "459:458": {
+    "inputs": {
+      "seed": 593103825222985,
+      "steps": 25,
+      "cfg": 1,
+      "sampler_name": "euler",
+      "scheduler": "simple",
+      "denoise": 1,
+      "model": [
+        "459:451",
+        0
+      ],
+      "positive": [
+        "459:452",
+        0
+      ],
+      "negative": [
+        "459:452",
+        1
+      ],
+      "latent_image": [
+        "459:456",
+        0
+      ]
+    },
+    "class_type": "KSampler",
+    "_meta": {
+      "title": "K采样器"
+    }
+  }
+}

calliope-backend/tests/test_comfyui_endpoints.py

@@ -381,10 +381,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:

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_pipeline.py

@@ -114,7 +114,8 @@ def test_queue_prompt_surfaces_comfy_error_body(monkeypatch):
 
     msg = asyncio.run(run())
     assert "prompt_outputs_failed_validation" in msg
-    assert "node 12" in msg
+    assert "节点 12" in msg
+    assert "HTTP 400" in msg
     assert "Invalid audio file" in msg
 
 

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_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

@@ -0,0 +1,289 @@
+"""HEL-623: workflows exported straight from ComfyUI (no (Input:…) title tags)
+still expose a prompt and their fillable widgets, patch back onto the right
+widget, and run the full 导入→填参→生成→历史 chain against a fake ComfyUI."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from calliope.comfyui.parser import parse_dynamic_inputs
+from calliope.comfyui.patcher import patch_workflow
+from calliope.comfyui.smart_fill import ref_image_slots
+from calliope.config import settings
+from calliope.db import get_db
+from tests.test_studio_generation import (  # noqa: F401 — fixture re-export
+    _import_workflow,
+    _real_run,
+    _wait_done,
+    fake_comfy,
+)
+
+FIXTURES = Path(__file__).parent / "fixtures" / "comfy_native"
+EXAMPLES = Path(__file__).resolve().parents[2] / "example_ComfyUI_workflows"
+
+
+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")}
+
+
+def test_native_qwen_t2i_exposes_prompt_and_sampler_widgets():
+    inputs = parse_dynamic_inputs(_load("qwen_image_t2i_API.json"))
+    roles = _by_role(inputs)
+    assert roles["prompt"]["nodeId"] == "6"
+    assert roles["prompt"]["required"] is True
+    assert roles["prompt"]["defaultValue"].startswith("一只橘猫")
+    assert roles["negative"]["nodeId"] == "7"
+    assert roles["seed"]["nodeId"] == "3@seed"
+    assert roles["steps"]["nodeId"] == "3@steps"
+    assert roles["cfg"]["nodeId"] == "3@cfg"
+    assert roles["width"]["nodeId"] == "58@width"
+    assert roles["height"]["nodeId"] == "58@height"
+    assert roles["batch"]["nodeId"] == "58@batch_size"
+    assert all(i["auto"] for i in inputs)
+    assert [i for i in inputs if i["required"]] == [roles["prompt"]]
+
+
+def test_native_qwen_edit_detects_image_and_mask_slots():
+    inputs = parse_dynamic_inputs(_load("qwen_image_edit_mask_API.json"))
+    roles = _by_role(inputs)
+    # TextEncodeQwenImageEditPlus writes `prompt`, not the class-derived field
+    assert roles["prompt"]["nodeId"] == "76@prompt"
+    assert roles["negative"]["nodeId"] == "77@prompt"
+    media = {i["nodeId"]: i for i in inputs if i["kind"] == "image"}
+    assert set(media) == {"78", "95"}
+    assert media["95"]["role"] == "mask"
+    assert "mask" in media["95"]["label"].lower() or "遮罩" in media["95"]["label"]
+    # 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():
+    inputs = parse_dynamic_inputs(_load("minimax_h3_t2v_untagged_API.json"))
+    roles = _by_role(inputs)
+    assert roles["prompt"]["nodeId"] == "6005"
+    assert roles["duration"]["nodeId"] == "221"
+    assert roles["seed"]["nodeId"] == "217@noise_seed"
+
+
+def test_real_qwen21_t2i_splits_single_encoder_into_both_prompts():
+    """白栖知的 wen-sheng-tu.json：一个 TextEncodeQwenImage21 同时喂 positive/negative."""
+    wf = _load("wen_sheng_tu_API.json")
+    inputs = parse_dynamic_inputs(wf)
+    roles = _by_role(inputs)
+    assert roles["prompt"]["nodeId"] == "459:452@prompt"
+    assert roles["prompt"]["label"] == "正向提示词"
+    assert roles["prompt"]["required"] is True
+    assert roles["prompt"]["defaultValue"].startswith("Greyscale fashion editorial")
+    assert roles["negative"]["nodeId"] == "459:452@negative_prompt"
+    assert roles["negative"]["label"] == "反向提示词"
+    assert roles["negative"]["required"] is False
+    assert roles["seed"]["nodeId"] == "459:458@seed"
+    assert roles["steps"]["nodeId"] == "459:458@steps"
+    assert roles["cfg"]["nodeId"] == "459:458@cfg"
+    assert roles["batch"]["nodeId"] == "459:456@batch_size"
+    # width/height are wired from the resolution selector — not exposed
+    assert "width" not in roles and "height" not in roles
+    assert [i for i in inputs if i["required"]] == [roles["prompt"]]
+
+    patched = patch_workflow(
+        wf, {roles["prompt"]["nodeId"]: "新正向", roles["negative"]["nodeId"]: "模糊"}
+    )
+    enc = patched["459:452"]["inputs"]
+    assert enc["prompt"] == "新正向"
+    assert enc["negative_prompt"] == "模糊"
+    assert enc["clip"] == ["459:453", 0]
+
+
+def test_real_h3_t2v_duration_from_expression_primitive():
+    """wen-sheng-shipin.json：无标题 PrimitiveFloat 经表达式换算帧数 → 时长（秒）."""
+    inputs = parse_dynamic_inputs(_load("wen_sheng_shipin_API.json"))
+    roles = _by_role(inputs)
+    assert roles["prompt"]["nodeId"] == "1"
+    assert roles["prompt"]["required"] is True
+    assert roles["duration"]["nodeId"] == "133"
+    assert roles["duration"]["label"] == "时长（秒）"
+    assert roles["duration"]["defaultValue"] == 10
+    assert roles["seed"]["nodeId"] == "129@noise_seed"
+    assert roles["steps"]["nodeId"] == "124@steps"
+    assert "negative" not in roles
+
+
+def _encoder_graph(encoder: dict, positive_slot: list, negative_slot: list) -> dict:
+    return {
+        "1": encoder,
+        "2": {
+            "class_type": "KSampler",
+            "inputs": {"seed": 1, "steps": 20, "cfg": 4, "positive": positive_slot,
+                       "negative": negative_slot},
+        },
+    }
+
+
+def test_custom_encoder_with_text_and_negative_prompt_is_split():
+    wf = _encoder_graph(
+        {"class_type": "MyTextEncodeDual", "inputs": {"text": "猫", "negative_prompt": "糊"},
+         "_meta": {"title": "MyTextEncodeDual"}},
+        ["1", 0],
+        ["1", 1],
+    )
+    roles = _by_role(parse_dynamic_inputs(wf))
+    assert roles["prompt"]["nodeId"] == "1"
+    assert roles["prompt"]["defaultValue"] == "猫"
+    assert roles["negative"]["nodeId"] == "1@negative_prompt"
+
+
+def test_clip_encoder_wired_to_both_positive_and_negative_stays_positive():
+    wf = _encoder_graph(
+        {"class_type": "CLIPTextEncode", "inputs": {"text": "猫"},
+         "_meta": {"title": "CLIP Text Encode"}},
+        ["1", 0],
+        ["1", 0],
+    )
+    roles = _by_role(parse_dynamic_inputs(wf))
+    assert roles["prompt"]["nodeId"] == "1"
+    assert "negative" not in roles
+
+
+def test_tagged_workflows_are_unchanged():
+    for path in sorted(EXAMPLES.glob("*.json")):
+        inputs = parse_dynamic_inputs(json.loads(path.read_text(encoding="utf-8")))
+        assert inputs, path.name
+        assert not any(i.get("auto") for i in inputs), path.name
+        assert all("@" not in i["nodeId"] for i in inputs), path.name
+
+
+def test_patch_field_keys_write_named_widget_and_keep_links():
+    wf = _load("qwen_image_t2i_API.json")
+    patched = patch_workflow(
+        wf,
+        {"6": "新的提示词", "3@seed": 7, "3@steps": 12, "58@width": 1024, "3@model": "x"},
+    )
+    assert patched["6"]["inputs"]["text"] == "新的提示词"
+    assert patched["3"]["inputs"]["seed"] == 7
+    assert patched["3"]["inputs"]["steps"] == 12
+    assert patched["58"]["inputs"]["width"] == 1024
+    # linked input stays wired; the base workflow is untouched
+    assert patched["3"]["inputs"]["model"] == ["66", 0]
+    assert wf["3"]["inputs"]["seed"] == 1125488487853216
+
+
+def test_smart_fill_sort_accepts_subgraph_and_field_ids():
+    slots = ref_image_slots(
+        [
+            {"nodeId": "171:12", "role": "image", "kind": "image"},
+            {"nodeId": "9", "role": "image", "kind": "image"},
+            {"nodeId": "3@image", "role": "image", "kind": "image"},
+        ]
+    )
+    assert [s["nodeId"] for s in slots] == ["3@image", "9", "171:12"]
+
+
+def test_list_backfills_schema_for_workflows_imported_before_detection(client):
+    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)",
+            ("旧导入·Qwen", json.dumps(_load("qwen_image_t2i_API.json"))),
+        )
+        conn.commit()
+        wf_id = cur.lastrowid
+    finally:
+        conn.close()
+    wf = client.get(f"/api/workflows/{wf_id}").json()
+    assert _by_role(wf["input_schema"])["prompt"]["nodeId"] == "6"
+    listed = next(w for w in client.get("/api/workflows").json() if w["id"] == wf_id)
+    assert len(listed["input_schema"]) == len(wf["input_schema"])
+
+
+def test_native_workflow_full_chain(client, fake_comfy):  # noqa: F811
+    """导入原生 Qwen 工作流 → 填参 → 生成 → ComfyUI 收到改写后的节点 → 历史可见."""
+    with _real_run(client, fake_comfy):
+        wf_id = _import_workflow(
+            client, "原生·Qwen 文生图", "image", _load("qwen_image_t2i_API.json")
+        )
+        wf = client.get(f"/api/workflows/{wf_id}").json()
+        roles = _by_role(wf["input_schema"])
+        r = client.post(
+            "/api/playground/generate",
+            json={
+                "workflow_id": wf_id,
+                "input_values": {
+                    roles["prompt"]["nodeId"]: "雨夜霓虹街道",
+                    roles["seed"]["nodeId"]: 99,
+                    roles["width"]["nodeId"]: 1024,
+                    roles["height"]["nodeId"]: 768,
+                },
+                "source": "studio-image",
+                "endpoint_id": settings.comfyui_active_id,
+            },
+        )
+        assert r.status_code == 200, r.text
+        job = _wait_done(client, r.json()["job"]["id"])
+        assert job["status"] == "done", job.get("error")
+        queued = fake_comfy.prompts[-1]["prompt"]
+        assert queued["6"]["inputs"]["text"] == "雨夜霓虹街道"
+        assert queued["3"]["inputs"]["seed"] == 99
+        assert queued["58"]["inputs"]["width"] == 1024
+        assert queued["58"]["inputs"]["height"] == 768
+        assert queued["3"]["inputs"]["positive"] == ["6", 0]
+        history = client.get("/api/playground/jobs").json()
+        assert any(j["id"] == job["id"] and j["status"] == "done" for j in history)
+
+
+def test_real_qwen21_t2i_full_chain(client, fake_comfy):  # noqa: F811
+    with _real_run(client, fake_comfy):
+        wf_id = _import_workflow(
+            client, "真实·Qwen2.1 文生图", "image", _load("wen_sheng_tu_API.json")
+        )
+        roles = _by_role(client.get(f"/api/workflows/{wf_id}").json()["input_schema"])
+        r = client.post(
+            "/api/playground/generate",
+            json={
+                "workflow_id": wf_id,
+                "input_values": {
+                    roles["prompt"]["nodeId"]: "雨夜霓虹街道",
+                    roles["negative"]["nodeId"]: "低清晰度",
+                    roles["seed"]["nodeId"]: 7,
+                },
+                "source": "studio-image",
+                "endpoint_id": settings.comfyui_active_id,
+            },
+        )
+        assert r.status_code == 200, r.text
+        job = _wait_done(client, r.json()["job"]["id"])
+        assert job["status"] == "done", job.get("error")
+        queued = fake_comfy.prompts[-1]["prompt"]
+        assert queued["459:452"]["inputs"]["prompt"] == "雨夜霓虹街道"
+        assert queued["459:452"]["inputs"]["negative_prompt"] == "低清晰度"
+        assert queued["459:458"]["inputs"]["seed"] == 7
+        assert queued["459:458"]["inputs"]["negative"] == ["459:452", 1]
+
+
+def test_comfy_rejection_is_reported_in_chinese(client, fake_comfy):  # noqa: F811
+    fake_comfy.fail_prompt = True
+    with _real_run(client, fake_comfy):
+        wf_id = _import_workflow(
+            client, "原生·Qwen(拒绝)", "image", _load("qwen_image_t2i_API.json")
+        )
+        r = client.post(
+            "/api/playground/generate",
+            json={"workflow_id": wf_id, "input_values": {"6": "x"}, "source": "studio-image"},
+        )
+        job = _wait_done(client, r.json()["job"]["id"])
+        assert job["status"] == "failed"
+        assert "ComfyUI 拒绝执行该工作流" in job["error"]
+        assert "HTTP 500" in job["error"]
+
+
+def test_generate_unknown_workflow_has_chinese_detail(client):
+    r = client.post("/api/playground/generate", json={"workflow_id": 987654, "input_values": {}})
+    assert r.status_code == 404
+    assert "工作流不存在" in r.json()["detail"]

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"}]}
         },
     }
 

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/app.html

@@ -4,7 +4,7 @@
 		<meta charset="utf-8" />
 		<link rel="icon" href="%sveltekit.assets%/favicon.png" />
 		<meta name="viewport" content="width=device-width, initial-scale=1" />
-		<title>Calliope Lab</title>
+		<title>影工坊</title>
 		<link rel="preconnect" href="https://fonts.googleapis.com" />
 		<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
 		<link

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> {
@@ -161,6 +167,28 @@ async function api<T>(path: string, init?: RequestInit): Promise<T> {
   return res.json() as Promise<T>;
 }
 
+/** Readable text for an api() failure: FastAPI `detail`, not the raw "400: {json}". */
+export function apiErrorMessage(err: unknown): string {
+  if (err instanceof TypeError) return t("api.networkError");
+  const raw = err instanceof Error ? err.message : String(err);
+  const m = /^(\d{3}): ([\s\S]*)$/.exec(raw);
+  if (!m) return raw;
+  try {
+    const detail = (JSON.parse(m[2]) as { detail?: unknown }).detail;
+    if (typeof detail === "string" && detail) return detail;
+    if (Array.isArray(detail) && detail.length) {
+      return detail
+        .map((d) =>
+          d && typeof d === "object" && "msg" in d ? String(d.msg) : String(d),
+        )
+        .join("；");
+    }
+  } catch {
+    /* non-JSON body */
+  }
+  return t("api.httpError", { status: m[1], detail: m[2].slice(0, 200) });
+}
+
 /** Multipart variant of api() — FormData sets its own Content-Type boundary. */
 async function apiUpload<T>(path: string, form: FormData): Promise<T> {
   const res = await fetch(`${API_BASE}${path}`, { method: "POST", body: form });
@@ -431,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 }),
     }),
@@ -443,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;
@@ -462,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/parser.ts

@@ -9,7 +9,7 @@ const TEXT_AREA = new Set([
 	'PrimitiveString',
 ]);
 const NUMBER = new Set(['INT', 'FLOAT', 'PrimitiveInt', 'PrimitiveFloat', 'KSampler', 'KSamplerAdvanced']);
-const IMAGE = new Set(['LoadImage', 'ImageLoader', 'ETN_LoadImageBase64']);
+const IMAGE = new Set(['LoadImage', 'LoadImageMask', 'ImageLoader', 'ETN_LoadImageBase64']);
 const IMAGE_URL = new Set(['Load Image From Url (mtb)']);
 const AUDIO = new Set(['LoadAudio', 'VHS_LoadAudio']);
 const VIDEO = new Set(['LoadVideo', 'VHS_LoadVideo', 'VHS_LoadVideoPath']);

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;
@@ -9,14 +27,80 @@ export interface ComfyDynamicInput {
 	kind: ComfyInputKind;
 	defaultValue?: string | number;
 	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 {
@@ -29,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[];
@@ -37,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 {
@@ -55,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/agent/AgentChat.svelte

@@ -195,7 +195,6 @@
 	{:else if messages.length === 0 && !running}
 		<div class="empty">
 			<div class="empty-mark"><Icon name="sparkle" size={22} /></div>
-			<p class="empty-eyebrow">Calliope</p>
 			<p class="empty-title">{t('agentChat.emptyTitle')}</p>
 			<p class="empty-hint">{t('agentChat.emptyHint')}</p>
 			{#if suggestions.length > 0}
@@ -370,15 +369,6 @@
 		box-shadow: 0 0 32px var(--accent-glow);
 		margin-bottom: 6px;
 	}
-	.empty-eyebrow {
-		margin: 0;
-		font-family: var(--font-display);
-		font-size: 12px;
-		font-weight: 600;
-		letter-spacing: 0.28em;
-		text-transform: uppercase;
-		color: var(--accent);
-	}
 	.empty-title {
 		margin: 0;
 		font-family: var(--font-display);

calliope-web/src/lib/components/home/AProjectCard.svelte

@@ -45,11 +45,11 @@
 
 	// Spec §2.1 allows the five avatar gradients as cover placeholders.
 	const PLACEHOLDER_GRADIENTS = [
-		'linear-gradient(135deg, #e8a33d, #b96a1b)',
-		'linear-gradient(135deg, #5b8def, #3a5fa9)',
-		'linear-gradient(135deg, #3fb97f, #2a7a54)',
-		'linear-gradient(135deg, #b98be0, #7a4fa9)',
-		'linear-gradient(135deg, #d98e6a, #a95535)',
+		'var(--avatar-1)',
+		'var(--avatar-2)',
+		'var(--avatar-3)',
+		'var(--avatar-4)',
+		'var(--avatar-5)',
 	];
 	const placeholder = $derived(PLACEHOLDER_GRADIENTS[project.id % PLACEHOLDER_GRADIENTS.length]);
 
@@ -57,20 +57,26 @@
 
 	let coverFailed = $state(false);
 
-	const STATUS_CLASS: Record<string, string> = {
-		draft: 'st-draft',
-		in_progress: 'st-progress',
-		completed: 'st-done',
-	};
-	const STATUS_KEY: Record<string, string> = {
-		draft: 'home.statusDraft',
-		in_progress: 'home.statusProgress',
-		completed: 'home.statusDone',
-	};
-	const statusClass = $derived(STATUS_CLASS[project.status] ?? 'st-draft');
-	const statusLabel = $derived(
-		project.status in STATUS_KEY ? t(STATUS_KEY[project.status]) : project.status,
-	);
+	// Cover tag reflects the real five-stage state (a1: 「分镜设计 · 进行中」):
+	// all confirmed → 已完成; otherwise the first unconfirmed stage + its state.
+	const cover = $derived.by(() => {
+		if (stats.stage_confirmed >= STAGE_SEGMENTS.length) {
+			return { cls: 'st-done', label: t('home.statusDone') };
+		}
+		const current = STAGE_SEGMENTS.find((k) => stats.stage_status?.[k] !== 'confirmed');
+		const state = current ? stats.stage_status?.[current] : undefined;
+		const stageName = current ? t(`workbench.stage.${current}`) : '';
+		if (state === 'running') {
+			return { cls: 'st-progress', label: `${stageName} · ${t('workbench.state.running')}` };
+		}
+		if (state === 'awaiting_confirm') {
+			return { cls: 'st-progress', label: `${stageName} · ${t('workbench.state.draft')}` };
+		}
+		if (stats.stage_confirmed > 0) {
+			return { cls: 'st-progress', label: `${stageName} · ${t('home.statusProgress')}` };
+		}
+		return { cls: 'st-draft', label: t('home.statusDraft') };
+	});
 
 	function relativeTime(iso: string): string {
 		const then = new Date(iso).getTime();
@@ -171,7 +177,7 @@
 					<Icon name="film" size={22} />
 				</span>
 			{/if}
-			<span class="status-tag {statusClass}">{statusLabel}</span>
+			<span class="status-tag {cover.cls}">{cover.label}</span>
 		</span>
 		<span class="body">
 			<span class="title-row">
@@ -334,20 +340,20 @@
 		border-radius: 999px;
 		font-size: 10.5px;
 		font-weight: 600;
+		background: rgba(13, 14, 17, 0.78);
+		border: 1px solid var(--border-strong);
 		backdrop-filter: blur(4px);
 	}
+	/* a1: dark capsule over the cover so it stays legible on any image;
+	   the text carries the semantic color (§2.1). */
 	.st-draft {
 		color: var(--text-2);
-		background: rgba(27, 30, 37, 0.85);
-		border: 1px solid var(--border-strong);
 	}
 	.st-progress {
 		color: var(--accent);
-		background: var(--accent-dim);
 	}
 	.st-done {
 		color: var(--success);
-		background: var(--success-dim);
 	}
 
 	.body {
@@ -511,14 +517,7 @@
 	}
 	.menu-item.danger:hover {
 		background: var(--error-dim);
-	}
-
-	/* restyle reused ui/Button + form primitives inside the darkroom scope */
-	.a-card :global(.btn-primary) {
-		background: var(--accent);
-		color: var(--accent-contrast);
-	}
-	.a-card :global(.field-input) {
+	}	.a-card :global(.field-input) {
 		background: var(--surface-2);
 		border-color: var(--border-strong);
 		color: var(--text);

calliope-web/src/lib/components/settings/MemoryPanel.svelte

@@ -53,15 +53,24 @@
 	const projectMemories = $derived(
 		($memoriesQuery.data ?? []).filter((m) => m.scope === 'project'),
 	);
+
+	const KIND_KEYS: Record<string, string> = {
+		preference: 'memory.kindPreference',
+		convention: 'memory.kindConvention',
+		correction: 'memory.kindCorrection',
+	};
+	function kindLabel(kind: string): string {
+		return KIND_KEYS[kind] ? t(KIND_KEYS[kind]) : kind;
+	}
 </script>
 
-<section class="panel">
-	<h1>{t('memory.title')}</h1>
-	<p class="lead">{t('memory.lead')}</p>
+<section class="a-panel">
+	<h2 class="a-panel-title">{t('memory.title')}</h2>
+	<p class="a-panel-lead lead">{t('memory.lead')}</p>
 
 	<div class="add-row">
 		<input
-			class="field-input add-input"
+			class="a-input add-input"
 			placeholder={t('memory.placeholder')}
 			maxlength={500}
 			bind:value={newContent}
@@ -69,25 +78,25 @@
 				if (e.key === 'Enter' && canAdd) $addMutation.mutate();
 			}}
 		/>
-		<select class="field-input scope-select" bind:value={newScope}>
+		<select class="a-select scope-select" bind:value={newScope}>
 			<option value="global">{t('memory.scopeGlobal')}</option>
 			<option value="project">{t('memory.scopeProject')}</option>
 		</select>
 		{#if newScope === 'project'}
-			<select class="field-input scope-select" bind:value={newProjectId}>
+			<select class="a-select scope-select" bind:value={newProjectId}>
 				<option value={null}>{t('memory.chooseProject')}</option>
 				{#each ($projectsQuery.data ?? []) as p (p.id)}
 					<option value={p.id}>{p.title}</option>
 				{/each}
 			</select>
 		{/if}
-		<select class="field-input scope-select" bind:value={newKind}>
+		<select class="a-select scope-select" bind:value={newKind}>
 			<option value="preference">{t('memory.kindPreference')}</option>
 			<option value="convention">{t('memory.kindConvention')}</option>
 			<option value="correction">{t('memory.kindCorrection')}</option>
 		</select>
 		<Button
-			variant="primary"
+			variant="secondary"
 			size="sm"
 			disabled={!canAdd || $addMutation.isPending}
 			onclick={() => $addMutation.mutate()}
@@ -102,11 +111,11 @@
 		<p class="muted">{t('memory.empty')}</p>
 	{:else}
 		{#if globalMemories.length > 0}
-			<h2 class="group-head">{t('memory.groupGlobal')}</h2>
+			<h3 class="group-head">{t('memory.groupGlobal')}</h3>
 			<div class="mem-list">
 				{#each globalMemories as m (m.id)}
 					<div class="mem-row">
-						<span class="mem-kind">{m.kind}</span>
+						<span class="mem-kind">{kindLabel(m.kind)}</span>
 						<span class="mem-content">{m.content}</span>
 						<span class="mem-meta">
 							{m.source === 'user' ? t('memory.sourceYou') : t('memory.sourceAgent')} · {t('memory.usedCount', { count: m.use_count })}
@@ -124,11 +133,11 @@
 			</div>
 		{/if}
 		{#if projectMemories.length > 0}
-			<h2 class="group-head">{t('memory.groupProject')}</h2>
+			<h3 class="group-head">{t('memory.groupProject')}</h3>
 			<div class="mem-list">
 				{#each projectMemories as m (m.id)}
 					<div class="mem-row">
-						<span class="mem-kind">{m.kind}</span>
+						<span class="mem-kind">{kindLabel(m.kind)}</span>
 						<span class="mem-project">{m.project_title ?? `#${m.project_id}`}</span>
 						<span class="mem-content">{m.content}</span>
 						<span class="mem-meta">
@@ -150,21 +159,8 @@
 </section>
 
 <style>
-	.panel {
-		background: rgba(255, 255, 255, 0.03);
-		border: 1px solid rgba(255, 255, 255, 0.08);
-		border-radius: var(--radius-lg);
-		padding: var(--space-lg);
-		margin-top: var(--space-lg);
-	}
-	.panel h1 {
-		margin: 0 0 6px;
-		font-size: 22px;
-	}
 	.lead {
-		margin: 0 0 var(--space-lg);
-		color: var(--text-secondary);
-		font-size: 14px;
+		margin-bottom: 16px;
 	}
 	.add-row {
 		display: flex;
@@ -177,19 +173,6 @@
 		flex: 1;
 		min-width: 220px;
 	}
-	.field-input {
-		background: var(--bg-elevated);
-		border: 1px solid var(--border);
-		border-radius: var(--radius-sm);
-		color: var(--text-primary);
-		padding: 8px 10px;
-		font-size: 13px;
-		font-family: inherit;
-	}
-	.field-input:focus {
-		outline: none;
-		border-color: var(--accent);
-	}
 	.scope-select {
 		width: auto;
 		max-width: 160px;
@@ -198,9 +181,7 @@
 		margin: var(--space-md) 0 6px;
 		font-size: 11px;
 		font-weight: 600;
-		text-transform: uppercase;
-		letter-spacing: 0.08em;
-		color: var(--text-muted);
+		color: var(--text-3);
 	}
 	.mem-list {
 		display: flex;
@@ -213,17 +194,15 @@
 		gap: 10px;
 		padding: 8px 12px;
 		border: 1px solid var(--border);
-		border-radius: var(--radius-sm);
-		background: rgba(0, 0, 0, 0.18);
-		font-size: 13px;
+		border-radius: 8px;
+		background: var(--surface-2);
+		font-size: 12.5px;
 	}
 	.mem-kind {
 		flex-shrink: 0;
-		font-size: 10px;
-		text-transform: uppercase;
-		letter-spacing: 0.05em;
-		color: var(--accent);
-		border: 1px solid color-mix(in srgb, var(--accent) 40%, transparent);
+		font-size: 10.5px;
+		color: var(--info);
+		background: var(--info-dim);
 		border-radius: 999px;
 		padding: 1px 8px;
 	}
@@ -257,7 +236,7 @@
 	}
 	.mem-del:hover {
 		color: var(--error);
-		background: rgba(239, 68, 68, 0.12);
+		background: var(--error-dim);
 	}
 	.muted {
 		color: var(--text-muted);

calliope-web/src/lib/components/settings/SettingsNav.svelte

@@ -1,111 +0,0 @@
-<script lang="ts">
-	import { page } from '$app/state';
-	import { t } from '$lib/i18n.svelte';
-
-	const items = [
-		{ id: 'llm', href: '/settings?tab=llm', labelKey: 'nav.llm', blurbKey: 'nav.llmBlurb' },
-		{ id: 'comfy', href: '/settings?tab=comfy', labelKey: 'nav.comfy', blurbKey: 'nav.comfyBlurb' },
-		{ id: 'workflows', href: '/settings?tab=workflows', labelKey: 'nav.workflows', blurbKey: 'nav.workflowsBlurb' },
-		{ id: 'agent', href: '/settings?tab=agent', labelKey: 'nav.agent', blurbKey: 'nav.agentBlurb' },
-		{ id: 'skills', href: '/settings?tab=skills', labelKey: 'nav.skills', blurbKey: 'nav.skillsBlurb' },
-		{ id: 'queue', href: '/settings?tab=queue', labelKey: 'nav.queue', blurbKey: 'nav.queueBlurb' },
-		{ id: 'storage', href: '/settings?tab=storage', labelKey: 'nav.storage', blurbKey: 'nav.storageBlurb' },
-	] as const;
-
-	interface Props {
-		/** Section ids with unsaved edits — shown with a small warning dot. */
-		dirty?: ReadonlySet<string>;
-	}
-
-	let { dirty }: Props = $props();
-
-	let active = $derived(page.url.searchParams.get('tab') || 'llm');
-</script>
-
-<aside class="side">
-	<p class="eyebrow">{t('nav.eyebrow')}</p>
-	{#each items as item (item.id)}
-		<a
-			class="item"
-			class:active={active === item.id}
-			href={item.href}
-			aria-current={active === item.id ? 'page' : undefined}
-		>
-			<span class="label">
-				{t(item.labelKey)}
-				{#if dirty?.has(item.id)}
-					<span class="dirty-dot" title={t('nav.unsaved')} aria-label={t('nav.unsaved')}></span>
-				{/if}
-			</span>
-			<span class="blurb">{t(item.blurbKey)}</span>
-		</a>
-	{/each}
-</aside>
-
-<style>
-	.side {
-		width: 220px;
-		flex-shrink: 0;
-		border-right: 1px solid var(--border);
-		background: var(--bg-surface);
-		padding: var(--space-lg) var(--space-md);
-		display: flex;
-		flex-direction: column;
-		gap: 4px;
-		min-height: calc(100vh - 56px);
-	}
-	.eyebrow {
-		margin: 0 8px 12px;
-		font-size: 11px;
-		text-transform: uppercase;
-		letter-spacing: 0.08em;
-		color: var(--text-muted);
-		font-weight: 600;
-	}
-	.item {
-		display: flex;
-		flex-direction: column;
-		gap: 2px;
-		padding: 10px 12px;
-		border-radius: var(--radius-md);
-		text-decoration: none;
-		color: var(--text-secondary);
-		border: 1px solid transparent;
-		transition: all 0.15s;
-	}
-	.item:hover {
-		background: var(--bg-elevated);
-		color: var(--text-primary);
-	}
-	.item.active {
-		background: rgba(139, 92, 246, 0.12);
-		border-color: rgba(139, 92, 246, 0.35);
-		color: var(--text-primary);
-	}
-	.item:focus-visible {
-		outline: 2px solid var(--accent);
-		outline-offset: 2px;
-	}
-	.label {
-		display: flex;
-		align-items: center;
-		gap: 6px;
-		font-weight: 600;
-		font-size: 14px;
-		font-family: var(--font-display);
-	}
-	.dirty-dot {
-		width: 7px;
-		height: 7px;
-		border-radius: 50%;
-		background: var(--warning);
-		flex-shrink: 0;
-	}
-	.blurb {
-		font-size: 11px;
-		color: var(--text-muted);
-	}
-	.item.active .blurb {
-		color: var(--text-secondary);
-	}
-</style>

calliope-web/src/lib/components/settings/SkillsLibrary.svelte

@@ -1,485 +0,0 @@
-<script lang="ts">
-	import { createQuery } from '@tanstack/svelte-query';
-	import { agentApi } from '$lib/api';
-	import Button from '$lib/components/ui/Button.svelte';
-	import Icon from '$lib/components/ui/Icon.svelte';
-	import Skeleton from '$lib/components/ui/Skeleton.svelte';
-	import { toast } from '$lib/toast';
-	import { t } from '$lib/i18n.svelte';
-
-	interface SkillSummary {
-		name: string;
-		description: string;
-		version: string;
-		tags: string[];
-		dir: string;
-	}
-
-	const skillsQuery = createQuery({
-		queryKey: ['agent-skills'],
-		queryFn: agentApi.listSkills,
-	});
-	const pathQuery = createQuery({
-		queryKey: ['agent-skills-path'],
-		queryFn: agentApi.skillsPath,
-	});
-
-	// Expanded skill (file list open) + the file whose body is being previewed.
-	let expanded = $state<string | null>(null);
-	let filesBySkill = $state<Record<string, string[]>>({});
-	let preview = $state<{
-		skill: string;
-		path: string;
-		content: string;
-		truncated: boolean;
-	} | null>(null);
-	let previewLoading = $state(false);
-
-	async function toggleFiles(name: string) {
-		if (expanded === name) {
-			expanded = null;
-			return;
-		}
-		expanded = name;
-		preview = null;
-		if (!filesBySkill[name]) {
-			try {
-				const res = await agentApi.skillFiles(name);
-				filesBySkill = { ...filesBySkill, [name]: res.files };
-			} catch {
-				filesBySkill = { ...filesBySkill, [name]: [] };
-			}
-		}
-	}
-
-	async function openFile(skill: string, file: string) {
-		previewLoading = true;
-		preview = null;
-		try {
-			const res = await agentApi.readSkillFile(skill, file);
-			preview = { skill, path: file, content: res.content, truncated: res.truncated };
-		} catch (err) {
-			toast.error(err instanceof Error ? err.message : t('skills.couldNotRead'));
-		} finally {
-			previewLoading = false;
-		}
-	}
-
-	async function copyText(text: string, quiet = false) {
-		try {
-			await navigator.clipboard.writeText(text);
-			if (!quiet) toast.success(t('skills.copied'));
-		} catch {
-			/* clipboard unavailable — text stays selectable */
-		}
-	}
-</script>
-
-<section class="panel">
-	<div class="panel-head">
-		<div>
-			<h1>{t('skills.title')}</h1>
-			<p class="lead">{t('skills.lead')}</p>
-		</div>
-		<Button
-			variant="secondary"
-			size="sm"
-			onclick={() => {
-				$skillsQuery.refetch();
-				toast.info(t('skills.refreshed'));
-			}}
-		>
-			<Icon name="retry" size={14} />
-			{t('skills.refresh')}
-		</Button>
-	</div>
-
-	{#if $pathQuery.data?.path}
-		<div class="path-banner">
-			<Icon name="folder" size={14} />
-			<span class="mono path-text">{$pathQuery.data.path}</span>
-			<button
-				type="button"
-				class="mini-btn"
-				onclick={() => copyText($pathQuery.data?.path ?? '')}
-				title={t('skills.copyPath')}
-			>
-				{t('skills.copyPathBtn')}
-			</button>
-		</div>
-	{/if}
-
-	<div class="callout info">
-		<Icon name="edit" size={16} />
-		<div class="callout-body">
-			<p class="howto-title"><strong>{t('skills.howtoTitle')}</strong></p>
-			<ol class="howto">
-				<li>{@html t('skills.howto1')}</li>
-				<li>{@html t('skills.howto2')}</li>
-				<li>{@html t('skills.howto3')}</li>
-				<li>{@html t('skills.howto4')}</li>
-			</ol>
-			<p class="note">{@html t('skills.note')}</p>
-		</div>
-	</div>
-
-	{#if $skillsQuery.isLoading}
-		<div class="stack">
-			<Skeleton height="72px" />
-			<Skeleton height="72px" />
-		</div>
-	{:else if ($skillsQuery.data ?? []).length === 0}
-		<p class="empty">{t('skills.noSkills')}</p>
-	{:else}
-		<div class="stack">
-			{#each $skillsQuery.data ?? [] as skill (skill.dir)}
-				<article class="skill-card">
-					<header class="card-head">
-						<button
-							type="button"
-							class="expand"
-							aria-expanded={expanded === skill.dir}
-							onclick={() => toggleFiles(skill.dir)}
-							title={expanded === skill.dir ? t('skills.hideFiles') : t('skills.showFiles')}
-						>
-							<Icon
-								name={expanded === skill.dir ? 'chevron-down' : 'chevron-right'}
-								size={14}
-							/>
-						</button>
-						<div class="card-text">
-							<div class="name-row">
-								<span class="name">/{skill.name}</span>
-								{#if skill.version}
-									<span class="version">v{skill.version}</span>
-								{/if}
-							</div>
-							{#if skill.description}
-								<p class="desc">{skill.description}</p>
-							{/if}
-							{#if Array.isArray(skill.tags) && skill.tags.length > 0}
-								<div class="tags">
-									{#each skill.tags as tag (tag)}
-										<span class="tag">{tag}</span>
-									{/each}
-								</div>
-							{/if}
-						</div>
-					</header>
-					{#if expanded === skill.dir}
-						<div class="files">
-							<p class="files-label">{t('skills.filesIn')} <span class="mono">{skill.dir}/</span></p>
-							{#each filesBySkill[skill.dir] ?? [] as file (file)}
-								<button
-									type="button"
-									class="file-row"
-									class:active={preview?.skill === skill.dir && preview?.path === file}
-									onclick={() => openFile(skill.dir, file)}
-								>
-									<Icon name="edit" size={12} />
-									<span class="mono">{file}</span>
-								</button>
-							{:else}
-								<span class="muted">{t('skills.noFiles')}</span>
-							{/each}
-						</div>
-					{/if}
-				</article>
-			{/each}
-		</div>
-	{/if}
-
-	{#if previewLoading}
-		<p class="muted">{t('skills.loadingFile')}</p>
-	{:else if preview}
-		<div class="preview-panel">
-			<header class="preview-head">
-				<span class="mono preview-path">{preview.skill}/{preview.path}</span>
-				{#if preview.truncated}
-					<span class="truncated-chip">{t('skills.truncated')}</span>
-				{/if}
-				<button
-					type="button"
-					class="mini-btn"
-					onclick={() => copyText(preview?.content ?? '')}
-				>
-					{t('skills.copy')}
-				</button>
-				<button type="button" class="mini-btn" onclick={() => (preview = null)}>{t('skills.close')}</button>
-			</header>
-			<pre class="mono preview-body">{preview.content}</pre>
-		</div>
-	{/if}
-</section>
-
-<style>
-	.panel {
-		background: rgba(255, 255, 255, 0.03);
-		border: 1px solid rgba(255, 255, 255, 0.08);
-		border-radius: var(--radius-lg);
-		padding: var(--space-lg);
-	}
-	.panel-head {
-		display: flex;
-		align-items: flex-start;
-		justify-content: space-between;
-		gap: var(--space-md);
-		margin-bottom: var(--space-md);
-	}
-	.panel-head h1 {
-		margin: 0 0 6px;
-		font-size: 22px;
-	}
-	.panel-head .lead {
-		margin: 0;
-	}
-	.lead {
-		color: var(--text-secondary);
-		font-size: 14px;
-	}
-	.path-banner {
-		display: flex;
-		align-items: center;
-		gap: 10px;
-		padding: 10px 14px;
-		margin-bottom: var(--space-md);
-		border-radius: var(--radius-md);
-		border: 1px solid color-mix(in srgb, var(--accent) 35%, transparent);
-		background: color-mix(in srgb, var(--accent) 10%, var(--bg-surface));
-	}
-	.path-banner :global(.icon) {
-		color: var(--accent);
-		flex-shrink: 0;
-	}
-	.path-text {
-		flex: 1;
-		min-width: 0;
-		overflow: hidden;
-		text-overflow: ellipsis;
-		white-space: nowrap;
-		color: var(--text-primary);
-		font-size: 12.5px;
-	}
-	.mini-btn {
-		flex-shrink: 0;
-		border: 1px solid var(--border);
-		background: transparent;
-		color: var(--text-secondary);
-		border-radius: 999px;
-		padding: 2px 10px;
-		font-size: 11px;
-		cursor: pointer;
-	}
-	.mini-btn:hover {
-		color: var(--text-primary);
-		border-color: var(--text-secondary);
-	}
-	.callout {
-		display: flex;
-		align-items: flex-start;
-		gap: 10px;
-		padding: 14px 16px;
-		margin-bottom: var(--space-lg);
-		border-radius: var(--radius-md);
-		border: 1px solid rgba(255, 255, 255, 0.08);
-		background: rgba(0, 0, 0, 0.18);
-	}
-	.callout.info :global(.icon) {
-		color: var(--accent);
-		flex-shrink: 0;
-		margin-top: 2px;
-	}
-	.callout-body {
-		min-width: 0;
-	}
-	.callout-body p {
-		margin: 0;
-		font-size: 13px;
-		line-height: 1.55;
-		color: var(--text-secondary);
-	}
-	.howto-title {
-		margin-bottom: 6px;
-	}
-	.howto {
-		margin: 6px 0 0;
-		padding-left: 20px;
-		display: flex;
-		flex-direction: column;
-		gap: 8px;
-	}
-	.howto li {
-		font-size: 13px;
-		line-height: 1.55;
-		color: var(--text-secondary);
-	}
-	.snippet {
-		margin: 8px 0 4px;
-		padding: 10px 12px;
-		background: var(--bg-elevated);
-		border: 1px solid var(--border);
-		border-radius: var(--radius-sm);
-		font-size: 11.5px;
-		line-height: 1.5;
-		overflow-x: auto;
-		color: var(--text-primary);
-		white-space: pre;
-	}
-	.snippet-note {
-		font-size: 12px;
-		color: var(--text-muted);
-	}
-	.note {
-		margin-top: 10px;
-		font-size: 12px;
-		color: var(--text-muted);
-	}
-	.stack {
-		display: flex;
-		flex-direction: column;
-		gap: var(--space-sm);
-	}
-	.empty {
-		color: var(--text-muted);
-		font-size: 14px;
-	}
-	.skill-card {
-		border: 1px solid rgba(255, 255, 255, 0.08);
-		border-radius: var(--radius-md);
-		background: rgba(0, 0, 0, 0.18);
-		padding: 12px 14px;
-	}
-	.card-head {
-		display: flex;
-		align-items: flex-start;
-		gap: 8px;
-	}
-	.expand {
-		border: none;
-		background: transparent;
-		color: var(--text-muted);
-		cursor: pointer;
-		padding: 2px;
-		margin-top: 2px;
-		flex-shrink: 0;
-	}
-	.expand:hover {
-		color: var(--text-primary);
-	}
-	.card-text {
-		min-width: 0;
-	}
-	.name-row {
-		display: flex;
-		align-items: baseline;
-		gap: 8px;
-		flex-wrap: wrap;
-	}
-	.name {
-		font-weight: 600;
-		font-size: 14px;
-		color: #7dd3fc;
-	}
-	.version {
-		font-size: 11px;
-		color: var(--text-muted);
-	}
-	.desc {
-		margin: 4px 0 0;
-		font-size: 13px;
-		line-height: 1.5;
-		color: var(--text-secondary);
-	}
-	.tags {
-		display: flex;
-		flex-wrap: wrap;
-		gap: 6px;
-		margin-top: 8px;
-	}
-	.tag {
-		font-size: 10.5px;
-		padding: 2px 8px;
-		border-radius: 999px;
-		border: 1px solid var(--border);
-		color: var(--text-muted);
-	}
-	.files {
-		margin-top: 10px;
-		padding: 10px 12px;
-		border-top: 1px solid var(--border);
-	}
-	.files-label {
-		margin: 0 0 6px;
-		font-size: 11px;
-		text-transform: uppercase;
-		letter-spacing: 0.05em;
-		color: var(--text-muted);
-	}
-	.file-row {
-		display: flex;
-		align-items: center;
-		gap: 8px;
-		width: 100%;
-		padding: 6px 8px;
-		border: none;
-		border-radius: var(--radius-sm);
-		background: transparent;
-		color: var(--text-secondary);
-		font-size: 12.5px;
-		cursor: pointer;
-		text-align: left;
-	}
-	.file-row:hover,
-	.file-row.active {
-		background: var(--bg-elevated);
-		color: var(--text-primary);
-	}
-	.file-row.active {
-		color: var(--accent);
-	}
-	.preview-panel {
-		margin-top: var(--space-md);
-		border: 1px solid var(--border);
-		border-radius: var(--radius-md);
-		background: var(--bg-elevated);
-		overflow: hidden;
-	}
-	.preview-head {
-		display: flex;
-		align-items: center;
-		gap: 10px;
-		padding: 8px 12px;
-		border-bottom: 1px solid var(--border);
-	}
-	.preview-path {
-		flex: 1;
-		min-width: 0;
-		overflow: hidden;
-		text-overflow: ellipsis;
-		white-space: nowrap;
-		font-size: 12px;
-		color: var(--text-secondary);
-	}
-	.truncated-chip {
-		font-size: 10.5px;
-		color: var(--warning);
-		border: 1px solid rgba(245, 158, 11, 0.4);
-		border-radius: 999px;
-		padding: 1px 8px;
-	}
-	.preview-body {
-		margin: 0;
-		padding: 12px 14px;
-		max-height: 420px;
-		overflow: auto;
-		font-size: 12px;
-		line-height: 1.55;
-		color: var(--text-primary);
-		white-space: pre-wrap;
-		word-break: break-word;
-	}
-	.muted {
-		color: var(--text-muted);
-		font-size: 13px;
-	}
-</style>

calliope-web/src/lib/components/settings/WorkflowsLibrary.svelte

@@ -1,700 +0,0 @@
-<script lang="ts">
-	import { createQuery, useQueryClient } from '@tanstack/svelte-query';
-	import { workflows, type Workflow, type ComfyDynamicInput, type ComfyDynamicOutput } from '$lib/api';
-	import { toast } from '$lib/toast';
-	import Button from '$lib/components/ui/Button.svelte';
-	import ConfirmDialog from '$lib/components/ui/ConfirmDialog.svelte';
-	import Skeleton from '$lib/components/ui/Skeleton.svelte';
-	import StatusChip from '$lib/components/ui/StatusChip.svelte';
-	import { t } from '$lib/i18n.svelte';
-
-	const client = useQueryClient();
-	const workflowsQuery = createQuery({
-		queryKey: ['workflows'],
-		queryFn: workflows.list,
-	});
-
-	let jsonText = $state('');
-	let uploadedFileName = $state<string | null>(null);
-	let dragging = $state(false);
-	let parseError = $state('');
-	let analyzedInputs = $state<ComfyDynamicInput[]>([]);
-	let analyzedOutputs = $state<ComfyDynamicOutput[]>([]);
-	let analyzed = $state(false);
-	let pendingJson = $state<Record<string, unknown> | null>(null);
-
-	let wfName = $state('');
-	let wfKind = $state<'image' | 'video'>('image');
-	let wfProfile = $state('prose');
-	let wfDescription = $state('');
-	let saving = $state(false);
-
-	let editingId = $state<number | null>(null);
-	let editName = $state('');
-	let editDescription = $state('');
-	let editProfile = $state('prose');
-	let detailsId = $state<number | null>(null);
-
-	async function analyzeRaw(text: string) {
-		parseError = '';
-		analyzed = false;
-		analyzedInputs = [];
-		analyzedOutputs = [];
-		pendingJson = null;
-		try {
-			const json = JSON.parse(text) as Record<string, unknown>;
-			pendingJson = json;
-			const result = await workflows.analyze(json);
-			analyzedInputs = result.inputs;
-			analyzedOutputs = result.outputs;
-			analyzed = true;
-			wfProfile = result.suggested_profile ?? 'prose';
-			if (!wfName.trim() && uploadedFileName) {
-				wfName = uploadedFileName.replace(/\.json$/i, '');
-			}
-		} catch (err) {
-			parseError = err instanceof Error ? err.message : t('wf.invalidJson');
-		}
-	}
-
-	async function onFile(file: File) {
-		uploadedFileName = file.name;
-		const text = await file.text();
-		jsonText = text;
-		await analyzeRaw(text);
-	}
-
-	function onDrop(e: DragEvent) {
-		e.preventDefault();
-		dragging = false;
-		const file = e.dataTransfer?.files?.[0];
-		if (file) void onFile(file);
-	}
-
-	async function saveToLibrary() {
-		if (!pendingJson || !wfName.trim() || !analyzed) return;
-		saving = true;
-		try {
-			await workflows.create({
-				name: wfName.trim(),
-				kind: wfKind,
-				workflow_json: pendingJson,
-				description: wfDescription.trim() || undefined,
-				prompt_profile: wfProfile,
-			});
-			jsonText = '';
-			uploadedFileName = null;
-			analyzed = false;
-			analyzedInputs = [];
-			analyzedOutputs = [];
-			pendingJson = null;
-			const name = wfName.trim();
-			wfName = '';
-			wfDescription = '';
-			wfKind = 'image';
-			wfProfile = 'prose';
-			client.invalidateQueries({ queryKey: ['workflows'] });
-			toast.success(t('wf.savedToLibrary', { name }));
-		} catch (err) {
-			toast.error(err instanceof Error ? err.message : t('wf.saveFailed'));
-		} finally {
-			saving = false;
-		}
-	}
-
-	function startEdit(wf: Workflow) {
-		editingId = wf.id;
-		editName = wf.name;
-		editDescription = wf.description ?? '';
-		editProfile = wf.prompt_profile ?? 'prose';
-	}
-
-	async function saveEdit(id: number) {
-		try {
-			await workflows.update(id, {
-				name: editName.trim(),
-				description: editDescription.trim(),
-				prompt_profile: editProfile,
-			});
-			editingId = null;
-			client.invalidateQueries({ queryKey: ['workflows'] });
-			toast.success(t('wf.updated'));
-		} catch (err) {
-			toast.error(err instanceof Error ? err.message : t('wf.updateFailed'));
-		}
-	}
-
-	async function toggleEnabled(wf: Workflow) {
-		try {
-			await workflows.update(wf.id, { is_enabled: !wf.is_enabled });
-			client.invalidateQueries({ queryKey: ['workflows'] });
-			toast.success(
-				t('wf.enabledState', {
-					name: wf.name,
-					state: wf.is_enabled ? t('wf.stateDisabled') : t('wf.stateEnabled'),
-				}),
-			);
-		} catch (err) {
-			toast.error(err instanceof Error ? err.message : t('wf.updateFailed'));
-		}
-	}
-
-	let deleteTarget = $state<Workflow | null>(null);
-	let deleteOpen = $state(false);
-
-	function askDelete(wf: Workflow) {
-		deleteTarget = wf;
-		deleteOpen = true;
-	}
-
-	async function confirmDelete() {
-		const wf = deleteTarget;
-		deleteTarget = null;
-		if (!wf) return;
-		try {
-			await workflows.delete(wf.id);
-			if (detailsId === wf.id) detailsId = null;
-			client.invalidateQueries({ queryKey: ['workflows'] });
-			toast.success(t('wf.deleted', { name: wf.name }));
-		} catch (err) {
-			toast.error(err instanceof Error ? err.message : t('wf.deleteFailed'));
-		}
-	}
-
-	let list = $derived($workflowsQuery.data ?? []);
-	let imageCount = $derived(list.filter((w) => w.kind === 'image').length);
-	let videoCount = $derived(list.filter((w) => w.kind === 'video').length);
-</script>
-
-<section class="block">
-	<header class="block-head">
-		<div>
-			<h2>{t('wf.title')}</h2>
-			<p>{@html t('wf.lead')}</p>
-		</div>
-		<div class="stats">
-			<span class="stat">{t('wf.countSaved', { count: list.length })}</span>
-			<span class="stat image">{t('wf.countImage', { count: imageCount })}</span>
-			<span class="stat video">{t('wf.countVideo', { count: videoCount })}</span>
-		</div>
-	</header>
-
-	<div class="register panel">
-		<h3>{t('wf.analyzeRegister')}</h3>
-		<div
-			class="drop"
-			class:dragging
-			role="button"
-			tabindex="0"
-			ondragover={(e) => {
-				e.preventDefault();
-				dragging = true;
-			}}
-			ondragleave={() => (dragging = false)}
-			ondrop={onDrop}
-			onclick={() => document.getElementById('wf-file')?.click()}
-			onkeydown={(e) => e.key === 'Enter' && document.getElementById('wf-file')?.click()}
-		>
-			<input
-				id="wf-file"
-				type="file"
-				accept="application/json,.json"
-				hidden
-				onchange={(e) => {
-					const f = (e.currentTarget as HTMLInputElement).files?.[0];
-					if (f) void onFile(f);
-				}}
-			/>
-			<div class="drop-icon">JSON</div>
-			<div>
-				<strong>{t('wf.dropHint')}</strong>
-				<p class="muted">{t('wf.dropSub')}</p>
-			</div>
-		</div>
-
-		{#if uploadedFileName}
-			<p class="file-name mono">{uploadedFileName}</p>
-		{/if}
-
-		{#if jsonText}
-			<label class="field">
-				<span class="field-label">{t('wf.jsonPreview')}</span>
-				<textarea class="field-textarea mono preview" rows="8" readonly value={jsonText}></textarea>
-			</label>
-			<Button variant="secondary" size="sm" onclick={() => analyzeRaw(jsonText)}>{t('wf.reanalyze')}</Button>
-		{/if}
-
-		{#if parseError}
-			<div class="error">{parseError}</div>
-		{/if}
-
-		{#if analyzed}
-			<div class="io-panel">
-				<div class="io-col">
-					<h4>{t('wf.detectedInputs', { count: analyzedInputs.length })}</h4>
-					{#if analyzedInputs.length === 0}
-						<p class="muted">{@html t('wf.noInputs')}</p>
-					{:else}
-						{#each analyzedInputs as inp}
-							<div class="pill input">
-								<span class="kind">{inp.kind}</span>
-								{#if inp.role}<span class="kind">{inp.role}</span>{/if}
-								<span>{inp.label}</span>
-								<span class="node mono">#{inp.nodeId}</span>
-							</div>
-						{/each}
-					{/if}
-				</div>
-				<div class="io-col">
-					<h4>{t('wf.detectedOutputs', { count: analyzedOutputs.length })}</h4>
-					{#if analyzedOutputs.length === 0}
-						<p class="muted">{@html t('wf.noOutputs')}</p>
-					{:else}
-						{#each analyzedOutputs as out}
-							<div class="pill output">
-								<span class="kind">{out.kind}</span>
-								{#if out.role}<span class="kind">{out.role}</span>{/if}
-								<span>{out.label}</span>
-								<span class="node mono">#{out.nodeId}</span>
-							</div>
-						{/each}
-					{/if}
-				</div>
-			</div>
-
-			<div class="meta-grid">
-				<label class="field">
-					<span class="field-label">{t('common.name')}</span>
-					<input class="field-input" bind:value={wfName} placeholder={t('wf.namePlaceholder')} required />
-				</label>
-				<label class="field">
-					<span class="field-label">{t('wf.kind')}</span>
-					<select class="field-select" bind:value={wfKind}>
-						<option value="image">{t('wf.kindImage')}</option>
-						<option value="video">{t('wf.kindVideo')}</option>
-					</select>
-				</label>
-			</div>
-			<label class="field">
-				<span class="field-label">{t('wf.promptFormat')}</span>
-				<select class="field-select" bind:value={wfProfile}>
-					<option value="prose">{t('wf.profileProse')}</option>
-					<option value="minimax_h3_ref">{t('wf.profileH3')}</option>
-				</select>
-			</label>
-			<label class="field">
-				<span class="field-label">{t('common.description')}</span>
-				<textarea
-					class="field-textarea"
-					bind:value={wfDescription}
-					rows="2"
-					placeholder={t('wf.descPlaceholder')}
-				></textarea>
-			</label>
-			<Button variant="primary" loading={saving} disabled={!wfName.trim()} onclick={saveToLibrary}>
-				{t('wf.saveToLibrary')}
-			</Button>
-		{/if}
-	</div>
-
-	<div class="library">
-		<div class="library-head">
-			<h3>{t('wf.savedWorkflows', { count: list.length })}</h3>
-		</div>
-
-		{#if $workflowsQuery.isLoading}
-			<div class="cards" aria-busy="true" aria-label={t('wf.loadingWorkflows')}>
-				{#each [1, 2, 3] as n (n)}
-					<div class="card skel-card">
-						<Skeleton circle height="40px" />
-						<div class="skel-lines">
-							<Skeleton width="45%" height="15px" />
-							<Skeleton width="70%" />
-						</div>
-					</div>
-				{/each}
-			</div>
-		{:else if list.length === 0}
-			<div class="empty">
-				<strong>{t('wf.noWorkflows')}</strong>
-				<p class="muted">{t('wf.noWorkflowsHint')}</p>
-			</div>
-		{:else}
-			<div class="cards">
-				{#each list as wf (wf.id)}
-					<article class="card" class:disabled={!wf.is_enabled}>
-						{#if editingId === wf.id}
-							<label class="field">
-								<span class="field-label">{t('common.name')}</span>
-								<input class="field-input" bind:value={editName} />
-							</label>
-							<label class="field">
-								<span class="field-label">{t('common.description')}</span>
-								<textarea class="field-textarea" rows="2" bind:value={editDescription}></textarea>
-							</label>
-							<label class="field">
-								<span class="field-label">{t('wf.promptFormat')}</span>
-								<select class="field-select" bind:value={editProfile}>
-									<option value="prose">{t('wf.profileProse')}</option>
-									<option value="minimax_h3_ref">{t('wf.profileH3')}</option>
-								</select>
-							</label>
-							<p class="field-hint">{t('wf.jsonLocked')}</p>
-							<div class="row">
-								<Button size="sm" onclick={() => saveEdit(wf.id)}>{t('common.save')}</Button>
-								<Button variant="ghost" size="sm" onclick={() => (editingId = null)}>{t('common.cancel')}</Button>
-							</div>
-						{:else}
-							<div class="card-top">
-								<div class="tile" class:video={wf.kind === 'video'}>
-									{wf.kind === 'video' ? 'VID' : 'IMG'}
-								</div>
-								<div class="card-meta">
-									<strong>{wf.name}</strong>
-									<div class="tags">
-										<span class="kind-badge" class:video={wf.kind === 'video'}>{wf.kind}</span>
-										{#if wf.prompt_profile === 'minimax_h3_ref'}
-											<span class="kind-badge h3">H3-ref</span>
-										{/if}
-										<span class="count">{t('wf.inputsCount', { count: wf.input_schema?.length ?? 0 })}</span>
-										<span class="count">{t('wf.outputsCount', { count: wf.output_schema?.length ?? 0 })}</span>
-										{#if !wf.is_enabled}<StatusChip status="disabled" label={t('wf.disabled')} />{/if}
-									</div>
-									{#if wf.description}
-										<p class="desc">{wf.description}</p>
-									{/if}
-								</div>
-							</div>
-							<div class="row">
-								<Button variant="ghost" size="sm" onclick={() => startEdit(wf)}>{t('common.edit')}</Button>
-								<Button
-									variant="ghost"
-									size="sm"
-									onclick={() => (detailsId = detailsId === wf.id ? null : wf.id)}
-								>
-									{detailsId === wf.id ? t('wf.hideIo') : t('wf.viewIo')}
-								</Button>
-								<Button variant="ghost" size="sm" onclick={() => toggleEnabled(wf)}>
-									{wf.is_enabled ? t('wf.disable') : t('wf.enable')}
-								</Button>
-								<Button variant="danger" size="sm" onclick={() => askDelete(wf)}>{t('common.delete')}</Button>
-							</div>
-							{#if detailsId === wf.id}
-								<div class="io-panel nested">
-									<div class="io-col">
-										<h4>{t('wf.inputs')}</h4>
-										{#each wf.input_schema ?? [] as inp}
-											<div class="pill input">
-												<span class="kind">{inp.kind}</span>
-												{#if inp.role}<span class="kind">{inp.role}</span>{/if}
-												<span>{inp.label}</span>
-											</div>
-										{:else}
-											<p class="muted">{t('wf.noInputsCached')}</p>
-										{/each}
-									</div>
-									<div class="io-col">
-										<h4>{t('wf.outputs')}</h4>
-										{#each wf.output_schema ?? [] as out}
-											<div class="pill output">
-												<span class="kind">{out.kind}</span>
-												<span>{out.label}</span>
-											</div>
-										{:else}
-											<p class="muted">{t('wf.noOutputsCached')}</p>
-										{/each}
-									</div>
-								</div>
-							{/if}
-						{/if}
-					</article>
-				{/each}
-			</div>
-		{/if}
-	</div>
-</section>
-
-<ConfirmDialog
-	bind:open={deleteOpen}
-	title={t('wf.deleteTitle')}
-	message={deleteTarget ? t('wf.deleteMessage', { name: deleteTarget.name }) : ''}
-	confirmLabel={t('common.delete')}
-	danger
-	onconfirm={confirmDelete}
-	oncancel={() => (deleteTarget = null)}
-/>
-
-<style>
-	.block-head {
-		display: flex;
-		justify-content: space-between;
-		gap: var(--space-lg);
-		align-items: flex-start;
-		margin-bottom: var(--space-lg);
-	}
-	.block-head h2 {
-		margin: 0 0 6px;
-		font-size: 22px;
-	}
-	.block-head p {
-		margin: 0;
-		color: var(--text-secondary);
-		font-size: 14px;
-		max-width: 52ch;
-		line-height: 1.45;
-	}
-	.block-head code {
-		background: var(--bg-elevated);
-		padding: 1px 6px;
-		border-radius: 4px;
-		font-size: 12px;
-	}
-	.stats {
-		display: flex;
-		gap: 8px;
-		flex-wrap: wrap;
-	}
-	.stat {
-		font-size: 11px;
-		font-weight: 600;
-		text-transform: uppercase;
-		letter-spacing: 0.04em;
-		padding: 4px 10px;
-		border-radius: 999px;
-		background: var(--bg-elevated);
-		color: var(--text-muted);
-		border: 1px solid var(--border);
-	}
-	.stat.image {
-		color: var(--accent);
-		border-color: rgba(139, 92, 246, 0.35);
-	}
-	.stat.video {
-		color: var(--info);
-		border-color: rgba(59, 130, 246, 0.35);
-	}
-	.panel,
-	.card {
-		background: rgba(255, 255, 255, 0.03);
-		border: 1px solid rgba(255, 255, 255, 0.08);
-		border-radius: var(--radius-lg);
-		padding: var(--space-lg);
-	}
-	.register {
-		margin-bottom: var(--space-xl);
-	}
-	.register h3,
-	.library-head h3 {
-		margin: 0 0 var(--space-md);
-		font-size: 16px;
-		color: var(--text-secondary);
-	}
-	.drop {
-		display: flex;
-		align-items: center;
-		gap: var(--space-md);
-		padding: var(--space-lg);
-		border: 1px dashed var(--border);
-		border-radius: var(--radius-md);
-		cursor: pointer;
-		margin-bottom: var(--space-md);
-		transition: all 0.15s;
-	}
-	.drop:hover,
-	.drop.dragging {
-		border-color: var(--accent);
-		background: rgba(139, 92, 246, 0.08);
-	}
-	.drop:focus-visible {
-		outline: 2px solid var(--accent);
-		outline-offset: 2px;
-	}
-	.drop-icon {
-		width: 44px;
-		height: 44px;
-		border-radius: var(--radius-md);
-		background: rgba(139, 92, 246, 0.12);
-		color: var(--accent);
-		display: flex;
-		align-items: center;
-		justify-content: center;
-		font-size: 11px;
-		font-weight: 700;
-		font-family: var(--font-mono);
-	}
-	.muted {
-		color: var(--text-muted);
-		margin: 4px 0 0;
-		font-size: 13px;
-	}
-	.file-name {
-		font-size: 12px;
-		color: var(--text-secondary);
-		margin: 0 0 var(--space-md);
-	}
-	.preview {
-		font-size: 11px;
-		max-height: 180px;
-	}
-	.error {
-		margin: var(--space-md) 0;
-		padding: 10px 12px;
-		border-radius: var(--radius-sm);
-		background: rgba(239, 68, 68, 0.1);
-		border: 1px solid rgba(239, 68, 68, 0.3);
-		color: var(--error);
-		font-size: 13px;
-	}
-	.io-panel {
-		display: grid;
-		grid-template-columns: 1fr 1fr;
-		gap: var(--space-md);
-		margin: var(--space-md) 0;
-		padding: var(--space-md);
-		background: var(--bg-primary);
-		border-radius: var(--radius-md);
-		border: 1px solid var(--border);
-	}
-	.io-panel.nested {
-		margin-top: var(--space-md);
-	}
-	@media (max-width: 800px) {
-		.io-panel {
-			grid-template-columns: 1fr;
-		}
-	}
-	.io-col h4 {
-		margin: 0 0 8px;
-		font-size: 12px;
-		text-transform: uppercase;
-		letter-spacing: 0.06em;
-		color: var(--text-muted);
-	}
-	.pill {
-		display: flex;
-		align-items: center;
-		gap: 8px;
-		padding: 6px 8px;
-		border-radius: var(--radius-sm);
-		margin-bottom: 6px;
-		font-size: 13px;
-		background: var(--bg-elevated);
-	}
-	.pill .kind {
-		font-size: 10px;
-		font-weight: 700;
-		text-transform: uppercase;
-		padding: 2px 6px;
-		border-radius: 999px;
-	}
-	.pill.input .kind {
-		background: rgba(139, 92, 246, 0.2);
-		color: var(--accent);
-	}
-	.pill.output .kind {
-		background: rgba(34, 197, 94, 0.15);
-		color: var(--success);
-	}
-	.pill .node {
-		margin-left: auto;
-		font-size: 11px;
-		color: var(--text-muted);
-	}
-	.meta-grid {
-		display: grid;
-		grid-template-columns: 2fr 1fr;
-		gap: var(--space-md);
-	}
-	.library-head {
-		margin-bottom: var(--space-md);
-	}
-	.cards {
-		display: flex;
-		flex-direction: column;
-		gap: var(--space-md);
-	}
-	.card.disabled {
-		opacity: 0.55;
-	}
-	.card-top {
-		display: flex;
-		gap: var(--space-md);
-		margin-bottom: var(--space-md);
-	}
-	.tile {
-		width: 40px;
-		height: 40px;
-		border-radius: var(--radius-md);
-		background: rgba(139, 92, 246, 0.12);
-		color: var(--accent);
-		display: flex;
-		align-items: center;
-		justify-content: center;
-		font-size: 10px;
-		font-weight: 700;
-		font-family: var(--font-mono);
-		flex-shrink: 0;
-	}
-	.tile.video {
-		background: rgba(59, 130, 246, 0.12);
-		color: var(--info);
-	}
-	.card-meta strong {
-		font-size: 15px;
-		font-family: var(--font-display);
-	}
-	.tags {
-		display: flex;
-		flex-wrap: wrap;
-		gap: 6px;
-		margin-top: 6px;
-	}
-	.kind-badge {
-		font-size: 10px;
-		font-weight: 700;
-		text-transform: uppercase;
-		padding: 2px 8px;
-		border-radius: 999px;
-		background: rgba(139, 92, 246, 0.15);
-		color: var(--accent);
-	}
-	.kind-badge.video {
-		background: rgba(59, 130, 246, 0.15);
-		color: var(--info);
-	}
-	.kind-badge.h3 {
-		background: rgba(34, 197, 94, 0.15);
-		color: var(--success);
-	}
-	.count {
-		font-size: 11px;
-		color: var(--text-muted);
-	}
-	.desc {
-		margin: 8px 0 0;
-		font-size: 13px;
-		color: var(--text-secondary);
-	}
-	.row {
-		display: flex;
-		flex-wrap: wrap;
-		gap: 6px;
-	}
-	.empty {
-		border: 1px dashed var(--border);
-		border-radius: var(--radius-lg);
-		padding: var(--space-xl);
-		text-align: center;
-	}
-	.skel-card {
-		display: flex;
-		align-items: center;
-		gap: var(--space-md);
-	}
-	.skel-lines {
-		flex: 1;
-		display: flex;
-		flex-direction: column;
-		gap: 8px;
-	}
-</style>

calliope-web/src/lib/components/shell/AppShell.svelte

@@ -1,9 +1,10 @@
 <script lang="ts">
 	import { createQuery } from '@tanstack/svelte-query';
+	import { toStore } from 'svelte/store';
 	import LanguageSwitcher from '$lib/components/LanguageSwitcher.svelte';
 	import Icon from '$lib/components/ui/Icon.svelte';
 	import type { IconName } from '$lib/components/ui/icons';
-	import { settings, jobsApi } from '$lib/api';
+	import { settings, jobsApi, comfy } from '$lib/api';
 	import { t } from '$lib/i18n.svelte';
 
 	/**
@@ -81,9 +82,9 @@
 			.length,
 	);
 
-	// The ACTIVE ComfyUI connection from settings (HEL-611). The dot stays
-	// neutral — a passing test is only claimed on the connections page,
-	// where it comes from a real server-side probe.
+	// The ACTIVE ComfyUI connection (HEL-611). Its status dot comes from a
+	// real server-side probe (GET /system_stats from the workbench server,
+	// §3) — green only when that probe passes.
 	const activeEndpoint = $derived.by(() => {
 		const s = $settingsQuery.data;
 		if (!s) return null;
@@ -100,6 +101,25 @@
 			return raw;
 		}
 	});
+
+	const activeId = $derived(activeEndpoint?.id ?? null);
+	const probeQuery = createQuery(
+		toStore(() => ({
+			queryKey: ['comfy-probe', activeId],
+			queryFn: () => comfy.testEndpoint({ endpoint_id: activeId ?? undefined, timeout_sec: 5 }),
+			enabled: activeId != null,
+			staleTime: 60_000,
+			refetchInterval: 60_000,
+			retry: false,
+		})),
+	);
+	const probeState = $derived.by<'unset' | 'testing' | 'ok' | 'fail'>(() => {
+		if (!activeEndpoint) return 'unset';
+		if ($probeQuery.isPending) return 'testing';
+		if ($probeQuery.isError) return 'fail';
+		return $probeQuery.data?.ok ? 'ok' : 'fail';
+	});
+	const endpointName = $derived(activeEndpoint?.name?.trim() || 'ComfyUI');
 </script>
 
 <svelte:head>
@@ -116,8 +136,11 @@
 	<div class="shell-frame">
 		<aside class="side">
 			<a class="brand" href="/" title={t('shell.brandHome')}>
-				<span class="brand-mark"><Icon name="film" size={17} /></span>
-				<span class="brand-name">{t('shell.brand')}</span>
+				<span class="brand-mark" aria-hidden="true">{t('shell.brandMark')}</span>
+				<span class="brand-copy">
+					<span class="brand-name">{t('shell.brand')}</span>
+					<span class="brand-sub">AIGC STUDIO</span>
+				</span>
 			</a>
 
 			<nav class="nav" aria-label={t('shell.navAria')}>
@@ -146,13 +169,22 @@
 			</nav>
 
 			<div class="side-foot">
-				<a class="comfy-row" href="/connections" title={t('shell.comfyManage')}>
-					<span class="dot" aria-hidden="true"></span>
+				<a
+					class="comfy-row"
+					href="/connections"
+					title={probeState === 'fail'
+						? ($probeQuery.data?.message ?? t('shell.comfyManage'))
+						: t('shell.comfyManage')}
+				>
+					<span class="dot {probeState}" aria-hidden="true"></span>
 					<span class="comfy-text">
-						{#if comfyUrl}
-							{t('shell.comfyAt', { host: comfyUrl })}
-						{:else}
+						{#if probeState === 'unset'}
 							{t('shell.comfyUnset')}
+						{:else}
+							<span class="comfy-state" class:fail={probeState === 'fail'}>
+								{t(`shell.comfy_${probeState}`, { name: endpointName })}
+							</span>
+							{#if comfyUrl}<span class="mono comfy-host">{comfyUrl}</span>{/if}
 						{/if}
 					</span>
 				</a>
@@ -224,21 +256,38 @@
 		width: 30px;
 		height: 30px;
 		border-radius: 8px;
-		background: linear-gradient(135deg, #e8a33d, #b96a1b);
-		color: #16130a;
+		background: var(--avatar-1);
+		color: var(--accent-contrast);
+		font-size: 15px;
+		font-weight: 700;
 		display: inline-flex;
 		align-items: center;
 		justify-content: center;
 		flex-shrink: 0;
 	}
 
+	.brand-copy {
+		display: flex;
+		flex-direction: column;
+		min-width: 0;
+		line-height: 1.25;
+	}
+
 	.brand-name {
-		font-size: 15.5px;
+		font-size: 15px;
 		font-weight: 700;
 		letter-spacing: 0.02em;
 		white-space: nowrap;
 	}
 
+	.brand-sub {
+		font-family: var(--font-a-mono);
+		font-size: 9.5px;
+		letter-spacing: 0.14em;
+		color: var(--text-3);
+		white-space: nowrap;
+	}
+
 	.nav {
 		display: flex;
 		flex-direction: column;
@@ -335,21 +384,52 @@
 		color: var(--text);
 	}
 
-	/* Neutral until a real server-side probe says otherwise — the
-	   connections page (a6) owns the tested/failed states (HEL-611). */
+	/* §5 连接状态点: green = probe passed, amber breathing = testing,
+	   red = failed, gray = no connection configured. */
 	.dot {
 		width: 7px;
 		height: 7px;
 		border-radius: 50%;
 		background: var(--text-3);
 		flex-shrink: 0;
+		align-self: flex-start;
+		margin-top: 5px;
+	}
+	.dot.ok {
+		background: var(--success);
+	}
+	.dot.fail {
+		background: var(--error);
+	}
+	.dot.testing {
+		background: var(--accent);
+		animation: shell-breathe 2s cubic-bezier(0.16, 1, 0.3, 1) infinite;
+	}
+	@keyframes shell-breathe {
+		50% {
+			opacity: 0.35;
+		}
 	}
 
 	.comfy-text {
+		display: flex;
+		flex-direction: column;
+		min-width: 0;
+		line-height: 1.5;
+	}
+	.comfy-state,
+	.comfy-host {
 		white-space: nowrap;
 		overflow: hidden;
 		text-overflow: ellipsis;
 	}
+	.comfy-state.fail {
+		color: var(--error);
+	}
+	.comfy-host {
+		font-size: 10.5px;
+		color: var(--text-3);
+	}
 
 	.lang-row :global(.lang-switcher) {
 		background: var(--surface-2);
@@ -426,7 +506,7 @@
 			padding: 0;
 			justify-content: center;
 		}
-		.brand-name {
+		.brand-copy {
 			display: none;
 		}
 		.nav {

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/components/ui/Button.svelte

@@ -5,6 +5,8 @@
 	interface Props {
 		variant?: 'primary' | 'secondary' | 'ghost' | 'danger';
 		size?: 'sm' | 'md';
+		/** Stretch to the container width (e.g. a panel's main action). */
+		block?: boolean;
 		disabled?: boolean;
 		loading?: boolean;
 		type?: 'button' | 'submit' | 'reset';
@@ -16,6 +18,7 @@
 	let {
 		variant = 'secondary',
 		size = 'md',
+		block = false,
 		disabled = false,
 		loading = false,
 		type = 'button',
@@ -27,7 +30,9 @@
 
 <button
 	{type}
-	class="btn btn-{variant} btn-{size}"
+	class="a-btn btn {variant}"
+	class:sm={size === 'sm'}
+	class:block
 	class:loading
 	disabled={disabled || loading}
 	{title}
@@ -44,86 +49,13 @@
 </button>
 
 <style>
+	/* Look comes from the shared `.a-btn` rules in app.css (§5). */
 	.btn {
 		position: relative;
-		display: inline-flex;
-		align-items: center;
-		justify-content: center;
-		gap: 8px;
-		border: 1px solid transparent;
-		border-radius: var(--radius-sm);
-		font-family: inherit;
-		font-weight: 500;
-		white-space: nowrap;
-		cursor: pointer;
-		transition:
-			background-color 150ms ease,
-			border-color 150ms ease,
-			color 150ms ease,
-			box-shadow 150ms ease,
-			transform 100ms ease;
-	}
-	.btn-sm {
-		min-height: 28px;
-		padding: 5px 10px;
-		font-size: 12px;
-	}
-	.btn-md {
-		min-height: 34px;
-		padding: 8px 14px;
-		font-size: 13px;
-	}
-
-	.btn-primary {
-		background: var(--accent);
-		color: #fff;
-	}
-	.btn-primary:hover:not(:disabled) {
-		background: var(--accent-hover);
-	}
-
-	.btn-secondary {
-		background: var(--bg-elevated);
-		border-color: var(--border);
-		color: var(--text-primary);
-	}
-	.btn-secondary:hover:not(:disabled) {
-		background: #23232b;
-		border-color: #3f3f46;
-	}
-
-	.btn-ghost {
-		background: transparent;
-		color: var(--text-secondary);
-	}
-	.btn-ghost:hover:not(:disabled) {
-		background: rgba(255, 255, 255, 0.05);
-		color: var(--text-primary);
-	}
-
-	.btn-danger {
-		background: rgba(239, 68, 68, 0.1);
-		border-color: rgba(239, 68, 68, 0.3);
-		color: var(--error);
-	}
-	.btn-danger:hover:not(:disabled) {
-		background: rgba(239, 68, 68, 0.18);
-		border-color: rgba(239, 68, 68, 0.45);
-	}
-
-	.btn:focus-visible {
-		outline: 2px solid var(--accent);
-		outline-offset: 2px;
-	}
-	.btn:active:not(:disabled) {
-		transform: scale(0.98);
 	}
 	.btn:disabled {
-		opacity: 0.45;
-		cursor: not-allowed;
 		pointer-events: none;
 	}
-
 	.btn-content {
 		display: inline-flex;
 		align-items: center;
@@ -139,9 +71,11 @@
 		align-items: center;
 		justify-content: center;
 	}
-	.btn-primary .btn-spinner,
-	.btn-danger .btn-spinner {
-		--spinner-track: rgba(255, 255, 255, 0.35);
-		--spinner-arc: #fff;
+	.btn.primary .btn-spinner {
+		--spinner-track: rgba(22, 19, 10, 0.3);
+		--spinner-arc: var(--accent-contrast);
+	}
+	.btn.danger .btn-spinner {
+		--spinner-arc: var(--error);
 	}
 </style>

calliope-web/src/lib/components/ui/ProgressBar.svelte

@@ -4,6 +4,10 @@
 		indeterminate?: boolean;
 		label?: string;
 		size?: 'sm' | 'md';
+		/** §5 进度条: running = amber, done = green, failed = red (static). */
+		tone?: 'accent' | 'success' | 'error';
+		/** Track only — no label / percentage row. */
+		bare?: boolean;
 	}
 
 	let {
@@ -11,13 +15,15 @@
 		indeterminate = false,
 		label,
 		size = 'md',
+		tone = 'accent',
+		bare = false,
 	}: Props = $props();
 
 	const pct = $derived(Math.round(Math.min(100, Math.max(0, value))));
-	const showMeta = $derived(Boolean(label) || !indeterminate);
+	const showMeta = $derived(!bare && (Boolean(label) || !indeterminate));
 </script>
 
-<div class="progress progress-{size}">
+<div class="progress progress-{size} tone-{tone}">
 	{#if showMeta}
 		<div class="progress-meta">
 			{#if label}
@@ -69,7 +75,7 @@
 		position: relative;
 		width: 100%;
 		overflow: hidden;
-		background: var(--bg-elevated);
+		background: var(--surface-3);
 		border-radius: 999px;
 	}
 	.progress-sm .track {
@@ -82,7 +88,13 @@
 		height: 100%;
 		background: var(--accent);
 		border-radius: 999px;
-		transition: width 250ms ease;
+		transition: width 300ms cubic-bezier(0.16, 1, 0.3, 1);
+	}
+	.tone-success .fill {
+		background: var(--success);
+	}
+	.tone-error .fill {
+		background: var(--error);
 	}
 	.fill.indeterminate {
 		position: absolute;

calliope-web/src/lib/components/ui/README.md

@@ -6,7 +6,7 @@ Svelte 5 runes mode, TypeScript strict, scoped styles driven by the CSS vars in
 
 Conventions shared by all primitives:
 
-- Styling uses the global tokens (`--bg-surface`, `--border`, `--accent`, `--radius-*`, `--space-*`, fonts). Never hardcode hex colors outside this directory.
+- Styling uses the global A「片场暗房」tokens in `src/routes/app.css` (`--surface`, `--border`, `--accent`, …; legacy names such as `--bg-surface` are aliases). Button renders the shared `.a-btn` classes. Never hardcode hex colors.
 - All interactive primitives expose a `:focus-visible` accent ring. `app.css` also provides a global `:focus-visible` fallback for native elements.
 - Motion respects `prefers-reduced-motion`: `app.css` kills animation/transition durations globally; components that need a styled static fallback (Skeleton, ProgressBar indeterminate, StatusChip pulse) handle it in their own scoped styles.
 
@@ -19,7 +19,8 @@ Conventions shared by all primitives:
 | Prop       | Type                                              | Default       | Notes                                              |
 | ---------- | ------------------------------------------------- | ------------- | -------------------------------------------------- |
 | `variant`  | `'primary' \| 'secondary' \| 'ghost' \| 'danger'` | `'secondary'` | primary = `--accent` bg; danger = `--error` tinted |
-| `size`     | `'sm' \| 'md'`                                    | `'md'`        | sm = 28px, md = 34px min-height                    |
+| `size`     | `'sm' \| 'md'`                                    | `'md'`        | sm = 30px, md = 34px min-height (shared `.a-btn`)  |
+| `block`    | `boolean`                                         | `false`       | full container width (`.a-btn.block`)              |
 | `disabled` | `boolean`                                         | `false`       | reduced opacity, no pointer events                 |
 | `loading`  | `boolean`                                         | `false`       | inline spinner, disables, width stays stable       |
 | `type`     | `'button' \| 'submit' \| 'reset'`                 | `'button'`    |                                                    |
@@ -97,6 +98,8 @@ Status → color mapping (unknown strings fall back to muted and show the raw st
 | `indeterminate` | `boolean`      | `false` | sliding accent gradient, no % readout     |
 | `label`         | `string`       | —       | text above the track, also the aria-label |
 | `size`          | `'sm' \| 'md'` | `'md'`  | sm = 4px, md = 6px track                  |
+| `tone`          | `'accent' \| 'success' \| 'error'` | `'accent'` | done = success, failed = error (§5) |
+| `bare`          | `boolean`      | `false` | track only, no label / % row              |
 
 ```svelte
 <ProgressBar value={job.progress} label={job.name} />

calliope-web/src/lib/components/ui/Switch.svelte

@@ -0,0 +1,65 @@
+<script lang="ts">
+	interface Props {
+		checked: boolean;
+		label: string;
+		disabled?: boolean;
+		onchange?: (next: boolean) => void;
+	}
+
+	let { checked, label, disabled = false, onchange }: Props = $props();
+</script>
+
+<!-- §5 开关: 34×19 capsule; on = amber track + dark knob, off = --surface-3. -->
+<button
+	type="button"
+	class="switch"
+	class:on={checked}
+	role="switch"
+	aria-checked={checked}
+	aria-label={label}
+	{disabled}
+	onclick={() => onchange?.(!checked)}
+>
+	<span class="knob"></span>
+</button>
+
+<style>
+	.switch {
+		flex-shrink: 0;
+		width: 34px;
+		height: 19px;
+		border-radius: 999px;
+		border: 1px solid var(--border-strong);
+		background: var(--surface-3);
+		position: relative;
+		cursor: pointer;
+		padding: 0;
+		transition:
+			background-color 150ms,
+			border-color 150ms;
+	}
+	.switch:disabled {
+		opacity: 0.4;
+		cursor: not-allowed;
+	}
+	.knob {
+		position: absolute;
+		top: 2px;
+		left: 2px;
+		width: 15px;
+		height: 15px;
+		border-radius: 999px;
+		background: var(--text-3);
+		transition:
+			transform 150ms cubic-bezier(0.16, 1, 0.3, 1),
+			background-color 150ms;
+	}
+	.switch.on {
+		background: var(--accent);
+		border-color: var(--accent);
+	}
+	.switch.on .knob {
+		transform: translateX(15px);
+		background: var(--accent-contrast);
+	}
+</style>

calliope-web/src/lib/endpointKind.ts

@@ -0,0 +1,33 @@
+import { t } from '$lib/i18n.svelte';
+
+export type EndpointKind = 'local' | 'lan' | 'cloud';
+
+/** 本机 / 局域网 / 云端 by host — drives the blue (local, LAN) vs purple (cloud) tags (§2.1). */
+export function classifyEndpoint(rawUrl: string): EndpointKind {
+	try {
+		const u = new URL(rawUrl.trim());
+		const h = u.hostname.toLowerCase();
+		if (h === 'localhost' || h === '::1' || h.startsWith('127.')) return 'local';
+		const m = h.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+		if (m) {
+			const a = Number(m[1]);
+			const b = Number(m[2]);
+			if (a === 10 || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168)) return 'lan';
+			if (a === 169 && b === 254) return 'lan';
+			return 'cloud';
+		}
+		if (!h.includes('.') || h.endsWith('.local') || h.endsWith('.lan') || h.endsWith('.internal'))
+			return 'lan';
+		return 'cloud';
+	} catch {
+		return 'cloud';
+	}
+}
+
+export function endpointTypeLabel(kind: EndpointKind): string {
+	return kind === 'local'
+		? t('models.typeLocal')
+		: kind === 'lan'
+			? t('models.typeLan')
+			: t('models.typeCloud');
+}

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

@@ -164,6 +164,8 @@ export const de: Dict = {
 
 	// --- API errors ---
 	'api.unknownError': 'Etwas ist schiefgelaufen',
+	'api.networkError': 'Backend nicht erreichbar – prüfe, ob es läuft, und versuche es erneut',
+	'api.httpError': 'Anfrage fehlgeschlagen (HTTP {status}): {detail}',
 	'playground.openFailed': 'Playground konnte nicht geöffnet werden',
 	'playground.opening': 'Playground wird geöffnet…',
 	'agents.opening': 'Agent wird geöffnet…',
@@ -964,6 +966,27 @@ export const de: Dict = {
 	'library.emptyFilterBody': 'Für diesen Filter gibt es noch nichts – probiere „Alle“ oder erzeuge etwas Neues.',
 
 	// --- Settings ---
+	'settings.pageSub': 'Warteschlange, Agenten-Laufzeit und Speicherpfade · LLMs, ComfyUI-Verbindungen und Skills haben eigene Seiten',
+	'settings.secQueue': 'Warteschlange',
+	'settings.secQueueBlurb': 'Parallelität, Wiederholungen, Abfrage und Testlauf',
+	'settings.secAgent': 'Agenten-Laufzeit',
+	'settings.secAgentBlurb': 'Schritte, Kontext, Prompt-Härtung und Shell',
+	'settings.secStorage': 'Speicherpfade',
+	'settings.secStorageBlurb': 'Daten-, Asset- und Arbeitsordner',
+	'settings.elsewhere': 'Weitere Einstellungen',
+	'settings.linkModelsBlurb': 'LLMs und Standardmodell je Agent',
+	'settings.linkConnectionsBlurb': 'Adressen, Verbindungstests und Workflow-Bibliothek',
+	'settings.linkAgentsBlurb': 'Skills und Einzelchats der fünf Agenten',
+	'settings.dryRunTitle': 'Testlauf-Modus',
+	'settings.dryRunHint': 'Aktiv: ComfyUI wird nicht aufgerufen, Aufträge liefern Platzhalter-Bilder/-Videos zum Durchspielen; für echte Generierung ausschalten.',
+	'settings.agentRunSection': 'Agenten-Laufzeit',
+	'settings.agentRunLead': 'Begrenzt Werkzeugschritte pro Lauf und mitgeführten Verlauf.',
+	'settings.rangeHint': 'Bereich {min}–{max}',
+	'settings.loadFailed': 'Einstellungen konnten nicht geladen werden – läuft der Server?',
+	'skillName.character-consistency': 'Figurenkonsistenz',
+	'skillName.h3-video-prompt-enhancer': 'H3-Videoprompt-Verstärker',
+	'skillName.scene-to-video': 'Szene zu Video',
+	'skillName.shot-composer-blockout': 'Einstellungs-Blocking',
 	'settings.loading': 'Einstellungen werden geladen',
 	'settings.allSaved': 'Alle Änderungen gespeichert',
 	'settings.unsaved': 'Ungespeicherte Änderungen',
@@ -1010,7 +1033,7 @@ export const de: Dict = {
 	'settings.queueSection': 'Job-Warteschlange',
 	'settings.queueLead': 'Parallelität und Zeitlimits für Generierungsjobs und Agent-Tool-Aufrufe.',
 	'settings.concurrencyField': 'Gleichzeitige Jobs',
-	'settings.pollIntervalField': 'Abfrageintervall (ms)',
+	'settings.pollIntervalField': 'Abfrageintervall (s)',
 	'settings.pollTimeoutField': 'Job-Timeout (s)',
 	'settings.pollTimeoutHint': 'Wie lange ein ComfyUI-Job oder ein Agent-Tool laufen darf. 0 wartet bis zum Ende.',
 	'settings.maxRetriesField': 'Max. Wiederholungen',
@@ -1141,7 +1164,7 @@ export const de: Dict = {
 	'models.title': 'Modelle',
 	'models.subtitle': 'Eigene LLMs für Agenten anlegen · Phase 1 nur LLMs; Bild-/Videomodelle folgen später',
 	'models.statusCount': '{n} Modelle · {m} verfügbar',
-	'models.add': '＋ Modell hinzufügen',
+	'models.add': 'Modell hinzufügen',
 	'models.tabLlm': 'Sprachmodelle',
 	'models.tabImage': 'Bildmodelle',
 	'models.tabVideo': 'Videomodelle',
@@ -1225,6 +1248,7 @@ export const de: Dict = {
 
 	// --- A shell + projects overview (HEL-608) ---
 	'shell.brand': 'Film-Atelier',
+	'shell.brandMark': 'F',
 	'shell.brandHome': 'Zur Projektübersicht',
 	'shell.navAria': 'Hauptnavigation',
 	'shell.navProjects': 'Projekte',
@@ -1238,7 +1262,9 @@ export const de: Dict = {
 	'shell.navSettings': 'Einstellungen',
 	'shell.wip': 'In Entwicklung',
 	'shell.wipHint': 'Diese Seite ist noch im Bau und folgt später',
-	'shell.comfyAt': 'ComfyUI · {host}',
+	'shell.comfy_ok': '{name} verbunden',
+	'shell.comfy_fail': '{name} nicht erreichbar',
+	'shell.comfy_testing': '{name} wird getestet…',
 	'shell.comfyUnset': 'ComfyUI · nicht konfiguriert',
 	'shell.comfyManage': 'ComfyUI-Adresse in den Einstellungen pflegen',
 	'shell.mobileNotice': 'Bitte öffne diese Werkbank in einem Desktop-Browser (mindestens 768px breit); Handys werden noch nicht unterstützt.',
@@ -1293,6 +1319,13 @@ export const de: Dict = {
 	'conn.loading': 'Verbindungen werden geladen…',
 	'conn.loadFailed': 'Verbindungen konnten nicht geladen werden',
 	'conn.empty': 'Noch keine ComfyUI-Verbindung — die erste Adresse über „Verbindung hinzufügen“ eintragen.',
+	'conn.targetsTitle': 'Ausführungsziel',
+	'conn.targetImage': 'Einzelbild',
+	'conn.targetVideo': 'Einzelvideo',
+	'conn.targetFlow': 'Aufträge im Arbeitsablauf',
+	'conn.targetChange': 'Ändern',
+	'conn.targetMixed': '{n} Verbindungen',
+	'conn.targetNote': 'Aufträge folgen der Workflow-Bindung; ungebundene Workflows nutzen die Standardverbindung. Bindungen in der Workflow-Bibliothek ändern – Bild-/Videoseite können vor dem Generieren umschalten.',
 	'conn.defaultBadge': 'Standard',
 	'conn.test': 'Verbindung testen',
 	'conn.testing': 'Teste…',
@@ -1356,13 +1389,63 @@ export const de: Dict = {
 	'conn.wfParams': '{n} ausfüllbare Parameter',
 	'conn.wfImport': 'Workflow importieren',
 	'conn.wfImporting': 'Importiere…',
-	'conn.wfImported': 'Workflow importiert',
+	'conn.wfNodes': '{n} Knoten',
+	'conn.wfImportedN': 'Workflow importiert – {n} Parameter erkannt',
+	'conn.wfImportedNoParams': 'Workflow importiert, aber keine ausfüllbaren Parameter erkannt: er läuft mit seinen eingebauten Einstellungen',
 	'conn.wfImportFailed': 'Import fehlgeschlagen: {detail}',
 	'conn.wfImportTitle': 'ComfyUI-Workflow importieren (API-Format-JSON)',
 	'conn.wfImportHint': 'Einfügen oder Datei wählen; Name ist Pflicht, die Art entscheidet über Bild- oder Video-Fenster.',
 	'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) ---
@@ -1370,14 +1453,24 @@ export const de: Dict = {
 	'studio.image.subtitle': 'Bilder mit importierten Workflows erzeugen · Verbindungen & Warteschlange gemeinsam mit ComfyUI-Verbindungen',
 	'studio.video.title': 'Video',
 	'studio.video.subtitle': 'Videos mit importierten Workflows erzeugen · Verbindungen & Warteschlange gemeinsam mit ComfyUI-Verbindungen',
+	'studio.genParams': 'Parameter',
+	'studio.modeTextToImage': 'Text zu Bild',
+	'studio.modeTextToVideo': 'Text zu Video',
+	'studio.chipIdle': '{name} · Warteschlange frei',
+	'studio.chipBusy': '{name} · {n} in Warteschlange',
+	'studio.video.resultsTitle': 'Vorschau',
+	'studio.image.historyTitle': 'Bildverlauf',
+	'studio.video.historyTitle': 'Videoverlauf',
+	'studio.historyCount': '{n} gesamt',
+	'studio.lastDone': 'Zuletzt fertig · {time}',
 	'studio.kindImageText': 'Bild',
 	'studio.kindVideoText': 'Video',
 	'studio.loading': 'Lädt…',
 	'studio.connLabel': 'Verbindung',
 	'studio.connQueue': 'Warteschlange {n}',
-	'studio.connUntested': 'Ungetestet',
-	'studio.connOk': 'Letzter Test OK · {ms} ms',
-	'studio.connFail': 'Letzter Test fehlgeschlagen',
+	'studio.connUntested': 'Prüfe…',
+	'studio.connOk': 'Verbunden · {ms} ms',
+	'studio.connFail': 'Nicht erreichbar',
 	'studio.connManage': 'Verbindungen verwalten',
 	'studio.wfLabel': 'Workflow',
 	'studio.wfParams': '{n} ausfüllbare Parameter',
@@ -1440,13 +1533,48 @@ export const de: Dict = {
 	'studio.sentToImg2ImgToast': 'Als Referenzbild eingetragen — Parameter prüfen und generieren',
 	'studio.noImg2ImgWf': 'Noch kein Bild-Workflow mit Referenzbild-Eingabe — zuerst einen img2img-Workflow in ComfyUI-Verbindungen importieren',
 	'studio.videoRefStrip': 'Referenz erster / letzter Frame',
-	'studio.historyTitle': 'Verlauf',
 	'studio.historyEmptyImage': 'Noch keine Bildgenerierungen — links Parameter setzen und Generieren drücken',
 	'studio.historyEmptyVideo': 'Noch keine Videogenerierungen — links Parameter setzen und Generieren drücken',
 	'studio.jobName': 'Aufgabe #{id}',
 	'studio.retryLink': 'Erneut versuchen',
 	'studio.retryQueuedToast': 'Aufgabe wieder eingereiht',
 	'studio.retryFailedToast': 'Erneut Einreihen fehlgeschlagen: {detail}',
+	'studio.errNoWorkflow': 'Bitte zuerst einen Workflow wählen',
+	'studio.errBlocked': 'Senden nicht möglich: {reason}',
+	'studio.queuedToast': 'An „{name}“ gesendet, in der Warteschlange',
+	'studio.submitFailedToast': 'Senden fehlgeschlagen: {detail}',
+	'studio.jobFailedToast': 'Generierung fehlgeschlagen: {detail}',
+	'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',
@@ -1492,8 +1620,11 @@ export const de: Dict = {
 	'agentsPage.title': 'Agenten',
 	'agentsPage.subtitle': 'Chatte unabhängig mit den fünf Kreativ-Agenten; Skills definieren und zuweisen',
 	'agentsPage.statusChip': '{n} Skills · {m} aktiv',
-	'agentsPage.agentsTitle': 'Agent',
+	'agentsPage.agentsTitle': 'Fünf Agenten',
 	'agentsPage.skillLib': 'Skill-Bibliothek',
+	'agentsPage.skillLibCount': '{n}',
+	'agentsPage.installedTitle': '{name} · installierte Skills',
+	'agentsPage.installedCount': '{n} · {m} aktiv',
 	'agentsPage.newSkill': 'Neuer Skill',
 	'agentsPage.skillLibEmpty': 'Noch keine Skills — lege einen über „Neuer Skill“ an.',
 	'agentsPage.skillsCount': '{n} Skills',
@@ -1706,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

@@ -164,6 +164,8 @@ export const en = {
 
 	// --- API errors ---
 	'api.unknownError': 'Something went wrong',
+	'api.networkError': 'Cannot reach the workbench backend — check that it is running and retry',
+	'api.httpError': 'Request failed (HTTP {status}): {detail}',
 	'playground.openFailed': 'Failed to open playground',
 	'playground.opening': 'Opening playground…',
 	'agents.opening': 'Opening agent…',
@@ -964,6 +966,27 @@ export const en = {
 	'library.emptyFilterBody': 'Nothing matches this filter yet — try All or generate something new.',
 
 	// --- Settings ---
+	'settings.pageSub': 'Generation queue, agent runtime and storage paths · LLMs, ComfyUI connections and Skills live on their own pages',
+	'settings.secQueue': 'Queue & generation',
+	'settings.secQueueBlurb': 'Concurrency, retries, polling and dry run',
+	'settings.secAgent': 'Agent runtime',
+	'settings.secAgentBlurb': 'Steps, context, prompt hardening and shell',
+	'settings.secStorage': 'Storage paths',
+	'settings.secStorageBlurb': 'Data, assets and agent workspace folders',
+	'settings.elsewhere': 'Managed elsewhere',
+	'settings.linkModelsBlurb': 'LLMs and default model per agent',
+	'settings.linkConnectionsBlurb': 'Addresses, connection tests and workflow library',
+	'settings.linkAgentsBlurb': 'Skills and standalone chats for the five agents',
+	'settings.dryRunTitle': 'Dry-run mode',
+	'settings.dryRunHint': 'When on, ComfyUI is not called and jobs return placeholder images / videos so you can walk the flow; turn off for real generation.',
+	'settings.agentRunSection': 'Agent runtime',
+	'settings.agentRunLead': 'Caps tool-call steps per run and how much history is carried along.',
+	'settings.rangeHint': 'Range {min}–{max}',
+	'settings.loadFailed': 'Could not load settings — check that the workbench server is running',
+	'skillName.character-consistency': 'Character consistency',
+	'skillName.h3-video-prompt-enhancer': 'H3 video prompt enhancer',
+	'skillName.scene-to-video': 'Scene to video',
+	'skillName.shot-composer-blockout': 'Shot blockout',
 	'settings.loading': 'Loading settings',
 	'settings.allSaved': 'All changes saved',
 	'settings.unsaved': 'Unsaved changes',
@@ -1010,7 +1033,7 @@ export const en = {
 	'settings.queueSection': 'Job queue',
 	'settings.queueLead': 'Concurrency and timeouts for generation jobs and agent tool calls.',
 	'settings.concurrencyField': 'Concurrent jobs',
-	'settings.pollIntervalField': 'Poll interval (ms)',
+	'settings.pollIntervalField': 'Poll interval (sec)',
 	'settings.pollTimeoutField': 'Job timeout (s)',
 	'settings.pollTimeoutHint': 'How long a ComfyUI job or one agent tool call may run. 0 waits until it finishes.',
 	'settings.maxRetriesField': 'Max retries',
@@ -1143,7 +1166,7 @@ export const en = {
 	'models.title': 'Models',
 	'models.subtitle': 'Add custom LLMs for your agents · phase 1 covers LLMs only; image / video models come later',
 	'models.statusCount': '{n} models · {m} available',
-	'models.add': '＋ Add model',
+	'models.add': 'Add model',
 	'models.tabLlm': 'Language models',
 	'models.tabImage': 'Image models',
 	'models.tabVideo': 'Video models',
@@ -1227,6 +1250,7 @@ export const en = {
 
 	// --- A shell + projects overview (HEL-608) ---
 	'shell.brand': 'Film Atelier',
+	'shell.brandMark': 'F',
 	'shell.brandHome': 'Back to project overview',
 	'shell.navAria': 'Primary',
 	'shell.navProjects': 'Projects',
@@ -1240,7 +1264,9 @@ export const en = {
 	'shell.navSettings': 'Settings',
 	'shell.wip': 'In development',
 	'shell.wipHint': 'This page is under construction and will open later',
-	'shell.comfyAt': 'ComfyUI · {host}',
+	'shell.comfy_ok': '{name} connected',
+	'shell.comfy_fail': '{name} unreachable',
+	'shell.comfy_testing': 'Testing {name}…',
 	'shell.comfyUnset': 'ComfyUI · not configured',
 	'shell.comfyManage': 'Configure the ComfyUI address in Settings',
 	'shell.mobileNotice': 'Please open this workbench in a desktop browser (at least 768px wide). Phones are not supported yet.',
@@ -1293,6 +1319,13 @@ export const en = {
 	'conn.loading': 'Loading connections…',
 	'conn.loadFailed': 'Failed to load connections',
 	'conn.empty': 'No ComfyUI connections yet — add your first address with “Add connection”.',
+	'conn.targetsTitle': 'Where jobs run',
+	'conn.targetImage': 'Standalone image',
+	'conn.targetVideo': 'Standalone video',
+	'conn.targetFlow': 'Workbench jobs',
+	'conn.targetChange': 'Change',
+	'conn.targetMixed': '{n} connections',
+	'conn.targetNote': 'Jobs follow each workflow’s binding; unbound workflows use the default connection. Change bindings in the workflow library — the image / video pages can also switch before generating.',
 	'conn.defaultBadge': 'Default',
 	'conn.test': 'Test connection',
 	'conn.testing': 'Testing…',
@@ -1356,27 +1389,87 @@ export const en = {
 	'conn.wfParams': '{n} fillable parameters',
 	'conn.wfImport': 'Import workflow',
 	'conn.wfImporting': 'Importing…',
-	'conn.wfImported': 'Workflow imported',
+	'conn.wfNodes': '{n} nodes',
+	'conn.wfImportedN': 'Workflow imported — {n} fillable parameters detected',
+	'conn.wfImportedNoParams': 'Workflow imported, but no fillable parameters were detected: it will run with its built-in settings',
 	'conn.wfImportFailed': 'Import failed: {detail}',
 	'conn.wfImportTitle': 'Import ComfyUI workflow (API-format JSON)',
 	'conn.wfImportHint': 'Paste or pick a file; name is required, the kind decides whether it shows in the image or video window.',
 	'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',
 	'studio.image.subtitle': 'Generate images with imported workflows · shares connections & queue with ComfyUI Connections',
 	'studio.video.title': 'Video',
 	'studio.video.subtitle': 'Generate videos with imported workflows · shares connections & queue with ComfyUI Connections',
+	'studio.genParams': 'Parameters',
+	'studio.modeTextToImage': 'Text to image',
+	'studio.modeTextToVideo': 'Text to video',
+	'studio.chipIdle': '{name} · queue idle',
+	'studio.chipBusy': '{name} · {n} in queue',
+	'studio.video.resultsTitle': 'Preview',
+	'studio.image.historyTitle': 'Image history',
+	'studio.video.historyTitle': 'Video history',
+	'studio.historyCount': '{n} total',
+	'studio.lastDone': 'Last done · {time}',
 	'studio.kindImageText': 'image',
 	'studio.kindVideoText': 'video',
 	'studio.loading': 'Loading…',
 	'studio.connLabel': 'Connection',
 	'studio.connQueue': 'Queue {n}',
-	'studio.connUntested': 'Untested',
-	'studio.connOk': 'Last test passed · {ms} ms',
-	'studio.connFail': 'Last test failed',
+	'studio.connUntested': 'Checking…',
+	'studio.connOk': 'Connected · {ms} ms',
+	'studio.connFail': 'Unreachable',
 	'studio.connManage': 'Manage connections',
 	'studio.wfLabel': 'Workflow',
 	'studio.wfParams': '{n} fillable params',
@@ -1439,13 +1532,48 @@ export const en = {
 	'studio.sentToImg2ImgToast': 'Filled in as the reference image — check the params and generate',
 	'studio.noImg2ImgWf': 'No image workflow declares a reference-image input yet — import an img2img workflow in ComfyUI Connections first',
 	'studio.videoRefStrip': 'First / last frame reference',
-	'studio.historyTitle': 'History',
 	'studio.historyEmptyImage': 'No image generations yet — set the parameters on the left and press Generate',
 	'studio.historyEmptyVideo': 'No video generations yet — set the parameters on the left and press Generate',
 	'studio.jobName': 'Task #{id}',
 	'studio.retryLink': 'Retry',
 	'studio.retryQueuedToast': 'Task re-queued',
 	'studio.retryFailedToast': 'Re-queue failed: {detail}',
+	'studio.errNoWorkflow': 'Choose a workflow first',
+	'studio.errBlocked': 'Cannot submit: {reason}',
+	'studio.queuedToast': 'Submitted to “{name}”, queued',
+	'studio.submitFailedToast': 'Submit failed: {detail}',
+	'studio.jobFailedToast': 'Generation failed: {detail}',
+	'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',
@@ -1491,8 +1619,11 @@ export const en = {
 	'agentsPage.title': 'Agents',
 	'agentsPage.subtitle': 'Chat independently with the five creation agents; define and assign Skills',
 	'agentsPage.statusChip': '{n} Skills · {m} enabled',
-	'agentsPage.agentsTitle': 'Agent',
+	'agentsPage.agentsTitle': 'Five agents',
 	'agentsPage.skillLib': 'Skill library',
+	'agentsPage.skillLibCount': '{n}',
+	'agentsPage.installedTitle': '{name} · installed Skills',
+	'agentsPage.installedCount': '{n} · {m} on',
 	'agentsPage.newSkill': 'New Skill',
 	'agentsPage.skillLibEmpty': 'No Skills yet — create one with “New Skill” above.',
 	'agentsPage.skillsCount': '{n} Skills',
@@ -1705,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

@@ -164,6 +164,8 @@ export const es: Dict = {
 
 	// --- API errors ---
 	'api.unknownError': 'Algo salió mal',
+	'api.networkError': 'No se puede conectar con el backend; comprueba que esté en marcha y reintenta',
+	'api.httpError': 'La solicitud falló (HTTP {status}): {detail}',
 	'playground.openFailed': 'No se pudo abrir el playground',
 	'playground.opening': 'Abriendo el playground…',
 	'agents.opening': 'Abriendo el agente…',
@@ -964,6 +966,27 @@ export const es: Dict = {
 	'library.emptyFilterBody': 'Nada coincide con este filtro todavía – prueba «Todo» o genera algo nuevo.',
 
 	// --- Settings ---
+	'settings.pageSub': 'Cola de generación, ejecución de agentes y rutas · LLM, conexiones ComfyUI y Skills tienen su propia página',
+	'settings.secQueue': 'Cola y generación',
+	'settings.secQueueBlurb': 'Concurrencia, reintentos, sondeo y prueba',
+	'settings.secAgent': 'Ejecución de agentes',
+	'settings.secAgentBlurb': 'Pasos, contexto, refuerzo de prompts y shell',
+	'settings.secStorage': 'Rutas de almacenamiento',
+	'settings.secStorageBlurb': 'Carpetas de datos, recursos y espacio de trabajo',
+	'settings.elsewhere': 'Gestionado en otras páginas',
+	'settings.linkModelsBlurb': 'LLM y modelo por defecto de cada agente',
+	'settings.linkConnectionsBlurb': 'Direcciones, pruebas de conexión y biblioteca de flujos',
+	'settings.linkAgentsBlurb': 'Skills y chats independientes de los cinco agentes',
+	'settings.dryRunTitle': 'Modo de prueba',
+	'settings.dryRunHint': 'Activado: no se llama a ComfyUI y las tareas devuelven imágenes / vídeos de muestra; desactívalo para generar de verdad.',
+	'settings.agentRunSection': 'Ejecución de agentes',
+	'settings.agentRunLead': 'Limita los pasos de herramientas por ejecución y el historial incluido.',
+	'settings.rangeHint': 'Rango {min}–{max}',
+	'settings.loadFailed': 'No se pudieron cargar los ajustes: comprueba que el servidor esté activo',
+	'skillName.character-consistency': 'Coherencia de personajes',
+	'skillName.h3-video-prompt-enhancer': 'Mejora de prompts de vídeo H3',
+	'skillName.scene-to-video': 'Escena a vídeo',
+	'skillName.shot-composer-blockout': 'Encuadre previo del plano',
 	'settings.loading': 'Cargando ajustes',
 	'settings.allSaved': 'Todos los cambios guardados',
 	'settings.unsaved': 'Cambios sin guardar',
@@ -1010,7 +1033,7 @@ export const es: Dict = {
 	'settings.queueSection': 'Cola de tareas',
 	'settings.queueLead': 'Concurrencia y tiempos de espera de las tareas de generación y las llamadas de herramientas del agente.',
 	'settings.concurrencyField': 'Tareas simultáneas',
-	'settings.pollIntervalField': 'Intervalo de sondeo (ms)',
+	'settings.pollIntervalField': 'Intervalo de sondeo (s)',
 	'settings.pollTimeoutField': 'Tiempo límite de tarea (s)',
 	'settings.pollTimeoutHint': 'Cuánto puede durar un trabajo de ComfyUI o una llamada de herramienta del agente. 0 espera hasta que termine.',
 	'settings.maxRetriesField': 'Reintentos máximos',
@@ -1141,7 +1164,7 @@ export const es: Dict = {
 	'models.title': 'Modelos',
 	'models.subtitle': 'Añade LLM personalizados para tus agentes · la fase 1 solo incluye LLM; los modelos de imagen / vídeo llegarán después',
 	'models.statusCount': '{n} modelos · {m} disponibles',
-	'models.add': '＋ Añadir modelo',
+	'models.add': 'Añadir modelo',
 	'models.tabLlm': 'Modelos de lenguaje',
 	'models.tabImage': 'Modelos de imagen',
 	'models.tabVideo': 'Modelos de vídeo',
@@ -1225,6 +1248,7 @@ export const es: Dict = {
 
 	// --- A shell + projects overview (HEL-608) ---
 	'shell.brand': 'Atelier de Cine',
+	'shell.brandMark': 'A',
 	'shell.brandHome': 'Volver al resumen de proyectos',
 	'shell.navAria': 'Navegación principal',
 	'shell.navProjects': 'Proyectos',
@@ -1238,7 +1262,9 @@ export const es: Dict = {
 	'shell.navSettings': 'Ajustes',
 	'shell.wip': 'En desarrollo',
 	'shell.wipHint': 'Esta página está en construcción y llegará más adelante',
-	'shell.comfyAt': 'ComfyUI · {host}',
+	'shell.comfy_ok': '{name} conectado',
+	'shell.comfy_fail': '{name} sin conexión',
+	'shell.comfy_testing': 'Probando {name}…',
 	'shell.comfyUnset': 'ComfyUI · sin configurar',
 	'shell.comfyManage': 'Configura la dirección de ComfyUI en Ajustes',
 	'shell.mobileNotice': 'Abre este banco de trabajo en un navegador de escritorio (mínimo 768 px); los móviles aún no se admiten.',
@@ -1293,6 +1319,13 @@ export const es: Dict = {
 	'conn.loading': 'Cargando conexiones…',
 	'conn.loadFailed': 'Error al cargar las conexiones',
 	'conn.empty': 'Aún no hay conexiones ComfyUI; añade la primera dirección con «Añadir conexión».',
+	'conn.targetsTitle': 'Destino de las tareas',
+	'conn.targetImage': 'Imagen independiente',
+	'conn.targetVideo': 'Vídeo independiente',
+	'conn.targetFlow': 'Tareas del flujo creativo',
+	'conn.targetChange': 'Cambiar',
+	'conn.targetMixed': '{n} conexiones',
+	'conn.targetNote': 'Las tareas siguen la conexión de cada flujo; los no vinculados usan la predeterminada. Cambia vínculos en la biblioteca de flujos; las páginas de imagen / vídeo también permiten cambiar antes de generar.',
 	'conn.defaultBadge': 'Predeterminada',
 	'conn.test': 'Probar conexión',
 	'conn.testing': 'Probando…',
@@ -1356,13 +1389,63 @@ export const es: Dict = {
 	'conn.wfParams': '{n} parámetros rellenables',
 	'conn.wfImport': 'Importar flujo',
 	'conn.wfImporting': 'Importando…',
-	'conn.wfImported': 'Flujo importado',
+	'conn.wfNodes': '{n} nodos',
+	'conn.wfImportedN': 'Flujo importado: {n} parámetros detectados',
+	'conn.wfImportedNoParams': 'Flujo importado, pero sin parámetros rellenables: se ejecutará con su configuración interna',
 	'conn.wfImportFailed': 'Error al importar: {detail}',
 	'conn.wfImportTitle': 'Importar flujo de ComfyUI (JSON en formato API)',
 	'conn.wfImportHint': 'Pega o elige un archivo; el nombre es obligatorio y el tipo decide si aparece en la ventana de imagen o vídeo.',
 	'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) ---
@@ -1370,14 +1453,24 @@ export const es: Dict = {
 	'studio.image.subtitle': 'Genera imágenes con flujos importados · conexiones y cola compartidas con Conexiones ComfyUI',
 	'studio.video.title': 'Vídeo',
 	'studio.video.subtitle': 'Genera vídeos con flujos importados · conexiones y cola compartidas con Conexiones ComfyUI',
+	'studio.genParams': 'Parámetros',
+	'studio.modeTextToImage': 'Texto a imagen',
+	'studio.modeTextToVideo': 'Texto a vídeo',
+	'studio.chipIdle': '{name} · cola libre',
+	'studio.chipBusy': '{name} · {n} en cola',
+	'studio.video.resultsTitle': 'Vista previa',
+	'studio.image.historyTitle': 'Historial de imágenes',
+	'studio.video.historyTitle': 'Historial de vídeos',
+	'studio.historyCount': '{n} en total',
+	'studio.lastDone': 'Último · {time}',
 	'studio.kindImageText': 'imagen',
 	'studio.kindVideoText': 'vídeo',
 	'studio.loading': 'Cargando…',
 	'studio.connLabel': 'Conexión',
 	'studio.connQueue': 'Cola {n}',
-	'studio.connUntested': 'Sin probar',
-	'studio.connOk': 'Última prueba OK · {ms} ms',
-	'studio.connFail': 'Última prueba fallida',
+	'studio.connUntested': 'Comprobando…',
+	'studio.connOk': 'Conectado · {ms} ms',
+	'studio.connFail': 'Sin conexión',
 	'studio.connManage': 'Gestionar conexiones',
 	'studio.wfLabel': 'Flujo',
 	'studio.wfParams': '{n} parámetros rellenables',
@@ -1440,13 +1533,48 @@ export const es: Dict = {
 	'studio.sentToImg2ImgToast': 'Añadido como referencia; revisa los parámetros y genera',
 	'studio.noImg2ImgWf': 'Ningún flujo de imagen declara una entrada de referencia todavía; importa antes un flujo img2img en Conexiones ComfyUI',
 	'studio.videoRefStrip': 'Referencia primer / último fotograma',
-	'studio.historyTitle': 'Historial',
 	'studio.historyEmptyImage': 'Aún no hay generaciones de imagen; ajusta los parámetros y pulsa Generar',
 	'studio.historyEmptyVideo': 'Aún no hay generaciones de vídeo; ajusta los parámetros y pulsa Generar',
 	'studio.jobName': 'Tarea #{id}',
 	'studio.retryLink': 'Reintentar',
 	'studio.retryQueuedToast': 'Tarea vuelta a la cola',
 	'studio.retryFailedToast': 'Error al reencolar: {detail}',
+	'studio.errNoWorkflow': 'Elige primero un flujo',
+	'studio.errBlocked': 'No se puede enviar: {reason}',
+	'studio.queuedToast': 'Enviado a «{name}», en cola',
+	'studio.submitFailedToast': 'Error al enviar: {detail}',
+	'studio.jobFailedToast': 'La generación falló: {detail}',
+	'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',
@@ -1492,8 +1620,11 @@ export const es: Dict = {
 	'agentsPage.title': 'Agentes',
 	'agentsPage.subtitle': 'Habla de forma independiente con los cinco agentes de creación; define y asigna Skills',
 	'agentsPage.statusChip': '{n} Skills · {m} activos',
-	'agentsPage.agentsTitle': 'Agent',
+	'agentsPage.agentsTitle': 'Cinco agentes',
 	'agentsPage.skillLib': 'Biblioteca de Skills',
+	'agentsPage.skillLibCount': '{n}',
+	'agentsPage.installedTitle': '{name} · Skills instalados',
+	'agentsPage.installedCount': '{n} · {m} activos',
 	'agentsPage.newSkill': 'Nuevo Skill',
 	'agentsPage.skillLibEmpty': 'Aún no hay Skills; crea uno con «Nuevo Skill».',
 	'agentsPage.skillsCount': '{n} Skills',
@@ -1706,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

@@ -164,6 +164,8 @@ export const fr: Dict = {
 
 	// --- API errors ---
 	'api.unknownError': "Une erreur s'est produite",
+	'api.networkError': 'Impossible de joindre le backend : vérifiez qu\'il tourne puis réessayez',
+	'api.httpError': 'Échec de la requête (HTTP {status}) : {detail}',
 	'playground.openFailed': "Échec de l'ouverture du bac à sable",
 	'playground.opening': 'Ouverture du bac à sable…',
 	'agents.opening': "Ouverture de l'agent…",
@@ -964,6 +966,27 @@ export const fr: Dict = {
 	'library.emptyFilterBody': 'Rien ne correspond à ce filtre pour l’instant – essayez « Tout » ou générez quelque chose de nouveau.',
 
 	// --- Settings ---
+	'settings.pageSub': 'File de génération, exécution des agents et chemins · LLM, connexions ComfyUI et Skills ont leur propre page',
+	'settings.secQueue': 'File et génération',
+	'settings.secQueueBlurb': 'Parallélisme, relances, interrogation et essai',
+	'settings.secAgent': 'Exécution des agents',
+	'settings.secAgentBlurb': 'Étapes, contexte, durcissement des prompts et shell',
+	'settings.secStorage': 'Chemins de stockage',
+	'settings.secStorageBlurb': 'Dossiers de données, ressources et espace de travail',
+	'settings.elsewhere': 'Géré ailleurs',
+	'settings.linkModelsBlurb': 'LLM et modèle par défaut de chaque agent',
+	'settings.linkConnectionsBlurb': 'Adresses, tests de connexion et bibliothèque de workflows',
+	'settings.linkAgentsBlurb': 'Skills et discussions dédiées des cinq agents',
+	'settings.dryRunTitle': 'Mode essai',
+	'settings.dryRunHint': 'Activé : ComfyUI n’est pas appelé et les tâches renvoient des images / vidéos factices ; désactivez pour générer réellement.',
+	'settings.agentRunSection': 'Exécution des agents',
+	'settings.agentRunLead': 'Limite les étapes d’outils par exécution et l’historique transmis.',
+	'settings.rangeHint': 'Plage {min}–{max}',
+	'settings.loadFailed': 'Impossible de charger les réglages : vérifiez que le serveur tourne',
+	'skillName.character-consistency': 'Cohérence des personnages',
+	'skillName.h3-video-prompt-enhancer': 'Amélioration de prompts vidéo H3',
+	'skillName.scene-to-video': 'Scène en vidéo',
+	'skillName.shot-composer-blockout': 'Pré-cadrage du plan',
 	'settings.loading': 'Chargement des paramètres',
 	'settings.allSaved': 'Toutes les modifications sont enregistrées',
 	'settings.unsaved': 'Modifications non enregistrées',
@@ -1010,7 +1033,7 @@ export const fr: Dict = {
 	'settings.queueSection': "File d'attente",
 	'settings.queueLead': 'Parallélisme et délais des tâches de génération et des appels d’outils de l’agent.',
 	'settings.concurrencyField': 'Tâches simultanées',
-	'settings.pollIntervalField': 'Intervalle de vérification (ms)',
+	'settings.pollIntervalField': 'Intervalle de vérification (s)',
 	'settings.pollTimeoutField': 'Délai de la tâche (s)',
 	'settings.pollTimeoutHint': 'Durée maximale d’un job ComfyUI ou d’un appel d’outil de l’agent. 0 attend la fin.',
 	'settings.maxRetriesField': 'Tentatives max.',
@@ -1141,7 +1164,7 @@ export const fr: Dict = {
 	'models.title': 'Modèles',
 	'models.subtitle': 'Ajoutez des LLM personnalisés pour vos agents · la phase 1 ne couvre que les LLM ; les modèles image / vidéo arriveront ensuite',
 	'models.statusCount': '{n} modèles · {m} disponibles',
-	'models.add': '＋ Ajouter un modèle',
+	'models.add': 'Ajouter un modèle',
 	'models.tabLlm': 'Modèles de langage',
 	'models.tabImage': "Modèles d'image",
 	'models.tabVideo': 'Modèles vidéo',
@@ -1225,6 +1248,7 @@ export const fr: Dict = {
 
 	// --- A shell + projects overview (HEL-608) ---
 	'shell.brand': 'Atelier Cinéma',
+	'shell.brandMark': 'A',
 	'shell.brandHome': 'Retour à l\'aperçu des projets',
 	'shell.navAria': 'Navigation principale',
 	'shell.navProjects': 'Projets',
@@ -1238,7 +1262,9 @@ export const fr: Dict = {
 	'shell.navSettings': 'Réglages',
 	'shell.wip': 'En développement',
 	'shell.wipHint': 'Cette page est en construction et arrivera plus tard',
-	'shell.comfyAt': 'ComfyUI · {host}',
+	'shell.comfy_ok': '{name} connecté',
+	'shell.comfy_fail': '{name} injoignable',
+	'shell.comfy_testing': 'Test de {name}…',
 	'shell.comfyUnset': 'ComfyUI · non configuré',
 	'shell.comfyManage': 'Configurez l\'adresse ComfyUI dans les Réglages',
 	'shell.mobileNotice': 'Ouvrez cet atelier dans un navigateur de bureau (largeur minimum 768 px) ; les téléphones ne sont pas encore pris en charge.',
@@ -1293,6 +1319,13 @@ export const fr: Dict = {
 	'conn.loading': 'Chargement des connexions…',
 	'conn.loadFailed': 'Échec du chargement des connexions',
 	'conn.empty': 'Aucune connexion ComfyUI pour l\'instant — ajoutez la première adresse via « Ajouter une connexion ».',
+	'conn.targetsTitle': 'Cible des tâches',
+	'conn.targetImage': 'Image autonome',
+	'conn.targetVideo': 'Vidéo autonome',
+	'conn.targetFlow': 'Tâches du flux créatif',
+	'conn.targetChange': 'Modifier',
+	'conn.targetMixed': '{n} connexions',
+	'conn.targetNote': 'Les tâches suivent la liaison de chaque workflow ; sans liaison, la connexion par défaut est utilisée. Modifiez les liaisons dans la bibliothèque — les pages image / vidéo peuvent aussi changer avant génération.',
 	'conn.defaultBadge': 'Par défaut',
 	'conn.test': 'Tester la connexion',
 	'conn.testing': 'Test…',
@@ -1356,13 +1389,63 @@ export const fr: Dict = {
 	'conn.wfParams': '{n} paramètres remplissables',
 	'conn.wfImport': 'Importer le workflow',
 	'conn.wfImporting': 'Import…',
-	'conn.wfImported': 'Workflow importé',
+	'conn.wfNodes': '{n} nœuds',
+	'conn.wfImportedN': 'Workflow importé : {n} paramètres détectés',
+	'conn.wfImportedNoParams': 'Workflow importé, mais aucun paramètre détecté : il sera exécuté avec ses réglages intégrés',
 	'conn.wfImportFailed': 'Échec de l\'import : {detail}',
 	'conn.wfImportTitle': 'Importer un workflow ComfyUI (JSON format API)',
 	'conn.wfImportHint': 'Collez ou choisissez un fichier ; le nom est requis, le type décide de la fenêtre image ou vidéo.',
 	'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) ---
@@ -1370,14 +1453,24 @@ export const fr: Dict = {
 	'studio.image.subtitle': 'Générez des images avec les workflows importés · connexions et file partagées avec Connexions ComfyUI',
 	'studio.video.title': 'Vidéo',
 	'studio.video.subtitle': 'Générez des vidéos avec les workflows importés · connexions et file partagées avec Connexions ComfyUI',
+	'studio.genParams': 'Paramètres',
+	'studio.modeTextToImage': 'Texte vers image',
+	'studio.modeTextToVideo': 'Texte vers vidéo',
+	'studio.chipIdle': '{name} · file libre',
+	'studio.chipBusy': '{name} · {n} en file',
+	'studio.video.resultsTitle': 'Aperçu',
+	'studio.image.historyTitle': 'Historique images',
+	'studio.video.historyTitle': 'Historique vidéos',
+	'studio.historyCount': '{n} au total',
+	'studio.lastDone': 'Dernier · {time}',
 	'studio.kindImageText': 'image',
 	'studio.kindVideoText': 'vidéo',
 	'studio.loading': 'Chargement…',
 	'studio.connLabel': 'Connexion',
 	'studio.connQueue': 'File {n}',
-	'studio.connUntested': 'Non testée',
-	'studio.connOk': 'Dernier test OK · {ms} ms',
-	'studio.connFail': 'Dernier test échoué',
+	'studio.connUntested': 'Vérification…',
+	'studio.connOk': 'Connecté · {ms} ms',
+	'studio.connFail': 'Injoignable',
 	'studio.connManage': 'Gérer les connexions',
 	'studio.wfLabel': 'Workflow',
 	'studio.wfParams': '{n} paramètres remplissables',
@@ -1440,13 +1533,48 @@ export const fr: Dict = {
 	'studio.sentToImg2ImgToast': 'Ajouté comme référence ; vérifiez les paramètres et lancez',
 	'studio.noImg2ImgWf': 'Aucun workflow image ne déclare d’entrée de référence ; importez d’abord un workflow img2img dans Connexions ComfyUI',
 	'studio.videoRefStrip': 'Référence premier / dernier cadre',
-	'studio.historyTitle': 'Historique',
 	'studio.historyEmptyImage': 'Aucune génération d’image ; réglez les paramètres puis lancez Générer',
 	'studio.historyEmptyVideo': 'Aucune génération de vidéo ; réglez les paramètres puis lancez Générer',
 	'studio.jobName': 'Tâche #{id}',
 	'studio.retryLink': 'Réessayer',
 	'studio.retryQueuedToast': 'Tâche remise en file',
 	'studio.retryFailedToast': 'Échec de la remise en file : {detail}',
+	'studio.errNoWorkflow': 'Choisissez d\'abord un workflow',
+	'studio.errBlocked': 'Envoi impossible : {reason}',
+	'studio.queuedToast': 'Envoyé à « {name} », en file',
+	'studio.submitFailedToast': 'Échec de l\'envoi : {detail}',
+	'studio.jobFailedToast': 'Échec de la génération : {detail}',
+	'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',
@@ -1492,8 +1620,11 @@ export const fr: Dict = {
 	'agentsPage.title': 'Agents',
 	'agentsPage.subtitle': 'Discutez séparément avec les cinq agents de création ; définissez et attribuez des Skills',
 	'agentsPage.statusChip': '{n} Skills · {m} activés',
-	'agentsPage.agentsTitle': 'Agent',
+	'agentsPage.agentsTitle': 'Cinq agents',
 	'agentsPage.skillLib': 'Bibliothèque de Skills',
+	'agentsPage.skillLibCount': '{n}',
+	'agentsPage.installedTitle': '{name} · Skills installés',
+	'agentsPage.installedCount': '{n} · {m} actifs',
 	'agentsPage.newSkill': 'Nouveau Skill',
 	'agentsPage.skillLibEmpty': 'Aucun Skill pour l’instant — créez-en un avec « Nouveau Skill ».',
 	'agentsPage.skillsCount': '{n} Skills',
@@ -1706,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

@@ -164,6 +164,8 @@ export const ja: Dict = {
 
 	// --- API errors ---
 	'api.unknownError': '問題が発生しました',
+	'api.networkError': 'ワークベンチのバックエンドに接続できません。起動を確認して再試行してください',
+	'api.httpError': 'リクエスト失敗（HTTP {status}）：{detail}',
 	'playground.openFailed': 'プレイグラウンドを開けませんでした',
 	'playground.opening': 'プレイグラウンドを開いています…',
 	'agents.opening': 'エージェントを開いています…',
@@ -964,6 +966,27 @@ export const ja: Dict = {
 	'library.emptyFilterBody': 'このフィルターに一致するものはまだありません – 「すべて」を試すか、新しく生成してください。',
 
 	// --- Settings ---
+	'settings.pageSub': '生成キュー・エージェント実行・保存パス · LLM、ComfyUI 接続、Skill はそれぞれのページで管理',
+	'settings.secQueue': '生成とキュー',
+	'settings.secQueueBlurb': '並列数・再試行・ポーリング・試運転',
+	'settings.secAgent': 'エージェント実行',
+	'settings.secAgentBlurb': 'ステップ・コンテキスト・プロンプト強化・Shell',
+	'settings.secStorage': '保存パス',
+	'settings.secStorageBlurb': 'データ・素材・作業フォルダ',
+	'settings.elsewhere': 'その他の設定',
+	'settings.linkModelsBlurb': 'LLM と各エージェントの既定モデル',
+	'settings.linkConnectionsBlurb': '接続先・接続テスト・ワークフロー',
+	'settings.linkAgentsBlurb': '5 つのエージェントの Skill と個別チャット',
+	'settings.dryRunTitle': '試運転モード',
+	'settings.dryRunHint': 'オンの間は ComfyUI を呼ばず、仮の画像 / 動画を返して流れを確認できます。実際に生成するにはオフにします。',
+	'settings.agentRunSection': 'エージェント実行',
+	'settings.agentRunLead': '1 回の実行のツール呼び出し数と持ち込む履歴を制限します。',
+	'settings.rangeHint': '範囲 {min}–{max}',
+	'settings.loadFailed': '設定を読み込めません。サーバーが起動しているか確認してください',
+	'skillName.character-consistency': 'キャラクター一貫性',
+	'skillName.h3-video-prompt-enhancer': 'H3 動画プロンプト強化',
+	'skillName.scene-to-video': 'シーンから動画',
+	'skillName.shot-composer-blockout': 'ショット構図プレビュー',
 	'settings.loading': '設定を読み込み中',
 	'settings.allSaved': 'すべての変更を保存しました',
 	'settings.unsaved': '未保存の変更',
@@ -1010,7 +1033,7 @@ export const ja: Dict = {
 	'settings.queueSection': 'ジョブキュー',
 	'settings.queueLead': '生成ジョブとエージェントのツール呼び出しの並列数とタイムアウト。',
 	'settings.concurrencyField': '同時実行ジョブ数',
-	'settings.pollIntervalField': 'ポーリング間隔（ms）',
+	'settings.pollIntervalField': 'ポーリング間隔（秒）',
 	'settings.pollTimeoutField': 'ジョブタイムアウト（秒）',
 	'settings.pollTimeoutHint': 'ComfyUI のジョブ、またはエージェントのツール呼び出し 1 回の上限。0 は完了まで待つ。',
 	'settings.maxRetriesField': '最大再試行回数',
@@ -1141,7 +1164,7 @@ export const ja: Dict = {
 	'models.title': 'モデル設定',
 	'models.subtitle': 'エージェントが使うカスタム LLM を追加 · 第一段階は LLM のみ、画像 / 動画モデルは後日',
 	'models.statusCount': 'モデル {n} 件 · 利用可能 {m} 件',
-	'models.add': '＋ モデルを追加',
+	'models.add': 'モデルを追加',
 	'models.tabLlm': '大規模言語モデル',
 	'models.tabImage': '画像モデル',
 	'models.tabVideo': '動画モデル',
@@ -1225,6 +1248,7 @@ export const ja: Dict = {
 
 	// --- A shell + projects overview (HEL-608) ---
 	'shell.brand': '映画工房',
+	'shell.brandMark': '映',
 	'shell.brandHome': 'プロジェクト概要へ戻る',
 	'shell.navAria': 'メインナビゲーション',
 	'shell.navProjects': 'プロジェクト',
@@ -1238,7 +1262,9 @@ export const ja: Dict = {
 	'shell.navSettings': '設定',
 	'shell.wip': '開発中',
 	'shell.wipHint': 'このページは準備中です。後ほど公開されます',
-	'shell.comfyAt': 'ComfyUI · {host}',
+	'shell.comfy_ok': '{name} 接続済み',
+	'shell.comfy_fail': '{name} 接続失敗',
+	'shell.comfy_testing': '{name} テスト中…',
 	'shell.comfyUnset': 'ComfyUI · 未設定',
 	'shell.comfyManage': '「設定」で ComfyUI のアドレスを設定できます',
 	'shell.mobileNotice': 'このワークベンチはデスクトップブラウザ（幅 768px 以上）で開いてください。スマートフォンには未対応です。',
@@ -1293,6 +1319,13 @@ export const ja: Dict = {
 	'conn.loading': '接続を読み込み中…',
 	'conn.loadFailed': '接続情報の読み込みに失敗しました',
 	'conn.empty': 'ComfyUI 接続がまだありません。右上の「接続を追加」で最初のアドレスを登録してください。',
+	'conn.targetsTitle': 'タスクの実行先',
+	'conn.targetImage': '単体画像生成',
+	'conn.targetVideo': '単体動画生成',
+	'conn.targetFlow': '制作フロー内のタスク',
+	'conn.targetChange': '変更',
+	'conn.targetMixed': '{n} 件の接続',
+	'conn.targetNote': '各ワークフローの割り当てに従い、未割り当てなら既定の接続を使います。割り当てはワークフローライブラリで変更。画像 / 動画ページでも生成前に切り替えられます。',
 	'conn.defaultBadge': 'デフォルト',
 	'conn.test': '接続テスト',
 	'conn.testing': 'テスト中…',
@@ -1356,13 +1389,63 @@ export const ja: Dict = {
 	'conn.wfParams': '記入可能パラメータ {n} 件',
 	'conn.wfImport': 'ワークフローを取り込む',
 	'conn.wfImporting': '取り込み中…',
-	'conn.wfImported': 'ワークフローを取り込みました',
+	'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.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）---
@@ -1370,14 +1453,24 @@ export const ja: Dict = {
 	'studio.image.subtitle': '取り込んだ画像ワークフローで生成 · 接続とキューは「ComfyUI 接続」と共通',
 	'studio.video.title': '動画生成',
 	'studio.video.subtitle': '取り込んだ動画ワークフローで生成 · 接続とキューは「ComfyUI 接続」と共通',
+	'studio.genParams': '生成パラメータ',
+	'studio.modeTextToImage': 'テキストから画像',
+	'studio.modeTextToVideo': 'テキストから動画',
+	'studio.chipIdle': '{name} · キュー空き',
+	'studio.chipBusy': '{name} · キュー {n} 件',
+	'studio.video.resultsTitle': 'プレビュー',
+	'studio.image.historyTitle': '画像生成履歴',
+	'studio.video.historyTitle': '動画生成履歴',
+	'studio.historyCount': '計 {n} 回',
+	'studio.lastDone': '最終完了 · {time}',
 	'studio.kindImageText': '画像',
 	'studio.kindVideoText': '動画',
 	'studio.loading': '読み込み中…',
 	'studio.connLabel': '生成接続',
 	'studio.connQueue': 'キュー {n}',
-	'studio.connUntested': '未テスト',
-	'studio.connOk': '前回テスト成功 · {ms} ms',
-	'studio.connFail': '前回テスト失敗',
+	'studio.connUntested': '確認中…',
+	'studio.connOk': '接続済み · {ms} ms',
+	'studio.connFail': '接続失敗',
 	'studio.connManage': '接続を管理',
 	'studio.wfLabel': 'ワークフロー',
 	'studio.wfParams': '入力可能パラメータ {n} 件',
@@ -1440,13 +1533,48 @@ export const ja: Dict = {
 	'studio.sentToImg2ImgToast': '参照画像として設定しました。パラメータを確認して生成してください',
 	'studio.noImg2ImgWf': '参照画像入力を持つ画像ワークフローがまだありません。先に「ComfyUI 接続」で img2img を取り込んでください',
 	'studio.videoRefStrip': '始端 / 終端フレーム参照',
-	'studio.historyTitle': '履歴',
 	'studio.historyEmptyImage': '画像生成の記録がありません。左でパラメータを設定して生成開始',
 	'studio.historyEmptyVideo': '動画生成の記録がありません。左でパラメータを設定して生成開始',
 	'studio.jobName': 'タスク #{id}',
 	'studio.retryLink': '再試行',
 	'studio.retryQueuedToast': 'タスクを再びキューに入れました',
 	'studio.retryFailedToast': '再キュー失敗：{detail}',
+	'studio.errNoWorkflow': '先にワークフローを選択してください',
+	'studio.errBlocked': '送信できません：{reason}',
+	'studio.queuedToast': '「{name}」に送信しました（待機中）',
+	'studio.submitFailedToast': '送信失敗：{detail}',
+	'studio.jobFailedToast': '生成失敗：{detail}',
+	'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': 'タスク記録を削除',
@@ -1492,8 +1620,11 @@ export const ja: Dict = {
 	'agentsPage.title': 'エージェント',
 	'agentsPage.subtitle': '5つの制作エージェントと個別に会話し、Skill を定義・割り当て',
 	'agentsPage.statusChip': 'Skill {n} 件 · 有効 {m} 件',
-	'agentsPage.agentsTitle': 'Agent',
+	'agentsPage.agentsTitle': '5 つの Agent',
 	'agentsPage.skillLib': 'Skill ライブラリ',
+	'agentsPage.skillLibCount': '{n} 件',
+	'agentsPage.installedTitle': '{name} · 導入済み Skill',
+	'agentsPage.installedCount': '{n} 件 · {m} 有効',
 	'agentsPage.newSkill': 'Skill を追加',
 	'agentsPage.skillLibEmpty': 'Skill がありません。上の「Skill を追加」から作成してください。',
 	'agentsPage.skillsCount': 'Skill {n} 件',
@@ -1706,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

@@ -164,6 +164,8 @@ export const ko: Dict = {
 
 	// --- API errors ---
 	'api.unknownError': '문제가 발생했습니다',
+	'api.networkError': '워크벤치 백엔드에 연결할 수 없습니다. 실행 중인지 확인 후 다시 시도하세요',
+	'api.httpError': '요청 실패 (HTTP {status}): {detail}',
 	'playground.openFailed': '플레이그라운드를 열지 못했습니다',
 	'playground.opening': '플레이그라운드 여는 중…',
 	'agents.opening': '에이전트 여는 중…',
@@ -964,6 +966,27 @@ export const ko: Dict = {
 	'library.emptyFilterBody': '이 필터와 일치하는 항목이 아직 없습니다 – 전체를 시도하거나 새로 생성해 보세요.',
 
 	// --- Settings ---
+	'settings.pageSub': '생성 대기열·에이전트 실행·저장 경로 · LLM, ComfyUI 연결, Skill은 각 페이지에서 관리',
+	'settings.secQueue': '대기열 및 생성',
+	'settings.secQueueBlurb': '동시 실행, 재시도, 폴링, 시험 실행',
+	'settings.secAgent': '에이전트 실행',
+	'settings.secAgentBlurb': '단계, 컨텍스트, 프롬프트 강화, Shell',
+	'settings.secStorage': '저장 경로',
+	'settings.secStorageBlurb': '데이터·에셋·작업 폴더',
+	'settings.elsewhere': '다른 설정',
+	'settings.linkModelsBlurb': 'LLM과 에이전트별 기본 모델',
+	'settings.linkConnectionsBlurb': '주소, 연결 테스트, 워크플로 라이브러리',
+	'settings.linkAgentsBlurb': '다섯 에이전트의 Skill과 개별 대화',
+	'settings.dryRunTitle': '시험 실행 모드',
+	'settings.dryRunHint': '켜면 ComfyUI를 호출하지 않고 임시 이미지/영상을 반환해 흐름을 점검합니다. 실제 생성하려면 끄세요.',
+	'settings.agentRunSection': '에이전트 실행',
+	'settings.agentRunLead': '실행당 도구 호출 단계와 가져오는 기록을 제한합니다.',
+	'settings.rangeHint': '범위 {min}–{max}',
+	'settings.loadFailed': '설정을 불러오지 못했습니다. 서버가 실행 중인지 확인하세요',
+	'skillName.character-consistency': '캐릭터 일관성',
+	'skillName.h3-video-prompt-enhancer': 'H3 영상 프롬프트 강화',
+	'skillName.scene-to-video': '장면을 영상으로',
+	'skillName.shot-composer-blockout': '숏 구도 블로킹',
 	'settings.loading': '설정 불러오는 중',
 	'settings.allSaved': '모든 변경 사항이 저장되었습니다',
 	'settings.unsaved': '저장되지 않은 변경 사항',
@@ -1010,7 +1033,7 @@ export const ko: Dict = {
 	'settings.queueSection': '작업 대기열',
 	'settings.queueLead': '생성 작업과 에이전트 도구 호출의 동시 실행 수와 시간 초과를 설정합니다.',
 	'settings.concurrencyField': '동시 작업 수',
-	'settings.pollIntervalField': '폴링 간격 (ms)',
+	'settings.pollIntervalField': '폴링 간격 (초)',
 	'settings.pollTimeoutField': '작업 시간 초과 (초)',
 	'settings.pollTimeoutHint': 'ComfyUI 작업 또는 에이전트 도구 호출 한 번의 제한 시간. 0이면 끝날 때까지 기다립니다.',
 	'settings.maxRetriesField': '최대 재시도',
@@ -1141,7 +1164,7 @@ export const ko: Dict = {
 	'models.title': '모델 설정',
 	'models.subtitle': '에이전트가 사용할 사용자 지정 LLM을 추가합니다 · 1단계는 LLM만 지원, 이미지 / 동영상 모델은 추후 제공',
 	'models.statusCount': '모델 {n}개 · 사용 가능 {m}개',
-	'models.add': '＋ 모델 추가',
+	'models.add': '모델 추가',
 	'models.tabLlm': '대규모 언어 모델',
 	'models.tabImage': '이미지 모델',
 	'models.tabVideo': '동영상 모델',
@@ -1225,6 +1248,7 @@ export const ko: Dict = {
 
 	// --- A shell + projects overview (HEL-608) ---
 	'shell.brand': '영화 공작소',
+	'shell.brandMark': '영',
 	'shell.brandHome': '프로젝트 개요로 돌아가기',
 	'shell.navAria': '주요 탐색',
 	'shell.navProjects': '프로젝트',
@@ -1238,7 +1262,9 @@ export const ko: Dict = {
 	'shell.navSettings': '설정',
 	'shell.wip': '개발 중',
 	'shell.wipHint': '이 페이지는 준비 중이며 곧 열립니다',
-	'shell.comfyAt': 'ComfyUI · {host}',
+	'shell.comfy_ok': '{name} 연결됨',
+	'shell.comfy_fail': '{name} 연결 실패',
+	'shell.comfy_testing': '{name} 테스트 중…',
 	'shell.comfyUnset': 'ComfyUI · 미설정',
 	'shell.comfyManage': '「설정」에서 ComfyUI 주소를 설정하세요',
 	'shell.mobileNotice': '이 워크벤치는 데스크톱 브라우저(폭 768px 이상)에서 열어 주세요. 휴대폰은 아직 지원되지 않습니다.',
@@ -1293,6 +1319,13 @@ export const ko: Dict = {
 	'conn.loading': '연결 불러오는 중…',
 	'conn.loadFailed': '연결 정보를 불러오지 못했습니다',
 	'conn.empty': '아직 ComfyUI 연결이 없습니다. 우측 상단 \'연결 추가\'로 첫 주소를 등록하세요.',
+	'conn.targetsTitle': '작업 실행 대상',
+	'conn.targetImage': '단독 이미지 생성',
+	'conn.targetVideo': '단독 영상 생성',
+	'conn.targetFlow': '제작 흐름 내 작업',
+	'conn.targetChange': '변경',
+	'conn.targetMixed': '연결 {n}개',
+	'conn.targetNote': '작업은 워크플로 바인딩을 따르고, 바인딩이 없으면 기본 연결을 사용합니다. 바인딩은 워크플로 라이브러리에서 변경하며, 이미지 / 영상 페이지에서도 생성 전에 바꿀 수 있습니다.',
 	'conn.defaultBadge': '기본',
 	'conn.test': '연결 테스트',
 	'conn.testing': '테스트 중…',
@@ -1356,13 +1389,63 @@ export const ko: Dict = {
 	'conn.wfParams': '채울 수 있는 매개변수 {n}개',
 	'conn.wfImport': '워크플로 가져오기',
 	'conn.wfImporting': '가져오는 중…',
-	'conn.wfImported': '워크플로를 가져왔습니다',
+	'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.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) ---
@@ -1370,14 +1453,24 @@ export const ko: Dict = {
 	'studio.image.subtitle': '가져온 이미지 워크플로로 생성 · 연결과 큐는 ComfyUI 연결과 공유',
 	'studio.video.title': '비디오 생성',
 	'studio.video.subtitle': '가져온 비디오 워크플로로 생성 · 연결과 큐는 ComfyUI 연결과 공유',
+	'studio.genParams': '생성 매개변수',
+	'studio.modeTextToImage': '텍스트→이미지',
+	'studio.modeTextToVideo': '텍스트→영상',
+	'studio.chipIdle': '{name} · 대기열 비어 있음',
+	'studio.chipBusy': '{name} · 대기열 {n}건',
+	'studio.video.resultsTitle': '미리보기',
+	'studio.image.historyTitle': '이미지 생성 기록',
+	'studio.video.historyTitle': '영상 생성 기록',
+	'studio.historyCount': '총 {n}회',
+	'studio.lastDone': '최근 완료 · {time}',
 	'studio.kindImageText': '이미지',
 	'studio.kindVideoText': '비디오',
 	'studio.loading': '불러오는 중…',
 	'studio.connLabel': '생성 연결',
 	'studio.connQueue': '대기열 {n}',
-	'studio.connUntested': '미테스트',
-	'studio.connOk': '마지막 테스트 통과 · {ms} ms',
-	'studio.connFail': '마지막 테스트 실패',
+	'studio.connUntested': '확인 중…',
+	'studio.connOk': '연결됨 · {ms} ms',
+	'studio.connFail': '연결 실패',
 	'studio.connManage': '연결 관리',
 	'studio.wfLabel': '워크플로',
 	'studio.wfParams': '채울 수 있는 매개변수 {n}개',
@@ -1440,13 +1533,48 @@ export const ko: Dict = {
 	'studio.sentToImg2ImgToast': '참조 이미지로 채웠습니다 — 매개변수를 확인하고 생성하세요',
 	'studio.noImg2ImgWf': '참조 이미지 입력을 선언한 이미지 워크플로가 아직 없습니다. 먼저 ComfyUI 연결에서 img2img 워크플로를 가져오세요',
 	'studio.videoRefStrip': '첫 / 마지막 프레임 참조',
-	'studio.historyTitle': '기록',
 	'studio.historyEmptyImage': '이미지 생성 기록이 없습니다. 왼쪽에서 매개변수를 설정하고 생성 시작',
 	'studio.historyEmptyVideo': '비디오 생성 기록이 없습니다. 왼쪽에서 매개변수를 설정하고 생성 시작',
 	'studio.jobName': '작업 #{id}',
 	'studio.retryLink': '재시도',
 	'studio.retryQueuedToast': '작업이 다시 대기열에 들어갔습니다',
 	'studio.retryFailedToast': '재대기열 실패: {detail}',
+	'studio.errNoWorkflow': '먼저 워크플로를 선택하세요',
+	'studio.errBlocked': '제출할 수 없음: {reason}',
+	'studio.queuedToast': '“{name}”에 제출됨, 대기 중',
+	'studio.submitFailedToast': '제출 실패: {detail}',
+	'studio.jobFailedToast': '생성 실패: {detail}',
+	'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': '작업 기록 삭제',
@@ -1492,8 +1620,11 @@ export const ko: Dict = {
 	'agentsPage.title': '에이전트',
 	'agentsPage.subtitle': '다섯 제작 에이전트와 개별 대화하며 Skill을 정의·할당',
 	'agentsPage.statusChip': 'Skill {n}개 · 활성 {m}개',
-	'agentsPage.agentsTitle': 'Agent',
+	'agentsPage.agentsTitle': '다섯 Agent',
 	'agentsPage.skillLib': 'Skill 라이브러리',
+	'agentsPage.skillLibCount': '{n}개',
+	'agentsPage.installedTitle': '{name} · 설치된 Skill',
+	'agentsPage.installedCount': '{n}개 · {m} 사용',
 	'agentsPage.newSkill': 'Skill 추가',
 	'agentsPage.skillLibEmpty': 'Skill이 없습니다. 위의「Skill 추가」로 만들어 보세요.',
 	'agentsPage.skillsCount': 'Skill {n}개',
@@ -1706,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

@@ -164,6 +164,8 @@ export const zh: Dict = {
 
 	// --- API errors ---
 	'api.unknownError': '出错了',
+	'api.networkError': '无法连接到工作台后端，请确认服务在运行、网络正常后重试',
+	'api.httpError': '请求失败（HTTP {status}）：{detail}',
 	'playground.openFailed': '无法打开演练场',
 	'playground.opening': '正在打开演练场……',
 	'agents.opening': '正在打开智能体……',
@@ -964,6 +966,27 @@ export const zh: Dict = {
 	'library.emptyFilterBody': '此筛选条件暂无匹配项 – 试试“全部”或生成新内容。',
 
 	// --- Settings ---
+	'settings.pageSub': '生成队列、智能体运行与存储路径 · 大模型、ComfyUI 连接与 Skill 在各自页面管理',
+	'settings.secQueue': '生成与队列',
+	'settings.secQueueBlurb': '并发、重试、轮询与试运行',
+	'settings.secAgent': '智能体运行',
+	'settings.secAgentBlurb': '步数、上下文、提示词加固与 Shell',
+	'settings.secStorage': '存储路径',
+	'settings.secStorageBlurb': '数据、素材与智能体工作区目录',
+	'settings.elsewhere': '其他设置入口',
+	'settings.linkModelsBlurb': '大语言模型与智能体默认模型',
+	'settings.linkConnectionsBlurb': '连接地址、连通测试与工作流库',
+	'settings.linkAgentsBlurb': '五个智能体的 Skill 与独立会话',
+	'settings.dryRunTitle': '试运行模式',
+	'settings.dryRunHint': '开启后不调用 ComfyUI，生成任务直接产出占位图片 / 视频，用于走通流程；关闭后才会真实生成。',
+	'settings.agentRunSection': '智能体运行',
+	'settings.agentRunLead': '限制每次运行的工具调用步数与带入的历史上下文。',
+	'settings.rangeHint': '范围 {min}–{max}',
+	'settings.loadFailed': '设置加载失败，请检查工作台服务是否在运行',
+	'skillName.character-consistency': '角色一致性',
+	'skillName.h3-video-prompt-enhancer': 'H3 视频提示词增强',
+	'skillName.scene-to-video': '分镜转视频',
+	'skillName.shot-composer-blockout': '镜头构图预演',
 	'settings.loading': '正在加载设置',
 	'settings.allSaved': '所有更改已保存',
 	'settings.unsaved': '未保存的更改',
@@ -1010,7 +1033,7 @@ export const zh: Dict = {
 	'settings.queueSection': '任务队列',
 	'settings.queueLead': '生成任务和代理工具调用的并发数与超时设置。',
 	'settings.concurrencyField': '并发任务数',
-	'settings.pollIntervalField': '轮询间隔（毫秒）',
+	'settings.pollIntervalField': '轮询间隔（秒）',
 	'settings.pollTimeoutField': '任务超时（秒）',
 	'settings.pollTimeoutHint': 'ComfyUI 任务或单次代理工具调用的最长时长。0 表示一直等到结束。',
 	'settings.maxRetriesField': '最大重试次数',
@@ -1143,7 +1166,7 @@ export const zh: Dict = {
 	'models.title': '模型设置',
 	'models.subtitle': '添加自定义大语言模型（LLM），供智能体选用 · 第一阶段仅开放 LLM，图片 / 视频模型后续接入',
 	'models.statusCount': '{n} 个模型 · {m} 个可用',
-	'models.add': '＋ 添加模型',
+	'models.add': '添加模型',
 	'models.tabLlm': '大语言模型',
 	'models.tabImage': '图片模型',
 	'models.tabVideo': '视频模型',
@@ -1227,6 +1250,7 @@ export const zh: Dict = {
 
 	// --- A shell + projects overview (HEL-608) ---
 	'shell.brand': '影工坊',
+	'shell.brandMark': '影',
 	'shell.brandHome': '返回项目总览',
 	'shell.navAria': '主导航',
 	'shell.navProjects': '项目',
@@ -1240,7 +1264,9 @@ export const zh: Dict = {
 	'shell.navSettings': '设置',
 	'shell.wip': '开发中',
 	'shell.wipHint': '该页面正在开发中，稍后开放',
-	'shell.comfyAt': 'ComfyUI · {host}',
+	'shell.comfy_ok': '{name} 已连接',
+	'shell.comfy_fail': '{name} 连接失败',
+	'shell.comfy_testing': '{name} 测试中…',
 	'shell.comfyUnset': 'ComfyUI · 未配置',
 	'shell.comfyManage': '管理 ComfyUI 连接',
 	'shell.mobileNotice': '请用桌面浏览器（宽 768px 以上）打开影工坊，手机端暂不适配。',
@@ -1293,6 +1319,13 @@ export const zh: Dict = {
 	'conn.loading': '正在加载连接…',
 	'conn.loadFailed': '连接信息加载失败',
 	'conn.empty': '还没有 ComfyUI 连接，点右上角「添加连接」登记第一个地址。',
+	'conn.targetsTitle': '任务使用目标',
+	'conn.targetImage': '独立生图',
+	'conn.targetVideo': '独立生视频',
+	'conn.targetFlow': '创作流程内任务',
+	'conn.targetChange': '更改',
+	'conn.targetMixed': '{n} 个连接',
+	'conn.targetNote': '按工作流绑定调度，未绑定的工作流使用默认连接；在工作流库里改绑定。生图 / 生视频页也可在生成前临时切换。',
 	'conn.defaultBadge': '默认',
 	'conn.test': '测试连接',
 	'conn.testing': '测试中…',
@@ -1346,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': '图片',
@@ -1356,27 +1389,87 @@ export const zh: Dict = {
 	'conn.wfParams': '{n} 个可填参数',
 	'conn.wfImport': '导入工作流',
 	'conn.wfImporting': '导入中…',
-	'conn.wfImported': '工作流已导入',
-	'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.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.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 连接」共用',
 	'studio.video.title': '生视频',
 	'studio.video.subtitle': '用已导入的视频工作流生成视频 · 连接与队列和「ComfyUI 连接」共用',
+	'studio.genParams': '生成参数',
+	'studio.modeTextToImage': '文生图',
+	'studio.modeTextToVideo': '文生视频',
+	'studio.chipIdle': '{name} · 队列空闲',
+	'studio.chipBusy': '{name} · 队列 {n} 个任务',
+	'studio.video.resultsTitle': '成片预览',
+	'studio.image.historyTitle': '生图历史',
+	'studio.video.historyTitle': '生视频历史',
+	'studio.historyCount': '共 {n} 次',
+	'studio.lastDone': '最近完成 · {time}',
 	'studio.kindImageText': '图片',
 	'studio.kindVideoText': '视频',
 	'studio.loading': '正在加载…',
 	'studio.connLabel': '生成连接',
 	'studio.connQueue': '队列 {n}',
-	'studio.connUntested': '未测试',
-	'studio.connOk': '上次测试通过 · {ms} ms',
-	'studio.connFail': '上次测试失败',
+	'studio.connUntested': '检测中…',
+	'studio.connOk': '已连接 · {ms} ms',
+	'studio.connFail': '连接失败',
 	'studio.connManage': '管理连接',
 	'studio.wfLabel': '工作流',
 	'studio.wfParams': '{n} 个可填参数',
@@ -1439,13 +1532,49 @@ export const zh: Dict = {
 	'studio.sentToImg2ImgToast': '已填入为参考图，请检查参数后生成',
 	'studio.noImg2ImgWf': '还没有声明参考图输入的图片工作流，请先在「ComfyUI 连接」导入图生图工作流',
 	'studio.videoRefStrip': '首帧 / 尾帧参考',
-	'studio.historyTitle': '历史',
 	'studio.historyEmptyImage': '还没有生图记录，从左边填好参数点「开始生成」',
 	'studio.historyEmptyVideo': '还没有生视频记录，从左边填好参数点「开始生成」',
 	'studio.jobName': '任务 #{id}',
 	'studio.retryLink': '重试',
 	'studio.retryQueuedToast': '任务已重新排队',
 	'studio.retryFailedToast': '重新排队失败：{detail}',
+	'studio.errNoWorkflow': '请先选择工作流',
+	'studio.errBlocked': '无法提交：{reason}',
+	'studio.queuedToast': '已提交到「{name}」，排队中',
+	'studio.submitFailedToast': '提交失败：{detail}',
+	'studio.jobFailedToast': '生成失败：{detail}',
+	'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': '删除任务记录',
@@ -1491,8 +1620,11 @@ export const zh: Dict = {
 	'agentsPage.title': '智能体',
 	'agentsPage.subtitle': '与五个创作智能体独立对话，自定义并分配 Skill',
 	'agentsPage.statusChip': '{n} 个 Skill · {m} 个启用',
-	'agentsPage.agentsTitle': 'Agent',
+	'agentsPage.agentsTitle': '五个 Agent',
 	'agentsPage.skillLib': 'Skill 库',
+	'agentsPage.skillLibCount': '{n} 个',
+	'agentsPage.installedTitle': '{name} · 已装 Skill',
+	'agentsPage.installedCount': '{n} 个 · {m} 启用',
 	'agentsPage.newSkill': '新增 Skill',
 	'agentsPage.skillLibEmpty': '还没有 Skill，点上方「新增 Skill」创建一个。',
 	'agentsPage.skillsCount': '{n} 个 Skill',
@@ -1705,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/jobLabels.ts

@@ -0,0 +1,20 @@
+import type { Job } from '$lib/api';
+import { t } from '$lib/i18n.svelte';
+
+/** Where a generation job came from: 独立生图 / 独立生视频 / 创作流程 / Playground. */
+export function jobSourceLabel(job: Job): string {
+	const src = job.payload?.source;
+	if (src === 'studio-image') return t('tasks.sourceStudioImage');
+	if (src === 'studio-video') return t('tasks.sourceStudioVideo');
+	if (src === 'workbench') return t('tasks.sourceWorkbench');
+	if (src === 'playground') return t('tasks.sourcePlayground');
+	if (job.scene_id || job.clip_id) return t('tasks.sourceFlow');
+	if (!src) return t('tasks.sourceFlow');
+	return t('tasks.sourceOther');
+}
+
+/** Jobs started outside any project (standalone windows / Playground). */
+export function isStandaloneJob(job: Job): boolean {
+	const src = job.payload?.source;
+	return src === 'studio-image' || src === 'studio-video' || src === 'playground';
+}

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/lib/wideLayout.ts

@@ -0,0 +1,8 @@
+/**
+ * ≥1440px is the full-width breakpoint of the spec. There the add form
+ * of 模型设置 / ComfyUI 连接 stays open in the right column (a6 / a7);
+ * below it the form is a drawer that only opens on demand.
+ */
+export function isWideLayout(): boolean {
+	return typeof window !== 'undefined' && window.matchMedia('(min-width: 1440px)').matches;
+}

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

@@ -5,14 +5,19 @@
 	// the sample progress rendered in the mockup.
 	import { goto } from '$app/navigation';
 	import { createMutation, createQuery, useQueryClient } from '@tanstack/svelte-query';
-	import { jobsApi, projects, workbenchApi, type Project } from '$lib/api';
+	import { jobsApi, projects, workbenchApi, workflows, type Job, type Project } from '$lib/api';
 	import AppShell from '$lib/components/shell/AppShell.svelte';
 	import AProjectCard from '$lib/components/home/AProjectCard.svelte';
 	import Button from '$lib/components/ui/Button.svelte';
 	import Icon from '$lib/components/ui/Icon.svelte';
+	import ProgressBar from '$lib/components/ui/ProgressBar.svelte';
 	import Skeleton from '$lib/components/ui/Skeleton.svelte';
 	import { toast } from '$lib/toast';
 	import { t } from '$lib/i18n.svelte';
+	import { classifyEndpoint, endpointTypeLabel } from '$lib/endpointKind';
+	import { isStandaloneJob, jobSourceLabel } from '$lib/jobLabels';
+	import { progressFor } from '$lib/jobProgress';
+	import { parseDbTs } from '$lib/dbtime';
 
 	const client = useQueryClient();
 
@@ -27,8 +32,20 @@
 		refetchInterval: 8000,
 	});
 
+	const workflowsQuery = createQuery({ queryKey: ['workflows'], queryFn: workflows.list });
+
 	const allProjects = $derived($projectsQuery.data ?? []);
-	const inProgressCount = $derived(allProjects.filter((p) => p.status === 'in_progress').length);
+	// 进行中 = started the five-stage flow but not all five confirmed yet.
+	const inProgressCount = $derived(
+		allProjects.filter((p) => {
+			const st = p.stats;
+			if (!st || st.stage_confirmed >= 5) return false;
+			return (
+				st.stage_confirmed > 0 ||
+				Object.values(st.stage_status ?? {}).some((v) => v === 'running' || v === 'awaiting_confirm')
+			);
+		}).length,
+	);
 
 	// ------------------------------------------------------------------
 	// Entry flows — both open the five-stage creation workbench (a2):
@@ -195,11 +212,46 @@
 	});
 
 	const KIND_KEY: Record<string, string> = {
-		image: 'home.kindImage',
-		video: 'home.kindVideo',
+		image: 'shell.navImage',
+		video: 'shell.navVideo',
 		export: 'home.kindExport',
 	};
 
+	// a1 task row: 「本机 · 生图」 tag + the project (or workflow) name.
+	function jobTag(job: Job): { cls: string; label: string } {
+		const kind = KIND_KEY[job.kind] ? t(KIND_KEY[job.kind]) : job.kind;
+		const url = (job.payload?.endpoint as { base_url?: string } | undefined)?.base_url;
+		if (!url) return { cls: 'tag-local', label: kind };
+		const where = classifyEndpoint(url);
+		return {
+			cls: where === 'cloud' ? 'tag-cloud' : 'tag-local',
+			label: `${endpointTypeLabel(where)} · ${kind}`,
+		};
+	}
+
+	function workflowName(job: Job): string {
+		return ($workflowsQuery.data ?? []).find((w) => w.id === job.workflow_id)?.name ?? '';
+	}
+
+	function jobTitle(job: Job): string {
+		const project = isStandaloneJob(job) ? undefined : projectTitles.get(job.project_id);
+		return project ? `《${project}》` : workflowName(job) || jobSourceLabel(job);
+	}
+
+	function jobMeta(job: Job): string {
+		const wf = workflowName(job);
+		const parts = [wf === jobTitle(job) ? '' : wf, jobSourceLabel(job), formatJobTime(job.created_at)];
+		if (job.status === 'failed' && job.error && job.error !== 'cancelled') parts.push(job.error);
+		return parts.filter(Boolean).join(' · ');
+	}
+
+	function jobBar(job: Job): { value: number; tone: 'accent' | 'success' | 'error' } {
+		if (job.status === 'done') return { value: 100, tone: 'success' };
+		if (job.status === 'failed') return { value: 100, tone: 'error' };
+		if (job.status === 'running') return { value: progressFor(job.id)?.progress ?? 3, tone: 'accent' };
+		return { value: 0, tone: 'accent' };
+	}
+
 	function jobStatusLabel(status: string): string {
 		if (status === 'done') return t('home.jobDone');
 		if (status === 'running') return t('home.jobRunning');
@@ -208,10 +260,10 @@
 		return status;
 	}
 
-	function formatJobTime(iso: string): string {
-		const d = new Date(iso);
-		if (Number.isNaN(d.getTime())) return '';
-		return d.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+	function formatJobTime(raw: string): string {
+		const ts = parseDbTs(raw);
+		if (!Number.isFinite(ts)) return '';
+		return new Date(ts).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
 	}
 
 	// English values are the backend contract; display labels come from the
@@ -457,45 +509,38 @@
 			{:else}
 				<ul class="job-list">
 					{#each recentJobs as job (job.id)}
-						{@const kindKey = KIND_KEY[job.kind] ?? null}
+						{@const tag = jobTag(job)}
+						{@const bar = jobBar(job)}
 						<li class="job-row" class:failed={job.status === 'failed'}>
-							<span class="job-main">
-								{#if kindKey}<span class="tag">{t(kindKey)}</span>{/if}
-								<span
-									class="job-name"
-									title={projectTitles.get(job.project_id) ?? `#${job.project_id}`}
-								>
-									{projectTitles.get(job.project_id) ??
-										t('home.jobProject', { id: job.project_id })}
+							<div class="job-top">
+								<span class="tag {tag.cls}">{tag.label}</span>
+								<span class="job-name" title={jobTitle(job)}>{jobTitle(job)}</span>
+								<span class="job-side">
+									{#if job.status === 'failed' && job.error !== 'cancelled'}
+										<span class="job-status mono failed-text">{jobStatusLabel(job.status)}</span>
+										<button
+											type="button"
+											class="retry-link"
+											onclick={() => $retryMutation.mutate(job.id)}
+										>
+											{t('common.retry')}
+										</button>
+									{:else}
+										<span
+											class="job-status mono {job.status === 'done'
+												? 'done-text'
+												: job.status === 'running'
+													? 'running-text'
+													: 'queued-text'}"
+										>
+											{#if job.status === 'running'}<span class="dot breathe" aria-hidden="true"
+												></span>{Math.round(bar.value)}%{:else}{jobStatusLabel(job.status)}{/if}
+										</span>
+									{/if}
 								</span>
-							</span>
-							<span class="job-side">
-								{#if job.status === 'failed' && job.error && job.error !== 'cancelled'}
-									<span class="job-status mono failed-text" title={job.error}
-										>{jobStatusLabel(job.status)}</span
-									>
-									<button
-										type="button"
-										class="retry-link"
-										onclick={() => $retryMutation.mutate(job.id)}
-									>
-										{t('common.retry')}
-									</button>
-								{:else}
-									<span
-										class="job-status mono {job.status === 'done'
-											? 'done-text'
-											: job.status === 'running'
-												? 'running-text'
-												: 'queued-text'}"
-									>
-										{#if job.status === 'running'}<span class="dot breathe" aria-hidden="true"
-											></span>{/if}
-										{jobStatusLabel(job.status)}
-									</span>
-									<span class="job-time mono">{formatJobTime(job.created_at)}</span>
-								{/if}
-							</span>
+							</div>
+							<ProgressBar bare size="sm" value={bar.value} tone={bar.tone} />
+							<p class="job-meta mono" title={jobMeta(job)}>{jobMeta(job)}</p>
 						</li>
 					{/each}
 				</ul>
@@ -724,31 +769,6 @@
 		padding-top: 12px;
 		border-top: 1px solid var(--border);
 	}
-
-	/* restyle reused ui/Button inside the darkroom scope (§5) */
-	.home :global(.btn-primary) {
-		background: var(--accent);
-		color: var(--accent-contrast);
-	}
-	.home :global(.btn-primary:hover:not(:disabled)) {
-		background: var(--accent-hover);
-	}
-	.home :global(.btn-secondary) {
-		background: var(--surface-2);
-		border-color: var(--border-strong);
-		color: var(--text);
-	}
-	.home :global(.btn-secondary:hover:not(:disabled)) {
-		background: var(--surface-3);
-	}
-	.home :global(.btn-ghost) {
-		color: var(--text-2);
-	}
-	.home :global(.btn-ghost:hover:not(:disabled)) {
-		background: var(--surface-3);
-		color: var(--text);
-	}
-
 	/* ---------------- project cards ---------------- */
 	.projects-head {
 		display: flex;
@@ -866,18 +886,16 @@
 	}
 	.job-row {
 		display: flex;
-		align-items: center;
-		justify-content: space-between;
-		gap: 8px;
-		padding: 10px 0;
+		flex-direction: column;
+		gap: 7px;
+		padding: 12px 0;
 		border-bottom: 1px solid var(--border);
-		min-height: 44px;
 	}
 	.job-row:last-child {
 		border-bottom: none;
 	}
-	.job-main {
-		display: inline-flex;
+	.job-top {
+		display: flex;
 		align-items: center;
 		gap: 8px;
 		min-width: 0;
@@ -885,14 +903,24 @@
 	.tag {
 		padding: 1px 8px;
 		border-radius: 999px;
-		background: var(--info-dim);
-		color: var(--info);
 		font-size: 10.5px;
 		font-weight: 600;
 		flex-shrink: 0;
+		white-space: nowrap;
+	}
+	.tag-local {
+		background: var(--info-dim);
+		color: var(--info);
+	}
+	.tag-cloud {
+		background: var(--cloud-dim);
+		color: var(--cloud);
 	}
 	.job-name {
+		flex: 1;
+		min-width: 0;
 		font-size: 12.5px;
+		font-weight: 600;
 		color: var(--text);
 		white-space: nowrap;
 		overflow: hidden;
@@ -904,6 +932,14 @@
 		gap: 8px;
 		flex-shrink: 0;
 	}
+	.job-meta {
+		margin: 0;
+		font-size: 10.5px;
+		color: var(--text-3);
+		white-space: nowrap;
+		overflow: hidden;
+		text-overflow: ellipsis;
+	}
 	.job-status {
 		display: inline-flex;
 		align-items: center;
@@ -945,11 +981,7 @@
 			opacity: 0.35;
 		}
 	}
-	.job-time {
-		font-size: 10.5px;
-		color: var(--text-3);
-	}
-	.retry-link {
+		.retry-link {
 		background: none;
 		border: none;
 		padding: 0;

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

@@ -8,6 +8,7 @@
 	import Button from '$lib/components/ui/Button.svelte';
 	import ConfirmDialog from '$lib/components/ui/ConfirmDialog.svelte';
 	import Icon from '$lib/components/ui/Icon.svelte';
+	import Switch from '$lib/components/ui/Switch.svelte';
 	import AgentChat from '$lib/components/agent/AgentChat.svelte';
 	import {
 		agentApi,
@@ -544,6 +545,14 @@
 				: t('agentsPage.skillTypeTemplate');
 	}
 
+	// Built-in skills ship with English slugs as their directory; show a
+	// localized name when one exists, otherwise the user's own name.
+	function skillLabel(dir: string): string {
+		const key = `skillName.${dir}`;
+		const label = t(key);
+		return label === key ? dir : label;
+	}
+
 	function formatUpdatedAt(ts: number | null): string {
 		if (!ts) return '';
 		return new Date(ts * 1000).toLocaleString([], {
@@ -570,6 +579,8 @@
 		});
 	}
 
+	const installedSkills = $derived(skills.filter((s) => s.bindings?.[activeKey]));
+
 	const editingVersion = $derived(
 		editorMode === 'edit' && editingDir
 			? (skills.find((s) => s.dir === editingDir)?.version ?? '')
@@ -581,6 +592,40 @@
 	}
 </script>
 
+{#snippet skillRow(skill: SkillAdminEntry, detail: string)}
+	<div class="skill-row" class:disabled={!skill.is_enabled}>
+		<div class="skill-row-main">
+			<button
+				type="button"
+				class="skill-name"
+				title={`${skill.dir} · ${skill.description}`}
+				onclick={() => startEditSkill(skill)}
+			>
+				{skillLabel(skill.dir)}
+			</button>
+			<span class="skill-tags">
+				<span class="skill-type">{typeLabel(skill.type)}</span>
+				<span class="skill-assign">{detail}</span>
+			</span>
+		</div>
+		<div class="skill-row-actions">
+			<button
+				type="button"
+				class="icon-btn"
+				aria-label={t('agentsPage.edit')}
+				onclick={() => startEditSkill(skill)}
+			>
+				<Icon name="edit" size={14} />
+			</button>
+			<Switch
+				checked={skill.is_enabled}
+				label={t('agentsPage.toggleSkill')}
+				onchange={(next) => $toggleSkillMutation.mutate({ dir: skill.dir, next })}
+			/>
+		</div>
+	</div>
+{/snippet}
+
 {#if legacyRedirect === 'pending'}
 	<div class="redirecting">{t('agents.opening')}</div>
 {:else if legacyRedirect === 'failed'}
@@ -629,6 +674,7 @@
 
 					<div class="lib-head">
 						<p class="col-title">{t('agentsPage.skillLib')}</p>
+						<span class="col-hint">{t('agentsPage.skillLibCount', { n: skills.length })}</span>
 						<button type="button" class="a-btn primary sm" onclick={startAddSkill}>
 							<Icon name="plus" size={13} />
 							{t('agentsPage.newSkill')}
@@ -639,44 +685,7 @@
 							<p class="lib-empty">{t('agentsPage.skillLibEmpty')}</p>
 						{/if}
 						{#each skills as skill (skill.dir)}
-							<div class="skill-row" class:disabled={!skill.is_enabled}>
-								<div class="skill-row-main">
-									<button
-										type="button"
-										class="skill-name"
-										title={skill.description}
-										onclick={() => startEditSkill(skill)}
-									>
-										{skill.dir}
-									</button>
-									<span class="skill-tags">
-										<span class="skill-type">{typeLabel(skill.type)}</span>
-										<span class="skill-assign">{t('agentsPage.assigned', { n: skill.assigned_count })}</span>
-									</span>
-								</div>
-								<div class="skill-row-actions">
-									<button
-										type="button"
-										class="icon-btn"
-										aria-label={t('agentsPage.edit')}
-										onclick={() => startEditSkill(skill)}
-									>
-										<Icon name="edit" size={14} />
-									</button>
-									<button
-										type="button"
-										class="switch"
-										class:on={skill.is_enabled}
-										role="switch"
-										aria-checked={skill.is_enabled}
-										aria-label={t('agentsPage.toggleSkill')}
-										onclick={() =>
-											$toggleSkillMutation.mutate({ dir: skill.dir, next: !skill.is_enabled })}
-									>
-										<span class="knob"></span>
-									</button>
-								</div>
-							</div>
+							{@render skillRow(skill, t('agentsPage.assigned', { n: skill.assigned_count }))}
 						{/each}
 					</div>
 				</aside>
@@ -801,7 +810,15 @@
 				{/if}
 				<aside class="right" class:open={editorMode !== 'idle' || drawerOpen} aria-label={t('agentsPage.skillManage')}>
 					<div class="right-head">
-						<p class="col-title">{t('agentsPage.skillManage')}</p>
+						<p class="col-title">
+							{activeAgent ? t('agentsPage.installedTitle', { name: activeAgent.name }) : t('agentsPage.skillManage')}
+						</p>
+						<span class="col-hint">
+							{t('agentsPage.installedCount', {
+								n: installedSkills.length,
+								m: installedSkills.filter((s) => s.is_enabled).length,
+							})}
+						</span>
 						<div class="right-head-actions">
 							{#if editorMode === 'edit' && editingDir}
 								<button type="button" class="link-btn" onclick={() => loadVersions(editingDir!)}>
@@ -809,14 +826,16 @@
 									{t('agentsPage.versions')}
 								</button>
 							{/if}
-							<button
-								type="button"
-								class="icon-btn"
-								aria-label={t('agentsPage.close')}
-								onclick={resetEditor}
-							>
-								<Icon name="close" size={16} />
-							</button>
+							{#if editorMode !== 'idle' || drawerOpen}
+								<button
+									type="button"
+									class="icon-btn"
+									aria-label={t('agentsPage.close')}
+									onclick={resetEditor}
+								>
+									<Icon name="close" size={16} />
+								</button>
+							{/if}
 						</div>
 					</div>
 
@@ -846,6 +865,16 @@
 						</div>
 					{/if}
 
+					{#if installedSkills.length}
+						<div class="skill-lib installed">
+							{#each installedSkills as skill (skill.dir)}
+								{@render skillRow(
+									skill,
+									[`v${skill.version}`, formatUpdatedAt(skill.updated_at)].filter(Boolean).join(' · '),
+								)}
+							{/each}
+						</div>
+					{/if}
 					{#if editorMode === 'idle'}
 						<div class="form-idle">
 							<Icon name="sparkle" size={20} />
@@ -1038,14 +1067,6 @@
 		min-height: 0;
 	}
 
-	.status-chip {
-		padding: 5px 12px;
-		border-radius: 999px;
-		background: var(--surface-3);
-		color: var(--text-2);
-		font-size: 11.5px;
-		white-space: nowrap;
-	}
 
 	.cols {
 		display: flex;
@@ -1067,13 +1088,16 @@
 		padding-right: 2px;
 	}
 	.col-title {
-		font-size: 11.5px;
+		font-size: 14.5px;
 		font-weight: 600;
-		letter-spacing: 0.06em;
-		color: var(--text-3);
-		text-transform: uppercase;
+		color: var(--text);
 		margin: 0;
 	}
+	.col-hint {
+		font-size: 11px;
+		color: var(--text-3);
+		white-space: nowrap;
+	}
 	.agent-list {
 		display: flex;
 		flex-direction: column;
@@ -1145,10 +1169,12 @@
 	.lib-head {
 		display: flex;
 		align-items: center;
-		justify-content: space-between;
 		gap: 8px;
 		margin-top: 6px;
 	}
+	.lib-head .a-btn {
+		margin-left: auto;
+	}
 	.skill-lib {
 		display: flex;
 		flex-direction: column;
@@ -1220,37 +1246,6 @@
 		flex-shrink: 0;
 	}
 
-	/* Toggle switch (spec §5: 34×19 capsule; on = amber track, dark knob) */
-	.switch {
-		width: 34px;
-		height: 19px;
-		border-radius: 999px;
-		border: 1px solid var(--border-strong);
-		background: var(--surface-3);
-		position: relative;
-		cursor: pointer;
-		padding: 0;
-		transition: background-color 150ms, border-color 150ms;
-	}
-	.switch .knob {
-		position: absolute;
-		top: 2px;
-		left: 2px;
-		width: 15px;
-		height: 15px;
-		border-radius: 999px;
-		background: var(--text-3);
-		transition: transform 150ms cubic-bezier(0.16, 1, 0.3, 1), background-color 150ms;
-	}
-	.switch.on {
-		background: var(--accent);
-		border-color: var(--accent);
-	}
-	.switch.on .knob {
-		transform: translateX(15px);
-		background: var(--accent-contrast);
-	}
-
 	/* ── 中栏 ─────────────────────────────────────────────── */
 	.mid {
 		flex: 1;
@@ -1382,12 +1377,13 @@
 	.right-head {
 		display: flex;
 		align-items: center;
-		justify-content: space-between;
+		gap: 8px;
 	}
 	.right-head-actions {
 		display: flex;
 		align-items: center;
 		gap: 6px;
+		margin-left: auto;
 	}
 	.link-btn {
 		display: inline-flex;
@@ -1583,58 +1579,6 @@
 	.editor-actions .link-danger {
 		margin-left: auto;
 	}
-
-	/* ── 通用 ─────────────────────────────────────────────── */
-	.a-btn {
-		display: inline-flex;
-		align-items: center;
-		gap: 6px;
-		min-height: 32px;
-		padding: 0 14px;
-		border-radius: 8px;
-		font-family: inherit;
-		font-size: 12.5px;
-		font-weight: 600;
-		cursor: pointer;
-		border: 1px solid transparent;
-		transition:
-			background-color 150ms cubic-bezier(0.16, 1, 0.3, 1),
-			border-color 150ms,
-			transform 100ms;
-	}
-	.a-btn.primary {
-		background: var(--accent);
-		color: var(--accent-contrast);
-	}
-	.a-btn.primary:hover:not(:disabled) {
-		background: var(--accent-hover);
-	}
-	.a-btn.secondary {
-		background: var(--surface-2);
-		border-color: var(--border-strong);
-		color: var(--text);
-	}
-	.a-btn.secondary:hover:not(:disabled) {
-		border-color: rgba(255, 255, 255, 0.24);
-	}
-	.a-btn:disabled {
-		opacity: 0.5;
-		cursor: default;
-	}
-	.a-btn:active:not(:disabled) {
-		transform: scale(0.98);
-	}
-	.a-btn.sm {
-		min-height: 30px;
-		padding: 0 11px;
-		font-size: 12px;
-	}
-	.a-btn.xs {
-		min-height: 24px;
-		padding: 0 9px;
-		font-size: 11px;
-	}
-
 	.icon-btn {
 		display: inline-flex;
 		align-items: center;
@@ -1691,22 +1635,10 @@
 			box-shadow: 0 0 0 4px var(--accent-dim);
 		}
 	}
-
-	.a-select {
-		background: var(--surface-2);
-		border: 1px solid var(--border-strong);
-		border-radius: 8px;
-		color: var(--text);
-		font-family: inherit;
-		font-size: 12px;
-		padding: 5px 8px;
+	.chat-head-actions .a-select {
 		max-width: 220px;
+		padding: 5px 8px;
 	}
-	.a-select:focus-visible {
-		outline: none;
-		border-color: var(--accent);
-	}
-
 	.manage-btn {
 		display: none;
 	}

calliope-web/src/routes/app.css

@@ -3,66 +3,18 @@
 @tailwind utilities;
 
 :root {
-	--bg-primary: #0a0a0c;
-	--bg-surface: #141418;
-	--bg-elevated: #1e1e24;
-	--border: #2a2a32;
-	--text-primary: #f4f4f5;
-	--text-secondary: #a1a1aa;
-	--text-muted: #71717a;
-	--accent: #8b5cf6;
-	--accent-hover: #7c3aed;
-	--accent-glow: rgba(139, 92, 246, 0.25);
-	--success: #22c55e;
-	--warning: #f59e0b;
-	--error: #ef4444;
-	--info: #3b82f6;
-
-	/* Omni Composer pill tokens */
-	--pill-bg: var(--bg-elevated);
-	--pill-border: var(--border);
-	--pill-radius: 9999px;
-	--pill-height: 36px;
-	--pill-padding: 0 14px;
-	--pill-font-size: 13px;
-
-	--radius-sm: 6px;
-	--radius-md: 10px;
-	--radius-lg: 16px;
-
-	--space-xs: 4px;
-	--space-sm: 8px;
-	--space-md: 16px;
-	--space-lg: 24px;
-	--space-xl: 32px;
-
-	--font-display: 'Outfit', system-ui, sans-serif;
-	--font-body: 'IBM Plex Sans', system-ui, sans-serif;
-	--font-mono: 'JetBrains Mono', ui-monospace, monospace;
-}
-
-body {
-	background: var(--bg-primary);
-	color: var(--text-primary);
-	font-family: var(--font-body);
-	margin: 0;
-	min-height: 100vh;
-}
-
-/* ------------------------------------------------------------------
- * A「片场暗房」scoped design tokens — spec-v2 §2 (HEL-603 confirmed).
- * Adopted incrementally by new A-style pages via the `.a-darkroom`
- * wrapper; graduates to :root when the full A shell (216px nav) lands.
- * Values are the single source of truth for A pages — do not hardcode
- * colors inside pages, and do not override these with ad-hoc CSS.
- * ------------------------------------------------------------------ */
-.a-darkroom {
+	/* ------------------------------------------------------------------
+	 * A「片场暗房」design tokens — spec-v2 §2 (HEL-603 confirmed).
+	 * Single source of truth for the whole app: do not hardcode colors in
+	 * pages or components, and do not override these with ad-hoc CSS.
+	 * ------------------------------------------------------------------ */
 	--bg: #0d0e11;
 	--surface: #14161b;
 	--surface-2: #1b1e25;
 	--surface-3: #22262f;
 	--border: rgba(255, 255, 255, 0.07);
 	--border-strong: rgba(255, 255, 255, 0.14);
+	--border-hover: rgba(255, 255, 255, 0.24);
 	--text: #edeef0;
 	--text-2: #9ba1ab;
 	--text-3: #5c626c;
@@ -71,19 +23,17 @@ body {
 	--accent-contrast: #16130a;
 	--accent-dim: rgba(232, 163, 61, 0.14);
 	--accent-glow: rgba(232, 163, 61, 0.35);
+	--accent-focus: rgba(232, 163, 61, 0.6);
 	--success: #3fb97f;
 	--success-dim: rgba(63, 185, 127, 0.14);
 	--info: #5b8def;
 	--info-dim: rgba(91, 141, 239, 0.14);
 	--error: #e5484d;
 	--error-dim: rgba(229, 72, 77, 0.14);
+	--error-border: rgba(229, 72, 77, 0.4);
 	--cloud: #b98be0;
 	--cloud-dim: rgba(185, 139, 224, 0.14);
 
-	/* Typography (§2.2) */
-	--font-ui: 'Noto Sans SC', 'Noto Sans CJK SC', var(--font-body);
-	--font-a-mono: 'JetBrains Mono', 'IBM Plex Mono', ui-monospace, monospace;
-
 	/* Avatar five-color set (§2.1) — five agents only */
 	--avatar-1: linear-gradient(135deg, #e8a33d, #b96a1b);
 	--avatar-2: linear-gradient(135deg, #5b8def, #3a5fa9);
@@ -91,6 +41,52 @@ body {
 	--avatar-4: linear-gradient(135deg, #b98be0, #7a4fa9);
 	--avatar-5: linear-gradient(135deg, #d98e6a, #a95535);
 
+	/* Typography (§2.2) */
+	--font-ui: 'Noto Sans SC', 'Noto Sans CJK SC', sans-serif;
+	--font-a-mono: 'JetBrains Mono', 'IBM Plex Mono', ui-monospace, monospace;
+
+	/* Radius / spacing (§2.3) */
+	--radius-sm: 7px;
+	--radius-md: 10px;
+	--radius-lg: 10px;
+
+	--space-xs: 4px;
+	--space-sm: 8px;
+	--space-md: 16px;
+	--space-lg: 24px;
+	--space-xl: 32px;
+
+	/* Legacy token names used by shared primitives — aliases of the A set,
+	   so every component renders in the same darkroom palette. */
+	--bg-primary: var(--bg);
+	--bg-surface: var(--surface);
+	--bg-elevated: var(--surface-2);
+	--text-primary: var(--text);
+	--text-secondary: var(--text-2);
+	--text-muted: var(--text-3);
+	--warning: var(--accent);
+	--font-display: var(--font-ui);
+	--font-body: var(--font-ui);
+	--font-mono: var(--font-a-mono);
+
+	/* Omni Composer pill tokens */
+	--pill-bg: var(--surface-2);
+	--pill-border: var(--border-strong);
+	--pill-radius: 9999px;
+	--pill-height: 36px;
+	--pill-padding: 0 14px;
+	--pill-font-size: 13px;
+}
+
+body {
+	background: var(--bg);
+	color: var(--text);
+	font-family: var(--font-ui);
+	margin: 0;
+	min-height: 100vh;
+}
+
+.a-darkroom {
 	background: var(--bg);
 	color: var(--text);
 	font-family: var(--font-ui);
@@ -98,72 +94,233 @@ body {
 	line-height: 1.6;
 }
 
-.a-darkroom .mono,
-.a-darkroom code,
-.a-darkroom .kh {
+code,
+.mono,
+.kh {
 	font-family: var(--font-a-mono);
 	font-variant-numeric: tabular-nums;
 }
 
-h1,
-h2,
-h3,
-.logo {
-	font-family: var(--font-display);
+/* ------------------------------------------------------------------
+ * Shared A controls (§5 组件状态全表). The only definitions of these
+ * looks — `ui/Button.svelte` renders `.a-btn`, pages use the classes
+ * directly for links / selects. Page styles may only tweak layout
+ * (width / margin), never re-declare colors.
+ * ------------------------------------------------------------------ */
+.a-btn {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	gap: 6px;
+	min-height: 34px;
+	padding: 0 16px;
+	border-radius: 8px;
+	border: 1px solid transparent;
+	font-family: inherit;
+	font-size: 13px;
+	font-weight: 600;
+	white-space: nowrap;
+	text-decoration: none;
+	cursor: pointer;
+	box-sizing: border-box;
+	transition:
+		background-color 150ms cubic-bezier(0.16, 1, 0.3, 1),
+		border-color 150ms,
+		color 150ms,
+		transform 100ms;
+}
+.a-btn.sm {
+	min-height: 30px;
+	padding: 0 12px;
+	font-size: 12px;
+}
+.a-btn.xs {
+	min-height: 24px;
+	padding: 0 9px;
+	font-size: 11px;
+}
+.a-btn.block {
+	width: 100%;
+}
+.a-btn.primary {
+	background: var(--accent);
+	color: var(--accent-contrast);
+}
+.a-btn.primary:hover:not(:disabled) {
+	background: var(--accent-hover);
+}
+.a-btn.secondary {
+	background: var(--surface-2);
+	border-color: var(--border-strong);
+	color: var(--text);
+}
+.a-btn.secondary:hover:not(:disabled) {
+	border-color: var(--border-hover);
+}
+.a-btn.ghost {
+	background: transparent;
+	color: var(--text-2);
+}
+.a-btn.ghost:hover:not(:disabled) {
+	background: var(--surface-3);
+	color: var(--text);
+}
+.a-btn.danger {
+	background: transparent;
+	border-color: var(--error-border);
+	color: var(--error);
+}
+.a-btn.danger:hover:not(:disabled) {
+	background: var(--error-dim);
+}
+.a-btn:active:not(:disabled) {
+	transform: scale(0.98);
+}
+.a-btn:disabled,
+.a-btn[aria-disabled='true'] {
+	opacity: 0.4;
+	cursor: not-allowed;
 }
 
-code,
-.mono {
-	font-family: var(--font-mono);
+/* Top-bar status capsule (counts / save state / connection). */
+.status-chip {
+	display: inline-flex;
+	align-items: center;
+	gap: 6px;
+	padding: 5px 12px;
+	border-radius: 999px;
+	background: var(--surface-3);
+	color: var(--text-2);
+	font-size: 11.5px;
+	white-space: nowrap;
+}
+.status-chip.accent {
+	background: var(--accent-dim);
+	color: var(--accent);
+}
+.status-chip-dot {
+	width: 6px;
+	height: 6px;
+	border-radius: 50%;
+	flex-shrink: 0;
+	background: currentColor;
+}
+.status-chip-dot.ok {
+	background: var(--success);
+}
+.status-chip-dot.fail {
+	background: var(--error);
+}
+.status-chip-dot.idle {
+	background: var(--text-3);
+}
+
+/* Card / panel surface (§2.3: 10px radius, 1px border, no shadow). */
+.a-panel {
+	background: var(--surface);
+	border: 1px solid var(--border);
+	border-radius: 10px;
+	padding: 20px 22px;
+	box-sizing: border-box;
+}
+.a-panel-title {
+	margin: 0;
+	font-size: 14.5px;
+	font-weight: 600;
+	color: var(--text);
+}
+.a-panel-lead {
+	margin: 4px 0 0;
+	font-size: 12px;
+	line-height: 1.6;
+	color: var(--text-3);
+}
+
+.a-select,
+.a-input,
+.a-textarea,
+.field-input,
+.field-textarea,
+.field-select {
+	box-sizing: border-box;
+	background: var(--surface-2);
+	border: 1px solid var(--border-strong);
+	border-radius: 7px;
+	color: var(--text);
+	font-family: inherit;
+	font-size: 12.5px;
+	transition: border-color 150ms cubic-bezier(0.16, 1, 0.3, 1);
+}
+.a-select {
+	padding: 7px 9px;
+	cursor: pointer;
+}
+.a-input,
+.field-input,
+.field-select {
+	width: 100%;
+	padding: 8px 11px;
+}
+.a-textarea,
+.field-textarea {
+	width: 100%;
+	padding: 9px 11px;
+	resize: vertical;
+	min-height: 96px;
+	line-height: 1.6;
+}
+.a-select:hover,
+.a-input:hover,
+.a-textarea:hover,
+.field-input:hover,
+.field-textarea:hover,
+.field-select:hover {
+	border-color: var(--border-hover);
+}
+.a-select:focus,
+.a-input:focus,
+.a-textarea:focus,
+.field-input:focus,
+.field-textarea:focus,
+.field-select:focus {
+	outline: none;
+	border-color: var(--accent-focus);
+}
+.a-input.invalid,
+.a-textarea.invalid,
+.field-input.invalid {
+	border-color: var(--error);
+}
+.a-select option.unavailable {
+	color: var(--text-3);
 }
 
 .field {
 	display: block;
-	margin-bottom: var(--space-md);
+	margin-bottom: 14px;
 }
 .field-label {
 	display: block;
 	font-size: 12px;
 	font-weight: 500;
-	letter-spacing: 0.02em;
-	color: var(--text-muted);
+	color: var(--text-2);
 	margin-bottom: 6px;
 }
-.field-input,
-.field-textarea,
-.field-select {
-	width: 100%;
-	box-sizing: border-box;
-	background: var(--bg-elevated);
-	border: 1px solid var(--border);
-	border-radius: var(--radius-sm);
-	padding: 10px 12px;
-	color: var(--text-primary);
-	font-size: 14px;
-	font-family: inherit;
-}
-.field-textarea {
-	resize: vertical;
-	min-height: 96px;
-	line-height: 1.5;
-}
-.field-input:focus,
-.field-textarea:focus,
-.field-select:focus {
-	outline: none;
-	border-color: var(--accent);
-	box-shadow: 0 0 0 3px var(--accent-glow);
-}
 .field-hint {
-	margin-top: 6px;
-	font-size: 12px;
-	color: var(--text-muted);
+	margin: 6px 0 0;
+	font-size: 11.5px;
+	color: var(--text-3);
+}
+.field-error {
+	margin: 6px 0 0;
+	font-size: 11.5px;
+	color: var(--error);
 }
 
 /* Dark theme scrollbars (Firefox + Chromium) */
 * {
 	scrollbar-width: thin;
-	scrollbar-color: #3f3f46 transparent;
+	scrollbar-color: var(--surface-3) transparent;
 }
 
 *::-webkit-scrollbar {
@@ -176,14 +333,14 @@ code,
 }
 
 *::-webkit-scrollbar-thumb {
-	background: #3f3f46;
+	background: var(--surface-3);
 	border-radius: 999px;
 	border: 2px solid transparent;
 	background-clip: padding-box;
 }
 
 *::-webkit-scrollbar-thumb:hover {
-	background: #52525b;
+	background: var(--text-3);
 	border: 2px solid transparent;
 	background-clip: padding-box;
 }

calliope-web/src/routes/build-scene/+page.ts

@@ -0,0 +1,8 @@
+import { redirect } from '@sveltejs/kit';
+
+export const ssr = false;
+export const prerender = false;
+
+export function load() {
+	redirect(308, '/');
+}

calliope-web/src/routes/canvas/+page.ts

@@ -1,2 +1,8 @@
+import { redirect } from '@sveltejs/kit';
+
 export const ssr = false;
 export const prerender = false;
+
+export function load() {
+	redirect(308, '/');
+}

calliope-web/src/routes/canvas/[id]/+page.ts

@@ -1,2 +1,8 @@
+import { redirect } from '@sveltejs/kit';
+
 export const ssr = false;
 export const prerender = false;
+
+export function load() {
+	redirect(308, '/');
+}

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

@@ -1,9 +1,5 @@
 <script lang="ts">
-	import AppShell from '$lib/components/shell/AppShell.svelte';
 	import StudioGenerate from '$lib/components/studio/StudioGenerate.svelte';
-	import { t } from '$lib/i18n.svelte';
 </script>
 
-<AppShell active="image" title={t('studio.image.title')} subtitle={t('studio.image.subtitle')}>
-	<StudioGenerate kind="image" />
-</AppShell>
+<StudioGenerate kind="image" />

calliope-web/src/routes/library/+page.ts

@@ -0,0 +1,8 @@
+import { redirect } from '@sveltejs/kit';
+
+export const ssr = false;
+export const prerender = false;
+
+export function load() {
+	redirect(308, '/');
+}

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

@@ -1,5 +1,6 @@
 <script lang="ts">
 	import { createMutation, createQuery, useQueryClient } from '@tanstack/svelte-query';
+	import { untrack } from 'svelte';
 	import { fade } from 'svelte/transition';
 	import AppShell from '$lib/components/shell/AppShell.svelte';
 	import Button from '$lib/components/ui/Button.svelte';
@@ -10,6 +11,8 @@
 	import { randomId } from '$lib/ids';
 	import { toast } from '$lib/toast';
 	import { t } from '$lib/i18n.svelte';
+	import { classifyEndpoint, endpointTypeLabel } from '$lib/endpointKind';
+	import { isWideLayout } from '$lib/wideLayout';
 
 	const client = useQueryClient();
 
@@ -66,7 +69,7 @@
 	// Form state — add / edit custom LLM (spec §9.3)
 	// ------------------------------------------------------------------
 	type FormMode = 'idle' | 'add' | 'edit';
-	let formMode = $state<FormMode>('idle');
+	let formMode = $state<FormMode>(isWideLayout() ? 'add' : 'idle');
 	let editingId = $state<string | null>(null);
 	let form = $state({ name: '', baseUrl: '', model: '', apiKey: '', timeout: 10 });
 	let formTest = $state<{ ok: boolean; ms?: number } | null>(null);
@@ -77,7 +80,7 @@
 	const TIMEOUT_OPTIONS = [5, 10, 15, 30, 60];
 
 	function resetForm() {
-		formMode = 'idle';
+		formMode = isWideLayout() ? 'add' : 'idle';
 		editingId = null;
 		form = { name: '', baseUrl: '', model: '', apiKey: '', timeout: 10 };
 		formTest = null;
@@ -426,35 +429,6 @@
 	// ------------------------------------------------------------------
 	// Helpers
 	// ------------------------------------------------------------------
-	function classifyEndpoint(rawUrl: string): 'local' | 'lan' | 'cloud' {
-		try {
-			const u = new URL(rawUrl.trim());
-			const h = u.hostname.toLowerCase();
-			if (h === 'localhost' || h === '::1' || h.startsWith('127.')) return 'local';
-			const m = h.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
-			if (m) {
-				const a = Number(m[1]);
-				const b = Number(m[2]);
-				if (a === 10 || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168)) return 'lan';
-				if (a === 169 && b === 254) return 'lan';
-				return 'cloud';
-			}
-			if (!h.includes('.') || h.endsWith('.local') || h.endsWith('.lan') || h.endsWith('.internal'))
-				return 'lan';
-			return 'cloud';
-		} catch {
-			return 'cloud';
-		}
-	}
-
-	function typeLabel(kind: 'local' | 'lan' | 'cloud'): string {
-		return kind === 'local'
-			? t('models.typeLocal')
-			: kind === 'lan'
-				? t('models.typeLan')
-				: t('models.typeCloud');
-	}
-
 	function formatTime(at: number): string {
 		return new Date(at).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
 	}
@@ -470,6 +444,22 @@
 		const data = $settingsQuery.data;
 		if (data) pruneTests(data.llm_profiles.map((p) => p.id));
 	});
+
+	// Test each model once per visit (1-token probe) so the cards show real
+	// state instead of 「未测试」; results younger than 10 minutes are reused.
+	const autoProbed = new Set<string>();
+	$effect(() => {
+		const list = $settingsQuery.data?.llm_profiles ?? [];
+		untrack(() => {
+			const now = Date.now();
+			for (const p of list) {
+				if (autoProbed.has(p.id)) continue;
+				autoProbed.add(p.id);
+				const rec = tests[p.id];
+				if (!rec || now - rec.at > 600_000) void testProfile(p);
+			}
+		});
+	});
 </script>
 
 <AppShell active="models" title={t('models.title')} subtitle={t('models.subtitle')}>
@@ -533,7 +523,7 @@
 									<div class="card-row">
 										<span class="card-icon"><Icon name="sparkle" size={18} /></span>
 										<span class="card-name">{profile.name}</span>
-										<span class="tag tag-{kind}">{typeLabel(kind)}</span>
+										<span class="tag tag-{kind}">{endpointTypeLabel(kind)}</span>
 										{#if isActive}
 											<span class="tag tag-default">{t('models.defaultBadge')}</span>
 										{/if}
@@ -676,14 +666,16 @@
 							<h2>
 								{formMode === 'add' ? t('models.formTitleAdd') : t('models.formTitleEdit')}
 							</h2>
-							<button
-								type="button"
-								class="icon-btn"
-								aria-label={t('models.formClose')}
-								onclick={resetForm}
-							>
-								<Icon name="close" size={16} />
-							</button>
+							{#if formMode === 'edit' || !isWideLayout()}
+								<button
+									type="button"
+									class="icon-btn"
+									aria-label={t('models.formClose')}
+									onclick={resetForm}
+								>
+									<Icon name="close" size={16} />
+								</button>
+							{/if}
 						</div>
 
 						<label class="f-field">
@@ -864,53 +856,6 @@
 	}
 
 	/* ---------------- topbar chip + button (§9.1, rendered in AppShell) ---------------- */
-	.status-chip {
-		padding: 5px 12px;
-		border-radius: 999px;
-		background: var(--surface-3);
-		color: var(--text-2);
-		font-size: 11.5px;
-		white-space: nowrap;
-	}
-
-	/* Amber primary / outline secondary per §5 — only one amber button per
-	   screen: the header one steps back to outline while the form is open. */
-	.a-btn {
-		display: inline-flex;
-		align-items: center;
-		gap: 6px;
-		min-height: 34px;
-		padding: 0 16px;
-		border-radius: 8px;
-		font-family: inherit;
-		font-size: 13px;
-		font-weight: 600;
-		cursor: pointer;
-		border: 1px solid transparent;
-		transition:
-			background-color 150ms cubic-bezier(0.16, 1, 0.3, 1),
-			border-color 150ms,
-			transform 100ms;
-	}
-	.a-btn.primary {
-		background: var(--accent);
-		color: var(--accent-contrast);
-	}
-	.a-btn.primary:hover {
-		background: var(--accent-hover);
-	}
-	.a-btn.secondary {
-		background: var(--surface-2);
-		border-color: var(--border-strong);
-		color: var(--text);
-	}
-	.a-btn.secondary:hover {
-		border-color: rgba(255, 255, 255, 0.24);
-	}
-	.a-btn:active {
-		transform: scale(0.98);
-	}
-
 	/* ---------------- tabs (§9.1 / §9.8 .tab) ---------------- */
 	.tabs {
 		display: flex;
@@ -1240,26 +1185,6 @@
 		font-weight: 600;
 		color: var(--text);
 	}
-	.a-select {
-		width: 100%;
-		box-sizing: border-box;
-		background: var(--surface-2);
-		border: 1px solid var(--border-strong);
-		border-radius: 7px;
-		padding: 7px 9px;
-		color: var(--text);
-		font-family: inherit;
-		font-size: 12px;
-		cursor: pointer;
-	}
-	.a-select:focus {
-		outline: none;
-		border-color: rgba(232, 163, 61, 0.6);
-	}
-	.a-select option.unavailable {
-		color: var(--text-3);
-	}
-
 	/* ---------------- form column (§9.3) ---------------- */
 	.form-col {
 		width: 384px;
@@ -1459,35 +1384,6 @@
 	.need-test.passed {
 		color: var(--success);
 	}
-
-	/* Reused ui/Button restyled inside the darkroom token scope (§5) */
-	.page :global(.btn-secondary) {
-		background: var(--surface-2);
-		border-color: var(--border-strong);
-		color: var(--text);
-	}
-	.page :global(.btn-secondary:hover:not(:disabled)) {
-		background: var(--surface-3);
-		border-color: rgba(255, 255, 255, 0.24);
-	}
-	.page :global(.btn-primary) {
-		background: var(--accent);
-		color: var(--accent-contrast);
-	}
-	.page :global(.btn-primary:hover:not(:disabled)) {
-		background: var(--accent-hover);
-	}
-	.page :global(.btn-ghost) {
-		color: var(--text-2);
-	}
-	.page :global(.btn-ghost:hover:not(:disabled)) {
-		background: var(--surface-3);
-		color: var(--text);
-	}
-	.page :global(.btn:focus-visible) {
-		outline-color: var(--accent);
-	}
-
 	.drawer-backdrop {
 		display: none;
 	}
@@ -1499,6 +1395,7 @@
 		}
 		.layout {
 			flex-direction: column;
+			align-items: stretch;
 		}
 		/* form becomes a right drawer (372px) */
 		.form-col {

calliope-web/src/routes/playground/+page.ts

@@ -1,2 +1,8 @@
+import { redirect } from '@sveltejs/kit';
+
 export const ssr = false;
 export const prerender = false;
+
+export function load() {
+	redirect(308, '/');
+}

calliope-web/src/routes/project/[id]/+page.ts

@@ -1,8 +1,9 @@
+import { redirect } from '@sveltejs/kit';
 import type { PageLoad } from './$types';
 
 export const prerender = false;
 export const ssr = false;
 
 export const load: PageLoad = ({ params }) => {
-	return { id: params.id };
+	redirect(308, `/workbench/${params.id}`);
 };

calliope-web/src/routes/projects/+page.ts

@@ -1,6 +1,8 @@
-export const prerender = false;
+import { redirect } from '@sveltejs/kit';
+
 export const ssr = false;
+export const prerender = false;
 
 export function load() {
-	return {};
+	redirect(308, '/');
 }

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

@@ -8,14 +8,17 @@
 		assetUrl,
 		jobsApi,
 		playgroundApi,
+		projects,
 		workflows,
 		type Job,
 	} 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';
 
 	/**
 	 * 生成任务页 (spec-v2 §3 nav item, HEL-612): one table summing both
@@ -30,6 +33,7 @@
 		refetchInterval: 5_000,
 	});
 	const workflowsQuery = createQuery({ queryKey: ['workflows'], queryFn: workflows.list });
+	const projectsQuery = createQuery({ queryKey: ['projects'], queryFn: projects.list });
 
 	$effect(() => {
 		const off = connectEvents((ev) => {
@@ -51,17 +55,6 @@
 	const shown = $derived(filter === 'all' ? genJobs : genJobs.filter((j) => j.kind === filter));
 	const activeCount = $derived(genJobs.filter((j) => j.status === 'pending' || j.status === 'running').length);
 
-	function sourceLabel(job: Job): string {
-		const src = job.payload?.source;
-		if (src === 'studio-image') return t('tasks.sourceStudioImage');
-		if (src === 'studio-video') return t('tasks.sourceStudioVideo');
-		if (src === 'workbench') return t('tasks.sourceWorkbench');
-		if (src === 'playground') return t('tasks.sourcePlayground');
-		if (job.scene_id || job.clip_id) return t('tasks.sourceFlow');
-		if (!src) return t('tasks.sourceFlow');
-		return t('tasks.sourceOther');
-	}
-
 	function wfName(job: Job): string {
 		return (
 			($workflowsQuery.data ?? []).find((w) => w.id === job.workflow_id)?.name ??
@@ -69,6 +62,12 @@
 		);
 	}
 
+	function projectOf(job: Job): string {
+		if (isStandaloneJob(job)) return '';
+		const title = ($projectsQuery.data ?? []).find((p) => p.id === job.project_id)?.title;
+		return title ? `《${title}》` : '';
+	}
+
 	function timeOf(job: Job): string {
 		const ts = parseDbTs(job.created_at);
 		if (!Number.isFinite(ts)) return '—';
@@ -77,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) {
@@ -166,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} />
@@ -183,13 +170,15 @@
 						<div class="tmain">
 							<div class="tname" title={wfName(job)}>{wfName(job)}</div>
 							<div class="tmeta mono">
-								{sourceLabel(job)} · {timeOf(job)}
+								{#if projectOf(job)}{projectOf(job)} · {/if}{jobSourceLabel(job)} · {timeOf(job)}
 								{#if (job.output_paths?.length ?? 0) > 0}
 									· {t('tasks.outputs', { n: job.output_paths.length })}
 								{/if}
 							</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">
@@ -207,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)}>
@@ -219,7 +208,7 @@
 									{t('tasks.cancel')}
 								</button>
 							{/if}
-							{#if job.payload?.source === 'studio-image' || job.payload?.source === 'studio-video' || job.payload?.source === 'playground'}
+							{#if isStandaloneJob(job)}
 								<button
 									type="button"
 									class="link-danger"
@@ -265,14 +254,6 @@
 		gap: 18px;
 	}
 
-	.status-chip {
-		padding: 5px 12px;
-		border-radius: 999px;
-		background: var(--surface-3);
-		color: var(--text-2);
-		font-size: 11.5px;
-		white-space: nowrap;
-	}
 
 	.seg {
 		display: flex;
@@ -477,29 +458,6 @@
 		opacity: 0.35;
 		cursor: default;
 	}
-
-	.a-btn {
-		display: inline-flex;
-		align-items: center;
-		gap: 6px;
-		min-height: 34px;
-		padding: 0 16px;
-		border-radius: 8px;
-		font-family: inherit;
-		font-size: 13px;
-		font-weight: 600;
-		cursor: pointer;
-		border: 1px solid transparent;
-		text-decoration: none;
-	}
-	.a-btn.primary {
-		background: var(--accent);
-		color: var(--accent-contrast);
-	}
-	.a-btn.primary:hover {
-		background: var(--accent-hover);
-	}
-
 	@media (max-width: 1023px) {
 		.tasks-page {
 			padding: 14px 16px 32px;

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

@@ -1,9 +1,5 @@
 <script lang="ts">
-	import AppShell from '$lib/components/shell/AppShell.svelte';
 	import StudioGenerate from '$lib/components/studio/StudioGenerate.svelte';
-	import { t } from '$lib/i18n.svelte';
 </script>
 
-<AppShell active="video" title={t('studio.video.title')} subtitle={t('studio.video.subtitle')}>
-	<StudioGenerate kind="video" />
-</AppShell>
+<StudioGenerate kind="video" />