fix(ui): split running/awaiting-confirm colors and neutral kind tags (HEL-651 A batch)

- project card stage segments: running -> --run, awaiting confirm -> --warn
- running counters/dots and 'testing' states -> --run; warn-named notes -> --warn
- image/video/usage kind tags and plain entry/card icons -> neutral tokens

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

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

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import logging
+import time
 import uuid
 from pathlib import Path
 from typing import Any
@@ -13,6 +14,22 @@ from calliope.comfyui.registry import IMAGE_CLASSES, AUDIO_CLASSES, VIDEO_CLASSE
 
 logger = logging.getLogger("calliope.comfyui")
 
+# Reachability probe budget (HEL-619): matches the connections-page test
+# probe (5s). Without it health() inherits the 120s client default, so a
+# bad endpoint hangs every queued job for two minutes before failing.
+HEALTH_TIMEOUT_SEC = 5.0
+
+# /object_info fetch is a few MB on big instances; the preflight check
+# (HEL-642/643) caches it per endpoint for this long. Manual refresh
+# (`force_refresh=True`) bypasses the TTL.
+OBJECT_INFO_TTL_SEC = 300.0
+_object_info_cache: dict[str, tuple[float, dict[str, Any]]] = {}
+
+
+def clear_object_info_cache() -> None:
+    """Drop cached /object_info payloads (tests swap fake endpoints in)."""
+    _object_info_cache.clear()
+
 
 def _surface_error(prefix: str, resp: httpx.Response) -> RuntimeError:
     """Raise with ComfyUI's own error body instead of an opaque status line.
@@ -76,11 +93,40 @@ class ComfyUIClient:
 
     async def health(self) -> bool:
         try:
-            resp = await self._http.get(f"{self.base_url}/system_stats")
+            resp = await self._http.get(
+                f"{self.base_url}/system_stats", timeout=HEALTH_TIMEOUT_SEC
+            )
             return resp.status_code == 200
         except Exception:
             return False
 
+    def _cache_key(self) -> str:
+        auth = self._headers.get("Authorization") or next(
+            (v for k, v in self._headers.items() if k.lower() not in ("authorization",)), ""
+        )
+        return f"{self.base_url}|{auth}"
+
+    async def object_info(self, force_refresh: bool = False) -> dict[str, Any]:
+        """The server's full ``/object_info`` node catalogue, cached per endpoint.
+
+        Cached for OBJECT_INFO_TTL_SEC; ``force_refresh`` re-fetches (the
+        connections page "重新检查" button after the user installs nodes).
+        Raises on transport/HTTP errors so callers can report honestly.
+        """
+        key = self._cache_key()
+        now = time.monotonic()
+        if not force_refresh:
+            hit = _object_info_cache.get(key)
+            if hit and now - hit[0] < OBJECT_INFO_TTL_SEC:
+                return hit[1]
+        resp = await self._http.get(f"{self.base_url}/object_info", timeout=30.0)
+        resp.raise_for_status()
+        data = resp.json()
+        if not isinstance(data, dict):
+            raise RuntimeError("ComfyUI 返回的 /object_info 不是对象")
+        _object_info_cache[key] = (now, data)
+        return data
+
     async def upload_image(self, path: Path, subfolder: str = "calliope") -> str:
         data = path.read_bytes()
         files = {"image": (path.name, data, "application/octet-stream")}
@@ -285,16 +331,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

@@ -83,10 +83,11 @@ def workflow_warnings(workflow: dict[str, Any]) -> list[dict[str, str]]:
                 }
             )
 
-    # HEL-636: a workflow without any recognizable output node can never
+    # 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 *possible* savers (needs_mapping) don't
-    # trigger this: the user confirms those on the import page.
+    # 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)
@@ -110,7 +111,7 @@ def workflow_warnings(workflow: dict[str, Any]) -> list[dict[str, str]]:
                     "code": "unknown_output_node",
                     "node_id": names,
                     "message": f"存在无法识别的输出节点（{names}），"
-                    "导入后需人工确认用途；结果按 ComfyUI 历史的图片/视频输出提取",
+                    "需人工指定实际输出节点及其媒体类型（图片/视频）后才能生成",
                 }
             )
     return found

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

@@ -12,6 +12,8 @@ from calliope.comfyui.registry import (
     IMAGE_CLASSES,
     IMAGE_OUTPUT_CLASSES,
     IMAGE_URL_CLASSES,
+    NUMBER_CLASSES,
+    TEXT_AREA_CLASSES,
     VIDEO_CLASSES,
     VIDEO_OUTPUT_CLASSES,
     ComfyOutputKind,
@@ -279,17 +281,45 @@ def resolution_selector_size(aspect_ratio: str, megapixels: float, multiple: int
     )
 
 
-# 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]]] = {
+# ComfyUI Autogrow media inputs a studio form fills as one 1…max list
+# (HEL-643 generalizes the original image-only registry to three media
+# kinds). The workflow wires ``<group>.<prefix>N``; extra items are cloned
+# loader nodes added at patch time (patcher.py). This registry only
+# beautifies known classes (label + real max + hint key); detection itself
+# is generic — any ``<group>.<prefix>N`` run of same-family media-loader
+# links folds into a group, image / video / audio alike.
+MEDIA_GROUPS: dict[str, dict[str, dict[str, Any]]] = {
     "MiniMaxH3ReferenceToVideo": {
-        "ref_images": {"prefix": "ref_image_", "max": 9, "label": "参考图"},
+        "ref_images": {
+            "prefix": "ref_image_",
+            "max": 9,
+            "label": "参考图",
+            "kind": "image",
+        },
+        "ref_videos": {
+            "prefix": "ref_video_",
+            "max": 3,
+            "label": "参考视频",
+            "kind": "video",
+        },
+        "ref_audios": {
+            "prefix": "ref_audio_",
+            "max": 3,
+            "label": "参考音频",
+            "kind": "audio",
+        },
     },
 }
 
+# Backwards-compatible alias for the original image-only view.
+IMAGE_GROUPS = MEDIA_GROUPS
+
+# Consuming-node classes whose groups carry official usage limits worth a
+# hint in the UI. Purely cosmetic — detection never depends on it.
+_MEDIA_HINTS: dict[str, str] = {
+    "MiniMaxH3ReferenceToVideo": "minimax_h3_ref2va",
+}
+
 # ``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+)$"
@@ -303,9 +333,27 @@ _FRAME_SLOT_ROLES: dict[str, tuple[str, str]] = {
     "end_image": ("last_frame", "尾帧"),
 }
 
+# Group media kind → (schema kind, role, default label, default max).
+_GROUP_KIND_META: dict[str, tuple[str, str, str, int]] = {
+    "image": ("image_list", "reference_image", "参考图", 9),
+    "video": ("video_list", "reference_video", "参考视频", 9),
+    "audio": ("audio_list", "reference_audio", "参考音频", 9),
+}
+
+# Loader class family for each media kind (registry.py sets).
+_GROUP_SOURCE_CLASSES: dict[str, frozenset[str]] = {
+    "image": IMAGE_CLASSES,
+    "video": VIDEO_CLASSES,
+    "audio": AUDIO_CLASSES,
+}
+
+
+def media_group_spec(class_type: str, group: str) -> dict[str, Any] | None:
+    return MEDIA_GROUPS.get(class_type, {}).get(group)
+
 
 def image_group_spec(class_type: str, group: str) -> dict[str, Any] | None:
-    return IMAGE_GROUPS.get(class_type, {}).get(group)
+    return media_group_spec(class_type, group)
 
 
 def image_group_prefix(node: dict[str, Any], group: str) -> str | None:
@@ -344,14 +392,14 @@ def image_group_slots(
 
 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.
+) -> list[tuple[str, str, list[str], str]]:
+    """``[(group, prefix, source loader ids, media kind)]`` for 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.
+    A run qualifies when the numbers are consecutive, every slot links to a
+    loader of the SAME media family (image / video / audio), 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():
@@ -359,7 +407,7 @@ def _detected_group_runs(
         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]]] = []
+    out: list[tuple[str, str, list[str], 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:])):
@@ -367,41 +415,57 @@ def _detected_group_runs(
         if not (ns[0] == 0 or len(ns) >= 2):
             continue
         sources: list[str] = []
+        family: str | None = None
         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 = []
+            if not isinstance(src, dict):
+                family = None
                 break
+            ct = str(src.get("class_type") or "")
+            kinds = [
+                kind
+                for kind, classes in _GROUP_SOURCE_CLASSES.items()
+                if ct in classes
+            ]
+            if len(kinds) != 1 or (family is not None and kinds[0] != family):
+                family = None
+                break
+            family = kinds[0]
             sources.append(str(link[0]))
-        if sources:
-            out.append((group, prefix, sources))
+        if family and sources:
+            out.append((group, prefix, sources, family))
     return out
 
 
-def _image_groups(
+def _media_groups(
     workflow: dict[str, Any],
 ) -> tuple[list[dict[str, Any]], set[str]]:
-    """Group entries for Autogrow reference inputs + the LoadImage ids they absorb."""
+    """Group entries for Autogrow reference inputs (image/video/audio) plus
+    the loader node 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 {}
+        class_type = str(node.get("class_type") or "")
+        for group, _prefix, sources, media_kind in _detected_group_runs(workflow, node):
+            spec = media_group_spec(class_type, group) or {}
+            kind, role, default_label, default_max = _GROUP_KIND_META[media_kind]
             absorbed.update(sources)
+            hint = _MEDIA_HINTS.get(class_type)
             entries.append(
                 _entry(
                     f"{nid}{FIELD_KEY_SEP}{group}",
-                    str(spec.get("label") or "参考图"),
-                    "reference_image",
-                    "image_list",
+                    str(spec.get("label") or default_label),
+                    role,
+                    kind,
                     None,
                     True,
                     min=1,
-                    max=spec.get("max", 9),
+                    max=spec.get("max", default_max),
+                    media_hint=hint,
                 )
             )
     return entries, absorbed
@@ -447,7 +511,7 @@ def detect_untagged_inputs(workflow: dict[str, Any]) -> list[dict[str, Any]]:
     )
 
     texts: list[tuple[str, dict[str, Any], str, bool]] = []  # (id, node, field, negative)
-    groups, grouped_images = _image_groups(workflow)
+    groups, grouped_loaders = _media_groups(workflow)
     media: list[dict[str, Any]] = []
     numbers: list[dict[str, Any]] = []
     taken_roles: set[str] = set()
@@ -473,7 +537,7 @@ def detect_untagged_inputs(workflow: dict[str, Any]) -> list[dict[str, Any]]:
         lowered = title.lower()
 
         if ct in IMAGE_CLASSES or ct in _MASK_IMAGE_CLASSES:
-            if nid in grouped_images:
+            if nid in grouped_loaders:
                 continue
             is_mask = ct in _MASK_IMAGE_CLASSES or "mask" in lowered or "遮罩" in lowered
             slot = _image_slot(nid, workflow, consumers)
@@ -502,6 +566,10 @@ def detect_untagged_inputs(workflow: dict[str, Any]) -> list[dict[str, Any]]:
             )
             continue
         if ct in VIDEO_CLASSES or ct in AUDIO_CLASSES:
+            if nid in grouped_loaders:
+                # Absorbed into an Autogrow media group (HEL-643) — the
+                # group entry owns its upload slots.
+                continue
             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))
@@ -707,6 +775,16 @@ def parse_dynamic_outputs(workflow: dict[str, Any]) -> list[dict[str, Any]]:
 # 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.
@@ -743,6 +821,17 @@ def _unknown_sink_looks_like_save(node: dict[str, Any], workflow: dict[str, Any]
     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():
@@ -757,52 +846,78 @@ def _video_semantics(workflow: dict[str, Any]) -> bool:
     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). Fuzzy class-name matches only
-    count at a sink. Unknown sink classes that look like savers become
-    ``other`` + ``unknown_node`` evidence — the import page then asks the
-    user to map them.
+    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)
-    results: list[dict[str, Any]] = []
+    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 not ct or ct in _INPUT_ONLY_CLASSES:
-            continue
-        title = _title_of(node)
         if ct in IMAGE_OUTPUT_CLASSES or ct in VIDEO_OUTPUT_CLASSES:
-            kind: ComfyOutputKind = "video" if ct in VIDEO_OUTPUT_CLASSES else "image"
-            evidence = "registry"
-        else:
-            kind = class_to_output_kind(ct)
-            if kind in ("image", "video"):
-                evidence = "class_name_match"
-            elif _unknown_sink_looks_like_save(node, workflow):
-                # A custom saver we cannot type: with video evidence in the
-                # graph it most likely saves video, but the user decides.
-                kind = "video" if videoish else "other"
-                evidence = "unknown_node"
-            else:
-                continue  # utility/primitive sink — not an output
-        results.append(
-            {
-                "nodeId": nid,
-                "label": title or ct,
-                "role": None,
-                "kind": kind,
-                "class_type": ct,
-                "evidence": evidence,
-            }
-        )
-    # Registry output classes consumed by other nodes are outputs too.
-    seen = {r["nodeId"] for r in results}
+            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]),
@@ -810,7 +925,7 @@ def detect_output_nodes(workflow: dict[str, Any]) -> list[dict[str, Any]]:
         ct = str(node.get("class_type") or "")
         if nid in seen or ct not in (IMAGE_OUTPUT_CLASSES | VIDEO_OUTPUT_CLASSES):
             continue
-        results.append(
+        registry_outputs.append(
             {
                 "nodeId": nid,
                 "label": _title_of(node) or ct,
@@ -820,6 +935,37 @@ def detect_output_nodes(workflow: dict[str, Any]) -> list[dict[str, Any]]:
                 "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
 
 
@@ -899,7 +1045,7 @@ def classify_usage(workflow: dict[str, Any]) -> dict[str, Any]:
         names = "、".join(
             f"节点 {o['nodeId']}（{o.get('class_type') or '?'}）" for o in unknown_outputs[:4]
         )
-        summary.append(f"存在无法识别的输出节点：{names}，需人工确认")
+        summary.append(f"存在无法识别的输出节点：{names}，需人工指定输出节点及媒体类型")
     for s in image_slots:
         if s["role"] != "mask":
             summary.append(f"图片输入：节点 {s['nodeId']}（{s['label']}）")
@@ -914,6 +1060,18 @@ def classify_usage(workflow: dict[str, Any]) -> dict[str, Any]:
             "未在图中找到输出节点（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 = "同一工作流同时输出图片和视频，需人工选择主用途"
@@ -929,10 +1087,6 @@ def classify_usage(workflow: dict[str, Any]) -> dict[str, Any]:
         else:
             ambiguous = True
             problem = "视频工作流中的单张图片输入无法判定是首帧还是参考图，需人工确认"
-    else:
-        # only unknown outputs — the user must map them before it is usable
-        ambiguous = True
-        problem = "输出节点的媒体类型无法识别，需人工确认用途后才能生成"
 
     return {
         "usage": usage,

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

@@ -5,12 +5,44 @@ from __future__ import annotations
 import copy
 from typing import Any
 
-from calliope.comfyui.registry import IMAGE_CLASSES, class_to_patch_field
+from calliope.comfyui.registry import (
+    AUDIO_CLASSES,
+    IMAGE_CLASSES,
+    VIDEO_CLASSES,
+    VIDEO_FILE_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 = "@"
 
+# Media-loader families and the Chinese slot label used on cloned nodes.
+_GROUP_LABELS: tuple[tuple[frozenset[str], str], ...] = (
+    (IMAGE_CLASSES, "参考图"),
+    (VIDEO_CLASSES, "参考视频"),
+    (AUDIO_CLASSES, "参考音频"),
+)
+
+
+def _loader_label(class_type: str) -> str:
+    for classes, label in _GROUP_LABELS:
+        if class_type in classes:
+            return label
+    return "参考素材"
+
+
+def _loader_field(class_type: str, inputs: dict[str, Any]) -> str:
+    """The widget a loader node of this class stores its file value in."""
+    if class_type in IMAGE_CLASSES:
+        return "image"
+    if class_type in VIDEO_CLASSES:
+        return "file" if class_type in VIDEO_FILE_CLASSES else "video"
+    if class_type in AUDIO_CLASSES:
+        # VHS_LoadAudio names its widget "audio:" (with the colon).
+        return "audio" if "audio" in inputs else "audio:"
+    return "image"
+
 
 def _resolve_field(field: str, inputs: dict[str, Any]) -> str:
     """Map the computed patch field onto a key that exists on this node.
@@ -43,15 +75,16 @@ def _next_node_id(workflow: dict[str, Any]) -> str:
     return str(max(numeric, default=0) + 1)
 
 
-def apply_image_group(
+def apply_media_group(
     workflow: dict[str, Any], node_id: str, group: str, paths: list[str]
 ) -> None:
-    """Rewire an Autogrow image group to exactly ``paths``, in order.
+    """Rewire an Autogrow media group (image/video/audio) to exactly ``paths``.
 
-    ``<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.
+    ``<group>.<prefix>0 … N-1`` each get their own loader node: 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 media reaches ComfyUI. File values are local paths —
+    ``prepare_media_inputs`` uploads them right before queueing.
     """
     from calliope.comfyui.parser import image_group_prefix, image_group_slots
 
@@ -61,7 +94,6 @@ def apply_image_group(
     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] = []
@@ -69,11 +101,14 @@ def apply_image_group(
         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:
+            if isinstance(src, dict) and str(src.get("class_type") or "") in (
+                IMAGE_CLASSES | VIDEO_CLASSES | AUDIO_CLASSES
+            ):
                 loaders.append(str(link[0]))
     if not loaders:
         return
     template = copy.deepcopy(workflow[loaders[0]])
+    label = _loader_label(str(template.get("class_type") or ""))
 
     still_used: set[str] = set()
     for nid, other in workflow.items():
@@ -94,7 +129,8 @@ def apply_image_group(
             nid = _next_node_id(workflow)
             loader = copy.deepcopy(template)
         loader_inputs = dict(loader.get("inputs") or {})
-        loader_inputs["image"] = path
+        field = _loader_field(str(loader.get("class_type") or ""), loader_inputs)
+        loader_inputs[field] = path
         loader["inputs"] = loader_inputs
         loader["_meta"] = {**(loader.get("_meta") or {}), "title": f"{label} {i + 1}"}
         workflow[nid] = loader
@@ -102,6 +138,10 @@ def apply_image_group(
     node["inputs"] = inputs
 
 
+# Original name kept: image groups were the first (and most common) family.
+apply_image_group = apply_media_group
+
+
 def patch_workflow(
     base: dict[str, Any],
     values_by_node_id: dict[str, Any],
@@ -125,7 +165,7 @@ def patch_workflow(
             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)
+                    apply_media_group(patched, key, field, clean)
             continue
         if field is None:
             field = resolve_patch_field(node)

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

@@ -0,0 +1,137 @@
+"""L2 connection preflight: check a workflow against a live /object_info (HEL-642/643).
+
+Layer 1 (lint.py) judges the JSON on its own; this module judges the JSON
+against what the target ComfyUI actually has installed. Two generic rules,
+zero hard-coding for any specific workflow or model name:
+
+1. Node existence — every ``class_type`` in the JSON must exist as a key of
+   the server's /object_info catalogue; missing ones are custom nodes the
+   user has not installed.
+2. Combo value legality — for every combo input the server declares (an
+   input whose spec carries a candidate list — unet_name/clip_name/
+   sampler/scheduler/…), the JSON's current widget value must be one of the
+   candidates; a miss usually means a model file or component is missing.
+
+File-upload widgets (LoadImage.image and friends) are skipped: their combo
+lists are the server's input directory at export time and the value is
+replaced by an upload before every submit, so a miss there says nothing.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from calliope.comfyui.registry import AUDIO_CLASSES, IMAGE_CLASSES, VIDEO_CLASSES
+
+# Media-loader classes and the widget names that hold their file values —
+# upload-backed combos that cannot be judged before an upload happens.
+_MEDIA_LOADER_FIELDS: tuple[frozenset[str], frozenset[str]] = (
+    (IMAGE_CLASSES, frozenset({"image"})),
+    (AUDIO_CLASSES, frozenset({"audio", "audio:"})),
+    (VIDEO_CLASSES, frozenset({"file", "video"})),
+)
+
+# object_info widget-config keys that mark an input as file-upload backed.
+_UPLOAD_CONFIG_KEYS = ("image_upload", "audio_upload", "video_upload", "upload")
+
+_MAX_CANDIDATES_SHOWN = 6
+
+
+def _node_title(node: dict[str, Any]) -> str:
+    title = (node.get("_meta") or {}).get("title")
+    return str(title).strip() if title else ""
+
+
+def _is_upload_backed(class_type: str, input_name: str, config: Any) -> bool:
+    if isinstance(config, dict) and any(config.get(k) for k in _UPLOAD_CONFIG_KEYS):
+        return True
+    for classes, fields in _MEDIA_LOADER_FIELDS:
+        if class_type in classes and input_name in fields:
+            return True
+    return False
+
+
+def _combo_candidates(spec: Any) -> list[str] | None:
+    """The candidate list when ``spec`` is a combo input, else None.
+
+    A combo spec is ``[["a", "b"], {config}]`` — first element a list of
+    plain strings. Typed inputs (``["FLOAT", {…}]``) return None.
+    """
+    if not (isinstance(spec, list) and len(spec) >= 1):
+        return None
+    values = spec[0]
+    if not isinstance(values, list) or not values:
+        return None
+    if not all(isinstance(v, str) for v in values):
+        return None
+    return values
+
+
+def check_workflow_against(
+    object_info: dict[str, Any], workflow: dict[str, Any]
+) -> list[dict[str, Any]]:
+    """Findings for every problem the target server's catalogue reveals.
+
+    Each finding is ``{level, code, node_id, node_title, message, hint}``
+    (``level`` is always ``"error"`` for now — both rules are hard misses).
+    """
+    findings: list[dict[str, Any]] = []
+    if not isinstance(object_info, dict) or not isinstance(workflow, dict):
+        return findings
+    for node_id, node in workflow.items():
+        if not isinstance(node, dict):
+            continue
+        class_type = str(node.get("class_type") or "")
+        title = _node_title(node)
+        label = f"节点 {node_id}「{title}」" if title else f"节点 {node_id}"
+        spec = object_info.get(class_type)
+        if not isinstance(spec, dict):
+            findings.append(
+                {
+                    "level": "error",
+                    "code": "missing_node",
+                    "node_id": str(node_id),
+                    "node_title": title,
+                    "message": (
+                        f"缺少自定义节点 {class_type or '(未知类名)'}（{label}）——"
+                        "该 ComfyUI 未安装此节点，需先安装对应的节点包"
+                    ),
+                    "hint": "安装节点包后回到本页点「重新检查」即可复查，无需重新导入。",
+                }
+            )
+            continue
+        declared = (spec.get("input") or {}) if isinstance(spec.get("input"), dict) else {}
+        inputs = node.get("inputs") or {}
+        for section in ("required", "optional"):
+            entries = declared.get(section)
+            if not isinstance(entries, dict):
+                continue
+            for input_name, in_spec in entries.items():
+                value = inputs.get(input_name)
+                # Wired inputs (links) and absent widgets are not combos to judge.
+                if isinstance(value, (list, dict)) or value is None:
+                    continue
+                config = in_spec[1] if isinstance(in_spec, list) and len(in_spec) > 1 else None
+                if _is_upload_backed(class_type, str(input_name), config):
+                    continue
+                candidates = _combo_candidates(in_spec)
+                if candidates is None:
+                    continue
+                if value in candidates:
+                    continue
+                shown = "、".join(candidates[:_MAX_CANDIDATES_SHOWN])
+                if len(candidates) > _MAX_CANDIDATES_SHOWN:
+                    shown += f" 等 {len(candidates)} 项"
+                findings.append(
+                    {
+                        "level": "error",
+                        "code": "value_not_in_list",
+                        "node_id": str(node_id),
+                        "node_title": title,
+                        "message": (
+                            f"{label}：值「{value}」不在 ComfyUI 的可选列表"
+                            f"（参数 {input_name}）——多为对应的模型文件或组件未安装"
+                        ),
+                        "hint": f"该 ComfyUI 上可选：{shown}" if shown else None,
+                    }
+                )
+    return findings

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

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

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

@@ -63,20 +63,24 @@ def validate_input_values(
                 errors.append(f"「{label}」不能大于 {_fmt(hi)}")
                 continue
             clean[key] = value
-        elif kind == "image_list":
+        elif kind in ("image_list", "video_list", "audio_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()]
+            unit = _LIST_UNITS[kind]
+            noun = _LIST_NOUNS[kind]
             hi = entry.get("max")
             if hi is not None and len(paths) > hi:
-                errors.append(f"{label}最多 {hi} 张（当前 {len(paths)} 张），请删除多余的图片")
+                errors.append(
+                    f"{label}最多 {hi} {unit}（当前 {len(paths)} {unit}），请删除多余的{noun}"
+                )
                 continue
             bad = [
                 f"{label} {i}：{msg}"
                 for i, p in enumerate(paths, 1)
-                if (msg := _image_file_problem(p))
+                if (msg := _media_file_problem(p, kind))
             ]
             if bad:
                 errors.extend(bad)
@@ -98,10 +102,11 @@ def validate_input_values(
             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":
+        elif required and entry.get("kind") in ("image_list", "video_list", "audio_list"):
             lo = entry.get("min") or 1
+            unit = _LIST_UNITS[entry.get("kind")]
             if len(clean.get(key) or []) < lo and not any(label in e for e in errors):
-                errors.append(f"需要至少 {lo} 张{label}")
+                errors.append(f"需要至少 {lo} {unit}{label}")
         elif required and entry.get("kind") == "image" and entry.get("role") != "mask":
             if key not in clean:
                 errors.append(f"请上传{label}")
@@ -109,19 +114,33 @@ def validate_input_values(
 
 
 _IMAGE_EXTS = frozenset({".png", ".jpg", ".jpeg", ".webp"})
+_VIDEO_EXTS = frozenset({".mp4", ".webm", ".mov"})
+_AUDIO_EXTS = frozenset({".mp3", ".wav", ".m4a"})
+_LIST_UNITS = {"image_list": "张", "video_list": "段", "audio_list": "段"}
+_LIST_NOUNS = {"image_list": "图片", "video_list": "视频", "audio_list": "音频"}
+_LIST_EXTS = {"image_list": _IMAGE_EXTS, "video_list": _VIDEO_EXTS, "audio_list": _AUDIO_EXTS}
+_LIST_FORMAT_HINT = {
+    "image_list": "格式不支持，请使用 PNG / JPG / WebP",
+    "video_list": "格式不支持，请使用 MP4 / WebM / MOV",
+    "audio_list": "格式不支持，请使用 MP3 / WAV / M4A",
+}
 
 
-def _image_file_problem(path: str) -> str | None:
-    """Why ``path`` cannot be a studio reference image (None = fine)."""
+def _media_file_problem(path: str, kind: str) -> str | None:
+    """Why ``path`` cannot fill a media-list slot of this kind (None = fine)."""
     from calliope import config
 
     target = Path(path)
-    if target.suffix.lower() not in _IMAGE_EXTS:
-        return "格式不支持，请使用 PNG / JPG / WebP"
+    if target.suffix.lower() not in _LIST_EXTS[kind]:
+        return _LIST_FORMAT_HINT[kind]
     try:
         target.resolve().relative_to(config.settings.assets_dir.resolve())
     except (ValueError, OSError):
-        return "只能使用在本页上传或从生成结果选入的图片"
+        return f"只能使用在本页上传或从生成结果选入的{_LIST_NOUNS[kind]}"
     if not target.is_file():
         return "文件已不存在，请重新上传"
     return None
+
+
+def _image_file_problem(path: str) -> str | None:
+    return _media_file_problem(path, "image_list")

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 (
@@ -370,6 +374,42 @@ def _backfill_workflow_usage(conn: sqlite3.Connection) -> None:
             )
 
 
+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)
@@ -421,9 +461,17 @@ async def migrate_db(db_path: Path) -> None:
         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")
@@ -470,6 +518,11 @@ async def migrate_db(db_path: Path) -> None:
         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")
+    # HEL-643: where a job came from — 'user' (every normal generation) or
+    # 'workflow_test' (L3 试运行). Existing rows default to 'user', semantics
+    # unchanged; test jobs get isolated artifacts and no entity write-back.
+    if "origin" not in job_cols:
+        conn.execute("ALTER TABLE jobs ADD COLUMN origin TEXT NOT NULL DEFAULT 'user'")
     # 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

@@ -222,6 +222,11 @@ class WorkflowCreate(BaseModel):
     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):
@@ -234,10 +239,31 @@ class WorkflowUpdate(BaseModel):
     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):
     workflow_json: dict[str, Any]
+    # HEL-643: optional target connection — given, the analyze response also
+    # carries an L2 connection check (node/model availability via /object_info).
+    endpoint_id: str | None = None
+    # Bypass the /object_info cache (user re-checks after installing nodes).
+    refresh: bool = False
+
+
+class WorkflowCheckRequest(BaseModel):
+    """L2 re-check of a saved workflow against a live ComfyUI (HEL-643)."""
+    endpoint_id: str | None = None
+    refresh: bool = False
+
+
+class WorkflowTestRequest(BaseModel):
+    """Launch one real test run of a workflow (HEL-643 L3)."""
+    endpoint_id: str | None = None
+    input_values: dict[str, Any] = Field(default_factory=dict)
 
 
 class JobCreate(BaseModel):

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

@@ -36,16 +36,18 @@ class QueueManager:
         scene_id: int | None = None,
         clip_id: int | None = None,
         payload: dict[str, Any] | None = None,
+        origin: str = "user",
     ) -> dict[str, Any]:
         conn = get_db(config.settings.db_path)
         try:
             payload = self._stamp_endpoint(conn, workflow_id, dict(payload or {}))
             cur = conn.execute(
                 """
-                INSERT INTO jobs (project_id, scene_id, clip_id, kind, workflow_id, status, payload_json)
-                VALUES (?, ?, ?, ?, ?, 'pending', ?)
+                INSERT INTO jobs (project_id, scene_id, clip_id, kind, workflow_id,
+                                  status, payload_json, origin)
+                VALUES (?, ?, ?, ?, ?, 'pending', ?, ?)
                 """,
-                (project_id, scene_id, clip_id, kind, workflow_id, json.dumps(payload)),
+                (project_id, scene_id, clip_id, kind, workflow_id, json.dumps(payload), origin),
             )
             conn.commit()
             row = conn.execute("SELECT * FROM jobs WHERE id = ?", (cur.lastrowid,)).fetchone()

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

@@ -21,6 +21,11 @@ from calliope.db import get_db
 from calliope.events.bus import event_bus
 from calliope.export.runner import run_export
 from calliope.queue.manager import queue_manager
+from calliope.queue.workflow_test import (
+    TEST_ORIGIN,
+    prune_workflow_tests,
+    workflow_test_dir,
+)
 
 logger = logging.getLogger("calliope.worker")
 
@@ -164,6 +169,16 @@ class QueueWorker:
                             "message": f"{self._job_label(job)} failed",
                         },
                     )
+                if str(job.get("origin") or "") == TEST_ORIGIN and job.get("workflow_id"):
+                    # Retention: keep only the newest records (and their
+                    # artifacts) per workflow (HEL-643).
+                    try:
+                        prune_workflow_tests(int(job["workflow_id"]))
+                    except Exception:
+                        logger.exception(
+                            "Pruning workflow-test records for workflow %s failed",
+                            job["workflow_id"],
+                        )
             except Exception:
                 logger.exception("Worker loop error")
                 await asyncio.sleep(config.settings.queue_poll_interval_sec)
@@ -173,6 +188,7 @@ class QueueWorker:
         payload = json.loads(job["payload_json"] or "{}")
         project_id = job["project_id"]
         kind = job["kind"]
+        is_test = str(job.get("origin") or "") == TEST_ORIGIN
         use_dry = bool(config.settings.dry_run)
 
         if kind == "export":
@@ -183,6 +199,13 @@ class QueueWorker:
         base_url, headers, endpoint_label = self._resolve_endpoint(payload)
         client = ComfyUIClient(base_url, headers=headers)
         try:
+            # A workflow test must be a REAL run — a dry-run placeholder that
+            # passes as "测试通过" is exactly the false positive HEL-643 bans.
+            if use_dry and is_test:
+                raise RuntimeError(
+                    "测试工作流必须真实运行：当前设置开启了 Dry-run（占位模式），"
+                    "请到「设置」关闭 Dry-run 后重新测试"
+                )
             if use_dry:
                 queue_manager.set_phase(job["id"], "dry_run")
                 return await self._dry_run(job, payload)
@@ -196,15 +219,25 @@ class QueueWorker:
                 )
 
             workflow_id = job.get("workflow_id") or payload.get("workflow_id")
-            workflow = self._load_workflow(workflow_id)
-            if not workflow:
+            workflow_row = self._load_workflow_row(workflow_id)
+            if not workflow_row:
                 raise RuntimeError(
                     "找不到该任务使用的工作流（可能已被删除），请重新选择工作流后再生成"
                 )
+            workflow = workflow_row["workflow_json"]
             broken = blocking_problem(workflow)
             if broken:
                 raise RuntimeError(broken)
 
+            # HEL-638: harvest only the confirmed output nodes. A workflow
+            # with unknown custom outputs and no user mapping must not run.
+            node_kinds = self._output_node_kinds(workflow_row)
+            if node_kinds is None:
+                raise RuntimeError(
+                    "该工作流含无法识别的自定义输出节点，尚未指定输出节点及媒体类型，"
+                    "请到「ComfyUI 连接」页确认后再生成"
+                )
+
             input_values = payload.get("input_values") or {}
             if payload.get("continue_source") and kind == "video":
                 input_values = await self._resolve_continue_source(
@@ -240,16 +273,39 @@ class QueueWorker:
                     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}），但没有返回任何图片或视频，"
-                    "不算生成完成。请确认工作流带有保存/预览节点，并到 ComfyUI 历史中核对该任务。"
+                    "不算生成完成。已按输出映射检查节点：" 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
+            if is_test:
+                # Test artifacts live in a scratch dir, isolated from project
+                # media and never written back to entities (HEL-643).
+                dest_dir = workflow_test_dir(int(workflow_id))
+            else:
+                dest_dir = config.settings.assets_dir / str(project_id) / kind
             dest_dir.mkdir(parents=True, exist_ok=True)
             paths: list[str] = []
             for meta in outputs_meta:
@@ -263,7 +319,8 @@ class QueueWorker:
                 )
                 paths.append(str(dest))
 
-            self._apply_outputs_to_entities(job, payload, paths)
+            if not is_test:
+                self._apply_outputs_to_entities(job, payload, paths)
             queue_manager.set_phase(job["id"], "finished")
             return paths
         finally:
@@ -476,20 +533,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/queue/workflow_test.py

@@ -0,0 +1,180 @@
+"""Workflow-test job helpers (HEL-643).
+
+A test job (jobs.origin = 'workflow_test') runs the FULL real pipeline —
+queue → ComfyUI → outputs — but its artifacts are isolated from project
+entities: files land under ``assets/_workflow_test/{workflow_id}/`` and are
+never written back to characters/locations/scenes/clips.
+
+This module owns the artifact directory, the retention policy (keep the
+newest N records per workflow) and the purge paths used by "清除测试记录"
+and workflow deletion.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import shutil
+from pathlib import Path
+from typing import Any
+
+from calliope import config
+from calliope.db import get_db
+
+logger = logging.getLogger("calliope.queue")
+
+TEST_ORIGIN = "workflow_test"
+TEST_SOURCE = "workflow_test"
+# Records (and artifacts) kept per workflow before older ones are pruned.
+TEST_KEEP = 5
+
+
+def workflow_test_dir(workflow_id: int) -> Path:
+    return config.settings.assets_dir / "_workflow_test" / str(workflow_id)
+
+
+def _safe_unlink(path_str: str) -> bool:
+    """Delete a file if it resolves under assets_dir (missing = already gone)."""
+    try:
+        target = Path(path_str).resolve()
+        target.relative_to(config.settings.assets_dir.resolve())
+    except (ValueError, OSError):
+        return False
+    if not target.is_file():
+        return False
+    try:
+        target.unlink()
+        return True
+    except OSError:
+        return False
+
+
+def _unlink_job_outputs(job: dict[str, Any]) -> None:
+    try:
+        paths = json.loads(job.get("output_paths_json") or "[]")
+    except (json.JSONDecodeError, TypeError):
+        return
+    if not isinstance(paths, list):
+        return
+    for p in paths:
+        if isinstance(p, str) and p.strip():
+            _safe_unlink(p)
+
+
+def _remove_test_dir_if_empty(workflow_id: int) -> None:
+    d = workflow_test_dir(workflow_id)
+    try:
+        if d.is_dir() and not any(d.iterdir()):
+            d.rmdir()
+    except OSError:
+        pass
+
+
+def _test_job_public(job: dict[str, Any]) -> dict[str, Any]:
+    out = dict(job)
+    out["payload"] = json.loads(job.get("payload_json") or "{}")
+    out["output_paths"] = json.loads(job.get("output_paths_json") or "[]")
+    out.pop("payload_json", None)
+    out.pop("output_paths_json", None)
+    return out
+
+
+def list_test_jobs(workflow_id: int, limit: int = 20) -> list[dict[str, Any]]:
+    conn = get_db(config.settings.db_path)
+    try:
+        rows = conn.execute(
+            "SELECT * FROM jobs WHERE workflow_id = ? AND origin = ?"
+            " ORDER BY id DESC LIMIT ?",
+            (workflow_id, TEST_ORIGIN, limit),
+        ).fetchall()
+        return [_test_job_public(dict(r)) for r in rows]
+    finally:
+        conn.close()
+
+
+def find_active_test_job(workflow_id: int, endpoint_id: str | None) -> dict[str, Any] | None:
+    """The unfinished test job for (workflow, endpoint), if one exists.
+
+    Idempotency guard for the "测试工作流" button: a second click re-uses the
+    in-flight job instead of enqueuing a duplicate.
+    """
+    conn = get_db(config.settings.db_path)
+    try:
+        rows = conn.execute(
+            "SELECT * FROM jobs WHERE workflow_id = ? AND origin = ?"
+            " AND status IN ('pending', 'running') ORDER BY id DESC",
+            (workflow_id, TEST_ORIGIN),
+        ).fetchall()
+    finally:
+        conn.close()
+    for r in rows:
+        job = dict(r)
+        try:
+            payload = json.loads(job.get("payload_json") or "{}")
+        except (json.JSONDecodeError, TypeError):
+            payload = {}
+        snap = payload.get("endpoint") or {}
+        if not isinstance(snap, dict):
+            snap = {}
+        if (snap.get("id") or None) == (endpoint_id or None):
+            return _test_job_public(job)
+    return None
+
+
+def prune_workflow_tests(workflow_id: int, keep: int = TEST_KEEP) -> int:
+    """Keep only the newest ``keep`` test records (older rows + files go)."""
+    conn = get_db(config.settings.db_path)
+    try:
+        rows = conn.execute(
+            "SELECT * FROM jobs WHERE workflow_id = ? AND origin = ?"
+            " ORDER BY id DESC LIMIT -1 OFFSET ?",
+            (workflow_id, TEST_ORIGIN, max(keep, 0)),
+        ).fetchall()
+        removed = 0
+        for r in rows:
+            job = dict(r)
+            if job.get("status") in ("pending", "running"):
+                continue
+            _unlink_job_outputs(job)
+            conn.execute("DELETE FROM jobs WHERE id = ?", (job["id"],))
+            removed += 1
+        conn.commit()
+    finally:
+        conn.close()
+    _remove_test_dir_if_empty(workflow_id)
+    if removed:
+        logger.info("Pruned %s old workflow-test records for workflow %s", removed, workflow_id)
+    return removed
+
+
+def purge_workflow_tests(workflow_id: int, *, allow_active: bool = False) -> int:
+    """Delete EVERY test record and artifact for a workflow.
+
+    Returns the removed row count; raises RuntimeError when an unfinished
+    test job is still in flight (unless ``allow_active``).
+    """
+    conn = get_db(config.settings.db_path)
+    try:
+        if not allow_active:
+            active = conn.execute(
+                "SELECT COUNT(*) AS n FROM jobs WHERE workflow_id = ? AND origin = ?"
+                " AND status IN ('pending', 'running')",
+                (workflow_id, TEST_ORIGIN),
+            ).fetchone()["n"]
+            if active:
+                raise RuntimeError(
+                    f"该工作流还有 {active} 个进行中的测试任务，请先等待完成或取消，再清除测试记录"
+                )
+        rows = conn.execute(
+            "SELECT * FROM jobs WHERE workflow_id = ? AND origin = ?",
+            (workflow_id, TEST_ORIGIN),
+        ).fetchall()
+        removed = 0
+        for r in rows:
+            _unlink_job_outputs(dict(r))
+            conn.execute("DELETE FROM jobs WHERE id = ?", (r["id"],))
+            removed += 1
+        conn.commit()
+    finally:
+        conn.close()
+    shutil.rmtree(workflow_test_dir(workflow_id), ignore_errors=True)
+    return removed

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

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

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

@@ -14,6 +14,7 @@ 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
@@ -196,7 +197,14 @@ async def list_playground_jobs(limit: int = 50) -> list[dict[str, Any]]:
         pid = ensure_playground_project(conn)
     finally:
         conn.close()
-    return [_job_public(j) for j in queue_manager.list_jobs(pid, None, limit)]
+    # Workflow-test jobs (HEL-643) ride the same scratch project but must not
+    # surface in the studio windows' history — they carry their own dialog.
+    jobs = [
+        j
+        for j in queue_manager.list_jobs(pid, None, limit)
+        if str(j.get("origin") or "user") != "workflow_test"
+    ]
+    return [_job_public(j) for j in jobs]
 
 
 @router.delete("/jobs/{job_id}")
@@ -335,7 +343,8 @@ async def generate(payload: PlaygroundGenerate) -> dict[str, Any]:
     try:
         pid = ensure_playground_project(conn)
         wf = conn.execute(
-            "SELECT id, kind, is_enabled, workflow_json, input_schema 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:
@@ -348,6 +357,11 @@ async def generate(payload: PlaygroundGenerate) -> dict[str, Any]:
             )
         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
         )

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

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

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

@@ -5,18 +5,42 @@ from typing import Any
 
 from fastapi import APIRouter, HTTPException
 
-from calliope.comfyui.lint import workflow_warnings
+from calliope.comfyui.endpoints import client_for, endpoint_snapshot
+from calliope.comfyui.lint import blocking_problem, 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.preflight import check_workflow_against
 from calliope.comfyui.profiles import detect_prompt_profile
 from calliope.comfyui.roles import usage_to_kind
+from calliope.comfyui.validate import validate_input_values
 from calliope.config import settings
 from calliope.db import get_db, row_to_dict
-from calliope.models.schemas import WorkflowAnalyze, WorkflowCreate, WorkflowUpdate
+from calliope.events.bus import event_bus
+from calliope.models.schemas import (
+    WorkflowAnalyze,
+    WorkflowCheckRequest,
+    WorkflowCreate,
+    WorkflowTestRequest,
+    WorkflowUpdate,
+)
+from calliope.queue.manager import queue_manager
+from calliope.queue.workflow_test import (
+    TEST_SOURCE,
+    find_active_test_job,
+    list_test_jobs,
+    purge_workflow_tests,
+)
 
 router = APIRouter()
 
@@ -26,18 +50,67 @@ def _serialize_workflow(row: Any) -> dict[str, Any]:
     data["workflow_json"] = json.loads(data["workflow_json"])
     stored = json.loads(data["input_schema"]) if data.get("input_schema") else []
     data["input_schema"] = effective_input_schema(stored, data["workflow_json"])
-    data["output_schema"] = json.loads(data["output_schema"]) if data.get("output_schema") else []
+    # 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
 
 
+async def _connection_check(
+    endpoint_id: str | None, workflow_json: dict[str, Any], refresh: bool = False
+) -> dict[str, Any]:
+    """L2 preflight (HEL-643): workflow vs the target ComfyUI's /object_info.
+
+    An unreachable connection degrades to ``reachable: False`` with an honest
+    「无法核查」 message — it never blocks and never pretends to pass.
+    """
+    endpoint = settings.resolve_comfyui_endpoint(endpoint_id)
+    if endpoint is None:
+        return {
+            "ok": False,
+            "reachable": False,
+            "endpoint_id": endpoint_id,
+            "endpoint_name": None,
+            "findings": [],
+            "message": "没有可用的 ComfyUI 连接，无法核查节点与模型",
+        }
+    base = {
+        "endpoint_id": endpoint.get("id"),
+        "endpoint_name": endpoint.get("name"),
+        "base_url": endpoint.get("base_url"),
+    }
+    client = client_for(endpoint)
+    try:
+        object_info = await client.object_info(force_refresh=refresh)
+    except Exception as exc:
+        return {
+            **base,
+            "ok": False,
+            "reachable": False,
+            "findings": [],
+            "message": f"无法核查（连不上该 ComfyUI）：{type(exc).__name__}",
+        }
+    finally:
+        await client.close()
+    findings = check_workflow_against(object_info, workflow_json)
+    ok = not any(f.get("level") == "error" for f in findings)
+    return {**base, "ok": ok, "reachable": True, "findings": findings}
+
+
 @router.post("/analyze")
 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 {
+    result: dict[str, Any] = {
         "inputs": inputs,
         "outputs": outputs,
         "suggested_profile": detect_prompt_profile(payload.workflow_json),
@@ -49,6 +122,13 @@ async def analyze_workflow(payload: WorkflowAnalyze) -> dict[str, Any]:
         "usage_evidence": judgment["evidence"],
         "usable_usage": judgment["usable_usage"],
     }
+    # L2 (optional): with a target connection the analyze response also
+    # reports which nodes/models that ComfyUI actually has (HEL-643).
+    if payload.endpoint_id:
+        result["connection_check"] = await _connection_check(
+            payload.endpoint_id, payload.workflow_json, payload.refresh
+        )
+    return result
 
 
 def _stored_schema(payload_schema: list[dict[str, Any]] | None, workflow: dict[str, Any]) -> str:
@@ -63,9 +143,9 @@ async def reanalyze_workflow(workflow_id: int) -> dict[str, Any]:
     """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. A usage the user
-    set by hand is never overwritten; only ``auto`` (and pending NULL)
-    rows get the new judgment.
+    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:
@@ -83,10 +163,31 @@ async def reanalyze_workflow(workflow_id: int) -> dict[str, Any]:
         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 = ?,"
-            " usage = ?, usage_source = ? WHERE id = ?",
-            (json.dumps(schema), json.dumps(outputs), usage, usage_source, workflow_id),
+            " 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(
@@ -97,16 +198,64 @@ async def reanalyze_workflow(workflow_id: int) -> dict[str, Any]:
         conn.close()
 
 
+def _last_test_summary(job: dict[str, Any]) -> dict[str, Any]:
+    """Slim "上次测试" record for a workflow row (queried live, never stored)."""
+    try:
+        outputs = json.loads(job.get("output_paths_json") or "[]")
+    except (json.JSONDecodeError, TypeError):
+        outputs = []
+    return {
+        "id": job["id"],
+        "status": job.get("status"),
+        "phase": job.get("phase"),
+        "error": job.get("error"),
+        "created_at": job.get("created_at"),
+        "completed_at": job.get("completed_at"),
+        "output_count": len(outputs) if isinstance(outputs, list) else 0,
+    }
+
+
 @router.get("")
 async def list_workflows() -> list[dict[str, Any]]:
     conn = get_db(settings.db_path)
     try:
         rows = conn.execute("SELECT * FROM workflows ORDER BY id DESC").fetchall()
-        return [_serialize_workflow(r) for r in rows]
+        out = [_serialize_workflow(r) for r in rows]
+        # 上次测试 state is read live from the newest test job per workflow —
+        # no cached column that could go stale (HEL-643).
+        latest: dict[int, dict[str, Any]] = {}
+        for jr in conn.execute(
+            "SELECT * FROM jobs WHERE origin = 'workflow_test' AND id IN"
+            " (SELECT MAX(id) FROM jobs WHERE origin = 'workflow_test' GROUP BY workflow_id)"
+        ).fetchall():
+            latest[int(jr["workflow_id"])] = _last_test_summary(dict(jr))
+        for data in out:
+            data["last_test"] = latest.get(int(data["id"]))
+        return out
     finally:
         conn.close()
 
 
+@router.post("/{workflow_id}/check")
+async def check_workflow(workflow_id: int, payload: WorkflowCheckRequest) -> dict[str, Any]:
+    """L2 re-check of a saved workflow against its (or a chosen) connection.
+
+    The user installs missing nodes/models in ComfyUI, comes back here and
+    re-checks — no re-import needed.
+    """
+    conn = get_db(settings.db_path)
+    try:
+        row = conn.execute(
+            "SELECT workflow_json, endpoint_id FROM workflows WHERE id = ?", (workflow_id,)
+        ).fetchone()
+    finally:
+        conn.close()
+    if not row:
+        raise HTTPException(status_code=404, detail="Workflow not found")
+    endpoint_id = payload.endpoint_id or row["endpoint_id"]
+    return await _connection_check(endpoint_id, json.loads(row["workflow_json"]), payload.refresh)
+
+
 @router.post("/dedupe")
 async def dedupe_workflows() -> dict[str, Any]:
     """Delete byte-identical duplicate workflows, keeping the lowest id.
@@ -158,6 +307,20 @@ async def create_workflow(payload: WorkflowCreate) -> dict[str, Any]:
         }
         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
@@ -174,16 +337,18 @@ async def create_workflow(payload: WorkflowCreate) -> dict[str, Any]:
                     f" “{existing['name']}”)."
                 ),
             )
-        # Unconfirmed workflows (ambiguous / unknown outputs) are stored but
-        # disabled: they must not reach the generate pages until the user
-        # confirms a usage on the connections page (PATCH sets it back on).
-        is_enabled = 1 if usage else 0
+        # 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, usage, usage_source)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                                   endpoint_id, is_enabled, usage, usage_source,
+                                   output_map, output_map_source)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
             """,
             (
                 payload.name,
@@ -197,6 +362,8 @@ async def create_workflow(payload: WorkflowCreate) -> dict[str, Any]:
                 is_enabled,
                 usage,
                 usage_source,
+                output_map,
+                output_map_source,
             ),
         )
         conn.commit()
@@ -228,20 +395,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
+        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:
-            # it re-enables the workflow and keeps kind (output media) in sync.
+            # 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 "is_enabled" not in data:
-                data["is_enabled"] = 1
         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.
-        explicit_null = {"endpoint_id"} & {k for k, v in data.items() if v is None}
+        # 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
@@ -253,14 +454,149 @@ async def update_workflow(workflow_id: int, payload: WorkflowUpdate) -> dict[str
         conn.close()
 
 
+def _job_public(job: dict[str, Any]) -> dict[str, Any]:
+    out = dict(job)
+    out["payload"] = json.loads(job.get("payload_json") or "{}")
+    out["output_paths"] = json.loads(job.get("output_paths_json") or "[]")
+    out.pop("payload_json", None)
+    out.pop("output_paths_json", None)
+    return out
+
+
+@router.post("/{workflow_id}/test")
+async def test_workflow(workflow_id: int, payload: WorkflowTestRequest) -> dict[str, Any]:
+    """Launch (or re-attach to) one REAL test run of a workflow (HEL-643 L3).
+
+    The job goes through the ordinary queue → ComfyUI → outputs pipeline;
+    only its artifacts and bookkeeping are isolated (origin='workflow_test').
+    A dry-run setting is refused outright — placeholder output must never
+    count as a test pass. Repeat clicks reuse the in-flight job.
+    """
+    from calliope import config
+
+    if config.settings.dry_run:
+        raise HTTPException(
+            status_code=400,
+            detail=(
+                "测试工作流必须真实运行：当前设置开启了 Dry-run（占位模式），"
+                "请到「设置」关闭 Dry-run 后再测试"
+            ),
+        )
+    conn = get_db(settings.db_path)
+    try:
+        wf = conn.execute(
+            "SELECT id, kind, workflow_json, input_schema, output_map, output_map_source,"
+            " endpoint_id FROM workflows WHERE id = ?",
+            (workflow_id,),
+        ).fetchone()
+        if not wf:
+            raise HTTPException(status_code=404, detail="Workflow not found")
+        workflow_json = json.loads(wf["workflow_json"])
+        broken = blocking_problem(workflow_json)
+        if broken:
+            raise HTTPException(status_code=400, detail=broken)
+        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
+        )
+        input_values, problems = validate_input_values(schema, payload.input_values)
+        if problems:
+            raise HTTPException(status_code=400, detail="参数有误：" + "；".join(problems))
+
+        endpoint_id = payload.endpoint_id or wf["endpoint_id"] or None
+        snapshot = endpoint_snapshot(endpoint_id)
+        active = find_active_test_job(workflow_id, (snapshot or {}).get("id"))
+        if active is not None:
+            return {"ok": True, "job": _job_public(active), "reused": True}
+
+        from calliope.routers.playground import ensure_playground_project
+
+        pid = ensure_playground_project(conn)
+    finally:
+        conn.close()
+
+    job = queue_manager.enqueue(
+        project_id=pid,
+        kind=wf["kind"],
+        workflow_id=workflow_id,
+        scene_id=None,
+        payload={
+            "input_values": input_values,
+            "source": TEST_SOURCE,
+            **({"endpoint_id": payload.endpoint_id} if payload.endpoint_id else {}),
+        },
+        origin="workflow_test",
+    )
+    await event_bus.publish(
+        "job.created",
+        {"job_id": job["id"], "kind": job["kind"], "source": TEST_SOURCE,
+         "project_id": job["project_id"], "workflow_test": True},
+    )
+    return {"ok": True, "job": _job_public(job), "reused": False}
+
+
+@router.get("/{workflow_id}/tests")
+async def list_workflow_tests(workflow_id: int) -> list[dict[str, Any]]:
+    conn = get_db(settings.db_path)
+    try:
+        row = conn.execute("SELECT id FROM workflows WHERE id = ?", (workflow_id,)).fetchone()
+    finally:
+        conn.close()
+    if not row:
+        raise HTTPException(status_code=404, detail="Workflow not found")
+    return list_test_jobs(workflow_id)
+
+
+@router.post("/{workflow_id}/clear-tests")
+async def clear_workflow_tests(workflow_id: int) -> dict[str, Any]:
+    """Delete every test record and artifact for this workflow."""
+    conn = get_db(settings.db_path)
+    try:
+        row = conn.execute("SELECT id FROM workflows WHERE id = ?", (workflow_id,)).fetchone()
+    finally:
+        conn.close()
+    if not row:
+        raise HTTPException(status_code=404, detail="Workflow not found")
+    try:
+        removed = purge_workflow_tests(workflow_id)
+    except RuntimeError as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+    await event_bus.publish("job.deleted", {"workflow_id": workflow_id, "source": TEST_SOURCE})
+    return {"ok": True, "removed": removed}
+
+
 @router.delete("/{workflow_id}")
 async def delete_workflow(workflow_id: int) -> dict[str, bool]:
     conn = get_db(settings.db_path)
     try:
-        cur = conn.execute("DELETE FROM workflows WHERE id = ?", (workflow_id,))
-        conn.commit()
-        if cur.rowcount == 0:
+        # HEL-619: refuse to delete while queued/running jobs still use the
+        # workflow — deleting sets their workflow_id NULL and the job dies
+        # with "工作流已被删除" only after the user waits for it.
+        row = conn.execute(
+            "SELECT id FROM workflows WHERE id = ?", (workflow_id,)
+        ).fetchone()
+        if not row:
             raise HTTPException(status_code=404, detail="Workflow not found")
+        pending = conn.execute(
+            "SELECT COUNT(*) AS n FROM jobs"
+            " WHERE workflow_id = ? AND status IN ('pending', 'running')",
+            (workflow_id,),
+        ).fetchone()["n"]
+        if pending:
+            raise HTTPException(
+                status_code=409,
+                detail=(
+                    f"该工作流还有 {pending} 个排队或执行中的任务，"
+                    "请先等任务完成或取消任务，再删除该工作流"
+                ),
+            )
+        # Test records/artifacts belong to the workflow — cascade (HEL-643).
+        # The 409 above guarantees none are in flight here.
+        purge_workflow_tests(workflow_id, allow_active=True)
+        conn.execute("DELETE FROM workflows WHERE id = ?", (workflow_id,))
+        conn.commit()
         return {"ok": True}
     finally:
         conn.close()

calliope-backend/tests/conftest.py

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

calliope-backend/tests/test_comfyui_endpoints.py

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

calliope-backend/tests/test_llm_profiles.py

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

calliope-backend/tests/test_media_groups.py

@@ -0,0 +1,266 @@
+"""媒体组泛化（HEL-643 批次 3）：参考视频/参考音频按 JSON 实际连线进入
+input_schema 与提交流程；无连线则无入口；05_ref2va 只保留参考图。
+
+视频/音频参考的真实 H3 JSON 暂无可执行样本（.15 无 ComfyUI），本套用
+自造 fixture + fake ComfyUI 验证解析/表单/回填/上传全链路（模拟链路）。
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+
+import pytest
+
+from calliope.comfyui.parser import parse_dynamic_inputs
+from calliope.comfyui.patcher import patch_workflow
+from calliope.comfyui.validate import validate_input_values
+from calliope.config import settings
+from tests.test_studio_generation import PNG_1PX, _real_run
+
+FIXTURES = Path(__file__).parent / "fixtures" / "comfy_native"
+
+
+@pytest.fixture
+def uploads_dir(client):
+    d = settings.assets_dir / "uploads"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def _load_05() -> dict:
+    return json.loads((FIXTURES / "h3_ref2va_05_API.json").read_text(encoding="utf-8"))
+
+
+def _ref2va_workflow(*, images=1, videos=1, audios=1) -> dict:
+    """H3 Ref2VA 形状的自造 JSON：图/视频/音频各一组 Autogrow 连线。"""
+    wf: dict = {
+        "1": {
+            "class_type": "PrimitiveStringMultiline",
+            "inputs": {"value": "提示词"},
+        },
+        "92": {
+            "class_type": "SaveVideo",
+            "inputs": {"video": ["131", 0]},
+        },
+        "131": {
+            "class_type": "MiniMaxH3ReferenceToVideo",
+            "inputs": {"prompt": ["1", 0]},
+        },
+        "901": {"class_type": "LoadImage", "inputs": {"image": "ref.png"}},
+        "902": {"class_type": "LoadVideo", "inputs": {"file": "ref.mp4", "force_rate": 0}},
+        "903": {"class_type": "LoadAudio", "inputs": {"audio": "ref.wav"}},
+    }
+    ins = wf["131"]["inputs"]
+    for i in range(images):
+        ins[f"ref_images.ref_image_{i}"] = ["901", 0]
+    for i in range(videos):
+        ins[f"ref_videos.ref_video_{i}"] = ["902", 0]
+    for i in range(audios):
+        ins[f"ref_audios.ref_audio_{i}"] = ["903", 0]
+    return wf
+
+
+def _entry(schema: list[dict], key_suffix: str) -> dict | None:
+    for e in schema:
+        if e["nodeId"].endswith("@" + key_suffix):
+            return e
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Schema: 入口只由实际连线决定
+# ---------------------------------------------------------------------------
+
+
+def test_ref2va_schema_exposes_three_media_groups():
+    schema = parse_dynamic_inputs(_ref2va_workflow())
+    img = _entry(schema, "ref_images")
+    vid = _entry(schema, "ref_videos")
+    aud = _entry(schema, "ref_audios")
+    assert img and img["kind"] == "image_list" and img["role"] == "reference_image"
+    assert img["max"] == 9 and img["label"] == "参考图"
+    assert vid and vid["kind"] == "video_list" and vid["role"] == "reference_video"
+    assert vid["max"] == 3 and vid["label"] == "参考视频"
+    assert aud and aud["kind"] == "audio_list" and aud["role"] == "reference_audio"
+    assert aud["max"] == 3 and aud["label"] == "参考音频"
+    # 官方限额提示按节点类名驱动（通用检测不携带 hint）
+    assert img["media_hint"] == vid["media_hint"] == aud["media_hint"] == "minimax_h3_ref2va"
+    # 被组吸收的 loader 不再单独出现
+    assert not any(e["nodeId"] == "902" for e in schema)
+    assert not any(e["nodeId"] == "903" for e in schema)
+
+
+def test_unwired_media_kinds_produce_no_entry():
+    schema = parse_dynamic_inputs(_ref2va_workflow(videos=0, audios=0))
+    assert _entry(schema, "ref_images") is not None
+    assert _entry(schema, "ref_videos") is None
+    assert _entry(schema, "ref_audios") is None
+
+
+def test_generic_class_gets_group_without_hint():
+    wf = _ref2va_workflow(videos=0, audios=0)
+    wf["20"] = {"class_type": "GenericRefNode", "inputs": {}}
+    wf["701"] = {"class_type": "VHS_LoadVideo", "inputs": {"video": "a.mp4"}}
+    wf["702"] = {"class_type": "VHS_LoadVideo", "inputs": {"video": "b.mp4"}}
+    wf["20"]["inputs"]["media.clip_0"] = ["701", 0]
+    wf["20"]["inputs"]["media.clip_1"] = ["702", 0]
+    schema = parse_dynamic_inputs(wf)
+    g = _entry(schema, "media")
+    assert g and g["kind"] == "video_list" and g["max"] == 9
+    assert "media_hint" not in g
+
+
+def test_05_ref2va_fixture_stays_image_only():
+    schema = parse_dynamic_inputs(_load_05())
+    lists = [e for e in schema if e["kind"].endswith("_list")]
+    assert len(lists) == 1
+    assert lists[0]["kind"] == "image_list" and lists[0]["max"] == 9
+    assert lists[0]["nodeId"] == "131@ref_images"
+
+
+# ---------------------------------------------------------------------------
+# Validation
+# ---------------------------------------------------------------------------
+
+
+def _media_file(path: str, data: bytes) -> str:
+    p = Path(path)
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_bytes(data)
+    return str(p)
+
+
+def test_validate_video_and_audio_lists(uploads_dir):
+    schema = parse_dynamic_inputs(_ref2va_workflow())
+    img_key = _entry(schema, "ref_images")["nodeId"]
+    vid_key = _entry(schema, "ref_videos")["nodeId"]
+    aud_key = _entry(schema, "ref_audios")["nodeId"]
+    png = _media_file(str(uploads_dir / "ok.png"), PNG_1PX)
+    mp4 = _media_file(str(uploads_dir / "ok.mp4"), b"00")
+    mp3 = _media_file(str(uploads_dir / "ok.mp3"), b"00")
+
+    clean, errs = validate_input_values(
+        schema, {"1": "p", img_key: [png], vid_key: [mp4], aud_key: [mp3]}
+    )
+    assert errs == [] and clean[vid_key] == [mp4] and clean[aud_key] == [mp3]
+
+    # 错误格式（图片文件填视频槽 / 视频文件填音频槽）
+    _, errs = validate_input_values(
+        schema, {"1": "p", img_key: [png], vid_key: [png], aud_key: [mp3]}
+    )
+    assert errs == ["参考视频 1：格式不支持，请使用 MP4 / WebM / MOV"]
+    _, errs = validate_input_values(
+        schema, {"1": "p", img_key: [png], vid_key: [mp4], aud_key: [mp4]}
+    )
+    assert errs == ["参考音频 1：格式不支持，请使用 MP3 / WAV / M4A"]
+
+    # 上限（H3 官方 3 段）与最少 1 段
+    four = [_media_file(str(uploads_dir / f"v{i}.mp4"), b"00") for i in range(4)]
+    _, errs = validate_input_values(
+        schema, {"1": "p", img_key: [png], vid_key: four, aud_key: [mp3]}
+    )
+    assert errs == ["参考视频最多 3 段（当前 4 段），请删除多余的视频"]
+    _, errs = validate_input_values(
+        schema, {"1": "p", img_key: [png], aud_key: [mp3]}
+    )
+    assert errs == ["需要至少 1 段参考视频"]
+
+
+# ---------------------------------------------------------------------------
+# Patcher + full chain against fake ComfyUI
+# ---------------------------------------------------------------------------
+
+
+def test_patcher_clones_and_backfills_each_media_kind(uploads_dir):
+    wf = _ref2va_workflow()
+    schema = parse_dynamic_inputs(wf)
+    pngs = [_media_file(str(uploads_dir / "r1.png"), PNG_1PX),
+            _media_file(str(uploads_dir / "r2.png"), PNG_1PX)]
+    mp4 = _media_file(str(uploads_dir / "v1.mp4"), b"00")
+    mp3 = _media_file(str(uploads_dir / "a1.mp3"), b"00")
+    patched = patch_workflow(
+        wf,
+        {
+            _entry(schema, "ref_images")["nodeId"]: pngs,
+            _entry(schema, "ref_videos")["nodeId"]: [mp4],
+            _entry(schema, "ref_audios")["nodeId"]: [mp3],
+        },
+    )
+    ins = patched["131"]["inputs"]
+    image_links = [v for k, v in ins.items() if k.startswith("ref_images.")]
+    video_links = [v for k, v in ins.items() if k.startswith("ref_videos.")]
+    audio_links = [v for k, v in ins.items() if k.startswith("ref_audios.")]
+    assert len(image_links) == 2 and len(video_links) == 1 and len(audio_links) == 1
+    loaders = {nid: n for nid, n in patched.items()
+               if n.get("class_type") in ("LoadImage", "LoadVideo", "LoadAudio")}
+    imgs = [n for n in loaders.values() if n["class_type"] == "LoadImage"]
+    vids = [n for n in loaders.values() if n["class_type"] == "LoadVideo"]
+    auds = [n for n in loaders.values() if n["class_type"] == "LoadAudio"]
+    assert len(imgs) == 2 and all(n["inputs"]["image"] in pngs for n in imgs)
+    assert vids and vids[0]["inputs"]["file"] == mp4
+    assert auds and auds[0]["inputs"]["audio"] == mp3
+    # 克隆出的节点带中文槽位标题
+    assert {n["_meta"]["title"] for n in imgs} == {"参考图 1", "参考图 2"}
+    assert vids[0]["_meta"]["title"] == "参考视频 1"
+    assert auds[0]["_meta"]["title"] == "参考音频 1"
+
+
+def test_full_chain_uploads_and_backfills_media_groups(client, fake_comfy, uploads_dir):
+    """提交 → 上传 → 回填：fake ComfyUI 收到的 prompt 里每类 loader 都
+    指向已上传文件（模拟链路：fake 端点，非真机 H3）。"""
+    wf = _ref2va_workflow()
+    png = _media_file(str(uploads_dir / "ref.png"), PNG_1PX)
+    mp4 = _media_file(str(uploads_dir / "ref.mp4"), b"00")
+    mp3 = _media_file(str(uploads_dir / "ref.mp3"), b"00")
+    r = client.post(
+        "/api/workflows",
+        json={"name": "媒体组链路", "workflow_json": wf, "usage": "ref2video"},
+    )
+    assert r.status_code == 200, r.text
+    wf_id = r.json()["id"]
+    schema = r.json()["input_schema"]
+
+    with _real_run(client, fake_comfy):
+        fake_comfy.out_name = "media_out.mp4"
+        r = client.post(
+            f"/api/workflows/{wf_id}/test",
+            json={
+                "input_values": {
+                    _entry(schema, "ref_images")["nodeId"]: [png],
+                    _entry(schema, "ref_videos")["nodeId"]: [mp4],
+                    _entry(schema, "ref_audios")["nodeId"]: [mp3],
+                }
+            },
+        )
+        assert r.status_code == 200, r.text
+        job_id = r.json()["job"]["id"]
+
+        deadline = time.time() + 25
+        job = {}
+        while time.time() < deadline:
+            job = client.get(f"/api/jobs/{job_id}").json()
+            if job["status"] not in ("pending", "running"):
+                break
+            time.sleep(0.4)
+        assert job["status"] == "done", job.get("error")
+
+    assert len(fake_comfy.uploads) >= 3  # 图、视频、音频各一次
+    queued = fake_comfy.prompts[-1]["prompt"]
+    loaders = [n for n in queued.values()
+               if n.get("class_type") in ("LoadImage", "LoadVideo", "LoadAudio")]
+    by_field = {
+        (n["class_type"], k): v
+        for n in loaders
+        for k, v in n["inputs"].items()
+        if isinstance(v, str) and "uploaded-input" in v
+    }
+    assert ("LoadImage", "image") in by_field
+    assert ("LoadVideo", "file") in by_field
+    assert ("LoadAudio", "audio") in by_field
+    # 组连线数与提交数一致
+    ins = queued["131"]["inputs"]
+    assert len([k for k in ins if k.startswith("ref_images.")]) == 1
+    assert len([k for k in ins if k.startswith("ref_videos.")]) == 1
+    assert len([k for k in ins if k.startswith("ref_audios.")]) == 1

calliope-backend/tests/test_shell_tool.py

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

calliope-backend/tests/test_studio_generation.py

@@ -25,9 +25,19 @@ PNG_1PX = bytes.fromhex(
 
 
 class _FakeComfyHandler(BaseHTTPRequestHandler):
-    """Minimal ComfyUI: /system_stats, /prompt, /history/{id}, /view, /upload/image."""
+    """Minimal ComfyUI: /system_stats, /prompt, /history/{id}, /view, /upload/image.
+
+    History outputs are keyed by the prompt's real output node id (what
+    ComfyUI does); a known output class that is absent falls back to
+    ``server.forced_output_node`` (default "9"). Scripted tests can pin
+    ``server.forced_output_node`` or drop entries via ``server.drop_outputs``.
+    """
 
     server_version = "FakeComfy/1.0"
+    KNOWN_OUTPUT_CLASSES = {
+        "SaveImage", "PreviewImage", "SaveImageAdvanced", "SaveImageWebsocket",
+        "SaveVideo", "VideoOutput", "VHS_VideoCombine", "AnimateDiffCombine",
+    }
 
     def do_GET(self):
         self.server.requests.append(self.path)
@@ -40,6 +50,9 @@ class _FakeComfyHandler(BaseHTTPRequestHandler):
                 },
             )
             return
+        if self.path == "/object_info":
+            self._json(200, dict(getattr(self.server, "object_info", None) or {}))
+            return
         if self.path.startswith("/history/"):
             pid = self.path[len("/history/") :]
             entry = self.server.history.get(pid)
@@ -64,11 +77,17 @@ 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"}
+                ]
             }
+            outputs = (
+                {} if getattr(self.server, "drop_outputs", False) else
+                {self._output_node(body): out_entry}
+            )
             self.server.history[prompt_id] = {
                 "status": {"status_str": "success", "completed": True},
-                "outputs": {"9": out_entry},
+                "outputs": outputs,
                 "prompt": [],
             }
             self.server.prompts.append(json.loads(body.decode("utf-8") or "{}"))
@@ -80,6 +99,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 +141,9 @@ def fake_comfy():
     server.fail_prompt = False
     server.out_name = "out-1.png"
     server.outputs_key = "images"
+    server.forced_output_node = None
+    server.object_info = {}
+    server.drop_outputs = False
     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_video_continue.py

@@ -268,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"}]}
         },
     }
 
@@ -287,7 +289,11 @@ def _stub_comfy(monkeypatch, captured: dict) -> list[str]:
     prepare_media_inputs handed it; download_image writes out.mp4. Returns
     the list that collects uploaded local paths.
     """
-    queue_manager.paused = True
+    # monkeypatch (not bare assignment): queue_manager is a process-level
+    # singleton — a bare `paused = True` leaks into every later test and
+    # stalls e.g. test_workbench's worker (HEL-619). monkeypatch restores
+    # the previous value at teardown.
+    monkeypatch.setattr(queue_manager, "paused", True)
     uploads: list[str] = []
 
     async def fake_upload_video(self, path, subfolder="calliope"):

calliope-backend/tests/test_workflow_preflight.py

@@ -0,0 +1,272 @@
+"""L2 连接核查（HEL-643 批次 1）：导入/复查时用目标 ComfyUI 的 /object_info
+预检节点与模型可用性。全部基于 fake ComfyUI 的脚本化 /object_info，
+不针对任何固定 JSON 或模型名写死判定。"""
+
+from __future__ import annotations
+
+import json
+import socket
+from pathlib import Path
+
+import pytest
+
+from calliope.comfyui.client import clear_object_info_cache
+from calliope.comfyui.preflight import check_workflow_against
+from calliope.config import settings
+from tests.test_studio_generation import _url
+
+FIXTURES = Path(__file__).parent / "fixtures" / "comfy_native"
+
+
+def _load_05() -> dict:
+    return json.loads((FIXTURES / "h3_ref2va_05_API.json").read_text(encoding="utf-8"))
+
+
+def build_object_info(workflow: dict) -> dict:
+    """A catalogue where every widget value the JSON carries is legal.
+
+    String widgets become combos whose candidates include the workflow's own
+    value (merged across nodes of the same class); numbers/booleans are typed
+    inputs; wired inputs are link types — none of those can mismatch.
+    """
+    info: dict = {}
+    for node in workflow.values():
+        if not isinstance(node, dict):
+            continue
+        ct = str(node.get("class_type") or "")
+        if not ct:
+            continue
+        spec = info.setdefault(ct, {"input": {"required": {}}, "output": ["*"]})
+        required = spec["input"]["required"]
+        for name, val in (node.get("inputs") or {}).items():
+            if isinstance(val, str):
+                # Merge: two nodes of one class with different values → both legal.
+                if name in required and isinstance(required[name][0], list):
+                    if val not in required[name][0]:
+                        required[name][0] = [*required[name][0], val]
+                    continue
+                required[name] = [[val], {}]
+            elif name in required:
+                continue
+            elif isinstance(val, list):
+                required[name] = ["*", {}]
+            elif isinstance(val, bool):
+                required[name] = ["BOOLEAN", {}]
+            elif isinstance(val, (int, float)):
+                required[name] = ["NUMBER", {}]
+    return info
+
+
+@pytest.fixture(autouse=True)
+def _fresh_cache():
+    clear_object_info_cache()
+    yield
+    clear_object_info_cache()
+
+
+@pytest.fixture
+def endpoint_at(client, fake_comfy):  # noqa: F811
+    """Register a connection pointing at the fake server; yields its id."""
+    prev_eps = [dict(ep) for ep in (settings.comfyui_endpoints or [])]
+    prev_active = settings.comfyui_active_id
+    r = client.post(
+        "/api/comfyui/endpoints",
+        json={"name": "预检桩", "base_url": _url(fake_comfy), "auth_type": "none"},
+    )
+    assert r.status_code == 200, r.text
+    endpoints = r.json()["endpoints"]
+    ep = next(e for e in endpoints if e["base_url"] == _url(fake_comfy))
+    settings.comfyui_endpoints = [dict(e) for e in endpoints if e["base_url"] == _url(fake_comfy)]
+    settings.comfyui_active_id = ep["id"]
+    settings.apply_active_comfyui()
+    try:
+        yield ep["id"]
+    finally:
+        settings.comfyui_endpoints = prev_eps
+        settings.comfyui_active_id = prev_active
+        settings.apply_active_comfyui()
+
+
+# ---------------------------------------------------------------------------
+# Unit rules
+# ---------------------------------------------------------------------------
+
+
+def test_unit_missing_node_reported_with_node_context():
+    wf = {"900": {"class_type": "H3SLAAttention", "inputs": {"enabled": True},
+                  "_meta": {"title": "H3 SLA Attention"}}}
+    findings = check_workflow_against({"OtherNode": {}}, wf)
+    assert len(findings) == 1
+    f = findings[0]
+    assert f["code"] == "missing_node" and f["level"] == "error"
+    msg = f["message"]
+    assert "H3SLAAttention" in msg and "900" in msg and "H3 SLA Attention" in msg
+    assert "重新检查" in f["hint"]
+
+
+def test_unit_combo_value_not_in_list():
+    wf = {"127": {"class_type": "UNETLoader",
+                  "inputs": {"unet_name": "missing_model.safetensors", "weight_dtype": "default"}}}
+    info = {"UNETLoader": {"input": {"required": {
+        "unet_name": [["installed_model.safetensors"], {}],
+        "weight_dtype": [["default", "fp8"], {"upload": False}],
+    }}, "output": ["MODEL"]}}
+    findings = check_workflow_against(info, wf)
+    assert len(findings) == 1
+    f = findings[0]
+    assert f["code"] == "value_not_in_list" and f["node_id"] == "127"
+    assert "missing_model.safetensors" in f["message"] and "unet_name" in f["message"]
+    assert "模型文件" in f["message"]
+    assert "installed_model.safetensors" in f["hint"]
+
+
+def test_unit_upload_backed_and_wired_inputs_skipped():
+    wf = {
+        "1": {"class_type": "LoadImage", "inputs": {"image": "placeholder.png"}},
+        "2": {"class_type": "LoadVideo", "inputs": {"file": "clip.mp4"}},
+        "3": {"class_type": "LoadAudio", "inputs": {"audio": "voice.wav"}},
+        "4": {"class_type": "KSampler", "inputs": {"seed": 7, "model": ["9", 0]}},
+    }
+    info = {
+        "LoadImage": {"input": {"required": {"image": [["other.png"], {"image_upload": True}]}},
+                      "output": ["IMAGE"]},
+        "LoadVideo": {"input": {"required": {"file": [[], {}]}}, "output": ["IMAGE"]},
+        "LoadAudio": {"input": {"required": {"audio": [[], {}]}}, "output": ["AUDIO"]},
+        "KSampler": {"input": {"required": {"seed": ["INT", {}], "model": ["MODEL", {}]}},
+                     "output": ["IMAGE"]},
+    }
+    assert check_workflow_against(info, wf) == []
+
+
+# ---------------------------------------------------------------------------
+# Analyze with a target connection
+# ---------------------------------------------------------------------------
+
+
+def test_analyze_all_green_against_fake_object_info(client, endpoint_at, fake_comfy):
+    fake_comfy.object_info = build_object_info(_load_05())
+    r = client.post(
+        "/api/workflows/analyze",
+        json={"workflow_json": _load_05(), "endpoint_id": endpoint_at},
+    )
+    assert r.status_code == 200, r.text
+    check = r.json()["connection_check"]
+    assert check["reachable"] is True and check["ok"] is True
+    assert check["findings"] == []
+
+
+def test_analyze_reports_missing_custom_node(client, endpoint_at, fake_comfy):
+    info = build_object_info(_load_05())
+    info.pop("H3SLAAttention")
+    fake_comfy.object_info = info
+    r = client.post(
+        "/api/workflows/analyze",
+        json={"workflow_json": _load_05(), "endpoint_id": endpoint_at},
+    )
+    check = r.json()["connection_check"]
+    assert check["ok"] is False
+    missing = [f for f in check["findings"] if f["code"] == "missing_node"]
+    assert missing and "H3SLAAttention" in missing[0]["message"]
+    assert "900" in missing[0]["message"]
+
+
+def test_analyze_reports_missing_model_value(client, endpoint_at, fake_comfy):
+    info = build_object_info(_load_05())
+    # The server has a DIFFERENT unet installed than the one the JSON names.
+    info["UNETLoader"]["input"]["required"]["unet_name"] = [["another_unet.safetensors"], {}]
+    fake_comfy.object_info = info
+    r = client.post(
+        "/api/workflows/analyze",
+        json={"workflow_json": _load_05(), "endpoint_id": endpoint_at},
+    )
+    check = r.json()["connection_check"]
+    assert check["ok"] is False
+    bad = [f for f in check["findings"] if f["code"] == "value_not_in_list"]
+    assert bad and bad[0]["node_id"] == "127"
+    assert "minimax_h3_fused_refdelta" in bad[0]["message"]
+
+
+def test_unreachable_connection_degrades_to_unchecked(client):
+    # A port that nothing listens on: the endpoint resolves, the server doesn't.
+    s = socket.socket()
+    s.bind(("127.0.0.1", 0))
+    port = s.getsockname()[1]
+    s.close()
+    prev_eps = [dict(ep) for ep in (settings.comfyui_endpoints or [])]
+    prev_active = settings.comfyui_active_id
+    r = client.post(
+        "/api/comfyui/endpoints",
+        json={"name": "断连桩", "base_url": f"http://127.0.0.1:{port}", "auth_type": "none"},
+    )
+    endpoints = r.json()["endpoints"]
+    ep = next(e for e in endpoints if e["base_url"] == f"http://127.0.0.1:{port}")
+    settings.comfyui_endpoints = [dict(e) for e in endpoints if e["id"] == ep["id"]]
+    settings.comfyui_active_id = ep["id"]
+    settings.apply_active_comfyui()
+    try:
+        r = client.post(
+            "/api/workflows/analyze",
+            json={"workflow_json": _load_05(), "endpoint_id": ep["id"]},
+        )
+        check = r.json()["connection_check"]
+        assert check["reachable"] is False and check["ok"] is False
+        assert "无法核查" in check["message"]
+        assert check["findings"] == []
+    finally:
+        settings.comfyui_endpoints = prev_eps
+        settings.comfyui_active_id = prev_active
+        settings.apply_active_comfyui()
+
+
+# ---------------------------------------------------------------------------
+# Saved-workflow re-check + cache
+# ---------------------------------------------------------------------------
+
+
+def _create_workflow(client, workflow: dict, endpoint_id: str | None = None) -> int:
+    r = client.post(
+        "/api/workflows",
+        json={
+            "name": "预检工作流",
+            "workflow_json": workflow,
+            "usage": "ref2video",
+            **({"endpoint_id": endpoint_id} if endpoint_id else {}),
+        },
+    )
+    assert r.status_code == 200, r.text
+    return r.json()["id"]
+
+
+def test_saved_workflow_recheck_and_refresh(client, endpoint_at, fake_comfy):
+    wf_id = _create_workflow(client, _load_05(), endpoint_at)
+    info = build_object_info(_load_05())
+    info.pop("UNETLoader")
+    fake_comfy.object_info = info
+    r = client.post(f"/api/workflows/{wf_id}/check", json={})
+    assert r.status_code == 200, r.text
+    body = r.json()
+    assert body["ok"] is False and body["endpoint_id"] == endpoint_at
+    assert any(f["code"] == "missing_node" for f in body["findings"])
+
+    # User installs the node package, comes back and re-checks with refresh.
+    fake_comfy.object_info = build_object_info(_load_05())
+    r = client.post(f"/api/workflows/{wf_id}/check", json={"refresh": True})
+    body = r.json()
+    assert body["ok"] is True and body["findings"] == []
+
+
+def test_object_info_cached_within_ttl(client, endpoint_at, fake_comfy):
+    fake_comfy.object_info = build_object_info(_load_05())
+    for _ in range(2):
+        r = client.post(
+            "/api/workflows/analyze",
+            json={"workflow_json": _load_05(), "endpoint_id": endpoint_at},
+        )
+        assert r.json()["connection_check"]["ok"] is True
+    hits = [p for p in fake_comfy.requests if p == "/object_info"]
+    assert len(hits) == 1  # second call served from the 5-minute cache
+
+    wf_id = _create_workflow(client, _load_05())
+    client.post(f"/api/workflows/{wf_id}/check", json={"refresh": True})
+    hits = [p for p in fake_comfy.requests if p == "/object_info"]
+    assert len(hits) == 2  # manual refresh bypasses the TTL

calliope-backend/tests/test_workflow_test.py

@@ -0,0 +1,197 @@
+"""「测试工作流」（HEL-643 批次 2）端到端：真实队列 → fake ComfyUI → 产物隔离。
+
+测试任务与普通任务区分（jobs.origin）、dry-run 拒绝、幂等复用、
+保留策略与级联清理，全部对着 fake ComfyUI 跑真实链路。
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+
+from calliope.config import settings
+from calliope.queue.workflow_test import workflow_test_dir
+from tests.test_studio_generation import (
+    IMAGE_WORKFLOW,
+    PNG_1PX,
+    _real_run,
+)
+
+
+def _wait_terminal(client, job_id: int, timeout: float = 25.0) -> dict:
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        r = client.get(f"/api/jobs/{job_id}")
+        assert r.status_code == 200, r.text
+        job = r.json()
+        if job["status"] not in ("pending", "running"):
+            return job
+        time.sleep(0.4)
+    raise AssertionError(f"test job {job_id} did not finish in {timeout}s")
+
+
+def _create_workflow(client, workflow: dict, name: str = "可测工作流") -> int:
+    r = client.post(
+        "/api/workflows",
+        json={"name": name, "workflow_json": workflow, "usage": "text2image"},
+    )
+    assert r.status_code == 200, r.text
+    return r.json()["id"]
+
+
+def test_passing_test_downloads_real_output_to_scratch_dir(client, fake_comfy):
+    with _real_run(client, fake_comfy):
+        wf_id = _create_workflow(client, IMAGE_WORKFLOW, name="通过用例")
+        r = client.post(
+            f"/api/workflows/{wf_id}/test", json={"input_values": {"1": "测试提示词"}}
+        )
+        assert r.status_code == 200, r.text
+        body = r.json()
+        assert body["reused"] is False
+        job = _wait_terminal(client, body["job"]["id"])
+        assert job["status"] == "done", job.get("error")
+        assert job["origin"] == "workflow_test"
+        assert job["payload"]["source"] == "workflow_test"
+        assert job["phase"] == "finished"
+        # 真实拿到可下载输出才算通过：产物落在独立 scratch 目录
+        assert len(job["output_paths"]) >= 1
+        out = Path(job["output_paths"][0])
+        assert out.is_file() and out.read_bytes() == PNG_1PX
+        assert workflow_test_dir(wf_id) in out.parents
+        # 提交给 fake ComfyUI 的是补丁后的真实提示词
+        queued = fake_comfy.prompts[-1]["prompt"]
+        assert queued["1"]["inputs"]["text"] == "测试提示词"
+
+
+def test_tasks_list_shows_origin_but_playground_history_hides_it(client, fake_comfy):
+    with _real_run(client, fake_comfy):
+        wf_id = _create_workflow(client, IMAGE_WORKFLOW, name="可见性用例")
+        r = client.post(f"/api/workflows/{wf_id}/test", json={"input_values": {"1": "p"}})
+        job_id = r.json()["job"]["id"]
+        _wait_terminal(client, job_id)
+
+        listed = client.get("/api/jobs?limit=50").json()
+        mine = [j for j in listed if j["id"] == job_id]
+        assert mine and mine[0]["origin"] == "workflow_test"
+
+        pg = client.get("/api/playground/jobs").json()
+        assert all(j["id"] != job_id for j in pg), "test jobs must stay out of studio history"
+
+
+def test_failed_prompt_reports_chinese_reason(client, fake_comfy):
+    with _real_run(client, fake_comfy):
+        wf_id = _create_workflow(client, IMAGE_WORKFLOW, name="排队被拒用例")
+        fake_comfy.fail_prompt = True
+        r = client.post(f"/api/workflows/{wf_id}/test", json={"input_values": {"1": "p"}})
+        job = _wait_terminal(client, r.json()["job"]["id"])
+        assert job["status"] == "failed"
+        assert "拒绝执行" in (job["error"] or "")
+
+
+def test_no_output_does_not_pass(client, fake_comfy):
+    with _real_run(client, fake_comfy):
+        wf_id = _create_workflow(client, IMAGE_WORKFLOW, name="无输出用例")
+        fake_comfy.drop_outputs = True
+        r = client.post(f"/api/workflows/{wf_id}/test", json={"input_values": {"1": "p"}})
+        job = _wait_terminal(client, r.json()["job"]["id"])
+        assert job["status"] == "failed"
+        assert "没有返回任何图片或视频" in (job["error"] or "")
+
+
+def test_dry_run_setting_refuses_real_test(client, fake_comfy):
+    with _real_run(client, fake_comfy):
+        settings.dry_run = True  # conftest default; _real_run clears it — set again
+        try:
+            wf_id = _create_workflow(client, IMAGE_WORKFLOW, name="dry 拒绝用例")
+            r = client.post(f"/api/workflows/{wf_id}/test", json={"input_values": {"1": "p"}})
+            assert r.status_code == 400
+            assert "Dry-run" in r.json()["detail"]
+        finally:
+            settings.dry_run = False
+
+
+def test_repeat_click_reuses_inflight_job(client, fake_comfy):
+    with _real_run(client, fake_comfy):
+        wf_id = _create_workflow(client, IMAGE_WORKFLOW, name="幂等用例")
+        assert client.post("/api/jobs/pause").status_code == 200
+        try:
+            r1 = client.post(
+                f"/api/workflows/{wf_id}/test", json={"input_values": {"1": "一次就好"}}
+            )
+            assert r1.status_code == 200 and r1.json()["reused"] is False
+            r2 = client.post(
+                f"/api/workflows/{wf_id}/test", json={"input_values": {"1": "重复点击"}}
+            )
+            assert r2.status_code == 200
+            assert r2.json()["reused"] is True
+            assert r2.json()["job"]["id"] == r1.json()["job"]["id"]
+        finally:
+            client.post("/api/jobs/resume")
+        client.post(f"/api/jobs/{r1.json()['job']['id']}/cancel")
+        _wait_terminal(client, r1.json()["job"]["id"])
+
+
+def test_retention_keeps_newest_records_and_prunes_artifacts(client, fake_comfy):
+    with _real_run(client, fake_comfy):
+        wf_id = _create_workflow(client, IMAGE_WORKFLOW, name="保留策略用例")
+        for i in range(7):
+            fake_comfy.out_name = f"t{i}.png"
+            r = client.post(
+                f"/api/workflows/{wf_id}/test",
+                json={"input_values": {"1": f"第{i}次"}},
+            )
+            _wait_terminal(client, r.json()["job"]["id"])
+        rows = client.get(f"/api/workflows/{wf_id}/tests").json()
+        assert len(rows) <= 5
+        kept_ids = {row["id"] for row in rows}
+        # 被清掉的旧记录其产物文件也一并删除
+        leftovers = [p for p in workflow_test_dir(wf_id).iterdir() if p.suffix == ".png"]
+        assert all(p.stem.lstrip("t").isdigit() and int(p.stem[1:]) >= 2 for p in leftovers)
+        assert len(kept_ids) == 5
+
+
+def test_clear_tests_and_workflow_delete_cascade(client, fake_comfy):
+    with _real_run(client, fake_comfy):
+        wf_id = _create_workflow(client, IMAGE_WORKFLOW, name="清理用例")
+        r = client.post(f"/api/workflows/{wf_id}/test", json={"input_values": {"1": "p"}})
+        _wait_terminal(client, r.json()["job"]["id"])
+        assert workflow_test_dir(wf_id).is_dir()
+
+        r = client.post(f"/api/workflows/{wf_id}/clear-tests")
+        assert r.status_code == 200 and r.json()["removed"] >= 1
+        assert not workflow_test_dir(wf_id).exists()
+        assert client.get(f"/api/workflows/{wf_id}/tests").json() == []
+
+        # 进行中的测试：先拒绝清除，取消后删除工作流级联清理
+        assert client.post("/api/jobs/pause").status_code == 200
+        try:
+            job_id = client.post(
+                f"/api/workflows/{wf_id}/test", json={"input_values": {"1": "p"}}
+            ).json()["job"]["id"]
+            r = client.post(f"/api/workflows/{wf_id}/clear-tests")
+            assert r.status_code == 409
+        finally:
+            client.post("/api/jobs/resume")
+        client.post(f"/api/jobs/{job_id}/cancel")
+        _wait_terminal(client, job_id)
+
+        # 工作流列表带出「上次测试」实时状态
+        listed = client.get("/api/workflows").json()
+        mine = [w for w in listed if w["id"] == wf_id][0]
+        assert mine["last_test"]["id"] == job_id
+
+        assert client.delete(f"/api/workflows/{wf_id}").status_code == 200
+        assert not workflow_test_dir(wf_id).exists()
+        assert client.get(f"/api/workflows/{wf_id}/tests").status_code == 404
+
+
+def test_last_test_summary_live_on_list(client, fake_comfy):
+    with _real_run(client, fake_comfy):
+        wf_a = _create_workflow(client, IMAGE_WORKFLOW, name="A")
+        wf_b = _create_workflow(client, IMAGE_WORKFLOW, name="B")
+        r = client.post(f"/api/workflows/{wf_a}/test", json={"input_values": {"1": "p"}})
+        done = _wait_terminal(client, r.json()["job"]["id"])
+        listed = {w["id"]: w for w in client.get("/api/workflows").json()}
+        assert listed[wf_a]["last_test"]["status"] == "done"
+        assert listed[wf_a]["last_test"]["output_count"] == len(done["output_paths"])
+        assert listed[wf_b]["last_test"] is None

calliope-web/src/lib/api.ts

@@ -137,6 +137,9 @@ import type {
   WorkflowAnalyzeResult,
   ComfyDynamicInput,
   ComfyDynamicOutput,
+  WorkflowOutputMapEntry,
+  WorkflowConnectionCheck,
+  WorkflowLastTest,
 } from "./comfy/types";
 export type {
   Job,
@@ -148,6 +151,9 @@ export type {
   WorkflowAnalyzeResult,
   ComfyDynamicInput,
   ComfyDynamicOutput,
+  WorkflowOutputMapEntry,
+  WorkflowConnectionCheck,
+  WorkflowLastTest,
 };
 
 async function api<T>(path: string, init?: RequestInit): Promise<T> {
@@ -456,13 +462,50 @@ export const comfy = {
 
 export const workflows = {
   list: () => api<Workflow[]>("/api/workflows"),
-  analyze: (workflow_json: Record<string, unknown>) =>
+  analyze: (
+    workflow_json: Record<string, unknown>,
+    endpoint_id?: string | null,
+    refresh = false,
+  ) =>
     api<WorkflowAnalyzeResult>("/api/workflows/analyze", {
       method: "POST",
-      body: JSON.stringify({ workflow_json }),
+      body: JSON.stringify({
+        workflow_json,
+        ...(endpoint_id ? { endpoint_id } : {}),
+        ...(refresh ? { refresh } : {}),
+      }),
     }),
   reanalyze: (id: number) =>
     api<Workflow>(`/api/workflows/${id}/reanalyze`, { method: "POST" }),
+  /** L2 re-check against a live ComfyUI (HEL-643): node/model availability. */
+  check: (
+    id: number,
+    payload?: { endpoint_id?: string | null; refresh?: boolean },
+  ) =>
+    api<WorkflowConnectionCheck>(`/api/workflows/${id}/check`, {
+      method: "POST",
+      body: JSON.stringify(payload ?? {}),
+    }),
+  /** Launch (or re-attach to) one REAL test run (HEL-643 L3). */
+  test: (
+    id: number,
+    payload: {
+      endpoint_id?: string | null;
+      input_values?: Record<string, unknown>;
+    },
+  ) =>
+    api<{ ok: boolean; job: Job; reused: boolean }>(
+      `/api/workflows/${id}/test`,
+      {
+        method: "POST",
+        body: JSON.stringify(payload),
+      },
+    ),
+  tests: (id: number) => api<Job[]>(`/api/workflows/${id}/tests`),
+  clearTests: (id: number) =>
+    api<{ ok: boolean; removed: number }>(`/api/workflows/${id}/clear-tests`, {
+      method: "POST",
+    }),
   create: (payload: {
     name: string;
     workflow_json: Record<string, unknown>;
@@ -470,6 +513,8 @@ export const workflows = {
     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;
@@ -490,6 +535,8 @@ export const workflows = {
       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

@@ -1,26 +1,72 @@
-import { t } from '$lib/i18n.svelte';
+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_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'];
+const IMAGE_EXTS = [".png", ".jpg", ".jpeg", ".webp"];
+
+/** Reference video slots (HEL-643): MP4 / WebM / MOV, ≤ 500MB (upload cap). */
+export const VIDEO_SLOT_ACCEPT =
+  "video/mp4,video/webm,video/quicktime,.mp4,.webm,.mov";
+export const VIDEO_SLOT_MAX_BYTES = 500 * 1024 * 1024;
+const VIDEO_EXTS = [".mp4", ".webm", ".mov"];
+
+/** Reference audio slots (HEL-643): MP3 / WAV / M4A, ≤ 100MB. */
+export const AUDIO_SLOT_ACCEPT =
+  "audio/mpeg,audio/wav,audio/mp4,.mp3,.wav,.m4a";
+export const AUDIO_SLOT_MAX_BYTES = 100 * 1024 * 1024;
+const AUDIO_EXTS = [".mp3", ".wav", ".m4a"];
+
+export type MediaSlotKind = "image" | "video" | "audio";
+
+export function mediaSlotAccept(kind: MediaSlotKind): string {
+  if (kind === "video") return VIDEO_SLOT_ACCEPT;
+  if (kind === "audio") return AUDIO_SLOT_ACCEPT;
+  return IMAGE_SLOT_ACCEPT;
+}
+
+/** Why this file cannot fill a media slot of this kind (null = fine). */
+export function mediaFileProblem(
+  kind: MediaSlotKind,
+  file: { name: string; size: number },
+): string | null {
+  const dot = file.name.lastIndexOf(".");
+  const ext = dot >= 0 ? file.name.slice(dot).toLowerCase() : "";
+  const max =
+    kind === "video"
+      ? VIDEO_SLOT_MAX_BYTES
+      : kind === "audio"
+        ? AUDIO_SLOT_MAX_BYTES
+        : IMAGE_SLOT_MAX_BYTES;
+  if (kind === "video" && !VIDEO_EXTS.includes(ext))
+    return t("studio.errVideoFormat", { name: file.name });
+  if (kind === "audio" && !AUDIO_EXTS.includes(ext))
+    return t("studio.errAudioFormat", { name: file.name });
+  if (kind === "image" && !IMAGE_EXTS.includes(ext))
+    return t("studio.errImageFormat", { name: file.name });
+  if (file.size > max)
+    return kind === "image"
+      ? t("studio.errImageSize", { name: file.name })
+      : t("studio.errMediaSize", { name: file.name });
+  return null;
+}
 
 /** 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 imageFileProblem(file: {
+  name: string;
+  size: number;
+}): string | null {
+  return mediaFileProblem("image", file);
 }
 
 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`;
+  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;
+  const raw = p.split(/[/\\]/).pop() ?? p;
+  return /^[0-9a-f]{8}-/.test(raw) ? raw.slice(9) : raw;
 }

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

@@ -8,7 +8,10 @@ export type ComfyInputKind =
 	| 'audio'
 	| 'video'
 	/** Ordered list of images for one Autogrow input (e.g. H3 ref_images, min…max). */
-	| 'image_list';
+	| 'image_list'
+	/** Ordered lists of videos / audios for Autogrow inputs (HEL-643). */
+	| 'video_list'
+	| 'audio_list';
 export type ComfyOutputKind = 'image' | 'video' | 'other';
 
 /** Structural finding on an imported workflow; `error` blocks generation. */
@@ -38,6 +41,8 @@ export interface ComfyDynamicInput {
 	options?: string[];
 	/** On a ResolutionSelector aspect_ratio entry: its megapixels key and rounding multiple. */
 	resolution?: { megapixels: string; multiple: number };
+	/** Official usage-limits hint key for known media groups (HEL-643, e.g. 'minimax_h3_ref2va'). */
+	media_hint?: string;
 }
 
 export interface ComfyDynamicOutput {
@@ -45,10 +50,21 @@ export interface ComfyDynamicOutput {
 	label: string;
 	/** 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). */
@@ -73,6 +89,40 @@ export const USAGE_BY_KIND: Record<'image' | 'video', WorkflowUsage[]> = {
 	video: ['text2video', 'image2video', 'ref2video'],
 };
 
+/** One L2 connection-check finding against a live ComfyUI (HEL-643). */
+export interface PreflightFinding {
+	level: 'error' | 'warn' | 'info' | 'ok';
+	code: string;
+	node_id?: string;
+	node_title?: string | null;
+	message: string;
+	hint?: string | null;
+}
+
+/** Result of checking a workflow against a target connection's /object_info. */
+export interface WorkflowConnectionCheck {
+	endpoint_id: string | null;
+	endpoint_name: string | null;
+	base_url?: string | null;
+	/** False when any error-level finding exists (or the server was unreachable). */
+	ok: boolean;
+	/** False → 无法核查 (server down): honest, non-blocking. */
+	reachable: boolean;
+	findings: PreflightFinding[];
+	message?: string | null;
+}
+
+/** Slim live record of a workflow's latest test run (HEL-643). */
+export interface WorkflowLastTest {
+	id: number;
+	status: string;
+	phase: string | null;
+	error: string | null;
+	created_at: string;
+	completed_at: string | null;
+	output_count: number;
+}
+
 /** Result of POST /api/workflows/analyze (import confirm step 1). */
 export interface WorkflowAnalyzeResult {
 	inputs: ComfyDynamicInput[];
@@ -90,6 +140,8 @@ export interface WorkflowAnalyzeResult {
 		summary: string[];
 	};
 	usable_usage: WorkflowUsage[];
+	/** Present when analyze was called with a target endpoint (HEL-643 L2). */
+	connection_check?: WorkflowConnectionCheck;
 }
 
 export interface WorkflowNode {
@@ -114,6 +166,13 @@ export interface Workflow {
 	/** 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;
+	/** Latest test-run record, queried live (HEL-643); null = never tested. */
+	last_test?: WorkflowLastTest | null;
 }
 
 export interface Job {
@@ -136,6 +195,8 @@ export interface Job {
 	comfy_prompt_id?: string | null;
 	/** connecting · comfy_queued · comfy_running · saving · finished · dry_run */
 	phase?: string | null;
+	/** 'user' (normal generation) or 'workflow_test' (HEL-643 test run). */
+	origin?: string;
 }
 
 export interface SceneVideoSettings {

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

@@ -52,15 +52,16 @@
 {/if}
 
 <style>
+	/* §四.5 Toast：右下角堆叠，220ms 上移入场；成功绿点 / 失败红点。 */
 	.toast-host {
 		position: fixed;
-		top: 72px;
-		right: 20px;
+		right: 24px;
+		bottom: 24px;
 		z-index: 1000;
 		display: flex;
 		flex-direction: column;
 		gap: 8px;
-		max-width: min(360px, calc(100vw - 32px));
+		max-width: min(400px, calc(100vw - 32px));
 		pointer-events: none;
 	}
 	.toast {
@@ -69,23 +70,10 @@
 		align-items: flex-start;
 		gap: 10px;
 		padding: 12px 14px;
-		border-radius: var(--radius-md);
-		border: 1px solid var(--border);
-		background: var(--bg-surface);
-		box-shadow: 0 12px 32px rgba(0, 0, 0, 0.45);
-		animation: toast-in 0.22s ease-out;
-	}
-	.toast.success {
-		border-color: rgba(34, 197, 94, 0.45);
-		box-shadow:
-			0 12px 32px rgba(0, 0, 0, 0.45),
-			0 0 0 1px rgba(34, 197, 94, 0.12);
-	}
-	.toast.error {
-		border-color: rgba(239, 68, 68, 0.5);
-	}
-	.toast.info {
-		border-color: rgba(59, 130, 246, 0.45);
+		border-radius: var(--r-lg);
+		background: var(--float-bg);
+		box-shadow: var(--shadow-float);
+		animation: toast-in var(--d-enter) var(--ease-out);
 	}
 	.badge {
 		display: inline-flex;
@@ -101,17 +89,17 @@
 		background: currentColor;
 	}
 	.toast.success .badge {
-		color: var(--success);
+		color: var(--ok);
 	}
 	.toast.error .badge {
-		color: var(--error);
+		color: var(--err);
 	}
 	.toast.info .badge {
-		color: var(--info);
+		color: var(--text-2);
 	}
 	.msg {
 		flex: 1;
-		font-size: 13px;
+		font-size: var(--fs-body);
 		line-height: 1.4;
 		color: var(--text-primary);
 		font-weight: 500;
@@ -127,10 +115,12 @@
 		padding: 0 2px;
 		min-width: 28px;
 		min-height: 28px;
-		border-radius: 4px;
+		border-radius: var(--r-sm);
 	}
-	.dismiss:hover {
-		color: var(--text-primary);
+	@media (hover: hover) and (pointer: fine) {
+		.dismiss:hover {
+			color: var(--text-primary);
+		}
 	}
 	.dismiss:focus-visible {
 		outline: 2px solid var(--accent);
@@ -139,7 +129,7 @@
 	@keyframes toast-in {
 		from {
 			opacity: 0;
-			transform: translateY(-8px);
+			transform: translateY(8px);
 		}
 		to {
 			opacity: 1;
@@ -151,9 +141,11 @@
 			animation: none;
 		}
 	}
-	@media (max-width: 640px) {
+	:global(:root[data-reduce='1']) .toast {
+		animation: none;
+	}
+	@media (max-width: 760px) {
 		.toast-host {
-			top: auto;
 			bottom: 20px;
 			right: 16px;
 			left: 16px;

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

@@ -0,0 +1,579 @@
+<script lang="ts">
+	import { createQuery, useQueryClient } from '@tanstack/svelte-query';
+	import { toStore } from 'svelte/store';
+	import {
+		apiErrorMessage,
+		assetUrl,
+		playgroundApi,
+		jobsApi,
+		workflows,
+		type ComfyEndpoint,
+		type Job,
+		type Workflow,
+	} from '$lib/api';
+	import ComfyDynamicForm from '$lib/components/ComfyDynamicForm.svelte';
+	import RefImageGrid from '$lib/components/studio/RefImageGrid.svelte';
+	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 Modal from '$lib/components/ui/Modal.svelte';
+	import SafeMedia from '$lib/components/SafeMedia.svelte';
+	import { mediaFileProblem, type MediaSlotKind } from '$lib/comfy/imageFile';
+	import { jobStatusInfo } from '$lib/jobStatus';
+	import { toast } from '$lib/toast';
+	import { t } from '$lib/i18n.svelte';
+
+	/**
+	 * 测试工作流 (HEL-643 L3): fill the workflow's REAL input slots, submit
+	 * one REAL run to the chosen ComfyUI through the ordinary job queue, and
+	 * call it a pass only when at least one downloadable output of the right
+	 * media kind came back. Test artifacts are isolated from projects.
+	 */
+	interface Props {
+		open?: boolean;
+		workflow: Workflow | null;
+		endpoints: ComfyEndpoint[];
+		onchanged?: () => void;
+	}
+
+	let { open = $bindable(false), workflow, endpoints, onchanged }: Props = $props();
+
+	const client = useQueryClient();
+
+	let endpointId = $state('');
+	let values = $state<Record<string, string | number>>({});
+	let listValues = $state<Record<string, string[]>>({});
+	let sizes = $state<Record<string, number>>({});
+	let uploadingName = $state<Record<string, string>>({});
+	let rejects = $state<Record<string, { name: string; message: string }[]>>({});
+	let submitError = $state('');
+	let confirmOpen = $state(false);
+	let submitting = $state(false);
+	let testJobId = $state<number | null>(null);
+
+	const wf = $derived(workflow);
+	const schema = $derived(wf?.input_schema ?? []);
+	const listEntries = $derived(
+		schema.filter((i) => i.kind === 'image_list' || i.kind === 'video_list' || i.kind === 'audio_list'),
+	);
+	const formEntries = $derived(
+		schema.filter((i) => i.kind !== 'image_list' && i.kind !== 'video_list' && i.kind !== 'audio_list'),
+	);
+	const hasH3Hint = $derived(
+		listEntries.some((e) => e.media_hint === 'minimax_h3_ref2va'),
+	);
+	const outputKind = $derived<'image' | 'video'>(wf?.kind === 'video' ? 'video' : 'image');
+
+	const testsQuery = createQuery(
+		toStore(() => ({
+			queryKey: ['workflow-tests', wf?.id ?? 0],
+			queryFn: () => workflows.tests(wf!.id),
+			enabled: !!wf && open,
+			refetchInterval: 2000,
+		})),
+	);
+	const jobsQuery = createQuery(
+		toStore(() => ({
+			queryKey: ['jobs'],
+			queryFn: () => jobsApi.list(),
+			enabled: !!wf && open,
+			refetchInterval: 5000,
+		})),
+	);
+	const queuedCount = $derived(
+		($jobsQuery.data ?? []).filter((j) => j.status === 'pending' || j.status === 'running')
+			.length,
+	);
+
+	const history = $derived(($testsQuery.data ?? []) as Job[]);
+	const activeJob = $derived.by(() => {
+		if (testJobId != null) {
+			const mine = history.find((j) => j.id === testJobId);
+			if (mine && (mine.status === 'pending' || mine.status === 'running')) return mine;
+		}
+		return history.find((j) => j.status === 'pending' || j.status === 'running') ?? null;
+	});
+	const finishedJob = $derived.by(() => {
+		if (testJobId != null) return history.find((j) => j.id === testJobId) ?? null;
+		return null;
+	});
+
+	const queueBusy = $derived(!!activeJob || submitting);
+
+	$effect(() => {
+		if (!open || !wf) return;
+		endpointId = wf.endpoint_id ?? '';
+		values = Object.fromEntries(
+			schema
+				.filter((i) => i.defaultValue !== undefined && i.defaultValue !== null)
+				.map((i) => [i.nodeId, i.defaultValue as string | number]),
+		);
+		listValues = {};
+		sizes = {};
+		rejects = {};
+		uploadingName = {};
+		submitError = '';
+		testJobId = wf.last_test && (wf.last_test.status === 'pending' || wf.last_test.status === 'running')
+			? wf.last_test.id
+			: null;
+	});
+
+	function kindOf(entry: { kind: string }): MediaSlotKind {
+		if (entry.kind === 'video_list') return 'video';
+		if (entry.kind === 'audio_list') return 'audio';
+		return 'image';
+	}
+
+	function unitOf(kind: MediaSlotKind): string {
+		return kind === 'image' ? '张' : '段';
+	}
+
+	function setRejects(key: string, next: { name: string; message: string }[]) {
+		rejects = { ...rejects, [key]: next };
+	}
+
+	async function uploadOne(file: File): Promise<string | null> {
+		const res = await playgroundApi.upload(file);
+		sizes = { ...sizes, [res.path]: file.size };
+		return res.path;
+	}
+
+	async function mediaAdd(entry: (typeof listEntries)[number], files: File[]) {
+		const kind = kindOf(entry);
+		const key = entry.nodeId;
+		const max = entry.max ?? 9;
+		const current = listValues[key] ?? [];
+		const ok: string[] = [];
+		const bad: { name: string; message: string }[] = [];
+		for (const f of files) {
+			const problem = mediaFileProblem(kind, f);
+			if (problem) bad.push({ name: f.name, message: problem });
+			else ok.push(f.name);
+		}
+		if (current.length + ok.length > max) {
+			toast.error(
+				t('studio.errRefMax', { max, n: current.length, k: ok.length }),
+			);
+			if (bad.length) setRejects(key, [...(rejects[key] ?? []), ...bad]);
+			return;
+		}
+		setRejects(key, [...(rejects[key] ?? []), ...bad]);
+		for (const f of files) {
+			if (!ok.includes(f.name)) continue;
+			uploadingName = { ...uploadingName, [key]: f.name };
+			try {
+				const path = await uploadOne(f);
+				if (path) listValues = { ...listValues, [key]: [...(listValues[key] ?? []), path] };
+			} catch (err) {
+				toast.error(apiErrorMessage(err));
+			} finally {
+				uploadingName = { ...uploadingName, [key]: '' };
+			}
+		}
+	}
+
+	async function mediaReplace(entry: (typeof listEntries)[number], index: number, file: File) {
+		const kind = kindOf(entry);
+		const key = entry.nodeId;
+		const problem = mediaFileProblem(kind, file);
+		if (problem) {
+			setRejects(key, [...(rejects[key] ?? []), { name: file.name, message: problem }]);
+			return;
+		}
+		uploadingName = { ...uploadingName, [key]: file.name };
+		try {
+			const path = await uploadOne(file);
+			if (path) {
+				const next = [...(listValues[key] ?? [])];
+				next[index] = path;
+				listValues = { ...listValues, [key]: next };
+			}
+		} catch (err) {
+			toast.error(apiErrorMessage(err));
+		} finally {
+			uploadingName = { ...uploadingName, [key]: '' };
+		}
+	}
+
+	function mediaRemove(entry: (typeof listEntries)[number], index: number) {
+		const key = entry.nodeId;
+		listValues = { ...listValues, [key]: (listValues[key] ?? []).filter((_, i) => i !== index) };
+	}
+
+	/** Mirrors the backend's validate_input_values for immediate feedback. */
+	function validate(): string[] {
+		const errs: string[] = [];
+		for (const e of schema) {
+			const label = e.label;
+			if (e.kind === 'image_list' || e.kind === 'video_list' || e.kind === 'audio_list') {
+				const n = (listValues[e.nodeId] ?? []).length;
+				const unit = unitOf(kindOf(e));
+				if (e.required && n < (e.min ?? 1)) errs.push(t('wft.errListMin', { n: e.min ?? 1, unit, label }));
+			} else if (e.auto && e.required && e.role === 'prompt') {
+				const v = values[e.nodeId];
+				if (!(typeof v === 'string' && v.trim()) && !String(e.defaultValue ?? '').trim()) {
+					errs.push(t('wft.errRequired', { label }));
+				}
+			} else if (e.required && (e.kind === 'image' || e.kind === 'video' || e.kind === 'audio') && e.role !== 'mask') {
+				if (!values[e.nodeId]) errs.push(t('wft.errRequired', { label }));
+			}
+		}
+		return errs;
+	}
+
+	async function submitTest() {
+		if (!wf) return;
+		const errs = validate();
+		if (errs.length) {
+			submitError = errs.join('；');
+			return;
+		}
+		submitError = '';
+		confirmOpen = true;
+	}
+
+	async function reallyRunTest() {
+		if (!wf) return;
+		submitting = true;
+		try {
+			const inputValues: Record<string, unknown> = { ...values };
+			for (const [k, v] of Object.entries(listValues)) {
+				if (v.length) inputValues[k] = v;
+			}
+			const res = await workflows.test(wf.id, {
+				...(endpointId ? { endpoint_id: endpointId } : {}),
+				input_values: inputValues as Record<string, string | number | string[]>,
+			});
+			testJobId = res.job.id;
+			if (res.reused) toast.info(t('wft.reusedToast'));
+			void $testsQuery.refetch();
+		} catch (err) {
+			submitError = apiErrorMessage(err);
+		} finally {
+			submitting = false;
+			confirmOpen = false;
+		}
+	}
+
+	async function cancelTest() {
+		if (!activeJob) return;
+		try {
+			await jobsApi.cancel(activeJob.id);
+			void $testsQuery.refetch();
+		} catch (err) {
+			toast.error(apiErrorMessage(err));
+		}
+	}
+
+	async function clearRecords() {
+		if (!wf) return;
+		try {
+			await workflows.clearTests(wf.id);
+			testJobId = null;
+			await $testsQuery.refetch();
+			onchanged?.();
+			toast.success(t('wft.cleared'));
+		} catch (err) {
+			toast.error(apiErrorMessage(err));
+		}
+	}
+
+	function resultLine(job: Job): string {
+		if (job.status === 'done' && (job.output_paths?.length ?? 0) > 0) {
+			return t('wft.passedShort', { n: job.output_paths.length });
+		}
+		if (job.error === 'cancelled') return t('wft.cancelledShort');
+		return job.error ? job.error.slice(0, 120) : t('wft.failedShort');
+	}
+
+	function timeOf(at: string | null): string {
+		if (!at) return '—';
+		const ts = Date.parse(at.replace(' ', 'T') + 'Z');
+		const d = new Date(Number.isFinite(ts) ? ts : at);
+		const p = (n: number) => String(n).padStart(2, '0');
+		return `${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
+	}
+
+	const endpointLabel = $derived(
+		endpoints.find((e) => e.id === endpointId)?.name ?? t('conn.wfConnectionActive'),
+	);
+</script>
+
+<Modal bind:open title={t('wft.title')} size="lg">
+	{#if wf}
+		<div class="wft">
+			<p class="wft-sub">
+				{wf.name}
+				<span class="mono wft-id">#{wf.id}</span>
+			</p>
+
+			<label class="f-field">
+				<span class="f-label">{t('wft.connection')}</span>
+				<select class="f-input" bind:value={endpointId} disabled={queueBusy}>
+					<option value="">{t('conn.wfConnectionActive')}</option>
+					{#each endpoints as ep (ep.id)}
+						<option value={ep.id}>{ep.name}</option>
+					{/each}
+				</select>
+				<span class="f-hint">{t('wft.costNote')}</span>
+			</label>
+
+			{#if hasH3Hint}
+				<div class="wft-note" role="note">
+					<Icon name="info" size={14} />
+					<p>{t('wfMedia.h3Limits')}</p>
+				</div>
+			{/if}
+
+			{#if activeJob}
+				{@const info = jobStatusInfo(activeJob)}
+				<div class="wft-active" class:ok={activeJob.status === 'done'} class:bad={activeJob.status === 'failed'}>
+					<div class="wft-active-head">
+						<span class="status-chip">{t('wft.running')}</span>
+						<span class="wft-active-detail">{info.detail}</span>
+						<Button variant="secondary" size="sm" onclick={cancelTest}>{t('wft.cancel')}</Button>
+					</div>
+				</div>
+			{:else if finishedJob && finishedJob.status === 'done' && (finishedJob.output_paths?.length ?? 0) > 0}
+				<div class="wft-result ok">
+					<p class="wft-verdict">{t('wft.passed', { n: finishedJob.output_paths.length })}</p>
+					<div class="wft-outputs">
+						{#each finishedJob.output_paths.slice(0, 4) as path (path)}
+							<a
+								class="wft-out"
+								href={assetUrl(path)}
+								download
+								target="_blank"
+								rel="noreferrer"
+								title={t('wft.download')}
+							>
+								<SafeMedia kind={outputKind} src={assetUrl(path)} controls={outputKind === 'video'} />
+							</a>
+						{/each}
+					</div>
+				</div>
+			{:else if finishedJob && finishedJob.status !== 'pending' && finishedJob.status !== 'running'}
+				<div class="wft-result bad">
+					<p class="wft-verdict">{t('wft.failed')}</p>
+					<p class="wft-error">{finishedJob.error === 'cancelled' ? t('wft.cancelledShort') : finishedJob.error}</p>
+				</div>
+			{/if}
+
+			{#if !queueBusy}
+				<div class="wft-form">
+					{#each listEntries as entry (entry.nodeId)}
+						{@const kind = kindOf(entry)}
+						<RefImageGrid
+							label={entry.label}
+							mediaKind={kind}
+							paths={listValues[entry.nodeId] ?? []}
+							max={entry.max ?? 9}
+							sizes={sizes}
+							uploadingName={uploadingName[entry.nodeId] || undefined}
+							rejects={rejects[entry.nodeId] ?? []}
+							onAdd={(files) => mediaAdd(entry, files)}
+							onReplace={(i, file) => mediaReplace(entry, i, file)}
+							onRemove={(i) => mediaRemove(entry, i)}
+							onDismissReject={(i) =>
+								setRejects(entry.nodeId, (rejects[entry.nodeId] ?? []).filter((_, j) => j !== i))}
+						/>
+					{/each}
+					{#if formEntries.length}
+						<ComfyDynamicForm inputs={formEntries} bind:values allowUpload showErrors={!!submitError} />
+					{/if}
+				</div>
+				{#if submitError}<span class="f-error" role="alert">{submitError}</span>{/if}
+				<div class="wft-actions">
+					<Button variant="primary" loading={submitting} onclick={submitTest}>
+						{t('wft.submit')}
+					</Button>
+				</div>
+			{/if}
+
+			<div class="wft-history">
+				<div class="wft-history-head">
+					<span class="f-label">{t('wft.history', { n: history.length })}</span>
+					{#if history.length}
+						<button type="button" class="link-danger" onclick={clearRecords}>
+							{t('wft.clear')}
+						</button>
+					{/if}
+				</div>
+				{#if history.length === 0}
+					<p class="wft-empty">{t('wft.never')}</p>
+				{:else}
+					<ul class="wft-rows">
+						{#each history as job (job.id)}
+							<li class:active={job.id === activeJob?.id}>
+								<span class="mono wft-row-id">#{job.id}</span>
+								<span class="wft-row-time">{timeOf(job.created_at)}</span>
+								<span class="wft-row-result" class:ok={job.status === 'done' && (job.output_paths?.length ?? 0) > 0}>
+									{resultLine(job)}
+								</span>
+							</li>
+						{/each}
+					</ul>
+				{/if}
+			</div>
+		</div>
+	{/if}
+</Modal>
+
+<ConfirmDialog
+	bind:open={confirmOpen}
+	title={t('wft.confirmTitle')}
+	message={t('wft.confirmBody', { endpoint: endpointLabel, n: queuedCount })}
+	confirmLabel={t('wft.submit')}
+	onconfirm={reallyRunTest}
+/>
+
+<style>
+	.wft {
+		display: flex;
+		flex-direction: column;
+		gap: 12px;
+		min-width: 0;
+	}
+	.wft-sub {
+		margin: 0;
+		font-size: 13px;
+		color: var(--text-2);
+	}
+	.wft-id {
+		color: var(--text-3);
+		font-size: 11px;
+		margin-left: 6px;
+	}
+	.wft-note {
+		display: flex;
+		gap: 8px;
+		align-items: flex-start;
+		padding: 8px 10px;
+		border: 1px solid var(--info, #3b82f6);
+		border-radius: 8px;
+		background: var(--surface-2);
+		color: var(--text-2);
+		font-size: 12px;
+		line-height: 1.6;
+	}
+	.wft-note p {
+		margin: 0;
+	}
+	.wft-active,
+	.wft-result {
+		border: 1px solid var(--border-strong);
+		border-radius: 8px;
+		padding: 10px 12px;
+		background: var(--surface-2);
+	}
+	.wft-active-head {
+		display: flex;
+		align-items: center;
+		gap: 10px;
+		flex-wrap: wrap;
+	}
+	.wft-active-detail {
+		flex: 1;
+		min-width: 160px;
+		font-size: 12px;
+		color: var(--text-2);
+	}
+	.wft-result.ok {
+		border-color: var(--success);
+	}
+	.wft-result.bad {
+		border-color: var(--error);
+	}
+	.wft-verdict {
+		margin: 0 0 8px;
+		font-size: 13px;
+		font-weight: 600;
+		color: var(--text);
+	}
+	.wft-result.ok .wft-verdict {
+		color: var(--success);
+	}
+	.wft-error {
+		margin: 0;
+		font-size: 12px;
+		color: var(--error);
+		line-height: 1.6;
+		word-break: break-all;
+	}
+	.wft-outputs {
+		display: grid;
+		grid-template-columns: repeat(auto-fill, minmax(140px, 1fr));
+		gap: 8px;
+	}
+	.wft-out {
+		display: block;
+		border: 1px solid var(--border);
+		border-radius: 8px;
+		overflow: hidden;
+		background: var(--bg);
+	}
+	.wft-form {
+		display: flex;
+		flex-direction: column;
+		gap: 14px;
+	}
+	.wft-actions {
+		display: flex;
+		justify-content: flex-end;
+		gap: 8px;
+	}
+	.wft-history {
+		border-top: 1px solid var(--border);
+		padding-top: 10px;
+	}
+	.wft-history-head {
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		gap: 8px;
+	}
+	.wft-empty {
+		margin: 6px 0 0;
+		font-size: 12px;
+		color: var(--text-3);
+	}
+	.wft-rows {
+		list-style: none;
+		margin: 6px 0 0;
+		padding: 0;
+		display: flex;
+		flex-direction: column;
+		gap: 4px;
+	}
+	.wft-rows li {
+		display: flex;
+		gap: 10px;
+		align-items: baseline;
+		font-size: 12px;
+		color: var(--text-2);
+		padding: 4px 6px;
+		border-radius: 6px;
+	}
+	.wft-rows li.active {
+		background: var(--surface-3);
+	}
+	.wft-row-id {
+		color: var(--text-3);
+		font-size: 11px;
+	}
+	.wft-row-time {
+		color: var(--text-3);
+		font-size: 11px;
+		white-space: nowrap;
+	}
+	.wft-row-result {
+		flex: 1;
+		min-width: 0;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
+	.wft-row-result.ok {
+		color: var(--success);
+	}
+</style>

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

@@ -39,7 +39,8 @@
 	function segClass(key: string): string {
 		const state = stats.stage_status?.[key];
 		if (state === 'confirmed') return 'seg-confirmed';
-		if (state === 'running' || state === 'awaiting_confirm') return 'seg-draft';
+		if (state === 'running') return 'seg-running';
+		if (state === 'awaiting_confirm') return 'seg-draft';
 		return '';
 	}
 
@@ -70,7 +71,7 @@
 			return { cls: 'st-progress', label: `${stageName} · ${t('workbench.state.running')}` };
 		}
 		if (state === 'awaiting_confirm') {
-			return { cls: 'st-progress', label: `${stageName} · ${t('workbench.state.draft')}` };
+			return { cls: 'st-pending', label: `${stageName} · ${t('workbench.state.draft')}` };
 		}
 		if (stats.stage_confirmed > 0) {
 			return { cls: 'st-progress', label: `${stageName} · ${t('home.statusProgress')}` };
@@ -329,7 +330,7 @@
 		display: inline-flex;
 		align-items: center;
 		justify-content: center;
-		color: rgba(22, 19, 10, 0.82);
+		color: color-mix(in srgb, var(--accent-ink) 82%, transparent);
 		opacity: 0.9;
 	}
 	.status-tag {
@@ -340,7 +341,7 @@
 		border-radius: 999px;
 		font-size: 10.5px;
 		font-weight: 600;
-		background: rgba(13, 14, 17, 0.78);
+		background: var(--media-scrim);
 		border: 1px solid var(--border-strong);
 		backdrop-filter: blur(4px);
 	}
@@ -350,7 +351,10 @@
 		color: var(--text-2);
 	}
 	.st-progress {
-		color: var(--accent);
+		color: var(--run);
+	}
+	.st-pending {
+		color: var(--warn);
 	}
 	.st-done {
 		color: var(--success);
@@ -409,8 +413,11 @@
 		border-radius: 2px;
 		background: var(--surface-3);
 	}
+	.seg-running {
+		background: var(--run);
+	}
 	.seg-draft {
-		background: var(--accent);
+		background: var(--warn);
 	}
 	.seg-confirmed {
 		background: var(--success);
@@ -425,8 +432,8 @@
 		margin-left: auto;
 		padding: 1px 8px;
 		border-radius: 999px;
-		background: var(--accent-dim);
-		color: var(--accent);
+		background: var(--run-soft);
+		color: var(--run);
 		font-size: 10px;
 		font-weight: 600;
 		font-variant-numeric: tabular-nums;
@@ -462,7 +469,7 @@
 		height: 28px;
 		border: 1px solid transparent;
 		border-radius: 7px;
-		background: rgba(13, 14, 17, 0.6);
+		background: var(--media-scrim);
 		color: var(--text-2);
 		font-size: 15px;
 		line-height: 1;

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

@@ -341,14 +341,14 @@
 		white-space: nowrap;
 	}
 
-	/* 进行数徽章 (spec §3): accent-dim capsule with amber count */
+	/* 进行数徽章：进行中计数用信号青 */
 	.nav-badge {
 		margin-left: auto;
 		min-width: 20px;
 		padding: 1px 7px;
 		border-radius: 999px;
-		background: var(--accent-dim);
-		color: var(--accent);
+		background: var(--run-soft);
+		color: var(--run);
 		font-size: 10.5px;
 		font-weight: 600;
 		font-variant-numeric: tabular-nums;
@@ -384,7 +384,7 @@
 		color: var(--text);
 	}
 
-	/* §5 连接状态点: green = probe passed, amber breathing = testing,
+	/* 连接状态点: cyan = online, cyan breathing = testing,
 	   red = failed, gray = no connection configured. */
 	.dot {
 		width: 7px;
@@ -396,13 +396,13 @@
 		margin-top: 5px;
 	}
 	.dot.ok {
-		background: var(--success);
+		background: var(--run);
 	}
 	.dot.fail {
 		background: var(--error);
 	}
 	.dot.testing {
-		background: var(--accent);
+		background: var(--run);
 		animation: shell-breathe 2s cubic-bezier(0.16, 1, 0.3, 1) infinite;
 	}
 	@keyframes shell-breathe {

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

@@ -258,7 +258,7 @@
 		color: var(--accent);
 	}
 	.slot-empty.invalid {
-		border-color: rgba(229, 72, 77, 0.65);
+		border-color: var(--err-line);
 	}
 	.slot-empty:disabled {
 		cursor: default;

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

@@ -2,14 +2,21 @@
 	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 {
+		IMAGE_SLOT_ACCEPT,
+		formatBytes,
+		mediaSlotAccept,
+		uploadBaseName,
+		type MediaSlotKind,
+	} 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.
+	 * Reference-media grid (ref-upload-spec §2 `.refgrid`, generalized to
+	 * image/video/audio in HEL-643): 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;
@@ -19,6 +26,8 @@
 		label: string;
 		paths: string[];
 		max: number;
+		/** Media family of the slots — drives thumbnails, accept and copy. */
+		mediaKind?: MediaSlotKind;
 		/** 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. */
@@ -39,6 +48,7 @@
 		label,
 		paths,
 		max,
+		mediaKind = 'image',
 		sizes = {},
 		uploadingName,
 		uploadingIndex = -1,
@@ -57,9 +67,28 @@
 	let replaceIndex = $state(-1);
 	let dragDepth = $state(0);
 	let dims = $state<Record<string, string>>({});
+	let durations = $state<Record<string, number>>({});
 
 	const uploading = $derived(!!uploadingName);
 	const remaining = $derived(Math.max(0, max - paths.length));
+	const accept = $derived(mediaKind === 'image' ? IMAGE_SLOT_ACCEPT : mediaSlotAccept(mediaKind));
+	const isMedia = $derived(mediaKind !== 'image');
+	const hintLabel = $derived(
+		isMedia
+			? t('studio.refHintMedia', { n: paths.length, max })
+			: t('studio.refHint', { n: paths.length, max }),
+	);
+	function durationOf(path: string): string {
+		const d = durations[path];
+		if (d == null || !Number.isFinite(d)) return '';
+		return `${d.toFixed(1)}s`;
+	}
+	function noteDuration(path: string, e: Event): void {
+		const el = e.currentTarget as HTMLVideoElement | HTMLAudioElement | null;
+		if (el && Number.isFinite(el.duration)) {
+			durations = { ...durations, [path]: el.duration };
+		}
+	}
 
 	function pickAdd() {
 		if (uploading || !addInput) return;
@@ -88,14 +117,16 @@
 	}
 
 	function metaOf(path: string): string {
-		return [dims[path], sizes[path] != null ? formatBytes(sizes[path]) : null].filter(Boolean).join(' · ');
+		return [dims[path], durationOf(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>
+		<span class="slot-hint">{hintLabel}</span>
 	</div>
 
 	<input
@@ -104,7 +135,7 @@
 		class="sr-file"
 		tabindex="-1"
 		aria-hidden="true"
-		accept={IMAGE_SLOT_ACCEPT}
+		accept={accept}
 		multiple
 		onchange={(e) => {
 			const files = Array.from(e.currentTarget.files ?? []);
@@ -117,14 +148,14 @@
 		class="sr-file"
 		tabindex="-1"
 		aria-hidden="true"
-		accept={IMAGE_SLOT_ACCEPT}
+		accept={accept}
 		onchange={(e) => {
 			const f = e.currentTarget.files?.[0];
 			if (f && replaceIndex >= 0) onReplace(replaceIndex, f);
 		}}
 	/>
 
-	<div class="refgrid">
+	<div class="refgrid" class:audio={mediaKind === 'audio'}>
 		{#each paths as path, i (path + i)}
 			<div class="ref-cell" class:busy={uploadingIndex === i}>
 				<button
@@ -133,7 +164,30 @@
 					title={t('studio.refReplace')}
 					onclick={() => pickReplace(i)}
 				>
-					<img src={assetUrl(path)} alt={t('studio.slotRefN', { n: i + 1 })} onload={(e) => noteDims(path, e)} />
+					{#if mediaKind === 'image'}
+						<img
+							src={assetUrl(path)}
+							alt={t('studio.slotRefN', { n: i + 1 })}
+							onload={(e) => noteDims(path, e)}
+						/>
+					{:else if mediaKind === 'video'}
+						<video
+							src={assetUrl(path)}
+							preload="metadata"
+							muted
+							playsinline
+							onloadedmetadata={(e) => noteDuration(path, e)}
+							title={uploadBaseName(path)}
+						></video>
+					{:else}
+						<span class="audio-glyph"><Icon name="music" size={18} /></span>
+						<audio
+							src={assetUrl(path)}
+							preload="metadata"
+							onloadedmetadata={(e) => noteDuration(path, e)}
+							title={uploadBaseName(path)}
+						></audio>
+					{/if}
 					<span class="ref-no mono">{i + 1}</span>
 					{#if uploadingIndex === i}
 						<span class="ref-busy"><Spinner size="sm" /></span>
@@ -142,7 +196,7 @@
 				<button
 					type="button"
 					class="ref-x"
-					aria-label={t('studio.refRemove', { n: i + 1 })}
+					aria-label={isMedia ? t('studio.refRemoveMedia', { kind: label, n: i + 1 }) : t('studio.refRemove', { n: i + 1 })}
 					onclick={() => onRemove(i)}
 				>
 					<Icon name="close" size={11} />
@@ -195,8 +249,8 @@
 					<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>
+					<span class="add-main">{isMedia ? t('studio.refAddMedia', { kind: label }) : t('studio.refAdd')}</span>
+					<span class="add-sub mono">{isMedia ? t('studio.refAddSubMedia', { n: remaining, max }) : t('studio.refAddSub', { n: remaining, max })}</span>
 				{/if}
 			</button>
 		{/if}
@@ -208,7 +262,7 @@
 		</button>
 	{/if}
 	{#if remaining === 0}
-		<span class="full-note">{t('studio.refFull', { max })}</span>
+		<span class="full-note">{isMedia ? t('studio.refFullMedia', { max }) : t('studio.refFull', { max })}</span>
 	{/if}
 	{#each rejects as rej, i (rej.name + i)}
 		<span class="slot-error">{rej.message}</span>
@@ -223,6 +277,30 @@
 		gap: 6px;
 		min-width: 0;
 	}
+	.refgrid.audio {
+		grid-template-columns: repeat(2, minmax(0, 1fr));
+	}
+	.refgrid.audio .ref-thumb {
+		aspect-ratio: auto;
+		min-height: 64px;
+		flex-direction: column;
+		gap: 2px;
+		padding: 8px 4px;
+	}
+	.refgrid.audio audio {
+		width: 90%;
+		height: 28px;
+	}
+	.refgrid video {
+		width: 100%;
+		height: 100%;
+		object-fit: cover;
+		display: block;
+	}
+	.audio-glyph {
+		color: var(--text-3);
+		display: inline-flex;
+	}
 	.slot-label {
 		display: flex;
 		align-items: baseline;

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

@@ -7,7 +7,7 @@
 	import ImageLightbox from '$lib/components/ImageLightbox.svelte';
 	import MediaSlot from '$lib/components/studio/MediaSlot.svelte';
 	import RefImageGrid from '$lib/components/studio/RefImageGrid.svelte';
-	import { imageFileProblem } from '$lib/comfy/imageFile';
+	import { mediaFileProblem } from '$lib/comfy/imageFile';
 	import { toStore } from 'svelte/store';
 	import { tick } from 'svelte';
 	import AppShell from '$lib/components/shell/AppShell.svelte';
@@ -63,13 +63,20 @@
 
 	const endpoints = $derived($settingsQuery.data?.comfyui_endpoints ?? []);
 	const activeId = $derived($settingsQuery.data?.comfyui_active_id ?? endpoints[0]?.id ?? '');
-	// HEL-636: the page serves its usages (image → t2i/i2i, video →
-	// t2v/i2v/ref2v); pending workflows (usage = null) never appear.
-	const kindWorkflows = $derived(
-		($workflowsQuery.data ?? []).filter(
-			(w) => w.is_enabled && (w.usage ?? null) !== null && USAGE_BY_KIND[kind].includes(w.usage!),
-		),
-	);
+ 	// HEL-636: the page serves its usages (image → t2i/i2i, video →
+ 	// t2v/i2v/ref2v); pending workflows (usage = null) never appear.
+ 	// HEL-638: workflows with unconfirmed unknown output nodes are also
+ 	// hidden — enabled rows carry a settled output mapping, this is a
+ 	// second guard for stale rows.
+ 	const kindWorkflows = $derived(
+ 		($workflowsQuery.data ?? []).filter(
+ 			(w) =>
+ 				w.is_enabled &&
+ 				(w.usage ?? null) !== null &&
+ 				!w.needs_mapping &&
+ 				USAGE_BY_KIND[kind].includes(w.usage!),
+ 		),
+ 	);
 
 	const allJobs = $derived.by(() => {
 		void $jobsQuery.data;
@@ -138,6 +145,7 @@
 	let fileSizes = $state<Record<string, number>>({});
 	/** Reference index being replaced while its upload runs. */
 	let replacingIndex = $state(-1);
+	let replacingKey = $state('');
 	let showErrors = $state(false);
 	let submitting = $state(false);
 	let lightboxOpen = $state(false);
@@ -205,7 +213,9 @@
 		inp.kind === 'image_url' ||
 		inp.kind === 'video' ||
 		inp.kind === 'audio' ||
-		inp.kind === 'image_list';
+		inp.kind === 'image_list' ||
+		inp.kind === 'video_list' ||
+		inp.kind === 'audio_list';
 	// Auto-detected slots carry their role from the wiring; tagged (Input:…)
 	// workflows still name frames only in the title.
 	const isFirstFrame = (inp: ComfyDynamicInput) =>
@@ -213,14 +223,44 @@
 	const isLastFrame = (inp: ComfyDynamicInput) =>
 		role(inp) === 'last_frame' || (!inp.auto && kind === 'video' && /last|end|尾帧/.test(hay(inp)));
 
+	/** Autogrow media lists actually wired in this workflow (HEL-643: image /
+	 * video / audio). No wiring → no entry, whatever the model could do. */
+	const listGroups = $derived(
+		schema.filter(
+			(i) => i.kind === 'image_list' || i.kind === 'video_list' || i.kind === 'audio_list',
+		),
+	);
+	function listKind(entry: ComfyDynamicInput): 'image' | 'video' | 'audio' {
+		if (entry.kind === 'video_list') return 'video';
+		if (entry.kind === 'audio_list') return 'audio';
+		return 'image';
+	}
 	// ComfyUI Autogrow reference images (H3 ref_images): one ordered 1…max list.
-	const refGroup = $derived(schema.find((i) => i.kind === 'image_list') ?? null);
+	const refGroup = $derived(listGroups.find((i) => i.kind === 'image_list') ?? null);
 	const refMax = $derived(refGroup?.max ?? 9);
 	const refPaths = $derived.by(() => {
 		const v = refGroup ? values[refGroup.nodeId] : undefined;
 		if (Array.isArray(v)) return v;
 		return typeof v === 'string' && v ? [v] : [];
 	});
+	function groupPaths(entry: ComfyDynamicInput): string[] {
+		const v = values[entry.nodeId];
+		if (Array.isArray(v)) return v;
+		return typeof v === 'string' && v ? [v] : [];
+	}
+	// H3 Ref2VA official limits (soft hint, keyed off the node class only).
+	const hasH3Hint = $derived(listGroups.some((e) => e.media_hint === 'minimax_h3_ref2va'));
+	const h3SoftWarnings = $derived.by(() => {
+		if (!hasH3Hint) return [];
+		const warns: string[] = [];
+		const counts = { image: 0, video: 0, audio: 0 };
+		for (const g of listGroups) counts[listKind(g)] += groupPaths(g).length;
+		const total = counts.image + counts.video + counts.audio;
+		if (total > 12) warns.push(t('wfMedia.h3TotalOver', { n: total }));
+		if (counts.audio > 0 && counts.image === 0 && counts.video === 0)
+			warns.push(t('wfMedia.h3AudioAlone'));
+		return warns;
+	});
 	const brokenReasons = $derived(
 		(currentWorkflow?.warnings ?? []).filter((w) => w.level === 'error').map((w) => w.message),
 	);
@@ -264,7 +304,10 @@
 	}
 
 	const mediaSlots = $derived.by(() => {
-		const media = schema.filter((i) => isMedia(i) && i.kind !== 'image_list');
+		const media = schema.filter(
+			(i) =>
+				isMedia(i) && i.kind !== 'image_list' && i.kind !== 'video_list' && i.kind !== 'audio_list',
+		);
 		const plainImages = media.filter(
 			(i) => i.kind === 'image' && role(i) !== 'mask' && !/mask|遮罩/.test(hay(i)) && !isFirstFrame(i) && !isLastFrame(i),
 		);
@@ -417,10 +460,17 @@
 				errs[s.inp.nodeId] = s.missing || t('studio.errUpload', { label: s.label });
 			}
 		}
-		if (refGroup) {
-			if (refPaths.length < (refGroup.min ?? 1)) errs[refGroup.nodeId] = t('studio.errNeedRef');
-			else if (refPaths.length > refMax)
-				errs[refGroup.nodeId] = t('studio.errRefMax', { max: refMax, n: refPaths.length, k: refPaths.length - refMax });
+		for (const g of listGroups) {
+			const n = groupPaths(g).length;
+			const max = g.max ?? 9;
+			if (n < (g.min ?? 1)) {
+				errs[g.nodeId] =
+					g.kind === 'image_list'
+						? t('studio.errNeedRef')
+						: t('studio.errNeedRefMedia', { n: g.min ?? 1, label: g.label });
+			} else if (n > max) {
+				errs[g.nodeId] = t('studio.errRefMax', { max, n, k: n - max });
+			}
 		}
 		for (const inp of restInputs) {
 			if (inp.required && !String(values[inp.nodeId] ?? '').trim()) {
@@ -479,12 +529,10 @@
 	}
 
 	async function slotFile(nodeId: string, file: File, mediaKind: 'image' | 'video' | 'audio' = 'image') {
-		if (mediaKind === 'image') {
-			const problem = imageFileProblem(file);
-			if (problem) {
-				setRejects(nodeId, [{ name: file.name, message: problem }]);
-				return;
-			}
+		const problem = mediaFileProblem(mediaKind, file);
+		if (problem) {
+			setRejects(nodeId, [{ name: file.name, message: problem }]);
+			return;
 		}
 		setRejects(nodeId, []);
 		const path = await uploadImage(nodeId, file);
@@ -492,46 +540,48 @@
 	}
 
 	/** Add picked/dropped files in order; a batch that would pass `max` is refused whole. */
-	async function refAdd(files: File[]) {
-		if (!refGroup) return;
-		const key = refGroup.nodeId;
-		const ok = files.filter((f) => !imageFileProblem(f));
+	async function groupAdd(entry: ComfyDynamicInput, files: File[]) {
+		const key = entry.nodeId;
+		const mk = listKind(entry);
+		const max = entry.max ?? 9;
+		const paths = groupPaths(entry);
+		const ok = files.filter((f) => !mediaFileProblem(mk, f));
 		const rejected = files
-			.filter((f) => imageFileProblem(f))
-			.map((f) => ({ name: f.name, message: imageFileProblem(f)! }));
+			.filter((f) => mediaFileProblem(mk, f))
+			.map((f) => ({ name: f.name, message: mediaFileProblem(mk, f)! }));
 		setRejects(key, rejected);
-		if (refPaths.length + ok.length > refMax) {
-			toast.error(t('studio.errRefMax', { max: refMax, n: refPaths.length, k: ok.length }));
+		if (paths.length + ok.length > max) {
+			toast.error(t('studio.errRefMax', { max, n: paths.length, k: ok.length }));
 			return;
 		}
 		for (const f of ok) {
 			const path = await uploadImage(key, f);
 			if (!path) break;
-			setVal(key, [...refPaths, path]);
+			setVal(key, [...paths, path]);
 		}
 	}
 
-	async function refReplace(index: number, file: File) {
-		if (!refGroup) return;
-		const key = refGroup.nodeId;
-		const problem = imageFileProblem(file);
+	async function groupReplace(entry: ComfyDynamicInput, index: number, file: File) {
+		const key = entry.nodeId;
+		const problem = mediaFileProblem(listKind(entry), file);
 		if (problem) {
 			setRejects(key, [{ name: file.name, message: problem }]);
 			return;
 		}
 		setRejects(key, []);
+		replacingKey = key;
 		replacingIndex = index;
 		try {
 			const path = await uploadImage(key, file);
-			if (path) setVal(key, refPaths.map((p, i) => (i === index ? path : p)));
+			if (path) setVal(key, groupPaths(entry).map((p, i) => (i === index ? path : p)));
 		} finally {
+			replacingKey = '';
 			replacingIndex = -1;
 		}
 	}
 
-	function refRemove(index: number) {
-		if (!refGroup) return;
-		setVal(refGroup.nodeId, refPaths.filter((_, i) => i !== index));
+	function groupRemove(entry: ComfyDynamicInput, index: number) {
+		setVal(entry.nodeId, groupPaths(entry).filter((_, i) => i !== index));
 	}
 
 	const imageResults = $derived(
@@ -699,6 +749,28 @@
 	const selectedEntry = $derived(
 		doneEntries.find((e) => e.key === selectedKey) ?? doneEntries[0] ?? null,
 	);
+	const selectedJobId = $derived(selectedEntry?.job.id ?? null);
+
+	/**
+	 * Clicking a history row: a finished job loads into the preview
+	 * (player / image), anything else just reports its live status —
+	 * never a silent jump to the newest finished clip.
+	 */
+	function selectFromHistory(job: Job) {
+		const st = jobStatusInfo(job);
+		if (st.tone === 'ok' && job.output_paths.length) {
+			selectedKey = `${job.id}:${job.output_paths[0]}`;
+			return;
+		}
+		toast.info(st.detail && st.detail !== st.label ? `${st.label} · ${st.detail}` : st.label);
+	}
+
+	function histRowKey(e: KeyboardEvent, job: Job) {
+		if (e.key === 'Enter' || e.key === ' ') {
+			e.preventDefault();
+			selectFromHistory(job);
+		}
+	}
 
 	function summaryOf(job: Job): string {
 		const parts: string[] = [];
@@ -751,6 +823,26 @@
 	let curSec = $state(0);
 	let durSec = $state(0);
 
+	// Switching the selected video must stop the old clip and rewind it,
+	// never keep playing the previous audio/progress into the new one.
+	// Runs BEFORE the DOM swaps the src so the reset cannot clobber the
+	// duration/metadata events of the clip being loaded in.
+	$effect.pre(() => {
+		void selectedEntry?.key;
+		const v = videoEl;
+		if (v) {
+			try {
+				v.pause();
+				v.currentTime = 0;
+			} catch {
+				/* no loaded metadata yet — src change already reset it */
+			}
+		}
+		playing = false;
+		curSec = 0;
+		durSec = 0;
+	});
+
 	function fmtClock(s: number): string {
 		if (!Number.isFinite(s)) return '0:00';
 		const m = Math.floor(s / 60);
@@ -778,13 +870,16 @@
 		else void playerBox?.requestFullscreen();
 	}
 
-	// First/last frame strip for the selected video job
+	// First/last frame + reference strip for the selected video job.
+	// Ref workflows come in two shapes: an autogrow image_list, or several
+	// plain image inputs — both are shown as reference images.
 	const selectedFrames = $derived.by(() => {
 		if (kind !== 'video' || !selectedEntry) return [];
 		const wf = ($workflowsQuery.data ?? []).find((w) => w.id === selectedEntry.job.workflow_id);
 		if (!wf) return [];
 		const vals = (selectedEntry.job.payload?.input_values ?? {}) as Record<string, unknown>;
 		const out: Array<{ label: string; path: string; ref?: boolean }> = [];
+		let refIdx = 0;
 		for (const inp of wf.input_schema ?? []) {
 			const h = `${inp.role ?? ''} ${inp.label}`.toLowerCase();
 			const v = vals[inp.nodeId];
@@ -798,6 +893,10 @@
 			if (typeof v !== 'string' || !v) continue;
 			if (/first|start|首帧/.test(h)) out.push({ label: t('studio.slotFirst'), path: v });
 			else if (/last|end|尾帧/.test(h)) out.push({ label: t('studio.slotLast'), path: v });
+			else if (isMedia(inp) && inp.kind === 'image' && !/mask|遮罩/.test(h)) {
+				refIdx += 1;
+				out.push({ label: t('studio.slotRefN', { n: refIdx }), path: v, ref: true });
+			}
 		}
 		return out;
 	});
@@ -845,12 +944,31 @@
 	}
 
 	const deleteTarget = $derived(kindJobs.find((j) => j.id === deleteJobId) ?? null);
+	// The dialog names the exact job and — when it produced several
+	// outputs — says plainly that ALL of them go away with it (the
+	// backend only deletes whole jobs, never a single output file).
+	const deleteTitle = $derived(
+		deleteTarget ? t('studio.delTitleJob', { name: wfName(deleteTarget) }) : t('studio.delTitle'),
+	);
+	const deleteMessage = $derived.by(() => {
+		const n = deleteTarget?.output_paths?.length ?? 0;
+		return n > 1 ? t('studio.delConfirmMulti', { n }) : t('studio.delConfirm');
+	});
+
+	function askDeleteJob(jobId: number) {
+		deleteJobId = jobId;
+		deleteOpen = true;
+	}
+
 	async function doDelete() {
 		if (!deleteJobId) return;
 		try {
 			await playgroundApi.deleteJob(deleteJobId);
+			submittedIds.delete(deleteJobId);
 			if (selectedEntry?.job.id === deleteJobId) selectedKey = null;
+			toast.success(t('studio.deletedToast'));
 			await client.invalidateQueries({ queryKey: ['playground-jobs'] });
+			await client.invalidateQueries({ queryKey: ['jobs'] });
 		} catch (err) {
 			toast.error(err instanceof Error ? err.message : String(err));
 		} finally {
@@ -1059,25 +1177,36 @@
 					{/if}
 				{/if}
 
-				{#if refGroup}
-					<div class="f-field">
-						<RefImageGrid
-							label={refGroup.label}
-							paths={refPaths}
-							max={refMax}
-							sizes={fileSizes}
-							uploadingName={uploads.uploading[refGroup.nodeId]}
-							uploadingIndex={replacingIndex}
-							rejects={slotRejects[refGroup.nodeId] ?? []}
-							error={showErrors ? errors[refGroup.nodeId] : undefined}
-							allowFromResults
-							onAdd={refAdd}
-							onReplace={refReplace}
-							onRemove={refRemove}
-							onDismissReject={(i) =>
-								setRejects(refGroup.nodeId, (slotRejects[refGroup.nodeId] ?? []).filter((_, j) => j !== i))}
-							onFromResults={() => openPicker(refGroup.nodeId)}
-						/>
+					{#if listGroups.length}
+					<div class="f-field ref-groups">
+						{#each listGroups as entry (entry.nodeId)}
+							<RefImageGrid
+								label={entry.label}
+								mediaKind={listKind(entry)}
+								paths={groupPaths(entry)}
+								max={entry.max ?? 9}
+								sizes={fileSizes}
+								uploadingName={uploads.uploading[entry.nodeId]}
+								uploadingIndex={replacingKey === entry.nodeId ? replacingIndex : -1}
+								rejects={slotRejects[entry.nodeId] ?? []}
+								error={showErrors ? errors[entry.nodeId] : undefined}
+								allowFromResults={entry.kind === 'image_list'}
+								onAdd={(files) => groupAdd(entry, files)}
+								onReplace={(i, file) => groupReplace(entry, i, file)}
+								onRemove={(i) => groupRemove(entry, i)}
+								onDismissReject={(i) =>
+									setRejects(entry.nodeId, (slotRejects[entry.nodeId] ?? []).filter((_, j) => j !== i))}
+								onFromResults={entry.kind === 'image_list' ? () => openPicker(entry.nodeId) : undefined}
+							/>
+						{/each}
+						{#if hasH3Hint}
+							<div class="h3-hint" role="note">
+								<p>{t('wfMedia.h3Limits')}</p>
+								{#each h3SoftWarnings as w (w)}
+									<p class="warn">{w}</p>
+								{/each}
+							</div>
+						{/if}
 					</div>
 				{/if}
 
@@ -1495,11 +1624,20 @@
 											<Icon name="upload" size={13} />
 											{t('studio.sendToImg2Img')}
 										</Button>
-										<a class="a-btn secondary sm" href={assetUrl(selectedEntry.path)} download={downloadName(selectedEntry.path)}>
-											<Icon name="download" size={13} />
-											{t('studio.download')}
-										</a>
-									</span>
+									<a class="a-btn secondary sm" href={assetUrl(selectedEntry.path)} download={downloadName(selectedEntry.path)}>
+										<Icon name="download" size={13} />
+										{t('studio.download')}
+									</a>
+									<Button
+										variant="danger"
+										size="sm"
+										title={t('studio.deleteBtn')}
+										onclick={() => askDeleteJob(selectedEntry!.job.id)}
+									>
+										<Icon name="trash" size={13} />
+										{t('studio.deleteBtn')}
+									</Button>
+								</span>
 								</div>
 							{/if}
 						{:else}
@@ -1514,7 +1652,8 @@
 							<h2>{t('studio.video.resultsTitle')}</h2>
 							{#if selectedEntry}
 								<span class="panel-hint">
-									{t('studio.lastDone', {
+									{wfName(selectedEntry.job)} ·
+									{t('studio.doneAt', {
 										time: fmtTime(parseDbTs(selectedEntry.job.completed_at ?? selectedEntry.job.created_at)),
 									})}
 								</span>
@@ -1587,11 +1726,20 @@
 										<Icon name="retry" size={13} />
 										{t('studio.retryLink')}
 									</Button>
-									<a class="a-btn secondary sm" href={assetUrl(selectedEntry.path)} download={downloadName(selectedEntry.path)}>
-										<Icon name="download" size={13} />
-										{t('studio.downloadMp4')}
-									</a>
-								</span>
+								<a class="a-btn secondary sm" href={assetUrl(selectedEntry.path)} download={downloadName(selectedEntry.path)}>
+									<Icon name="download" size={13} />
+									{t('studio.downloadMp4')}
+								</a>
+								<Button
+									variant="danger"
+									size="sm"
+									title={t('studio.deleteBtn')}
+									onclick={() => askDeleteJob(selectedEntry!.job.id)}
+								>
+									<Icon name="trash" size={13} />
+									{t('studio.deleteBtn')}
+								</Button>
+							</span>
 							</div>
 						{:else}
 							<p class="empty-line">{t('studio.historyEmptyVideo')}</p>
@@ -1612,59 +1760,73 @@
 					{kind === 'image' ? t('studio.historyEmptyImage') : t('studio.historyEmptyVideo')}
 				</p>
 			{:else}
-				<div class="history-list">
-					{#each kindJobs as job (job.id)}
-						{@const st = jobStatusInfo(job)}
-						<div class="hist-row" class:failed={job.status === 'failed'} class:video={kind === 'video'}>
-							<div class="hist-thumb" class:video={kind === 'video'}>
-								{#if job.output_paths?.[0]}
-									{#if kind === 'image'}
-										<img src={assetUrl(job.output_paths[0])} alt={wfName(job)} loading="lazy" />
-									{:else}
-										<video
-											src={assetUrl(job.output_paths[0])}
-											preload="metadata"
-											muted
-											onloadedmetadata={(e) => noteDuration(job.output_paths![0], e)}
-										></video>
-										{#if durations[job.output_paths[0]]}
-											<span class="dur mono">{fmtClock(durations[job.output_paths[0]])}</span>
-										{/if}
-									{/if}
-								{:else if job.status === 'failed'}
-									<span class="thumb-fallback failed"><Icon name="alert" size={14} /></span>
+			<div class="history-list">
+				{#each kindJobs as job (job.id)}
+					{@const st = jobStatusInfo(job)}
+					<div
+						class="hist-row"
+						class:failed={job.status === 'failed'}
+						class:video={kind === 'video'}
+						class:selected={selectedJobId === job.id}
+						role="button"
+						tabindex={0}
+						aria-label={`${wfName(job)} · ${st.label}`}
+						aria-current={selectedJobId === job.id ? 'true' : undefined}
+						onclick={() => selectFromHistory(job)}
+						onkeydown={(e) => histRowKey(e, job)}
+					>
+						<div class="hist-thumb" class:video={kind === 'video'}>
+							{#if job.output_paths?.[0]}
+								{#if kind === 'image'}
+									<img src={assetUrl(job.output_paths[0])} alt={wfName(job)} loading="lazy" />
 								{:else}
-									<span class="thumb-fallback"><Icon name={kind === 'image' ? 'image' : 'film'} size={14} /></span>
-								{/if}
-							</div>
-							<div class="hist-body">
-								<div class="hist-name" title={wfName(job)}>{wfName(job)}</div>
-								<div class="hist-meta mono">{summaryOf(job)}</div>
-								<div class="hist-status">
-									{#if job.status !== 'failed'}
-										<span class="st {st.tone}" title={st.detail}>{st.label}</span>
-									{:else}
-										<button
-											type="button"
-											class="st fail-link"
-											disabled={retryingId === job.id}
-											onclick={() => retryJob(job)}
-										>
-											{t('studio.retryLink')}
-										</button>
+									<video
+										src={assetUrl(job.output_paths[0])}
+										preload="metadata"
+										muted
+										onloadedmetadata={(e) => noteDuration(job.output_paths![0], e)}
+									></video>
+									{#if durations[job.output_paths[0]]}
+										<span class="dur mono">{fmtClock(durations[job.output_paths[0]])}</span>
 									{/if}
+								{/if}
+							{:else if job.status === 'failed'}
+								<span class="thumb-fallback failed"><Icon name="alert" size={14} /></span>
+							{:else}
+								<span class="thumb-fallback"><Icon name={kind === 'image' ? 'image' : 'film'} size={14} /></span>
+							{/if}
+						</div>
+						<div class="hist-body">
+							<div class="hist-name" title={wfName(job)}>{wfName(job)}</div>
+							<div class="hist-meta mono">{summaryOf(job)}</div>
+							<div class="hist-status">
+								{#if job.status !== 'failed'}
+									<span class="st {st.tone}" title={st.detail}>{st.label}</span>
+								{:else}
 									<button
 										type="button"
-										class="hist-del"
-										title={t('studio.deleteBtn')}
-										onclick={() => {
-											deleteJobId = job.id;
-											deleteOpen = true;
+										class="st fail-link"
+										disabled={retryingId === job.id}
+										onclick={(e) => {
+											e.stopPropagation();
+											retryJob(job);
 										}}
 									>
-										<Icon name="trash" size={13} />
+										{t('studio.retryLink')}
 									</button>
-								</div>
+								{/if}
+								<button
+									type="button"
+									class="hist-del"
+									title={t('studio.deleteBtn')}
+									onclick={(e) => {
+										e.stopPropagation();
+										askDeleteJob(job.id);
+									}}
+								>
+									<Icon name="trash" size={13} />
+								</button>
+							</div>
 								{#if job.status === 'failed' && job.error}
 									<div class="hist-error">{job.error}</div>
 								{:else if st.tone === 'fail' || (job.status === 'done' && job.phase === 'dry_run')}
@@ -1704,9 +1866,10 @@
 
 <ConfirmDialog
 	bind:open={deleteOpen}
-	title={t('studio.delTitle')}
-	message={t('studio.delConfirm')}
+	title={deleteTitle}
+	message={deleteMessage}
 	confirmLabel={t('studio.deleteBtn')}
+	cancelLabel={t('common.cancel')}
 	danger
 	onconfirm={doDelete}
 	oncancel={() => {
@@ -1716,6 +1879,26 @@
 />
 
 <style>
+	.ref-groups {
+		display: flex;
+		flex-direction: column;
+		gap: 14px;
+	}
+	.h3-hint {
+		padding: 8px 10px;
+		border: 1px solid var(--border-strong);
+		border-radius: 8px;
+		background: var(--surface-2);
+	}
+	.h3-hint p {
+		margin: 0;
+		font-size: 11px;
+		line-height: 1.6;
+		color: var(--text-3);
+	}
+	.h3-hint p.warn {
+		color: var(--warn);
+	}
 	.studio-page {
 		display: grid;
 		grid-template-columns: 352px minmax(0, 1fr) 296px;
@@ -1807,10 +1990,10 @@
 	}
 	.f-input:focus {
 		outline: none;
-		border-color: rgba(232, 163, 61, 0.6);
+		border-color: var(--accent-line);
 	}
 	.f-input.invalid {
-		border-color: rgba(229, 72, 77, 0.65);
+		border-color: var(--err-line);
 	}
 	.f-error {
 		display: block;
@@ -1956,13 +2139,10 @@
 		font-weight: 600;
 		flex-shrink: 0;
 	}
-	.tag.info {
-		color: var(--info);
-		background: var(--info-dim);
-	}
+	.tag.info,
 	.tag.cloud {
-		color: var(--cloud);
-		background: var(--cloud-dim);
+		color: var(--text-2);
+		background: var(--bg-4);
 	}
 	.task-body {
 		margin-top: 12px;
@@ -1985,9 +2165,9 @@
 	.progress .fill {
 		height: 100%;
 		border-radius: 999px;
-		background: var(--accent);
-		box-shadow: 0 0 10px var(--accent-glow);
-		transition: width 300ms cubic-bezier(0.16, 1, 0.3, 1);
+		background: var(--run-grad);
+		box-shadow: 0 0 8px var(--run-soft);
+		transition: width var(--d-progress) linear;
 	}
 	.task-meta {
 		font-size: 11px;
@@ -2055,7 +2235,7 @@
 		display: block;
 	}
 	.thumb:hover {
-		border-color: rgba(255, 255, 255, 0.24);
+		border-color: var(--line-2);
 	}
 	.thumb.selected {
 		border: 2px solid var(--accent);
@@ -2288,10 +2468,23 @@
 		border-radius: 8px;
 		min-height: 44px;
 		align-items: center;
+		cursor: pointer;
 	}
 	.hist-row:hover {
 		background: var(--surface-2);
 	}
+	.hist-row:focus-visible {
+		outline: 1px solid var(--accent);
+		outline-offset: -1px;
+	}
+	/* The row loaded into the preview stays marked, and its delete stays visible. */
+	.hist-row.selected {
+		background: var(--surface-2);
+		box-shadow: inset 2px 0 0 var(--accent);
+	}
+	.hist-row.selected .hist-del {
+		opacity: 1;
+	}
 	.hist-row.failed {
 		background: var(--error-dim);
 	}
@@ -2375,7 +2568,7 @@
 		color: var(--success);
 	}
 	.st.run {
-		color: var(--accent);
+		color: var(--run);
 	}
 	.st.queue {
 		color: var(--text-3);
@@ -2417,6 +2610,15 @@
 	.hist-row:hover .hist-del {
 		opacity: 1;
 	}
+	.hist-del:focus-visible {
+		opacity: 1;
+	}
+	/* Touch devices have no hover to reveal the delete affordance. */
+	@media (hover: none) {
+		.hist-del {
+			opacity: 1;
+		}
+	}
 	.hist-del:hover {
 		color: var(--error);
 		background: var(--error-dim);

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

@@ -3,8 +3,9 @@
 	import Spinner from './Spinner.svelte';
 
 	interface Props {
-		variant?: 'primary' | 'secondary' | 'ghost' | 'danger';
-		size?: 'sm' | 'md';
+		/** `danger` = outlined (list rows); `danger-solid` = confirm dialogs only. */
+		variant?: 'primary' | 'secondary' | 'ghost' | 'danger' | 'danger-solid';
+		size?: 'sm' | 'md' | 'lg';
 		/** Stretch to the container width (e.g. a panel's main action). */
 		block?: boolean;
 		disabled?: boolean;
@@ -32,6 +33,7 @@
 	{type}
 	class="a-btn btn {variant}"
 	class:sm={size === 'sm'}
+	class:lg={size === 'lg'}
 	class:block
 	class:loading
 	disabled={disabled || loading}
@@ -49,7 +51,7 @@
 </button>
 
 <style>
-	/* Look comes from the shared `.a-btn` rules in app.css (§5). */
+	/* Look comes from the shared `.a-btn` rules in app.css (§四.1). */
 	.btn {
 		position: relative;
 	}
@@ -72,10 +74,14 @@
 		justify-content: center;
 	}
 	.btn.primary .btn-spinner {
-		--spinner-track: rgba(22, 19, 10, 0.3);
-		--spinner-arc: var(--accent-contrast);
+		--spinner-track: color-mix(in srgb, var(--accent-ink) 30%, transparent);
+		--spinner-arc: var(--accent-ink);
 	}
 	.btn.danger .btn-spinner {
-		--spinner-arc: var(--error);
+		--spinner-arc: var(--err);
+	}
+	.btn.danger-solid .btn-spinner {
+		--spinner-track: color-mix(in srgb, var(--on-media) 30%, transparent);
+		--spinner-arc: var(--on-media);
 	}
 </style>

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

@@ -46,16 +46,18 @@
 	.card {
 		background: var(--bg-surface);
 		border: 1px solid var(--border);
-		border-radius: var(--radius-md);
+		border-radius: var(--r-lg);
 	}
 	.card.hoverable {
 		transition:
-			border-color 150ms ease,
-			transform 150ms ease;
+			border-color var(--d-state) ease,
+			transform var(--d-state) var(--ease-out);
 	}
-	.card.hoverable:hover {
-		border-color: #3f3f46;
-		transform: translateY(-1px);
+	@media (hover: hover) and (pointer: fine) {
+		.card.hoverable:hover {
+			border-color: var(--line-2);
+			transform: translateY(-1px);
+		}
 	}
 	.card-header {
 		display: flex;

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

@@ -47,7 +47,7 @@
 	{#snippet footer()}
 		<Button variant="ghost" onclick={() => (open = false)}>{cancelLabel}</Button
 		>
-		<Button variant={danger ? 'danger' : 'primary'} onclick={handleConfirm}
+		<Button variant={danger ? 'danger-solid' : 'primary'} onclick={handleConfirm}
 			>{confirmLabel}</Button
 		>
 	{/snippet}

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

@@ -144,22 +144,19 @@
 		align-items: center;
 		justify-content: center;
 		padding: 24px;
-		background: rgba(5, 5, 8, 0.6);
-		backdrop-filter: blur(6px);
-		-webkit-backdrop-filter: blur(6px);
-		animation: modal-fade 150ms ease-out;
+		background: var(--overlay);
+		animation: modal-fade var(--d-state) ease-out;
 	}
 	.modal-panel {
 		width: min(520px, 100%);
 		max-height: calc(100vh - 96px);
 		display: flex;
 		flex-direction: column;
-		background: var(--bg-surface);
-		border: 1px solid var(--border);
-		border-radius: var(--radius-lg);
-		box-shadow: 0 24px 64px rgba(0, 0, 0, 0.5);
+		background: var(--float-bg);
+		border-radius: var(--r-lg);
+		box-shadow: var(--shadow-float);
 		outline: none;
-		animation: modal-rise 180ms ease-out;
+		animation: modal-rise var(--d-pop) var(--ease-out);
 	}
 	.modal-panel.size-lg {
 		width: min(920px, 100%);
@@ -177,7 +174,7 @@
 	.modal-title {
 		margin: 0;
 		font-family: var(--font-display);
-		font-size: 16px;
+		font-size: var(--fs-title);
 		font-weight: 600;
 		color: var(--text-primary);
 	}
@@ -194,12 +191,14 @@
 		color: var(--text-muted);
 		cursor: pointer;
 		transition:
-			background-color 150ms ease,
-			color 150ms ease;
+			background-color var(--d-state) ease,
+			color var(--d-state) ease;
 	}
-	.modal-close:hover {
-		background: rgba(255, 255, 255, 0.06);
-		color: var(--text-primary);
+	@media (hover: hover) and (pointer: fine) {
+		.modal-close:hover {
+			background: var(--bg-4);
+			color: var(--text-primary);
+		}
 	}
 	.modal-close:focus-visible {
 		outline: 2px solid var(--accent);

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

@@ -4,8 +4,8 @@
 		indeterminate?: boolean;
 		label?: string;
 		size?: 'sm' | 'md';
-		/** §5 进度条: running = amber, done = green, failed = red (static). */
-		tone?: 'accent' | 'success' | 'error';
+		/** 进度条: running = 信号青, done = green, failed = red (static). */
+		tone?: 'run' | 'success' | 'error';
 		/** Track only — no label / percentage row. */
 		bare?: boolean;
 	}
@@ -15,7 +15,7 @@
 		indeterminate = false,
 		label,
 		size = 'md',
-		tone = 'accent',
+		tone = 'run',
 		bare = false,
 	}: Props = $props();
 
@@ -45,7 +45,7 @@
 		{#if indeterminate}
 			<div class="fill indeterminate"></div>
 		{:else}
-			<div class="fill" style:width={pct + '%'}></div>
+			<div class="fill" style:transform="scaleX({pct / 100})"></div>
 		{/if}
 	</div>
 </div>
@@ -75,8 +75,8 @@
 		position: relative;
 		width: 100%;
 		overflow: hidden;
-		background: var(--surface-3);
-		border-radius: 999px;
+		background: var(--bg-4);
+		border-radius: var(--r-pill);
 	}
 	.progress-sm .track {
 		height: 4px;
@@ -86,15 +86,18 @@
 	}
 	.fill {
 		height: 100%;
-		background: var(--accent);
-		border-radius: 999px;
-		transition: width 300ms cubic-bezier(0.16, 1, 0.3, 1);
+		background: var(--run-grad);
+		box-shadow: 0 0 8px var(--run-soft);
+		transform-origin: left;
+		transition: transform var(--d-progress) linear;
 	}
 	.tone-success .fill {
-		background: var(--success);
+		background: var(--ok);
+		box-shadow: none;
 	}
 	.tone-error .fill {
-		background: var(--error);
+		background: var(--err);
+		box-shadow: none;
 	}
 	.fill.indeterminate {
 		position: absolute;
@@ -104,10 +107,11 @@
 		background: linear-gradient(
 			90deg,
 			transparent,
-			var(--accent) 40%,
-			var(--accent) 60%,
+			var(--run) 40%,
+			var(--run) 60%,
 			transparent
 		);
+		box-shadow: none;
 		transition: none;
 		animation: progress-slide 1.2s ease-in-out infinite;
 	}

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

@@ -19,36 +19,26 @@
 ></div>
 
 <style>
+	/* §四.9 骨架屏：--bg-3 圆角块，1.4s 呼吸透明度；减少动态时静态。 */
 	.skeleton {
-		position: relative;
-		overflow: hidden;
-		background: var(--bg-elevated);
-		border-radius: var(--radius-sm);
+		background: var(--bg-3);
+		border-radius: var(--r-sm);
+		animation: skeleton-breath 1.4s ease-in-out infinite;
 	}
 	.skeleton.circle {
 		border-radius: 50%;
 	}
-	.skeleton::after {
-		content: '';
-		position: absolute;
-		inset: 0;
-		background: linear-gradient(
-			90deg,
-			transparent,
-			rgba(255, 255, 255, 0.06),
-			transparent
-		);
-		transform: translateX(-100%);
-		animation: skeleton-shimmer 1.6s ease-in-out infinite;
-	}
-	@keyframes skeleton-shimmer {
-		to {
-			transform: translateX(100%);
+	@keyframes skeleton-breath {
+		50% {
+			opacity: 0.5;
 		}
 	}
 	@media (prefers-reduced-motion: reduce) {
-		.skeleton::after {
-			display: none;
+		.skeleton {
+			animation: none;
 		}
 	}
+	:global(:root[data-reduce='1']) .skeleton {
+		animation: none;
+	}
 </style>

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

@@ -6,27 +6,27 @@
 
 	let { status, label }: Props = $props();
 
-	type Tone = 'success' | 'info' | 'muted' | 'error' | 'warning' | 'accent';
+	type Tone = 'ok' | 'run' | 'muted' | 'err' | 'warn';
 
 	const toneByStatus: Record<string, Tone> = {
-		ready: 'success',
-		done: 'success',
-		completed: 'success',
-		running: 'info',
-		generating: 'info',
-		queued: 'info',
+		ready: 'ok',
+		done: 'ok',
+		completed: 'ok',
+		running: 'run',
+		generating: 'run',
+		in_progress: 'run',
+		queued: 'muted',
 		pending: 'muted',
 		idle: 'muted',
 		draft: 'muted',
-		failed: 'error',
-		error: 'error',
-		paused: 'warning',
-		in_progress: 'accent',
+		failed: 'err',
+		error: 'err',
+		paused: 'warn',
 	};
 
 	const key = $derived(status.trim().toLowerCase());
 	const tone: Tone = $derived(toneByStatus[key] ?? 'muted');
-	const pulsing = $derived(key === 'running');
+	const pulsing = $derived(tone === 'run');
 </script>
 
 <span class="chip chip-{tone}">
@@ -35,59 +35,48 @@
 </span>
 
 <style>
+	/* §四.2 状态标签：20px 高、--r-sm、12px；语义色文字 + 13% 软底。 */
 	.chip {
 		display: inline-flex;
 		align-items: center;
-		gap: 6px;
-		padding: 3px 9px;
-		border: 1px solid;
-		border-radius: 999px;
-		font-size: 10px;
+		gap: var(--sp-2);
+		height: 20px;
+		padding: 0 var(--sp-2);
+		border-radius: var(--r-sm);
+		font-size: var(--fs-aux);
 		font-weight: 600;
-		letter-spacing: 0.08em;
-		text-transform: uppercase;
-		line-height: 1.4;
 		white-space: nowrap;
+		box-sizing: border-box;
 	}
 	.dot {
-		width: 6px;
-		height: 6px;
+		width: 7px;
+		height: 7px;
 		border-radius: 50%;
 		background: currentColor;
 		flex-shrink: 0;
 	}
-	.chip-success {
-		color: var(--success);
-		background: color-mix(in srgb, var(--success) 12%, transparent);
-		border-color: color-mix(in srgb, var(--success) 35%, transparent);
+	.chip-ok {
+		color: var(--ok);
+		background: var(--ok-soft);
 	}
-	.chip-info {
-		color: var(--info);
-		background: color-mix(in srgb, var(--info) 12%, transparent);
-		border-color: color-mix(in srgb, var(--info) 35%, transparent);
+	.chip-run {
+		color: var(--run);
+		background: var(--run-soft);
 	}
-	.chip-error {
-		color: var(--error);
-		background: color-mix(in srgb, var(--error) 12%, transparent);
-		border-color: color-mix(in srgb, var(--error) 35%, transparent);
+	.chip-err {
+		color: var(--err);
+		background: var(--err-soft);
 	}
-	.chip-warning {
-		color: var(--warning);
-		background: color-mix(in srgb, var(--warning) 12%, transparent);
-		border-color: color-mix(in srgb, var(--warning) 35%, transparent);
-	}
-	.chip-accent {
-		color: var(--accent);
-		background: color-mix(in srgb, var(--accent) 12%, transparent);
-		border-color: color-mix(in srgb, var(--accent) 35%, transparent);
+	.chip-warn {
+		color: var(--warn);
+		background: var(--warn-soft);
 	}
 	.chip-muted {
-		color: var(--text-secondary);
-		background: rgba(255, 255, 255, 0.04);
-		border-color: var(--border);
+		color: var(--text-2);
+		background: var(--bg-4);
 	}
 	.dot.pulsing {
-		animation: chip-pulse 1.2s ease-in-out infinite;
+		animation: chip-pulse 1.4s ease-in-out infinite;
 	}
 	@keyframes chip-pulse {
 		0%,
@@ -103,4 +92,7 @@
 			animation: none;
 		}
 	}
+	:global(:root[data-reduce='1']) .dot.pulsing {
+		animation: none;
+	}
 </style>

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

@@ -9,7 +9,7 @@
 	let { checked, label, disabled = false, onchange }: Props = $props();
 </script>
 
-<!-- §5 开关: 34×19 capsule; on = amber track + dark knob, off = --surface-3. -->
+<!-- §3.10 开关: 34×19 capsule; on = --accent-lo track + ink knob, off = --bg-4. -->
 <button
 	type="button"
 	class="switch"
@@ -28,38 +28,38 @@
 		flex-shrink: 0;
 		width: 34px;
 		height: 19px;
-		border-radius: 999px;
-		border: 1px solid var(--border-strong);
-		background: var(--surface-3);
+		border-radius: var(--r-pill);
+		border: 1px solid var(--line-2);
+		background: var(--bg-4);
 		position: relative;
 		cursor: pointer;
 		padding: 0;
 		transition:
-			background-color 150ms,
-			border-color 150ms;
+			background-color var(--d-state) ease,
+			border-color var(--d-state) ease;
 	}
 	.switch:disabled {
-		opacity: 0.4;
+		opacity: 0.45;
 		cursor: not-allowed;
 	}
 	.knob {
 		position: absolute;
-		top: 2px;
-		left: 2px;
+		top: 1px;
+		left: 1px;
 		width: 15px;
 		height: 15px;
-		border-radius: 999px;
+		border-radius: var(--r-pill);
 		background: var(--text-3);
 		transition:
-			transform 150ms cubic-bezier(0.16, 1, 0.3, 1),
-			background-color 150ms;
+			transform var(--d-state) var(--ease-out),
+			background-color var(--d-state) ease;
 	}
 	.switch.on {
-		background: var(--accent);
-		border-color: var(--accent);
+		background: var(--accent-lo);
+		border-color: var(--accent-lo);
 	}
 	.switch.on .knob {
 		transform: translateX(15px);
-		background: var(--accent-contrast);
+		background: var(--accent-ink);
 	}
 </style>

calliope-web/src/lib/components/workbench/AssetsStagePanel.svelte

@@ -369,7 +369,7 @@
 	}
 	.wb-input:focus {
 		outline: none;
-		border-color: rgba(232, 163, 61, 0.6);
+		border-color: var(--accent-line);
 	}
 	.wb-input::placeholder {
 		color: var(--text-3);
@@ -438,7 +438,7 @@
 	}
 	.btn.ghost:hover:not(:disabled) {
 		color: var(--text);
-		border-color: rgba(255, 255, 255, 0.24);
+		border-color: var(--line-2);
 	}
 	.btn.gen {
 		color: var(--accent);

calliope-web/src/lib/components/workbench/JobChip.svelte

@@ -60,8 +60,8 @@
 		background: var(--surface-3);
 	}
 	.st-running {
-		color: var(--accent);
-		background: var(--accent-dim);
+		color: var(--run);
+		background: var(--run-soft);
 	}
 	.st-done {
 		color: var(--success);

calliope-web/src/lib/components/workbench/ScriptStagePanel.svelte

@@ -258,7 +258,7 @@
 	}
 	.wb-input:focus {
 		outline: none;
-		border-color: rgba(232, 163, 61, 0.6);
+		border-color: var(--accent-line);
 	}
 	.wb-input::placeholder {
 		color: var(--text-3);
@@ -294,7 +294,7 @@
 	}
 	.btn.ghost:hover:not(:disabled) {
 		color: var(--text);
-		border-color: rgba(255, 255, 255, 0.24);
+		border-color: var(--line-2);
 	}
 	.btn.sm {
 		padding: 6px 12px;

calliope-web/src/lib/components/workbench/ShotStagePanel.svelte

@@ -341,7 +341,7 @@
 	}
 	.wb-input:focus {
 		outline: none;
-		border-color: rgba(232, 163, 61, 0.6);
+		border-color: var(--accent-line);
 	}
 	.wb-input::placeholder {
 		color: var(--text-3);
@@ -412,7 +412,7 @@
 	}
 	.btn.ghost:hover:not(:disabled) {
 		color: var(--text);
-		border-color: rgba(255, 255, 255, 0.24);
+		border-color: var(--line-2);
 	}
 	.btn.gen {
 		color: var(--accent);

calliope-web/src/lib/components/workbench/StageStepper.svelte

@@ -3,9 +3,9 @@
 	import { t } from '$lib/i18n.svelte';
 
 	/**
-	 * Five-stage stepper (a2): one step per agent with the spec §2.1 semantic
-	 * colors — gray=待开始, amber=进行中/待确认 (+breath while running),
-	 * green=已确认, blue=用户改过草稿. A step unlocks when itself or any
+	 * Five-stage stepper (a2): one step per agent with the fusion status
+	 * colors — gray=待开始, cyan=进行中 (+breath), amber=待确认,
+	 * green=已确认, --info=用户改过草稿. A step unlocks when itself or any
 	 * earlier stage has content; later steps stay clickable only after the
 	 * previous one is confirmed.
 	 */
@@ -159,7 +159,7 @@
 		justify-content: center;
 		font-size: 14px;
 		font-weight: 700;
-		color: #edeef0;
+		color: var(--text);
 		flex-shrink: 0;
 	}
 
@@ -188,9 +188,11 @@
 	.st-todo {
 		color: var(--text-3);
 	}
-	.st-running,
+	.st-running {
+		color: var(--run);
+	}
 	.st-draft {
-		color: var(--accent);
+		color: var(--warn);
 	}
 	.st-edited {
 		color: var(--info);
@@ -201,14 +203,14 @@
 
 	.step-btn.active[data-state='running'] .avatar,
 	.step-btn[data-state='running'] .avatar {
-		box-shadow: 0 0 10px rgba(232, 163, 61, 0.35);
+		box-shadow: 0 0 10px var(--run-soft);
 	}
 
 	.breath {
 		width: 6px;
 		height: 6px;
 		border-radius: 50%;
-		background: var(--accent);
+		background: var(--run);
 		animation: wb-breath 2s cubic-bezier(0.16, 1, 0.3, 1) infinite;
 	}
 

calliope-web/src/lib/components/workbench/StoryboardStagePanel.svelte

@@ -297,7 +297,7 @@
 	}
 	.wb-input:focus {
 		outline: none;
-		border-color: rgba(232, 163, 61, 0.6);
+		border-color: var(--accent-line);
 	}
 	.wb-input::placeholder {
 		color: var(--text-3);
@@ -386,7 +386,7 @@
 	}
 	.btn.ghost:hover:not(:disabled) {
 		color: var(--text);
-		border-color: rgba(255, 255, 255, 0.24);
+		border-color: var(--line-2);
 	}
 	.btn:disabled {
 		opacity: 0.4;

calliope-web/src/lib/components/workbench/StyleStagePanel.svelte

@@ -214,7 +214,7 @@
 	}
 	.dir-card.chosen {
 		border-color: var(--accent);
-		box-shadow: 0 0 10px rgba(232, 163, 61, 0.35);
+		box-shadow: 0 0 10px var(--accent-glow);
 	}
 	.dir-card input[type='radio'] {
 		position: absolute;
@@ -310,7 +310,7 @@
 	}
 	.wb-input:focus {
 		outline: none;
-		border-color: rgba(232, 163, 61, 0.6);
+		border-color: var(--accent-line);
 	}
 	.wb-input::placeholder {
 		color: var(--text-3);
@@ -375,7 +375,7 @@
 	}
 	.btn.ghost:hover:not(:disabled) {
 		color: var(--text);
-		border-color: rgba(255, 255, 255, 0.24);
+		border-color: var(--line-2);
 	}
 	.btn:disabled {
 		opacity: 0.4;

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

@@ -1435,6 +1435,17 @@ export const de: Dict = {
 	'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) ---
@@ -1451,7 +1462,7 @@ export const de: Dict = {
 	'studio.image.historyTitle': 'Bildverlauf',
 	'studio.video.historyTitle': 'Videoverlauf',
 	'studio.historyCount': '{n} gesamt',
-	'studio.lastDone': 'Zuletzt fertig · {time}',
+	'studio.doneAt': 'Fertiggestellt um {time}',
 	'studio.kindImageText': 'Bild',
 	'studio.kindVideoText': 'Video',
 	'studio.loading': 'Lädt…',
@@ -1567,7 +1578,10 @@ export const de: Dict = {
 	'studio.cancelToast': 'Abbruch angefordert',
 	'studio.deleteBtn': 'Löschen',
 	'studio.delTitle': 'Aufgabeneintrag löschen',
-	'studio.delConfirm': 'Die Ergebnisdateien werden mitgelöscht. Löschen?',
+	'studio.delConfirm': 'Beim Löschen werden auch die Ergebnisdateien dieses Auftrags entfernt; der Verlauf ist nicht wiederherstellbar. Löschen?',
+	'studio.delTitleJob': 'Auftrag „{name}“ löschen',
+	'studio.delConfirmMulti': 'Dieser Auftrag hat {n} Ergebnisse. Beim Löschen werden der gesamte Auftragsdatensatz und alle {n} Ergebnisdateien entfernt; dies ist unwiderruflich. Löschen?',
+	'studio.deletedToast': 'Auftrag und zugehörige Ergebnisdateien gelöscht',
 	'studio.wfEmptyTitle': 'Noch keine {kind}-Workflows',
 	'studio.wfEmptyBody': 'Entwicklermodus in ComfyUI aktivieren, Workflow als API-JSON exportieren und auf der Seite ComfyUI-Verbindungen als {kind} importieren.',
 	'studio.wfEmptyGo': 'In ComfyUI-Verbindungen importieren',
@@ -1861,4 +1875,53 @@ export const de: Dict = {
 	'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.',
+	// --- HEL-643: Import-Prüfung / Echtlauf-Test / Mediengruppen ---
+	'studio.errVideoFormat': '„{name}“ ist kein unterstütztes Videoformat — MP4 / WebM / MOV verwenden',
+	'studio.errAudioFormat': '„{name}“ ist kein unterstütztes Audioformat — MP3 / WAV / M4A verwenden',
+	'studio.errMediaSize': '„{name}“ überschreitet die Größenbeschränkung — bitte vorher komprimieren',
+	'studio.errNeedRefMedia': '„{label}“ benötigt mindestens {n} Clips',
+	'studio.refHintMedia': 'Pflicht · 1–{max} Clips · {n} ausgewählt',
+	'studio.refAddMedia': '{kind} hinzufügen',
+	'studio.refAddSubMedia': 'Noch {n} · max {max}',
+	'studio.refRemoveMedia': '{kind} {n} entfernen',
+	'studio.refFullMedia': 'Maximum von {max} Clips erreicht — erst eines entfernen',
+	'wfMedia.h3Limits': 'Offizielle Limits des MiniMax H3 Ref2VA: bis zu 9 Referenzbilder, 3 Referenzvideos und 3 Referenzaudios; je Clip 2–15 s, Summen je Typ ≤15 s; Audio allein ist keine gültige Referenz; insgesamt höchstens 12 Referenzdateien.',
+	'wfMedia.h3TotalOver': '{n} Referenzdateien — über dem offiziellen Limit von 12; die Generierung kann fehlschlagen',
+	'wfMedia.h3AudioAlone': 'Audio allein kann nicht die einzige Referenz sein — mindestens ein Bild oder Video ergänzen',
+	'conn.wfCheckTitle': 'Kompatibilitätsprüfung der Verbindung',
+	'conn.wfCheckEndpoint': 'Ziel: {name}',
+	'conn.wfCheckBtn': 'Erneut prüfen',
+	'conn.wfChecking': 'Prüfe…',
+	'conn.wfCheckOk': 'Diese Verbindung besitzt die Knoten und Modelle, die dieser Workflow braucht',
+	'conn.wfCheckProblems': '{n} fehlende Knoten/Modelle gefunden',
+	'conn.wfCheckUnreachable': 'Keine Prüfung möglich (ComfyUI unerreichbar) — Speichern bleibt möglich; nach Reparatur erneut prüfen',
+	'conn.wfCheckSaveHint': 'Der Entwurf kann trotzdem gespeichert werden (wird nicht als generierbar markiert); Fehlendes installieren und erneut prüfen.',
+	'conn.wfTestBtn': 'Testen',
+	'conn.wfLastTest': 'Letzter Test',
+	'conn.wfTestPassed': '{time} bestanden ({n} Dateien)',
+	'conn.wfTestRunning': '{time} läuft',
+	'conn.wfTestFailed': '{time} nicht bestanden',
+	'wft.title': 'Workflow testen',
+	'wft.connection': 'Zielverbindung',
+	'wft.costNote': 'Ein Test schickt einen echten Auftrag an den gewählten ComfyUI und belegt VRAM und Warteschlange.',
+	'wft.submit': 'Test starten',
+	'wft.confirmTitle': 'Echten Lauf bestätigen',
+	'wft.confirmBody': 'An „{endpoint}“ wird ein echter Auftrag gesendet ({n} Aufträge in der Warteschlange). Der Test gilt nur als bestanden, wenn mindestens eine herunterladbare Ausgabedatei des richtigen Typs zurückkommt.',
+	'wft.running': 'Test läuft…',
+	'wft.cancel': 'Test abbrechen',
+	'wft.passed': 'Test bestanden: {n} Datei(en) erzeugt',
+	'wft.passedShort': 'Bestanden ({n} Dateien)',
+	'wft.failed': 'Test nicht bestanden',
+	'wft.failedShort': 'Nicht bestanden',
+	'wft.cancelledShort': 'Abgebrochen',
+	'wft.reusedToast': 'Für diesen Workflow läuft bereits ein Test — angebunden',
+	'wft.history': 'Testverlauf ({n})',
+	'wft.clear': 'Testverlauf löschen',
+	'wft.cleared': 'Testverlauf gelöscht',
+	'wft.never': 'Nie getestet',
+	'wft.download': 'Herunterladen',
+	'wft.errRequired': 'Bitte „{label}“ ausfüllen',
+	'wft.errListMin': '„{label}“ benötigt mindestens {n} {unit}',
+	'tasks.testBadge': 'Test',
+	'tasks.sourceWorkflowTest': 'Workflow-Test',
 };

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

@@ -1435,6 +1435,17 @@ export const en = {
 	'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',
@@ -1450,7 +1461,7 @@ export const en = {
 	'studio.image.historyTitle': 'Image history',
 	'studio.video.historyTitle': 'Video history',
 	'studio.historyCount': '{n} total',
-	'studio.lastDone': 'Last done · {time}',
+	'studio.doneAt': 'Done at {time}',
 	'studio.kindImageText': 'image',
 	'studio.kindVideoText': 'video',
 	'studio.loading': 'Loading…',
@@ -1566,7 +1577,10 @@ export const en = {
 	'studio.cancelToast': 'Cancel requested',
 	'studio.deleteBtn': 'Delete',
 	'studio.delTitle': 'Delete task record',
-	'studio.delConfirm': 'The result files will be removed together with the record. Delete it?',
+	'studio.delConfirm': 'Deleting also removes this job’s result files; the history cannot be restored. Delete?',
+	'studio.delTitleJob': 'Delete job “{name}”',
+	'studio.delConfirmMulti': 'This job produced {n} results. Deleting removes the whole job record and all {n} result files; this cannot be undone. Delete?',
+	'studio.deletedToast': 'Job deleted together with its result files',
 	'studio.wfEmptyTitle': 'No {kind} workflows yet',
 	'studio.wfEmptyBody': "Enable ComfyUI's developer mode, export the workflow as API JSON, then import it on the ComfyUI Connections page as {kind}.",
 	'studio.wfEmptyGo': 'Import in ComfyUI Connections',
@@ -1860,6 +1874,55 @@ export const en = {
 	'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.',
+	// --- HEL-643: workflow import check / real test / media groups ---
+	'studio.errVideoFormat': '"{name}" is not a supported video format — use MP4 / WebM / MOV',
+	'studio.errAudioFormat': '"{name}" is not a supported audio format — use MP3 / WAV / M4A',
+	'studio.errMediaSize': '"{name}" exceeds the size limit — compress it first',
+	'studio.errNeedRefMedia': '"{label}" needs at least {n} clips',
+	'studio.refHintMedia': 'Required · 1–{max} clips · {n} selected',
+	'studio.refAddMedia': 'Add {kind}',
+	'studio.refAddSubMedia': '{n} more · max {max}',
+	'studio.refRemoveMedia': 'Remove {kind} {n}',
+	'studio.refFullMedia': 'Limit of {max} clips reached — remove one to add another',
+	'wfMedia.h3Limits': 'MiniMax H3 Ref2VA official limits: up to 9 reference images, 3 reference videos and 3 reference audios; each clip 2–15s with video/audio totals ≤15s each; audio cannot be the only reference; at most 12 reference files in total.',
+	'wfMedia.h3TotalOver': '{n} reference files selected — above the official cap of 12; generation may fail',
+	'wfMedia.h3AudioAlone': 'Audio cannot be the only reference — add at least one reference image or video',
+	'conn.wfCheckTitle': 'Connection compatibility check',
+	'conn.wfCheckEndpoint': 'Target: {name}',
+	'conn.wfCheckBtn': 'Re-check',
+	'conn.wfChecking': 'Checking…',
+	'conn.wfCheckOk': 'This connection has the nodes and models this workflow needs',
+	'conn.wfCheckProblems': '{n} missing node(s)/model(s) found',
+	'conn.wfCheckUnreachable': 'Cannot verify (ComfyUI unreachable) — saving stays possible; re-check after fixing the connection',
+	'conn.wfCheckSaveHint': 'You can still save the draft (it is not marked generatable); install the missing pieces and re-check.',
+	'conn.wfTestBtn': 'Test',
+	'conn.wfLastTest': 'Last test',
+	'conn.wfTestPassed': '{time} passed ({n} files)',
+	'conn.wfTestRunning': '{time} running',
+	'conn.wfTestFailed': '{time} failed',
+	'wft.title': 'Test workflow',
+	'wft.connection': 'Target connection',
+	'wft.costNote': 'A test submits one real job to the selected ComfyUI and uses its VRAM and queue time.',
+	'wft.submit': 'Start test',
+	'wft.confirmTitle': 'Confirm a real run',
+	'wft.confirmBody': 'One real job will be submitted to "{endpoint}" ({n} jobs in queue). The test only passes when at least one downloadable output of the right media type comes back.',
+	'wft.running': 'Testing…',
+	'wft.cancel': 'Cancel test',
+	'wft.passed': 'Test passed: {n} file(s) produced',
+	'wft.passedShort': 'Passed ({n} files)',
+	'wft.failed': 'Test failed',
+	'wft.failedShort': 'Failed',
+	'wft.cancelledShort': 'Cancelled',
+	'wft.reusedToast': 'A test is already running for this workflow — attached to it',
+	'wft.history': 'Test records ({n})',
+	'wft.clear': 'Clear test records',
+	'wft.cleared': 'Test records cleared',
+	'wft.never': 'Never tested',
+	'wft.download': 'Download',
+	'wft.errRequired': 'Please fill in "{label}"',
+	'wft.errListMin': '"{label}" needs at least {n} {unit}',
+	'tasks.testBadge': 'Test',
+	'tasks.sourceWorkflowTest': 'Workflow test',
 };
 
 export type Dict = typeof en;

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

@@ -1435,6 +1435,17 @@ export const es: Dict = {
 	'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) ---
@@ -1451,7 +1462,7 @@ export const es: Dict = {
 	'studio.image.historyTitle': 'Historial de imágenes',
 	'studio.video.historyTitle': 'Historial de vídeos',
 	'studio.historyCount': '{n} en total',
-	'studio.lastDone': 'Último · {time}',
+	'studio.doneAt': 'Completado a las {time}',
 	'studio.kindImageText': 'imagen',
 	'studio.kindVideoText': 'vídeo',
 	'studio.loading': 'Cargando…',
@@ -1567,7 +1578,10 @@ export const es: Dict = {
 	'studio.cancelToast': 'Cancelación solicitada',
 	'studio.deleteBtn': 'Eliminar',
 	'studio.delTitle': 'Eliminar registro de tarea',
-	'studio.delConfirm': 'Los archivos de resultados se eliminarán junto con el registro. ¿Eliminar?',
+	'studio.delConfirm': 'Al eliminar también se quitan los archivos de resultados de esta tarea; el historial no se puede restaurar. ¿Eliminar?',
+	'studio.delTitleJob': 'Eliminar tarea «{name}»',
+	'studio.delConfirmMulti': 'Esta tarea produjo {n} resultados. Al eliminarla se quita el registro completo y los {n} archivos de resultados; no se puede deshacer. ¿Eliminar?',
+	'studio.deletedToast': 'Tarea eliminada junto con sus archivos de resultados',
 	'studio.wfEmptyTitle': 'Aún no hay flujos de {kind}',
 	'studio.wfEmptyBody': 'Activa el modo desarrollador de ComfyUI, exporta el flujo como JSON API e impórtalo en Conexiones ComfyUI como {kind}.',
 	'studio.wfEmptyGo': 'Importar en Conexiones ComfyUI',
@@ -1861,4 +1875,53 @@ export const es: Dict = {
 	'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.',
+	// --- HEL-643: verificación de importación / prueba real / grupos de medios ---
+	'studio.errVideoFormat': '«{name}» no es un formato de vídeo admitido: usa MP4 / WebM / MOV',
+	'studio.errAudioFormat': '«{name}» no es un formato de audio admitido: usa MP3 / WAV / M4A',
+	'studio.errMediaSize': '«{name}» supera el límite de tamaño, comprímelo primero',
+	'studio.errNeedRefMedia': '«{label}» necesita al menos {n} clips',
+	'studio.refHintMedia': 'Obligatorio · 1–{max} clips · {n} seleccionados',
+	'studio.refAddMedia': 'Añadir {kind}',
+	'studio.refAddSubMedia': 'Quedan {n} · máx. {max}',
+	'studio.refRemoveMedia': 'Quitar {kind} {n}',
+	'studio.refFullMedia': 'Límite de {max} clips alcanzado: quita uno para añadir otro',
+	'wfMedia.h3Limits': 'Límites oficiales de MiniMax H3 Ref2VA: hasta 9 imágenes, 3 vídeos y 3 audios de referencia; cada clip de 2–15 s con totales ≤15 s por tipo; el audio no puede ser la única referencia; 12 archivos de referencia como máximo.',
+	'wfMedia.h3TotalOver': '{n} archivos de referencia: por encima del límite oficial de 12; la generación puede fallar',
+	'wfMedia.h3AudioAlone': 'El audio no puede ser la única referencia: añade al menos una imagen o un vídeo',
+	'conn.wfCheckTitle': 'Comprobación de compatibilidad de la conexión',
+	'conn.wfCheckEndpoint': 'Destino: {name}',
+	'conn.wfCheckBtn': 'Volver a comprobar',
+	'conn.wfChecking': 'Comprobando…',
+	'conn.wfCheckOk': 'Esta conexión tiene los nodos y modelos que necesita este flujo',
+	'conn.wfCheckProblems': 'Se encontraron {n} nodos/modelos ausentes',
+	'conn.wfCheckUnreachable': 'No se puede verificar (ComfyUI inaccesible): puedes guardar igualmente; vuelve a comprobar tras arreglar la conexión',
+	'conn.wfCheckSaveHint': 'Puedes guardar el borrador (no se marcará como generable); instala lo que falta y vuelve a comprobar.',
+	'conn.wfTestBtn': 'Probar',
+	'conn.wfLastTest': 'Última prueba',
+	'conn.wfTestPassed': '{time} superada ({n} archivos)',
+	'conn.wfTestRunning': '{time} en curso',
+	'conn.wfTestFailed': '{time} no superada',
+	'wft.title': 'Probar flujo',
+	'wft.connection': 'Conexión de destino',
+	'wft.costNote': 'La prueba envía un trabajo real al ComfyUI elegido y usa su VRAM y su cola.',
+	'wft.submit': 'Iniciar prueba',
+	'wft.confirmTitle': 'Confirmar ejecución real',
+	'wft.confirmBody': 'Se enviará un trabajo real a «{endpoint}» ({n} trabajos en cola). La prueba solo se aprueba si vuelve al menos un archivo descargable del tipo correcto.',
+	'wft.running': 'Probando…',
+	'wft.cancel': 'Cancelar prueba',
+	'wft.passed': 'Prueba superada: {n} archivo(s) producidos',
+	'wft.passedShort': 'Superada ({n} archivos)',
+	'wft.failed': 'Prueba no superada',
+	'wft.failedShort': 'No superada',
+	'wft.cancelledShort': 'Cancelada',
+	'wft.reusedToast': 'Ya hay una prueba en curso para este flujo: se ha retomado',
+	'wft.history': 'Registros de prueba ({n})',
+	'wft.clear': 'Borrar registros de prueba',
+	'wft.cleared': 'Registros de prueba borrados',
+	'wft.never': 'Nunca probado',
+	'wft.download': 'Descargar',
+	'wft.errRequired': 'Rellena «{label}»',
+	'wft.errListMin': '«{label}» necesita al menos {n} {unit}',
+	'tasks.testBadge': 'Prueba',
+	'tasks.sourceWorkflowTest': 'Prueba de flujo',
 };

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

@@ -1435,6 +1435,17 @@ export const fr: Dict = {
 	'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) ---
@@ -1451,7 +1462,7 @@ export const fr: Dict = {
 	'studio.image.historyTitle': 'Historique images',
 	'studio.video.historyTitle': 'Historique vidéos',
 	'studio.historyCount': '{n} au total',
-	'studio.lastDone': 'Dernier · {time}',
+	'studio.doneAt': 'Terminé à {time}',
 	'studio.kindImageText': 'image',
 	'studio.kindVideoText': 'vidéo',
 	'studio.loading': 'Chargement…',
@@ -1567,7 +1578,10 @@ export const fr: Dict = {
 	'studio.cancelToast': 'Annulation demandée',
 	'studio.deleteBtn': 'Supprimer',
 	'studio.delTitle': 'Supprimer la tâche',
-	'studio.delConfirm': 'Les fichiers de résultats seront supprimés avec la tâche. Supprimer ?',
+	'studio.delConfirm': 'La suppression retire aussi les fichiers de résultats de cette tâche ; l’historique est irrécupérable. Supprimer ?',
+	'studio.delTitleJob': 'Supprimer la tâche « {name} »',
+	'studio.delConfirmMulti': 'Cette tâche a produit {n} résultats. La suppression retire la tâche entière et ses {n} fichiers de résultats ; action irréversible. Supprimer ?',
+	'studio.deletedToast': 'Tâche supprimée avec ses fichiers de résultats',
 	'studio.wfEmptyTitle': 'Pas encore de workflows {kind}',
 	'studio.wfEmptyBody': 'Activez le mode développeur de ComfyUI, exportez le workflow en JSON API, puis importez-le dans Connexions ComfyUI comme {kind}.',
 	'studio.wfEmptyGo': 'Importer dans Connexions ComfyUI',
@@ -1861,4 +1875,53 @@ export const fr: Dict = {
 	'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.',
+	// --- HEL-643 : vérification d'import / test réel / groupes de médias ---
+	'studio.errVideoFormat': "« {name} » n'est pas un format vidéo pris en charge — utilisez MP4 / WebM / MOV",
+	'studio.errAudioFormat': "« {name} » n'est pas un format audio pris en charge — utilisez MP3 / WAV / M4A",
+	'studio.errMediaSize': "« {name} » dépasse la limite de taille — compressez-le d'abord",
+	'studio.errNeedRefMedia': '« {label} » exige au moins {n} clips',
+	'studio.refHintMedia': 'Requis · 1–{max} clips · {n} sélectionnés',
+	'studio.refAddMedia': 'Ajouter {kind}',
+	'studio.refAddSubMedia': '{n} de plus · max {max}',
+	'studio.refRemoveMedia': 'Retirer {kind} {n}',
+	'studio.refFullMedia': 'Limite de {max} clips atteinte — retirez-en un pour en ajouter un autre',
+	'wfMedia.h3Limits': "Limites officielles MiniMax H3 Ref2VA : jusqu'à 9 images, 3 vidéos et 3 audios de référence ; chaque clip de 2–15 s, totaux ≤15 s par type ; l'audio ne peut être la seule référence ; 12 fichiers de référence au maximum.",
+	'wfMedia.h3TotalOver': '{n} fichiers de référence — au-delà du plafond officiel de 12 ; la génération peut échouer',
+	'wfMedia.h3AudioAlone': "L'audio ne peut pas être la seule référence — ajoutez au moins une image ou une vidéo",
+	'conn.wfCheckTitle': 'Vérification de compatibilité de la connexion',
+	'conn.wfCheckEndpoint': 'Cible : {name}',
+	'conn.wfCheckBtn': 'Revérifier',
+	'conn.wfChecking': 'Vérification…',
+	'conn.wfCheckOk': 'Cette connexion possède les nœuds et modèles requis par ce flux',
+	'conn.wfCheckProblems': '{n} nœud(s)/modèle(s) manquant(s) détecté(s)',
+	'conn.wfCheckUnreachable': "Vérification impossible (ComfyUI injoignable) — l'enregistrement reste possible ; revérifiez après avoir réparé la connexion",
+	'conn.wfCheckSaveHint': 'Vous pouvez enregistrer le brouillon (il ne sera pas marqué générable) ; installez le manquant puis revérifiez.',
+	'conn.wfTestBtn': 'Tester',
+	'conn.wfLastTest': 'Dernier test',
+	'conn.wfTestPassed': '{time} réussi ({n} fichiers)',
+	'conn.wfTestRunning': '{time} en cours',
+	'conn.wfTestFailed': '{time} échoué',
+	'wft.title': 'Tester le flux',
+	'wft.connection': 'Connexion cible',
+	'wft.costNote': 'Un test envoie une tâche réelle au ComfyUI choisi et mobilise son VRAM et sa file.',
+	'wft.submit': 'Lancer le test',
+	'wft.confirmTitle': 'Confirmer une exécution réelle',
+	'wft.confirmBody': 'Une tâche réelle sera envoyée à « {endpoint} » ({n} tâches en file). Le test ne réussit que si au moins un fichier téléchargeable du bon type revient.',
+	'wft.running': 'Test en cours…',
+	'wft.cancel': 'Annuler le test',
+	'wft.passed': 'Test réussi : {n} fichier(s) produit(s)',
+	'wft.passedShort': 'Réussi ({n} fichiers)',
+	'wft.failed': 'Test échoué',
+	'wft.failedShort': 'Échoué',
+	'wft.cancelledShort': 'Annulé',
+	'wft.reusedToast': 'Un test est déjà en cours pour ce flux — rattaché à celui-ci',
+	'wft.history': 'Historique des tests ({n})',
+	'wft.clear': "Effacer l'historique des tests",
+	'wft.cleared': 'Historique des tests effacé',
+	'wft.never': 'Jamais testé',
+	'wft.download': 'Télécharger',
+	'wft.errRequired': 'Veuillez renseigner « {label} »',
+	'wft.errListMin': '« {label} » exige au moins {n} {unit}',
+	'tasks.testBadge': 'Test',
+	'tasks.sourceWorkflowTest': 'Test de flux',
 };

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

@@ -1435,6 +1435,17 @@ export const ja: Dict = {
 	'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）---
@@ -1451,7 +1462,7 @@ export const ja: Dict = {
 	'studio.image.historyTitle': '画像生成履歴',
 	'studio.video.historyTitle': '動画生成履歴',
 	'studio.historyCount': '計 {n} 回',
-	'studio.lastDone': '最終完了 · {time}',
+	'studio.doneAt': '完了 {time}',
 	'studio.kindImageText': '画像',
 	'studio.kindVideoText': '動画',
 	'studio.loading': '読み込み中…',
@@ -1567,7 +1578,10 @@ export const ja: Dict = {
 	'studio.cancelToast': 'キャンセルを要求しました',
 	'studio.deleteBtn': '削除',
 	'studio.delTitle': 'タスク記録を削除',
-	'studio.delConfirm': '結果ファイルも一緒に削除され、履歴は復元できません。削除しますか？',
+	'studio.delConfirm': '削除するとこのタスクの結果ファイルも削除され、履歴は元に戻せません。削除しますか？',
+	'studio.delTitleJob': 'タスク「{name}」を削除',
+	'studio.delConfirmMulti': 'このタスクには結果が {n} 件あります。削除するとタスク記録と {n} 件すべての結果ファイルが失われ、元に戻せません。削除しますか？',
+	'studio.deletedToast': 'タスクと結果ファイルを削除しました',
 	'studio.wfEmptyTitle': '{kind}ワークフローがまだありません',
 	'studio.wfEmptyBody': 'ComfyUI の開発者モードで API 形式 JSON を書き出し、「ComfyUI 接続」ページで{kind}として取り込んでください。',
 	'studio.wfEmptyGo': '「ComfyUI 接続」で取り込む',
@@ -1861,4 +1875,53 @@ export const ja: Dict = {
 	'studio.doneToast': '完了：{n} ファイル（ComfyUI プロンプト ID {id}）',
 	'studio.dryRunToast': 'プレースホルダーのみ：Dry-run が有効で ComfyUI は呼び出されていません',
 	'studio.dryRunNote': 'Dry-run が有効です：生成はプレースホルダーを書き出すだけで ComfyUI を呼び出しません。設定でオフにできます。',
+	// --- HEL-643: インポート検査 / 実テスト / メディアグループ ---
+	'studio.errVideoFormat': '「{name}」は未対応の動画形式です。MP4 / WebM / MOV を使ってください',
+	'studio.errAudioFormat': '「{name}」は未対応の音声形式です。MP3 / WAV / M4A を使ってください',
+	'studio.errMediaSize': '「{name}」はサイズ上限を超えています。先に圧縮してください',
+	'studio.errNeedRefMedia': '「{label}」は最低 {n} 本必要です',
+	'studio.refHintMedia': '必須 · 1–{max} 本 · 選択 {n}',
+	'studio.refAddMedia': '{kind}を追加',
+	'studio.refAddSubMedia': 'あと {n} 本 · 上限 {max}',
+	'studio.refRemoveMedia': '{kind} {n} を削除',
+	'studio.refFullMedia': '上限 {max} 本に達しました。削除してから追加してください',
+	'wfMedia.h3Limits': 'MiniMax H3 Ref2VA の公式上限：参照画像は最大 9 枠、参照動画は 3 本、参照音声は 3 本。各クリップ 2–15 秒で種類ごとの合計 15 秒以下。音声のみの参照は不可。参照ファイルは合計 12 まで。',
+	'wfMedia.h3TotalOver': '参照ファイルが {n} 個あり、公式上限 12 を超えています。生成に失敗する可能性があります',
+	'wfMedia.h3AudioAlone': '音声だけで参照にすることはできません。参照画像か参照動画を少なくとも 1 つ追加してください',
+	'conn.wfCheckTitle': '接続互換性チェック',
+	'conn.wfCheckEndpoint': '対象：{name}',
+	'conn.wfCheckBtn': '再チェック',
+	'conn.wfChecking': 'チェック中…',
+	'conn.wfCheckOk': 'この接続にはこのワークフローに必要なノードとモデルがあります',
+	'conn.wfCheckProblems': '不足しているノード/モデルが {n} 件見つかりました',
+	'conn.wfCheckUnreachable': '確認できません（ComfyUI に接続不可）。保存は可能です。接続を直してから再チェックしてください',
+	'conn.wfCheckSaveHint': 'ドラフトは保存できます（生成可能とは表示されません）。不足項目を入れて再チェックしてください。',
+	'conn.wfTestBtn': 'テスト',
+	'conn.wfLastTest': '前回のテスト',
+	'conn.wfTestPassed': '{time} 合格（{n} ファイル）',
+	'conn.wfTestRunning': '{time} 実行中',
+	'conn.wfTestFailed': '{time} 不合格',
+	'wft.title': 'ワークフローをテスト',
+	'wft.connection': '対象接続',
+	'wft.costNote': 'テストは選択した ComfyUI に実際のジョブを投入し、VRAM と待ち時間を消費します。',
+	'wft.submit': 'テスト開始',
+	'wft.confirmTitle': '実行の確認',
+	'wft.confirmBody': '「{endpoint}」へ実際のジョブを 1 件投入します（現在のキュー {n} 件）。正しい種類のダウンロード可能な出力が 1 つ以上戻った場合のみ合格です。',
+	'wft.running': 'テスト中…',
+	'wft.cancel': 'テストを中止',
+	'wft.passed': 'テスト合格：{n} ファイル生成',
+	'wft.passedShort': '合格（{n} ファイル）',
+	'wft.failed': 'テスト不合格',
+	'wft.failedShort': '不合格',
+	'wft.cancelledShort': '中止しました',
+	'wft.reusedToast': 'このワークフローはテスト実行中のため、そのジョブに接続しました',
+	'wft.history': 'テスト記録（{n} 件）',
+	'wft.clear': 'テスト記録を消去',
+	'wft.cleared': 'テスト記録を消去しました',
+	'wft.never': '未テスト',
+	'wft.download': 'ダウンロード',
+	'wft.errRequired': '「{label}」を入力してください',
+	'wft.errListMin': '「{label}」は最低 {n} {unit} 必要です',
+	'tasks.testBadge': 'テスト',
+	'tasks.sourceWorkflowTest': 'ワークフローテスト',
 };

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

@@ -1435,6 +1435,17 @@ export const ko: Dict = {
 	'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) ---
@@ -1451,7 +1462,7 @@ export const ko: Dict = {
 	'studio.image.historyTitle': '이미지 생성 기록',
 	'studio.video.historyTitle': '영상 생성 기록',
 	'studio.historyCount': '총 {n}회',
-	'studio.lastDone': '최근 완료 · {time}',
+	'studio.doneAt': '완료 {time}',
 	'studio.kindImageText': '이미지',
 	'studio.kindVideoText': '비디오',
 	'studio.loading': '불러오는 중…',
@@ -1567,7 +1578,10 @@ export const ko: Dict = {
 	'studio.cancelToast': '취소를 요청했습니다',
 	'studio.deleteBtn': '삭제',
 	'studio.delTitle': '작업 기록 삭제',
-	'studio.delConfirm': '결과 파일도 함께 삭제되며 기록은 복구할 수 없습니다. 삭제할까요?',
+	'studio.delConfirm': '삭제 시 이 작업의 결과 파일도 함께 제거되며 기록은 복구할 수 없습니다. 삭제할까요?',
+	'studio.delTitleJob': '작업 «{name}» 삭제',
+	'studio.delConfirmMulti': '이 작업에는 결과가 {n}개 있습니다. 삭제하면 작업 기록과 결과 파일 {n}개 모두 제거되며 복구할 수 없습니다. 삭제할까요?',
+	'studio.deletedToast': '작업과 결과 파일을 삭제했습니다',
 	'studio.wfEmptyTitle': '{kind} 워크플로가 아직 없습니다',
 	'studio.wfEmptyBody': 'ComfyUI 개발자 모드를 켜고 API 형식 JSON으로 내보낸 뒤, ComfyUI 연결 페이지에서 {kind}(으)로 가져오세요.',
 	'studio.wfEmptyGo': 'ComfyUI 연결에서 가져오기',
@@ -1861,4 +1875,53 @@ export const ko: Dict = {
 	'studio.doneToast': '완료: 파일 {n}개 (ComfyUI 프롬프트 ID {id})',
 	'studio.dryRunToast': '자리표시자만: Dry-run이 켜져 있어 ComfyUI를 호출하지 않았습니다',
 	'studio.dryRunNote': 'Dry-run이 켜져 있습니다: 생성은 자리표시자만 쓰고 ComfyUI를 호출하지 않습니다. 설정에서 끌 수 있습니다.',
+	// --- HEL-643: 가져오기 검사 / 실제 테스트 / 미디어 그룹 ---
+	'studio.errVideoFormat': '«{name}»은(는) 지원하지 않는 동영상 형식입니다. MP4 / WebM / MOV를 사용하세요',
+	'studio.errAudioFormat': '«{name}»은(는) 지원하지 않는 오디오 형식입니다. MP3 / WAV / M4A를 사용하세요',
+	'studio.errMediaSize': '«{name}»이(가) 크기 제한을 초과합니다. 먼저 압축하세요',
+	'studio.errNeedRefMedia': '«{label}»에 최소 {n}개가 필요합니다',
+	'studio.refHintMedia': '필수 · 1–{max}개 · 선택 {n}',
+	'studio.refAddMedia': '{kind} 추가',
+	'studio.refAddSubMedia': '{n}개 더 · 최대 {max}',
+	'studio.refRemoveMedia': '{kind} {n} 제거',
+	'studio.refFullMedia': '최대 {max}개에 도달했습니다. 제거 후 추가하세요',
+	'wfMedia.h3Limits': 'MiniMax H3 Ref2VA 공식 한도: 참조 이미지 최대 9장, 참조 영상 3개, 참조 오디오 3개. 클립당 2–15초이며 유형별 총합 15초 이하. 오디오만 단독 참조는 불가. 참조 파일은 총 12개까지.',
+	'wfMedia.h3TotalOver': '참조 파일이 {n}개로 공식 한도 12를 초과했습니다. 생성이 실패할 수 있습니다',
+	'wfMedia.h3AudioAlone': '오디오만 단독 참조가 될 수 없습니다. 참조 이미지 또는 영상을 1개 이상 추가하세요',
+	'conn.wfCheckTitle': '연결 호환성 검사',
+	'conn.wfCheckEndpoint': '대상: {name}',
+	'conn.wfCheckBtn': '다시 검사',
+	'conn.wfChecking': '검사 중…',
+	'conn.wfCheckOk': '이 연결은 이 워크플로에 필요한 노드와 모델을 갖추고 있습니다',
+	'conn.wfCheckProblems': '누락된 노드/모델 {n}개를 발견했습니다',
+	'conn.wfCheckUnreachable': '확인할 수 없습니다(ComfyUI 연결 불가). 저장은 가능하며 연결을 고친 뒤 다시 검사하세요',
+	'conn.wfCheckSaveHint': '초안은 저장할 수 있습니다(생성 가능으로 표시되지 않음). 누락 항목을 설치한 뒤 다시 검사하세요.',
+	'conn.wfTestBtn': '테스트',
+	'conn.wfLastTest': '마지막 테스트',
+	'conn.wfTestPassed': '{time} 통과({n}개 파일)',
+	'conn.wfTestRunning': '{time} 진행 중',
+	'conn.wfTestFailed': '{time} 실패',
+	'wft.title': '워크플로 테스트',
+	'wft.connection': '대상 연결',
+	'wft.costNote': '테스트는 선택한 ComfyUI에 실제 작업을 1건 보내 VRAM과 대기열을 사용합니다.',
+	'wft.submit': '테스트 시작',
+	'wft.confirmTitle': '실제 실행 확인',
+	'wft.confirmBody': '«{endpoint}»에 실제 작업 1건을 제출합니다(현재 대기열 {n}건). 올바른 유형의 다운로드 가능한 출력이 1개 이상 돌아와야 통과입니다.',
+	'wft.running': '테스트 중…',
+	'wft.cancel': '테스트 취소',
+	'wft.passed': '테스트 통과: 파일 {n}개 생성',
+	'wft.passedShort': '통과({n}개 파일)',
+	'wft.failed': '테스트 실패',
+	'wft.failedShort': '실패',
+	'wft.cancelledShort': '취소됨',
+	'wft.reusedToast': '이 워크플로는 이미 테스트 진행 중입니다. 해당 작업에 연결했습니다',
+	'wft.history': '테스트 기록({n}건)',
+	'wft.clear': '테스트 기록 삭제',
+	'wft.cleared': '테스트 기록을 삭제했습니다',
+	'wft.never': '테스트 이력 없음',
+	'wft.download': '다운로드',
+	'wft.errRequired': '«{label}»을(를) 입력하세요',
+	'wft.errListMin': '«{label}»에 최소 {n}{unit}이(가) 필요합니다',
+	'tasks.testBadge': '테스트',
+	'tasks.sourceWorkflowTest': '워크플로 테스트',
 };

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

@@ -1435,6 +1435,17 @@ export const zh: Dict = {
 	'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': '生图',
@@ -1450,7 +1461,7 @@ export const zh: Dict = {
 	'studio.image.historyTitle': '生图历史',
 	'studio.video.historyTitle': '生视频历史',
 	'studio.historyCount': '共 {n} 次',
-	'studio.lastDone': '最近完成 · {time}',
+	'studio.doneAt': '完成于 {time}',
 	'studio.kindImageText': '图片',
 	'studio.kindVideoText': '视频',
 	'studio.loading': '正在加载…',
@@ -1568,6 +1579,9 @@ export const zh: Dict = {
 	'studio.deleteBtn': '删除',
 	'studio.delTitle': '删除任务记录',
 	'studio.delConfirm': '删除后该任务的结果文件会一并移除，历史不可恢复。确定删除？',
+	'studio.delTitleJob': '删除任务「{name}」',
+	'studio.delConfirmMulti': '该任务共生成 {n} 个结果，删除将移除整条任务记录及其全部 {n} 个结果文件，历史不可恢复。确定删除？',
+	'studio.deletedToast': '已删除该任务及其结果文件',
 	'studio.wfEmptyTitle': '还没有{kind}工作流',
 	'studio.wfEmptyBody': '在 ComfyUI 里启用开发者模式，用「导出（API 格式）」得到 JSON，再到「ComfyUI 连接」页导入并分类为{kind}。',
 	'studio.wfEmptyGo': '去「ComfyUI 连接」导入',
@@ -1861,4 +1875,53 @@ export const zh: Dict = {
 	'studio.doneToast': '生成完成：{n} 个文件（ComfyUI 任务 ID {id}）',
 	'studio.dryRunToast': '占位完成：当前开启了 Dry-run，没有调用 ComfyUI，结果不是真实生成',
 	'studio.dryRunNote': '已开启 Dry-run：点生成只会写占位文件，不会调用 ComfyUI。可在「设置」中关闭。',
+	// --- HEL-643: workflow import check / real test / media groups ---
+	'studio.errVideoFormat': '「{name}」不是支持的视频格式，请使用 MP4 / WebM / MOV',
+	'studio.errAudioFormat': '「{name}」不是支持的音频格式，请使用 MP3 / WAV / M4A',
+	'studio.errMediaSize': '「{name}」超过大小限制，请压缩后再传',
+	'studio.errNeedRefMedia': '「{label}」需要至少 {n} 段',
+	'studio.refHintMedia': '必填 · 1–{max} 段 · 已选 {n}',
+	'studio.refAddMedia': '添加{kind}',
+	'studio.refAddSubMedia': '还可加 {n} 段 · 上限 {max}',
+	'studio.refRemoveMedia': '移除{kind} {n}',
+	'studio.refFullMedia': '已达上限 {max} 段，移除后才能再添加',
+	'wfMedia.h3Limits': 'MiniMax H3 Ref2VA 官方限额：参考图最多 9 张、参考视频 3 段、参考音频 3 段；单段音视频 2–15 秒，视频与音频各自总时长不超过 15 秒；音频不能单独作为唯一参考；参考文件总数最多 12。',
+	'wfMedia.h3TotalOver': '参考文件总数已达 {n} 个，超过官方上限 12，生成可能失败',
+	'wfMedia.h3AudioAlone': '音频不能单独作为唯一参考，请至少搭配一张参考图或一段参考视频',
+	'conn.wfCheckTitle': '连接兼容性检查',
+	'conn.wfCheckEndpoint': '目标：{name}',
+	'conn.wfCheckBtn': '重新检查',
+	'conn.wfChecking': '检查中…',
+	'conn.wfCheckOk': '该连接具备运行此工作流的节点与模型',
+	'conn.wfCheckProblems': '发现 {n} 个缺失的节点/模型',
+	'conn.wfCheckUnreachable': '无法核查（连不上该 ComfyUI），不阻断保存；修好连接后可重新检查',
+	'conn.wfCheckSaveHint': '仍可保存草稿（不会误称可生成）；装好缺失项后回来重新检查即可。',
+	'conn.wfTestBtn': '测试',
+	'conn.wfLastTest': '上次测试',
+	'conn.wfTestPassed': '{time} 通过（{n} 个文件）',
+	'conn.wfTestRunning': '{time} 进行中',
+	'conn.wfTestFailed': '{time} 未通过',
+	'wft.title': '测试工作流',
+	'wft.connection': '目标连接',
+	'wft.costNote': '测试会把一次真实任务加入所选 ComfyUI 的队列，占用其显存与排队时间。',
+	'wft.submit': '开始测试',
+	'wft.confirmTitle': '确认真实运行',
+	'wft.confirmBody': '将向「{endpoint}」提交一次真实任务并占用其资源（当前队列 {n} 个任务）。只有拿到可下载且类型正确的输出文件才算测试通过。',
+	'wft.running': '测试中…',
+	'wft.cancel': '取消测试',
+	'wft.passed': '测试通过：产出 {n} 个文件',
+	'wft.passedShort': '通过（{n} 个文件）',
+	'wft.failed': '测试未通过',
+	'wft.failedShort': '未通过',
+	'wft.cancelledShort': '已取消',
+	'wft.reusedToast': '该工作流已有进行中的测试，已连接到该任务',
+	'wft.history': '测试记录（{n} 条）',
+	'wft.clear': '清除测试记录',
+	'wft.cleared': '已清除测试记录',
+	'wft.never': '尚未测试过',
+	'wft.download': '下载',
+	'wft.errRequired': '请填写「{label}」',
+	'wft.errListMin': '「{label}」需要至少 {n} {unit}',
+	'tasks.testBadge': '测试',
+	'tasks.sourceWorkflowTest': '工作流测试',
 };

calliope-web/src/lib/jobLabels.ts

@@ -1,20 +1,34 @@
-import type { Job } from '$lib/api';
-import { t } from '$lib/i18n.svelte';
+import type { Job } from "$lib/api";
+import { t } from "$lib/i18n.svelte";
 
-/** Where a generation job came from: 独立生图 / 独立生视频 / 创作流程 / Playground. */
+/** 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');
+  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 (src === "workflow_test" || job.origin === "workflow_test")
+    return t("tasks.sourceWorkflowTest");
+  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). */
+/** A real run launched from the workflow library's 测试 button (HEL-643). */
+export function isWorkflowTestJob(job: Job): boolean {
+  return (
+    job.origin === "workflow_test" || job.payload?.source === "workflow_test"
+  );
+}
+
+/** Jobs started outside any project (standalone windows / Playground / tests). */
 export function isStandaloneJob(job: Job): boolean {
-	const src = job.payload?.source;
-	return src === 'studio-image' || src === 'studio-video' || src === 'playground';
+  const src = job.payload?.source;
+  return (
+    src === "studio-image" ||
+    src === "studio-video" ||
+    src === "playground" ||
+    isWorkflowTestJob(job)
+  );
 }

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

@@ -245,11 +245,11 @@
 		return parts.filter(Boolean).join(' · ');
 	}
 
-	function jobBar(job: Job): { value: number; tone: 'accent' | 'success' | 'error' } {
+	function jobBar(job: Job): { value: number; tone: 'run' | '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' };
+		if (job.status === 'running') return { value: progressFor(job.id)?.progress ?? 3, tone: 'run' };
+		return { value: 0, tone: 'run' };
 	}
 
 	function jobStatusLabel(status: string): string {
@@ -493,7 +493,7 @@
 		<aside class="tasks">
 			<div class="tasks-head">
 				<h2>{t('home.tasksTitle')}</h2>
-				<span class="chip" class:amber={activeJobCount > 0}>
+				<span class="chip" class:run={activeJobCount > 0}>
 					{t('home.activeJobs', { n: activeJobCount })}
 				</span>
 			</div>
@@ -580,9 +580,9 @@
 		font-size: 11.5px;
 		white-space: nowrap;
 	}
-	.chip.amber {
-		background: var(--accent-dim);
-		color: var(--accent);
+	.chip.run {
+		background: var(--run-soft);
+		color: var(--run);
 	}
 
 	.entry-btn {
@@ -616,7 +616,7 @@
 		color: var(--text);
 	}
 	.entry-btn.secondary:hover {
-		border-color: rgba(255, 255, 255, 0.24);
+		border-color: var(--line-2);
 	}
 	.entry-btn:active {
 		transform: scale(0.98);
@@ -651,7 +651,7 @@
 		display: inline-flex;
 		align-items: center;
 		justify-content: center;
-		color: var(--accent);
+		color: var(--text-2);
 	}
 	.entry-card h2 {
 		margin: 4px 0 0;
@@ -736,10 +736,10 @@
 	}
 	.f-input:focus {
 		outline: none;
-		border-color: rgba(232, 163, 61, 0.6);
+		border-color: var(--accent-line);
 	}
 	.f-input.invalid {
-		border-color: rgba(229, 72, 77, 0.65);
+		border-color: var(--err-line);
 	}
 	.f-hint {
 		display: block;
@@ -908,13 +908,10 @@
 		flex-shrink: 0;
 		white-space: nowrap;
 	}
-	.tag-local {
-		background: var(--info-dim);
-		color: var(--info);
-	}
+	.tag-local,
 	.tag-cloud {
-		background: var(--cloud-dim);
-		color: var(--cloud);
+		background: var(--bg-4);
+		color: var(--text-2);
 	}
 	.job-name {
 		flex: 1;
@@ -950,7 +947,7 @@
 		color: var(--success);
 	}
 	.running-text {
-		color: var(--accent);
+		color: var(--run);
 	}
 	.queued-text {
 		color: var(--text-3);
@@ -966,8 +963,8 @@
 		width: 6px;
 		height: 6px;
 		border-radius: 50%;
-		background: var(--accent);
-		box-shadow: 0 0 10px var(--accent-glow);
+		background: var(--run);
+		box-shadow: 0 0 10px var(--run-soft);
 	}
 	.dot.breathe {
 		animation: breathe 2s ease-in-out infinite;

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

@@ -18,7 +18,6 @@
 		type NamedAgent,
 		type SkillAdminEntry,
 		type SkillVersion,
-		type Settings,
 		canvasApi,
 	} from '$lib/api';
 	import { AGENT_TASK_PROMPTS, AGENT_TASK_TITLE_KEYS, isAgentTaskKind } from '$lib/agentTasks';
@@ -378,10 +377,10 @@
 		},
 	});
 
-	function setAgentModel(s: Settings, role: string, value: string) {
-		const merged: Record<string, string | null> = { ...(s.agent_llm_assignments ?? {}) };
-		merged[role] = value === '' ? null : value;
-		$assignMutation.mutate(merged);
+	function setAgentModel(role: string, value: string) {
+		// Single-role delta only (HEL-619): the whole-snapshot replay races
+		// concurrent switches; the server merges per role.
+		$assignMutation.mutate({ [role]: value === '' ? null : value });
 	}
 
 	// ─────────────────────────────────────────────────────────────────────
@@ -718,7 +717,7 @@
 										<select
 											class="a-select"
 											value={s.agent_llm_assignments?.[activeAgent.llm_role] ?? ''}
-											onchange={(e) => setAgentModel(s, activeAgent.llm_role, e.currentTarget.value)}
+											onchange={(e) => setAgentModel(activeAgent.llm_role, e.currentTarget.value)}
 										>
 											<option value="">{t('agentsPage.modelDefault')}</option>
 											{#each s.llm_profiles as p (p.id)}
@@ -1134,11 +1133,11 @@
 		justify-content: center;
 		font-size: 14px;
 		font-weight: 700;
-		color: #edeef0;
+		color: var(--text);
 		flex-shrink: 0;
 	}
 	.avatar.dark {
-		color: #16130a;
+		color: var(--accent-ink);
 	}
 	.avatar.lg {
 		width: 42px;
@@ -1295,8 +1294,8 @@
 		white-space: nowrap;
 	}
 	.status-tag.busy {
-		background: var(--accent-dim);
-		color: var(--accent);
+		background: var(--run-soft);
+		color: var(--run);
 	}
 	.chat-head-actions {
 		display: flex;
@@ -1619,7 +1618,7 @@
 		background: var(--success);
 	}
 	.dot.amber {
-		background: var(--accent);
+		background: var(--run);
 	}
 	.dot.amber.breathing {
 		animation: breathe 2s ease-in-out infinite;

calliope-web/src/routes/app.css

@@ -4,84 +4,201 @@
 
 :root {
 	/* ------------------------------------------------------------------
-	 * 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.
+	 * 融合视觉 design tokens — HEL-649 整站施工规范 §一（流水台结构 ×
+	 * 放映厅配色）。Single source of truth for the whole app: pages and
+	 * components reference these variables only — no hardcoded colors,
+	 * no ad-hoc overrides. Gold is for key actions and the current
+	 * selection only; status colors each carry exactly one meaning.
 	 * ------------------------------------------------------------------ */
-	--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;
-	--accent: #e8a33d;
-	--accent-hover: #f1b155; /* +8% brightness (§5 主按钮) */
-	--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);
 
-	/* Avatar five-color set (§2.1) — five agents only */
+	/* 底色：蓝黑四阶，逐层浮起 (§1.1) */
+	--bg: #07090e;
+	--bg-2: #0c0f16;
+	--bg-3: #121724;
+	--bg-4: #1a2133;
+	--line: #1b2233;
+	--line-2: #2a3450;
+	--page-glow: radial-gradient(1200px 500px at 70% -10%, rgba(38, 52, 92, 0.25), transparent 60%);
+	--float-bg: linear-gradient(180deg, #10152a, var(--bg-2));
+	--overlay: rgba(4, 6, 10, 0.6);
+	--media-scrim: rgba(7, 9, 14, 0.65);
+	--on-media: #fff;
+	--on-media-line: rgba(255, 255, 255, 0.05);
+
+	/* 放映金：主按钮、当前选中、改过的参数、聚焦框、Toast 动作 (§1.2) */
+	--accent: #f2c784;
+	--accent-ink: #23170a;
+	--accent-soft: rgba(242, 199, 132, 0.13);
+	--accent-hi: #f7d9a2;
+	--accent-lo: #ecaf63;
+	--accent-glow: rgba(236, 175, 99, 0.28);
+	--accent-line: rgba(242, 199, 132, 0.55);
+	--accent-grad: linear-gradient(180deg, var(--accent-hi), var(--accent-lo));
+	--accent-grad-hover: linear-gradient(180deg, #fbe3b6, #f0b968);
+	--accent-ring: 0 0 0 1px rgba(242, 199, 132, 0.7), 0 0 22px var(--accent-glow);
+	--btn-glow: 0 2px 14px var(--accent-glow), inset 0 1px 0 rgba(255, 255, 255, 0.35);
+	--btn-glow-hover: 0 4px 18px var(--accent-glow), inset 0 1px 0 rgba(255, 255, 255, 0.4);
+
+	/* 信号色：绿=完成/已确认/通过，青=进行中/在线，红=失败/危险，
+	   琥珀=待确认/文件缺失/限额 (§1.3) */
+	--ok: #49cb90;
+	--ok-soft: rgba(73, 203, 144, 0.13);
+	--run: #54dfd2;
+	--run-soft: rgba(84, 223, 210, 0.13);
+	--run-grad: linear-gradient(90deg, #3bbfb4, var(--run));
+	--err: #f0645a;
+	--err-soft: rgba(240, 100, 90, 0.13);
+	--err-line: rgba(240, 100, 90, 0.6);
+	--warn: #f0b45c;
+	--warn-soft: rgba(240, 180, 92, 0.13);
+
+	/* 文字与字体 (§1.4)；--text-2 是深底可读性下限，不得再暗 */
+	--text: #f4f6fa;
+	--text-2: #aab2c5;
+	--text-3: #6d7690;
+	--font: 'PingFang SC', 'Noto Sans SC', 'Microsoft YaHei', system-ui, sans-serif;
+	--mono: 'JetBrains Mono', ui-monospace, monospace;
+	--fs-title: 15px;
+	--fs-section: 14px;
+	--fs-body: 13px;
+	--fs-body-sm: 12.5px;
+	--fs-aux: 12px;
+	--fs-mini: 11px;
+	--lh-body: 1.55;
+
+	/* 间距阶梯 4/6/8/10/12/16/20/28，不得出现阶梯外数值 (§1.5) */
+	--sp-1: 4px;
+	--sp-2: 6px;
+	--sp-3: 8px;
+	--sp-4: 10px;
+	--sp-5: 12px;
+	--sp-6: 16px;
+	--sp-7: 20px;
+	--sp-8: 28px;
+
+	/* 圆角与唯一一级阴影 (§1.5)；卡片不投影，用底色差分层 */
+	--r-sm: 6px;
+	--r-md: 10px;
+	--r-lg: 14px;
+	--r-pill: 999px;
+	--shadow-float: 0 14px 44px rgba(0, 0, 0, 0.6), 0 0 0 1px var(--line-2);
+
+	/* 专属符号 (§1.7)：齿孔只在记录流/输入台分隔带，光晕只在播放舞台 */
+	--sprocket: radial-gradient(circle 2px, var(--line-2) 98%, transparent);
+	--stage-bg:
+		radial-gradient(60% 45% at 50% 38%, rgba(242, 199, 132, 0.07), transparent 70%),
+		radial-gradient(80% 70% at 50% 50%, #0d1220, #05070c);
+
+	/* 动效 (§1.6，取 HEL-648 实测值)；只动 transform / opacity */
+	--ease-out: cubic-bezier(0.23, 1, 0.32, 1);
+	--ease-in-out: cubic-bezier(0.77, 0, 0.175, 1);
+	--ease-drawer: cubic-bezier(0.32, 0.72, 0, 1);
+	--ease-spring: cubic-bezier(0.34, 1.45, 0.44, 1);
+	--d-press: 120ms;
+	--d-state: 150ms;
+	--d-pop: 180ms;
+	--d-leave: 200ms;
+	--d-enter: 220ms;
+	--d-drawer: 280ms;
+	--d-flash: 900ms;
+	--d-progress: 400ms;
+	--press-scale: 0.97;
+
+	/* Avatar five-color set — five agents only; the one colorful gradient
+	   family the spec keeps (§3.6). */
 	--avatar-1: linear-gradient(135deg, #e8a33d, #b96a1b);
 	--avatar-2: linear-gradient(135deg, #5b8def, #3a5fa9);
 	--avatar-3: linear-gradient(135deg, #3fb97f, #2a7a54);
 	--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. */
+	/* ------------------------------------------------------------------
+	 * Legacy token names (§六 映射表) — aliases only, never new values,
+	 * so every existing component renders in the fusion palette.
+	 * ------------------------------------------------------------------ */
+	--surface: var(--bg-2);
+	--surface-2: var(--bg-3);
+	--surface-3: var(--bg-4);
+	--border: var(--line);
+	--border-strong: var(--line-2);
+	--border-hover: var(--line-2);
+	--accent-hover: var(--accent-hi);
+	--accent-contrast: var(--accent-ink);
+	--accent-dim: var(--accent-soft);
+	--accent-focus: var(--accent-line);
+	--success: var(--ok);
+	--success-dim: var(--ok-soft);
+	--info: var(--run);
+	--info-dim: var(--run-soft);
+	--error: var(--err);
+	--error-dim: var(--err-soft);
+	--error-border: var(--err-line);
+	--warning: var(--warn);
 	--bg-primary: var(--bg);
-	--bg-surface: var(--surface);
-	--bg-elevated: var(--surface-2);
+	--bg-surface: var(--bg-2);
+	--bg-elevated: var(--bg-3);
 	--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);
+	--font-ui: var(--font);
+	--font-a-mono: var(--mono);
+	--font-display: var(--font);
+	--font-body: var(--font);
+	--font-mono: var(--mono);
+	--radius-sm: var(--r-sm);
+	--radius-md: var(--r-md);
+	--radius-lg: var(--r-lg);
+	--space-xs: var(--sp-1);
+	--space-sm: var(--sp-3);
+	--space-md: var(--sp-6);
+	--space-lg: var(--sp-7);
+	--space-xl: var(--sp-8);
 
 	/* Omni Composer pill tokens */
-	--pill-bg: var(--surface-2);
-	--pill-border: var(--border-strong);
-	--pill-radius: 9999px;
+	--pill-bg: var(--bg-3);
+	--pill-border: var(--line-2);
+	--pill-radius: var(--r-pill);
 	--pill-height: 36px;
 	--pill-padding: 0 14px;
-	--pill-font-size: 13px;
+	--pill-font-size: var(--fs-body);
+}
+
+/* 减少动态效果 (§五)：系统设置自动生效，顶栏开关写 data-reduce="1"。
+   位移/缩放/弹入/光晕全部取消，只留 ≤120ms 透明度，进度条直接跳变。 */
+:root[data-reduce='1'] {
+	--d-press: 0ms;
+	--d-state: 120ms;
+	--d-pop: 120ms;
+	--d-leave: 120ms;
+	--d-enter: 120ms;
+	--d-drawer: 120ms;
+	--d-flash: 0ms;
+	--d-progress: 0ms;
+	--press-scale: 1;
+	--ease-spring: ease;
+}
+@media (prefers-reduced-motion: reduce) {
+	:root {
+		--d-press: 0ms;
+		--d-state: 120ms;
+		--d-pop: 120ms;
+		--d-leave: 120ms;
+		--d-enter: 120ms;
+		--d-drawer: 120ms;
+		--d-flash: 0ms;
+		--d-progress: 0ms;
+		--press-scale: 1;
+		--ease-spring: ease;
+	}
 }
 
 body {
-	background: var(--bg);
+	background: var(--page-glow), var(--bg);
 	color: var(--text);
-	font-family: var(--font-ui);
+	font-family: var(--font);
+	font-size: var(--fs-body);
+	line-height: var(--lh-body);
+	-webkit-font-smoothing: antialiased;
 	margin: 0;
 	min-height: 100vh;
 }
@@ -89,20 +206,20 @@ body {
 .a-darkroom {
 	background: var(--bg);
 	color: var(--text);
-	font-family: var(--font-ui);
-	font-size: 13.5px;
-	line-height: 1.6;
+	font-family: var(--font);
+	font-size: var(--fs-body);
+	line-height: var(--lh-body);
 }
 
 code,
 .mono,
 .kh {
-	font-family: var(--font-a-mono);
+	font-family: var(--mono);
 	font-variant-numeric: tabular-nums;
 }
 
 /* ------------------------------------------------------------------
- * Shared A controls (§5 组件状态全表). The only definitions of these
+ * Shared controls (§四 组件状态通用规范). 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.
@@ -111,91 +228,120 @@ code,
 	display: inline-flex;
 	align-items: center;
 	justify-content: center;
-	gap: 6px;
+	gap: var(--sp-2);
 	min-height: 34px;
-	padding: 0 16px;
-	border-radius: 8px;
+	padding: 0 var(--sp-6);
+	border-radius: var(--r-md);
 	border: 1px solid transparent;
 	font-family: inherit;
-	font-size: 13px;
+	font-size: var(--fs-body);
 	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;
+		transform var(--d-press) var(--ease-out),
+		background-color var(--d-state) ease,
+		border-color var(--d-state) ease,
+		box-shadow var(--d-state) ease,
+		color var(--d-state) ease,
+		opacity var(--d-state) ease;
+}
+.a-btn.lg {
+	min-height: 38px;
+	padding: 0 var(--sp-7);
 }
 .a-btn.sm {
-	min-height: 30px;
-	padding: 0 12px;
-	font-size: 12px;
+	min-height: 28px;
+	padding: 0 var(--sp-4);
+	font-size: var(--fs-aux);
+	border-radius: var(--r-sm);
 }
 .a-btn.xs {
 	min-height: 24px;
-	padding: 0 9px;
-	font-size: 11px;
+	padding: 0 var(--sp-3);
+	font-size: var(--fs-mini);
+	border-radius: var(--r-sm);
 }
 .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);
+	background: var(--accent-grad);
+	color: var(--accent-ink);
+	box-shadow: var(--btn-glow);
 }
 .a-btn.secondary {
-	background: var(--surface-2);
-	border-color: var(--border-strong);
+	background: var(--bg-3);
+	border-color: var(--line);
 	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);
-}
+/* 危险两级制：列表行内只用描边红 danger；实心红 danger-solid 只在确认弹层内。 */
 .a-btn.danger {
 	background: transparent;
-	border-color: var(--error-border);
-	color: var(--error);
+	border-color: var(--err-line);
+	color: var(--err);
 }
-.a-btn.danger:hover:not(:disabled) {
-	background: var(--error-dim);
+.a-btn.danger-solid {
+	background: var(--err);
+	color: var(--on-media);
+}
+@media (hover: hover) and (pointer: fine) {
+	.a-btn.primary:hover:not(:disabled) {
+		background: var(--accent-grad-hover);
+		box-shadow: var(--btn-glow-hover);
+	}
+	.a-btn.secondary:hover:not(:disabled) {
+		border-color: var(--line-2);
+		background: var(--bg-4);
+	}
+	.a-btn.ghost:hover:not(:disabled) {
+		background: var(--bg-4);
+		color: var(--text);
+	}
+	.a-btn.danger:hover:not(:disabled) {
+		background: var(--err-soft);
+	}
+	.a-btn.danger-solid:hover:not(:disabled) {
+		box-shadow:
+			0 0 0 1px var(--err-line),
+			0 0 18px var(--err-soft);
+	}
 }
 .a-btn:active:not(:disabled) {
-	transform: scale(0.98);
+	transform: scale(var(--press-scale));
 }
+/* 禁用必须在旁边给出中文原因（§1.2），由调用方渲染。 */
 .a-btn:disabled,
 .a-btn[aria-disabled='true'] {
-	opacity: 0.4;
+	opacity: 0.45;
+	box-shadow: none;
 	cursor: not-allowed;
 }
 
-/* Top-bar status capsule (counts / save state / connection). */
+/* Top-bar status capsule (queue / connection / save state) — §二 顶栏胶囊. */
 .status-chip {
 	display: inline-flex;
 	align-items: center;
-	gap: 6px;
-	padding: 5px 12px;
-	border-radius: 999px;
-	background: var(--surface-3);
+	gap: var(--sp-2);
+	height: 30px;
+	padding: 0 var(--sp-5);
+	border-radius: var(--r-pill);
+	border: 1px solid var(--line);
+	background: var(--bg-2);
 	color: var(--text-2);
-	font-size: 11.5px;
+	font-size: var(--fs-aux);
 	white-space: nowrap;
+	box-sizing: border-box;
 }
 .status-chip.accent {
-	background: var(--accent-dim);
+	background: var(--accent-soft);
+	border-color: var(--accent-line);
 	color: var(--accent);
 }
 .status-chip-dot {
@@ -206,33 +352,122 @@ code,
 	background: currentColor;
 }
 .status-chip-dot.ok {
-	background: var(--success);
+	background: var(--ok);
+}
+.status-chip-dot.run {
+	background: var(--run);
 }
 .status-chip-dot.fail {
-	background: var(--error);
+	background: var(--err);
 }
 .status-chip-dot.idle {
 	background: var(--text-3);
 }
 
-/* Card / panel surface (§2.3: 10px radius, 1px border, no shadow). */
+/* Status label (§四.2)：语义色文字 + 13% 软底；默认为中性（排队 / 未开始）。 */
+.a-tag {
+	display: inline-flex;
+	align-items: center;
+	gap: var(--sp-1);
+	height: 20px;
+	padding: 0 var(--sp-2);
+	border-radius: var(--r-sm);
+	background: var(--bg-4);
+	color: var(--text-2);
+	font-size: var(--fs-aux);
+	white-space: nowrap;
+	box-sizing: border-box;
+	transition:
+		color var(--d-state) ease,
+		background-color var(--d-state) ease;
+}
+.a-tag.accent {
+	color: var(--accent);
+	background: var(--accent-soft);
+}
+.a-tag.ok {
+	color: var(--ok);
+	background: var(--ok-soft);
+}
+.a-tag.run {
+	color: var(--run);
+	background: var(--run-soft);
+}
+.a-tag.err {
+	color: var(--err);
+	background: var(--err-soft);
+}
+.a-tag.warn {
+	color: var(--warn);
+	background: var(--warn-soft);
+}
+
+/* Real-progress bar (§1.3)：<div class="a-progress" style="--p:.42"><i></i></div>.
+   Only for true progress values — never fake progress. */
+.a-progress {
+	position: relative;
+	height: 4px;
+	border-radius: var(--r-pill);
+	background: var(--bg-4);
+	overflow: hidden;
+}
+.a-progress > i {
+	position: absolute;
+	inset: 0;
+	background: var(--run-grad);
+	box-shadow: 0 0 8px var(--run-soft);
+	transform-origin: left;
+	transform: scaleX(var(--p, 0));
+	transition: transform var(--d-progress) linear;
+}
+
+/* Film sprocket divider — only between the take feed and the composer (§1.7). */
+.a-sprocket {
+	height: 6px;
+	background-image: var(--sprocket);
+	background-size: 18px 6px;
+	background-repeat: repeat-x;
+	background-position: center;
+	opacity: 0.55;
+}
+:root[data-reduce='1'] .a-sprocket {
+	opacity: 0.3;
+}
+
+/* Projection stage — only behind media in the inspector (§1.7). */
+.a-stage {
+	position: relative;
+	border-radius: var(--r-lg);
+	overflow: hidden;
+	background: var(--stage-bg);
+	box-shadow: 0 0 0 1px var(--line);
+}
+
+/* Floating surface for pop / drawer / confirm / toast / lightbox (§四.3). */
+.a-float {
+	background: var(--float-bg);
+	border-radius: var(--r-lg);
+	box-shadow: var(--shadow-float);
+}
+
+/* Card / panel surface (§1.5：卡片不投影，用底色差分层). */
 .a-panel {
-	background: var(--surface);
-	border: 1px solid var(--border);
-	border-radius: 10px;
-	padding: 20px 22px;
+	background: var(--bg-2);
+	border: 1px solid var(--line);
+	border-radius: var(--r-lg);
+	padding: var(--sp-7);
 	box-sizing: border-box;
 }
 .a-panel-title {
 	margin: 0;
-	font-size: 14.5px;
+	font-size: var(--fs-section);
 	font-weight: 600;
 	color: var(--text);
 }
 .a-panel-lead {
-	margin: 4px 0 0;
-	font-size: 12px;
-	line-height: 1.6;
+	margin: var(--sp-1) 0 0;
+	font-size: var(--fs-aux);
+	line-height: var(--lh-body);
 	color: var(--text-3);
 }
 
@@ -243,39 +478,47 @@ code,
 .field-textarea,
 .field-select {
 	box-sizing: border-box;
-	background: var(--surface-2);
-	border: 1px solid var(--border-strong);
-	border-radius: 7px;
+	background: var(--bg-3);
+	border: 1px solid var(--line);
+	border-radius: var(--r-md);
 	color: var(--text);
 	font-family: inherit;
-	font-size: 12.5px;
-	transition: border-color 150ms cubic-bezier(0.16, 1, 0.3, 1);
+	font-size: var(--fs-body-sm);
+	transition: border-color var(--d-state) ease;
 }
 .a-select {
-	padding: 7px 9px;
+	padding: var(--sp-2) var(--sp-4);
 	cursor: pointer;
 }
 .a-input,
 .field-input,
 .field-select {
 	width: 100%;
-	padding: 8px 11px;
+	padding: var(--sp-3) var(--sp-5);
 }
 .a-textarea,
 .field-textarea {
 	width: 100%;
-	padding: 9px 11px;
+	padding: var(--sp-4) var(--sp-5);
 	resize: vertical;
 	min-height: 96px;
-	line-height: 1.6;
+	line-height: var(--lh-body);
 }
-.a-select:hover,
-.a-input:hover,
-.a-textarea:hover,
-.field-input:hover,
-.field-textarea:hover,
-.field-select:hover {
-	border-color: var(--border-hover);
+.a-input::placeholder,
+.a-textarea::placeholder,
+.field-input::placeholder,
+.field-textarea::placeholder {
+	color: var(--text-3);
+}
+@media (hover: hover) and (pointer: fine) {
+	.a-select:hover,
+	.a-input:hover,
+	.a-textarea:hover,
+	.field-input:hover,
+	.field-textarea:hover,
+	.field-select:hover {
+		border-color: var(--line-2);
+	}
 }
 .a-select:focus,
 .a-input:focus,
@@ -284,12 +527,12 @@ code,
 .field-textarea:focus,
 .field-select:focus {
 	outline: none;
-	border-color: var(--accent-focus);
+	border-color: var(--accent-line);
 }
 .a-input.invalid,
 .a-textarea.invalid,
 .field-input.invalid {
-	border-color: var(--error);
+	border-color: var(--err);
 }
 .a-select option.unavailable {
 	color: var(--text-3);
@@ -297,30 +540,30 @@ code,
 
 .field {
 	display: block;
-	margin-bottom: 14px;
+	margin-bottom: var(--sp-5);
 }
 .field-label {
 	display: block;
-	font-size: 12px;
+	font-size: var(--fs-aux);
 	font-weight: 500;
 	color: var(--text-2);
-	margin-bottom: 6px;
+	margin-bottom: var(--sp-2);
 }
 .field-hint {
-	margin: 6px 0 0;
-	font-size: 11.5px;
+	margin: var(--sp-2) 0 0;
+	font-size: var(--fs-aux);
 	color: var(--text-3);
 }
 .field-error {
-	margin: 6px 0 0;
-	font-size: 11.5px;
-	color: var(--error);
+	margin: var(--sp-2) 0 0;
+	font-size: var(--fs-aux);
+	color: var(--err);
 }
 
 /* Dark theme scrollbars (Firefox + Chromium) */
 * {
 	scrollbar-width: thin;
-	scrollbar-color: var(--surface-3) transparent;
+	scrollbar-color: var(--bg-4) transparent;
 }
 
 *::-webkit-scrollbar {
@@ -333,8 +576,8 @@ code,
 }
 
 *::-webkit-scrollbar-thumb {
-	background: var(--surface-3);
-	border-radius: 999px;
+	background: var(--bg-4);
+	border-radius: var(--r-pill);
 	border: 2px solid transparent;
 	background-clip: padding-box;
 }
@@ -349,17 +592,19 @@ code,
 	background: transparent;
 }
 
-/* Global keyboard focus fallback: every natively focusable element gets a ring,
-   even before the ui/ primitives are adopted. Component-scoped :focus-visible
-   rules (e.g. .field-input) override this via higher specificity. */
+/* Global keyboard focus (§四.8): every natively focusable element gets the
+   gold ring. Component-scoped :focus-visible rules override this via higher
+   specificity. */
 :focus-visible {
 	outline: 2px solid var(--accent);
 	outline-offset: 2px;
+	border-radius: var(--r-sm);
 }
 
-/* Global reduced-motion baseline. Components that need a styled static fallback
-   (Skeleton shimmer, ProgressBar indeterminate, StatusChip pulse) also handle
-   this in their own scoped styles. */
+/* Reduced-motion baseline for components that still carry their own
+   durations. Components that need a styled static fallback (Skeleton,
+   ProgressBar indeterminate, StatusChip pulse) also handle this in their
+   scoped styles. */
 @media (prefers-reduced-motion: reduce) {
 	*,
 	*::before,
@@ -369,3 +614,10 @@ code,
 		transition-duration: 0.01ms !important;
 	}
 }
+:root[data-reduce='1'] *,
+:root[data-reduce='1'] *::before,
+:root[data-reduce='1'] *::after {
+	animation-duration: 0.01ms !important;
+	animation-iteration-count: 1 !important;
+	transition-duration: 0.01ms !important;
+}

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

@@ -7,7 +7,8 @@
 	import ConfirmDialog from '$lib/components/ui/ConfirmDialog.svelte';
 	import Icon from '$lib/components/ui/Icon.svelte';
 	import EmptyState from '$lib/components/ui/EmptyState.svelte';
-	import { apiErrorMessage, comfy, settings, workflows, type ComfyEndpoint, type Workflow, type WorkflowUsage, type WorkflowAnalyzeResult } from '$lib/api';
+	import WorkflowTestDialog from '$lib/components/WorkflowTestDialog.svelte';
+	import { apiErrorMessage, comfy, settings, workflows, type ComfyEndpoint, type Workflow, type WorkflowOutputMapEntry, type WorkflowUsage, type WorkflowAnalyzeResult, type WorkflowConnectionCheck } from '$lib/api';
 	import { WORKFLOW_USAGES } from '$lib/comfy/types';
 	import { toast } from '$lib/toast';
 	import { t } from '$lib/i18n.svelte';
@@ -337,6 +338,9 @@
 	let wfAnalysis = $state<WorkflowAnalyzeResult | null>(null);
 	let wfUsage = $state<WorkflowUsage | null>(null);
 	let wfRoleOverrides = $state<Record<string, string>>({});
+	// HEL-638: explicit output-node designation for unknown custom nodes.
+	let wfOutputPicked = $state<Record<string, boolean>>({});
+	let wfOutputKind = $state<Record<string, 'image' | 'video'>>({});
 	let wfAnalyzing = $state(false);
 	let wfAnalyzeError = $state('');
 
@@ -374,6 +378,8 @@
 		wfAnalysis = null;
 		wfUsage = null;
 		wfRoleOverrides = {};
+		wfOutputPicked = {};
+		wfOutputKind = {};
 		wfAnalyzeError = '';
 	}
 
@@ -381,15 +387,32 @@
 		return (wf.warnings ?? []).filter((w) => w.level === 'error').map((w) => w.message);
 	}
 
-	async function runWfAnalyze() {
+	async function runWfAnalyze(refresh = false) {
 		if (!wfParsed.valid || !wfParsed.json) return;
 		wfAnalyzing = true;
 		wfAnalyzeError = '';
 		try {
-			const res = await workflows.analyze(wfParsed.json);
+			const res = await workflows.analyze(
+				wfParsed.json,
+				wfImportEndpoint || undefined,
+				refresh,
+			);
 			wfAnalysis = res;
 			wfUsage = res.usage ?? null;
 			wfRoleOverrides = {};
+			// Unknown output candidates: preselect only when there is exactly
+			// one — with several the user must decide (HEL-638).
+			const candidates = (res.usage_evidence.outputs ?? []).filter(
+				(o) => o.evidence === 'unknown_node',
+			);
+			const picked: Record<string, boolean> = {};
+			const kinds: Record<string, 'image' | 'video'> = {};
+			for (const c of candidates) {
+				kinds[c.nodeId] = c.suggested_kind ?? 'image';
+			}
+			if (candidates.length === 1) picked[candidates[0].nodeId] = true;
+			wfOutputPicked = picked;
+			wfOutputKind = kinds;
 			wfStep = 'confirm';
 		} catch (err) {
 			wfAnalyzeError = apiErrorMessage(err);
@@ -402,6 +425,22 @@
 	const wfFatal = $derived(
 		wfStep === 'confirm' && wfAnalysis !== null && (wfAnalysis.outputs?.length ?? 0) === 0,
 	);
+	/** Unknown custom output nodes the user must designate (HEL-638). */
+	const wfOutputCandidates = $derived(
+		wfStep === 'confirm' && wfAnalysis !== null
+			? (wfAnalysis.usage_evidence.outputs ?? []).filter((o) => o.evidence === 'unknown_node')
+			: [],
+	);
+	const wfOutputRows = $derived(
+		wfOutputCandidates.map((o) => ({
+			...o,
+			picked: wfOutputPicked[o.nodeId] ?? false,
+			kind: wfOutputKind[o.nodeId] ?? o.suggested_kind ?? 'image',
+		})),
+	);
+	const wfOutputPickedCount = $derived(
+		Object.values(wfOutputPicked).filter(Boolean).length,
+	);
 	const wfMustPick = $derived(
 		wfStep === 'confirm' &&
 			wfAnalysis !== null &&
@@ -409,7 +448,12 @@
 			(wfAnalysis.usage_ambiguous || wfAnalysis.needs_mapping) &&
 			wfUsage === null,
 	);
-	const wfSaveable = $derived(wfStep === 'confirm' && wfUsage !== null && !wfFatal);
+	const wfSaveable = $derived(
+		wfStep === 'confirm' &&
+			wfUsage !== null &&
+			!wfFatal &&
+			(wfOutputCandidates.length === 0 || wfOutputPickedCount > 0),
+	);
 	/** Media slots the confirm page lets the user re-role. */
 	const wfSlotRows = $derived.by(() => {
 		if (wfStep !== 'confirm' || !wfAnalysis) return [];
@@ -421,27 +465,39 @@
 	});
 	const wfParamPreview = $derived.by(() => {
 		if (!wfAnalysis) return [];
-		return wfAnalysis.inputs
-			.filter((i) => !['image', 'image_list', 'image_url', 'video', 'audio'].includes(i.kind))
-			.map((i) => i.label);
+		// Count EVERY analyzed input (media slots included) so the preview
+		// matches the inline count shown after import (input_schema.length)
+		// and in the studio — HEL-619.
+		return wfAnalysis.inputs.map((i) => i.label);
 	});
 
 	const wfImportMutation = createMutation({
 		mutationFn: async () => {
 			if (!wfParsed.valid || !wfParsed.json || !wfAnalysis || !wfUsage)
 				throw new Error(t('conn.wfPickUsage'));
+			if (wfOutputCandidates.length > 0 && wfOutputPickedCount === 0)
+				throw new Error(t('conn.wfOutputPick'));
 			const corrected = Object.keys(wfRoleOverrides).length > 0;
 			const schema = wfAnalysis.inputs.map((e) =>
 				wfRoleOverrides[e.nodeId]
 					? { ...e, role: wfRoleOverrides[e.nodeId], manual: true }
 					: e,
 			);
+			const outputMap = wfOutputRows
+				.filter((r) => r.picked)
+				.map((r) => ({
+					nodeId: r.nodeId,
+					kind: r.kind,
+					label: r.label,
+					...(r.class_type ? { class_type: r.class_type } : {}),
+				}));
 			return workflows.create({
 				name: wfImportName.trim(),
 				workflow_json: wfParsed.json,
 				usage: wfUsage,
 				usage_source: wfUsage !== wfAnalysis.usage || corrected ? 'user' : 'auto',
 				input_schema: schema,
+				...(outputMap.length ? { output_map: outputMap, output_map_source: 'user' } : {}),
 				...(wfImportEndpoint ? { endpoint_id: wfImportEndpoint } : {}),
 			});
 		},
@@ -472,6 +528,66 @@
 		$wfImportMutation.mutate();
 	}
 
+	// ------------------------------------------------------------------
+	// HEL-643 L2: connection-compatibility check on the import confirm
+	// step, and per-row 重新检查 / 测试 in the workflow library.
+	// ------------------------------------------------------------------
+	const wfConnCheck = $derived<WorkflowConnectionCheck | null>(
+		wfAnalysis?.connection_check ?? null,
+	);
+	let wfRecheckId = $state<number | null>(null);
+	const wfRecheckResult = $state<Record<number, WorkflowConnectionCheck>>({});
+
+	async function recheckRow(wf: Workflow) {
+		wfRecheckId = wf.id;
+		try {
+			const res = await workflows.check(wf.id, { refresh: true });
+			wfRecheckResult[wf.id] = res;
+		} catch (err) {
+			toast.error(apiErrorMessage(err));
+		} finally {
+			wfRecheckId = null;
+		}
+	}
+
+	function recheckLine(wf: Workflow): { tone: 'ok' | 'bad' | 'warn'; text: string } | null {
+		const check = wfRecheckResult[wf.id];
+		if (!check) return null;
+		if (!check.reachable) return { tone: 'warn', text: t('conn.wfCheckUnreachable') };
+		if (check.ok) return { tone: 'ok', text: t('conn.wfCheckOk') };
+		const n = check.findings.length;
+		return { tone: 'bad', text: t('conn.wfCheckProblems', { n }) };
+	}
+
+	let testWf = $state<Workflow | null>(null);
+	let testOpen = $state(false);
+
+	function openTest(wf: Workflow) {
+		testWf = wf;
+		testOpen = true;
+	}
+
+	function lastTestLine(wf: Workflow): string | null {
+		const lt = wf.last_test;
+		if (!lt) return null;
+		if (lt.status === 'done' && lt.output_count > 0) {
+			return t('conn.wfTestPassed', { n: lt.output_count, time: formatDbTime(lt.completed_at ?? lt.created_at) });
+		}
+		if (lt.status === 'pending' || lt.status === 'running') {
+			return t('conn.wfTestRunning', { time: formatDbTime(lt.created_at) });
+		}
+		return t('conn.wfTestFailed', { time: formatDbTime(lt.completed_at ?? lt.created_at) });
+	}
+
+	function formatDbTime(at: string | null): string {
+		if (!at) return '—';
+		const ts = Date.parse(at.replace(' ', 'T') + 'Z');
+		const d = new Date(Number.isFinite(ts) ? ts : at);
+		if (Number.isNaN(d.getTime())) return '—';
+		const p = (n: number) => String(n).padStart(2, '0');
+		return `${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
+	}
+
 	const wfConfirmMutation = createMutation({
 		mutationFn: ({ id, usage }: { id: number; usage: WorkflowUsage }) =>
 			workflows.update(id, { usage, usage_source: 'user' }),
@@ -488,6 +604,80 @@
 		},
 	});
 
+	// ------------------------------------------------------------------
+	// HEL-638: per-row output-node designation for pending workflows with
+	// unknown custom output nodes (imported earlier or parked by migration).
+	// ------------------------------------------------------------------
+	let wfMapEditId = $state<number | null>(null);
+	let wfMapPicked = $state<Record<string, boolean>>({});
+	let wfMapKind = $state<Record<string, 'image' | 'video'>>({});
+
+	function rowOutputCandidates(wf: Workflow) {
+		return (wf.output_schema ?? []).filter((o) => o.evidence === 'unknown_node');
+	}
+
+	function rowNeedsOutputMap(wf: Workflow): boolean {
+		return Boolean(wf.needs_mapping) && !(wf.output_map ?? []).length;
+	}
+
+	function toggleWfMapEdit(wf: Workflow) {
+		if (wfMapEditId === wf.id) {
+			wfMapEditId = null;
+			return;
+		}
+		const picked: Record<string, boolean> = {};
+		const kinds: Record<string, 'image' | 'video'> = {};
+		const mapped = new Map((wf.output_map ?? []).map((e) => [e.nodeId, e.kind]));
+		for (const c of rowOutputCandidates(wf)) {
+			const known = mapped.get(c.nodeId);
+			if (known) picked[c.nodeId] = true;
+			kinds[c.nodeId] = known ?? c.suggested_kind ?? 'image';
+		}
+		wfMapPicked = picked;
+		wfMapKind = kinds;
+		wfMapEditId = wf.id;
+	}
+
+	const wfMapMutation = createMutation({
+		mutationFn: ({ id, outputMap }: { id: number; outputMap: WorkflowOutputMapEntry[] }) =>
+			workflows.update(
+				id,
+				outputMap.length
+					? { output_map: outputMap, output_map_source: 'user' }
+					: { output_map: [] },
+			),
+		onSuccess: (wf) => {
+			client.invalidateQueries({ queryKey: ['workflows'] });
+			wfMapEditId = null;
+			const nodes = (wf.output_map ?? []).map((e) => e.nodeId).join('、');
+			toast.success(
+				wf.output_map?.length
+					? t('conn.wfOutputApplied', { nodes })
+					: t('conn.wfOutputCleared'),
+			);
+		},
+		onError: (err) => {
+			toast.error(
+				t('conn.wfImportFailed', {
+					detail: err instanceof Error ? err.message : String(err),
+				}),
+			);
+		},
+	});
+
+	function submitWfMap(wf: Workflow) {
+		if ($wfMapMutation.isPending) return;
+		const outputMap = rowOutputCandidates(wf)
+			.filter((c) => wfMapPicked[c.nodeId])
+			.map((c) => ({
+				nodeId: c.nodeId,
+				kind: wfMapKind[c.nodeId] ?? c.suggested_kind ?? 'image',
+				label: c.label,
+				...(c.class_type ? { class_type: c.class_type } : {}),
+			}));
+		$wfMapMutation.mutate({ id: wf.id, outputMap });
+	}
+
 	const wfBindMutation = createMutation({
 		mutationFn: ({ id, endpointId }: { id: number; endpointId: string | null }) =>
 			workflows.update(id, { endpoint_id: endpointId }),
@@ -511,6 +701,10 @@
 			client.invalidateQueries({ queryKey: ['workflows'] });
 			toast.success(t('conn.wfDeleted'));
 		},
+		onError: (err) => {
+			// e.g. 409 "该工作流还有 N 个排队或执行中的任务…" (HEL-619)
+			toast.error(apiErrorMessage(err));
+		},
 	});
 
 	// ------------------------------------------------------------------
@@ -805,7 +999,7 @@
 										size="sm"
 										disabled={!wfParsed.valid || !wfImportName.trim()}
 										loading={wfAnalyzing}
-										onclick={runWfAnalyze}
+										onclick={() => runWfAnalyze()}
 									>
 										{wfAnalyzing ? t('conn.wfAnalyzing') : t('conn.wfAnalyze')}
 									</Button>
@@ -813,18 +1007,53 @@
 							{:else if wfAnalysis}
 								<p class="wf-import-hint">{t('conn.wfConfirmHint')}</p>
 
-								{#if wfAnalysis.usage_problem}
-									<div class="wf-note" class:fatal={wfFatal} role={wfFatal ? 'alert' : 'note'}>
-										<Icon name={wfFatal ? 'alert' : 'info'} size={14} />
-										<p>{wfAnalysis.usage_problem}</p>
+							{#if wfAnalysis.usage_problem}
+								<div class="wf-note" class:fatal={wfFatal} role={wfFatal ? 'alert' : 'note'}>
+									<Icon name={wfFatal ? 'alert' : 'info'} size={14} />
+									<p>{wfAnalysis.usage_problem}</p>
+								</div>
+							{/if}
+							{#if wfAnalyzeError}
+								<div class="wf-note fatal" role="alert">
+									<Icon name="alert" size={14} />
+									<p>{wfAnalyzeError}</p>
+								</div>
+							{/if}
+
+							{#if wfConnCheck}
+								<div class="wf-conn-check" class:ok={wfConnCheck.ok} class:bad={wfConnCheck.ok === false && wfConnCheck.reachable} class:warn={!wfConnCheck.reachable}>
+									<div class="wf-conn-head">
+										<Icon name={wfConnCheck.ok ? 'check' : wfConnCheck.reachable ? 'alert' : 'info'} size={14} />
+										<span class="wf-conn-title">{t('conn.wfCheckTitle')}</span>
+										{#if wfConnCheck.endpoint_name}
+											<span class="wf-conn-ep">{t('conn.wfCheckEndpoint', { name: wfConnCheck.endpoint_name })}</span>
+										{/if}
+										<button
+											type="button"
+											class="mini-link"
+											disabled={wfAnalyzing}
+											onclick={() => runWfAnalyze(true)}
+										>
+											{wfAnalyzing ? t('conn.wfChecking') : t('conn.wfCheckBtn')}
+										</button>
 									</div>
-								{/if}
-								{#if wfAnalyzeError}
-									<div class="wf-note fatal" role="alert">
-										<Icon name="alert" size={14} />
-										<p>{wfAnalyzeError}</p>
-									</div>
-								{/if}
+									{#if !wfConnCheck.reachable}
+										<p class="wf-conn-line">{wfConnCheck.message ?? t('conn.wfCheckUnreachable')}</p>
+									{:else if wfConnCheck.ok}
+										<p class="wf-conn-line">{t('conn.wfCheckOk')}</p>
+									{:else}
+										<ul class="wf-conn-findings">
+											{#each wfConnCheck.findings as f (f.node_id + f.code)}
+												<li>
+													<span class="wf-conn-msg">{f.message}</span>
+													{#if f.hint}<span class="wf-conn-hint">{f.hint}</span>{/if}
+												</li>
+											{/each}
+										</ul>
+										<p class="wf-conn-line">{t('conn.wfCheckSaveHint')}</p>
+									{/if}
+								</div>
+							{/if}
 
 								<ul class="wf-evidence">
 									{#each wfAnalysis.usage_evidence.summary as line (line)}
@@ -856,10 +1085,56 @@
 											</button>
 										{/each}
 									</div>
-									{#if wfMustPick}<span class="f-error">{t('conn.wfPickUsage')}</span>{/if}
-								</div>
+								{#if wfMustPick}<span class="f-error">{t('conn.wfPickUsage')}</span>{/if}
+							</div>
 
-								{#if wfSlotRows.length}
+							{#if wfOutputRows.length}
+								<div class="f-field">
+									<span class="f-label">
+										{t('conn.wfOutputLabel')}<em>*</em>
+										<span class="f-hint-inline">{t('conn.wfOutputNeedPick')}</span>
+									</span>
+									<div class="wf-slot-rows">
+										{#each wfOutputRows as row (row.nodeId)}
+											<div class="wf-slot-row" class:off={!row.picked}>
+												<label class="wf-out-check">
+													<input
+														type="checkbox"
+														checked={row.picked}
+														onchange={(e) =>
+															(wfOutputPicked = {
+																...wfOutputPicked,
+																[row.nodeId]: e.currentTarget.checked,
+															})}
+													/>
+													<span class="wf-slot-id mono">{row.nodeId}</span>
+													<span class="wf-slot-name" title={row.class_type}>{row.label}</span>
+												</label>
+												<select
+													class="a-select"
+													aria-label={t('conn.wfOutputKindAria')}
+													disabled={!row.picked}
+													value={row.kind}
+													onchange={(e) =>
+														(wfOutputKind = {
+															...wfOutputKind,
+															[row.nodeId]: e.currentTarget.value as 'image' | 'video',
+														})}
+												>
+													<option value="image">{t('conn.wfKindImage')}</option>
+													<option value="video">{t('conn.wfKindVideo')}</option>
+												</select>
+											</div>
+										{/each}
+									</div>
+									<span class="f-hint">{t('conn.wfOutputHint')}</span>
+									{#if wfOutputPickedCount === 0}
+										<span class="f-error">{t('conn.wfOutputPick')}</span>
+									{/if}
+								</div>
+							{/if}
+
+							{#if wfSlotRows.length}
 									<div class="f-field">
 										<span class="f-label">{t('conn.wfSlotsLabel')}</span>
 										<div class="wf-slot-rows">
@@ -916,7 +1191,11 @@
 										{t('conn.wfBack')}
 									</Button>
 									<span class="need-test" class:passed={wfSaveable && wfImportName.trim() !== ''}>
-										{wfSaveable ? usageLabel(wfUsage) : t('conn.wfUsageNeedPick')}
+										{wfUsage
+											? wfOutputCandidates.length && wfOutputPickedCount === 0
+												? t('conn.wfOutputPick')
+												: usageLabel(wfUsage)
+											: t('conn.wfUsageNeedPick')}
 									</span>
 									<Button
 										variant="primary"
@@ -948,71 +1227,177 @@
 								<span class="wf-pending-note">· {t('conn.wfPendingCount', { n: pending })}</span>
 							{/if}
 						</p>
-						<div class="wf-table">
-							{#each wfs as wf (wf.id)}
-								<div class="wf-row" class:pending={!wf.usage}>
-									<span class="wf-kind {wf.kind}">
-										<Icon name={wf.kind === 'image' ? 'image' : 'film'} size={14} />
-									</span>
-									<span class="wf-name" title={wf.description ?? wf.name}>{wf.name}</span>
-									{#if wf.usage}
-										<span
-											class="tag tag-usage"
-											title={wf.usage_source === 'user' ? t('conn.wfSourceUser') : t('conn.wfSourceAuto')}
-										>
-											{usageLabel(wf.usage)}
-										</span>
-									{:else}
-										<select
-											class="a-select wf-confirm-select"
-											aria-label={t('conn.wfConfirmAria')}
-											disabled={$wfConfirmMutation.isPending}
-											onchange={(e) => {
-												const usage = e.currentTarget.value as WorkflowUsage;
-												if (usage) $wfConfirmMutation.mutate({ id: wf.id, usage });
-												e.currentTarget.value = '';
-											}}
-										>
-											<option value="">{t('usage.pending')}…</option>
-											{#each WORKFLOW_USAGES as u (u)}
-												<option value={u}>{usageLabel(u)}</option>
-											{/each}
-										</select>
-									{/if}
-									{#if !wf.is_enabled && wf.usage}
-										<span class="tag tag-disabled">{t('conn.wfDisabledBadge')}</span>
-									{/if}
-									{#if wfProblems(wf).length}
-										<span class="tag tag-error" title={wfProblems(wf).join('\n')}>
-											{t('conn.wfBrokenBadge')}
-										</span>
-									{/if}
-									<span class="wf-params">{t('conn.wfParams', { n: wf.input_schema?.length ?? 0 })}</span>
-									<select
-										class="a-select"
-										value={wf.endpoint_id ?? ''}
-										onchange={(e) =>
-											$wfBindMutation.mutate({
-												id: wf.id,
-												endpointId: e.currentTarget.value || null,
-											})}
+					<div class="wf-table">
+						{#each wfs as wf (wf.id)}
+							<div class="wf-row" class:pending={!wf.usage}>
+								<span class="wf-kind {wf.kind}">
+									<Icon name={wf.kind === 'image' ? 'image' : 'film'} size={14} />
+								</span>
+								<span class="wf-name" title={wf.description ?? wf.name}>{wf.name}</span>
+								{#if wf.usage}
+									<span
+										class="tag tag-usage"
+										title={wf.usage_source === 'user' ? t('conn.wfSourceUser') : t('conn.wfSourceAuto')}
 									>
-										<option value="">{t('conn.wfConnectionActive')}</option>
-										{#each endpoints as ep (ep.id)}
-											<option value={ep.id}>{ep.name}</option>
+										{usageLabel(wf.usage)}
+									</span>
+								{:else}
+									<select
+										class="a-select wf-confirm-select"
+										aria-label={t('conn.wfConfirmAria')}
+										disabled={$wfConfirmMutation.isPending}
+										onchange={(e) => {
+											const usage = e.currentTarget.value as WorkflowUsage;
+											if (usage) $wfConfirmMutation.mutate({ id: wf.id, usage });
+											e.currentTarget.value = '';
+										}}
+									>
+										<option value="">{t('usage.pending')}…</option>
+										{#each WORKFLOW_USAGES as u (u)}
+											<option value={u}>{usageLabel(u)}</option>
 										{/each}
 									</select>
+								{/if}
+								{#if rowNeedsOutputMap(wf)}
 									<button
 										type="button"
-										class="link-danger"
-										title={t('conn.delete')}
-										onclick={() => $wfDeleteMutation.mutate(wf.id)}
+										class="tag tag-mapbtn"
+										class:open={wfMapEditId === wf.id}
+										title={t('conn.wfOutputNeedMap')}
+										onclick={() => toggleWfMapEdit(wf)}
 									>
-										<Icon name="trash" size={14} />
+										<Icon name="alert" size={12} />
+										{t('conn.wfOutputPendingBadge')}
 									</button>
-								</div>
-							{/each}
+								{/if}
+								{#if !wf.is_enabled && wf.usage && !rowNeedsOutputMap(wf)}
+									<span class="tag tag-disabled">{t('conn.wfDisabledBadge')}</span>
+								{/if}
+								{#if wfProblems(wf).length}
+									<span class="tag tag-error" title={wfProblems(wf).join('\n')}>
+										{t('conn.wfBrokenBadge')}
+									</span>
+								{/if}
+							<span class="wf-params">{t('conn.wfParams', { n: wf.input_schema?.length ?? 0 })}</span>
+							<button
+								type="button"
+								class="link-accent wf-test-btn"
+								title={t('wft.title')}
+								onclick={() => openTest(wf)}
+							>
+								<Icon name="play" size={13} />
+								{t('conn.wfTestBtn')}
+							</button>
+							<button
+								type="button"
+								class="link-accent wf-test-btn"
+								disabled={wfRecheckId === wf.id}
+								title={t('conn.wfCheckBtn')}
+								onclick={() => recheckRow(wf)}
+							>
+								<Icon name="retry" size={13} />
+								{wfRecheckId === wf.id ? t('conn.wfChecking') : t('conn.wfCheckBtn')}
+							</button>
+							<select
+								class="a-select"
+								value={wf.endpoint_id ?? ''}
+								onchange={(e) =>
+									$wfBindMutation.mutate({
+										id: wf.id,
+										endpointId: e.currentTarget.value || null,
+									})}
+							>
+								<option value="">{t('conn.wfConnectionActive')}</option>
+								{#each endpoints as ep (ep.id)}
+									<option value={ep.id}>{ep.name}</option>
+								{/each}
+							</select>
+							<button
+								type="button"
+								class="link-danger"
+								title={t('conn.delete')}
+								onclick={() => $wfDeleteMutation.mutate(wf.id)}
+							>
+								<Icon name="trash" size={14} />
+							</button>
 						</div>
+						{@const lastLine = lastTestLine(wf)}
+						{@const recheck = recheckLine(wf)}
+						{#if lastLine || recheck}
+							<div class="wf-meta-row">
+								{#if lastLine}<span class="wf-meta-item">{t('conn.wfLastTest')}：{lastLine}</span>{/if}
+								{#if recheck}
+									<span class="wf-meta-item recheck" class:ok={recheck.tone === 'ok'} class:bad={recheck.tone === 'bad'} class:warn={recheck.tone === 'warn'}>
+										{#if recheck.tone === 'bad'}
+											{@const check = wfRecheckResult[wf.id]}
+											<span class="wf-recheck-text" title={(check?.findings ?? []).map((f) => f.message).join('\n')}>
+												{recheck.text}
+											</span>
+										{:else}
+											<span class="wf-recheck-text">{recheck.text}</span>
+										{/if}
+									</span>
+								{/if}
+							</div>
+						{/if}
+							{#if wfMapEditId === wf.id}
+								<div class="wf-map-editor">
+									<p class="wf-map-hint">{t('conn.wfOutputHint')}</p>
+									<div class="wf-slot-rows">
+										{#each rowOutputCandidates(wf) as c (c.nodeId)}
+											<div class="wf-slot-row" class:off={!wfMapPicked[c.nodeId]}>
+												<label class="wf-out-check">
+													<input
+														type="checkbox"
+														checked={wfMapPicked[c.nodeId] ?? false}
+														onchange={(e) =>
+															(wfMapPicked = {
+																...wfMapPicked,
+																[c.nodeId]: e.currentTarget.checked,
+															})}
+													/>
+													<span class="wf-slot-id mono">{c.nodeId}</span>
+													<span class="wf-slot-name" title={c.class_type}>{c.label}</span>
+												</label>
+												<select
+													class="a-select"
+													aria-label={t('conn.wfOutputKindAria')}
+													disabled={!wfMapPicked[c.nodeId]}
+													value={wfMapKind[c.nodeId] ?? c.suggested_kind ?? 'image'}
+													onchange={(e) =>
+														(wfMapKind = {
+															...wfMapKind,
+															[c.nodeId]: e.currentTarget.value as 'image' | 'video',
+														})}
+												>
+													<option value="image">{t('conn.wfKindImage')}</option>
+													<option value="video">{t('conn.wfKindVideo')}</option>
+												</select>
+											</div>
+										{/each}
+									</div>
+									<div class="form-actions">
+										<Button
+											variant="secondary"
+											size="sm"
+											onclick={() => (wfMapEditId = null)}
+										>
+											{t('conn.wfMapCancel')}
+										</Button>
+										<Button
+											variant="primary"
+											size="sm"
+											disabled={!Object.values(wfMapPicked).some(Boolean)}
+											loading={$wfMapMutation.isPending}
+											onclick={() => submitWfMap(wf)}
+										>
+											{t('conn.wfOutputApply')}
+										</Button>
+									</div>
+								</div>
+							{/if}
+						{/each}
+					</div>
 					{/if}
 					</section>
 				</section>
@@ -1207,6 +1592,12 @@
 			</div>
 		{/if}
 	</div>
+<WorkflowTestDialog
+		bind:open={testOpen}
+		workflow={testWf}
+		{endpoints}
+		onchanged={() => client.invalidateQueries({ queryKey: ['workflows'] })}
+	/>
 </AppShell>
 
 <ConfirmDialog
@@ -1263,7 +1654,7 @@
 		transition: border-color 150ms cubic-bezier(0.16, 1, 0.3, 1);
 	}
 	.card.failed {
-		border-color: rgba(229, 72, 77, 0.35);
+		border-color: color-mix(in srgb, var(--err) 35%, transparent);
 	}
 	.card-row {
 		display: flex;
@@ -1280,7 +1671,7 @@
 		display: inline-flex;
 		align-items: center;
 		justify-content: center;
-		color: var(--accent);
+		color: var(--text-2);
 		flex-shrink: 0;
 	}
 	.card-name {
@@ -1297,13 +1688,10 @@
 		font-weight: 600;
 	}
 	.tag-local,
-	.tag-lan {
-		color: var(--info);
-		background: var(--info-dim);
-	}
+	.tag-lan,
 	.tag-cloud {
-		color: var(--cloud);
-		background: var(--cloud-dim);
+		color: var(--text-2);
+		background: var(--bg-4);
 	}
 	.tag-auth {
 		color: var(--text-2);
@@ -1352,8 +1740,8 @@
 		background: var(--text-3);
 	}
 	.dot.amber {
-		background: var(--accent);
-		box-shadow: 0 0 10px var(--accent-glow);
+		background: var(--run);
+		box-shadow: 0 0 10px var(--run-soft);
 	}
 	.dot.breathing {
 		animation: breathe 2s ease-in-out infinite;
@@ -1378,7 +1766,7 @@
 		color: var(--error);
 	}
 	.status-text.amber {
-		color: var(--accent);
+		color: var(--run);
 	}
 	.status-text.gray {
 		color: var(--text-3);
@@ -1551,6 +1939,133 @@
 		font-size: 11.5px;
 		line-height: 1.55;
 	}
+	.wf-conn-check {
+		margin: 0 0 12px;
+		padding: 9px 12px;
+		border: 1px solid var(--border-strong);
+		border-radius: 7px;
+		background: var(--surface-2);
+		display: flex;
+		flex-direction: column;
+		gap: 6px;
+	}
+	.wf-conn-check.ok {
+		border-color: var(--success);
+	}
+	.wf-conn-check.bad {
+		border-color: var(--error);
+	}
+	.wf-conn-check.warn {
+		border-color: var(--warn);
+	}
+	.wf-conn-head {
+		display: flex;
+		align-items: center;
+		gap: 8px;
+		flex-wrap: wrap;
+	}
+	.wf-conn-head :global(.icon) {
+		flex-shrink: 0;
+	}
+	.wf-conn-check.ok .wf-conn-head :global(.icon) {
+		color: var(--success);
+	}
+	.wf-conn-check.bad .wf-conn-head :global(.icon) {
+		color: var(--error);
+	}
+	.wf-conn-check.warn .wf-conn-head :global(.icon) {
+		color: var(--warn);
+	}
+	.wf-conn-title {
+		font-size: 12px;
+		font-weight: 600;
+		color: var(--text);
+	}
+	.wf-conn-ep {
+		font-size: 11px;
+		color: var(--text-3);
+	}
+	.mini-link {
+		margin-left: auto;
+		background: none;
+		border: none;
+		padding: 0;
+		font-family: inherit;
+		font-size: 11px;
+		color: var(--accent);
+		text-decoration: underline;
+		cursor: pointer;
+	}
+	.mini-link:disabled {
+		opacity: 0.6;
+		cursor: default;
+	}
+	.wf-conn-line {
+		margin: 0;
+		font-size: 11.5px;
+		color: var(--text-2);
+		line-height: 1.55;
+	}
+	.wf-conn-findings {
+		margin: 0;
+		padding: 0;
+		list-style: none;
+		display: flex;
+		flex-direction: column;
+		gap: 5px;
+	}
+	.wf-conn-findings li {
+		display: flex;
+		flex-direction: column;
+		gap: 2px;
+		padding: 6px 8px;
+		border-radius: 6px;
+		background: var(--error-dim);
+	}
+	.wf-conn-msg {
+		font-size: 11.5px;
+		color: var(--text);
+		line-height: 1.5;
+	}
+	.wf-conn-hint {
+		font-size: 10.5px;
+		color: var(--text-3);
+		line-height: 1.5;
+	}
+	.wf-test-btn {
+		display: inline-flex;
+		align-items: center;
+		gap: 4px;
+		white-space: nowrap;
+	}
+	.wf-test-btn:disabled {
+		opacity: 0.6;
+		cursor: default;
+	}
+	.wf-meta-row {
+		display: flex;
+		gap: 14px;
+		flex-wrap: wrap;
+		padding: 0 10px 8px;
+		margin-top: -2px;
+	}
+	.wf-meta-item {
+		font-size: 10.5px;
+		color: var(--text-3);
+	}
+	.wf-meta-item.recheck .wf-recheck-text {
+		color: var(--text-3);
+	}
+	.wf-meta-item.recheck.ok .wf-recheck-text {
+		color: var(--success);
+	}
+	.wf-meta-item.recheck.bad .wf-recheck-text {
+		color: var(--error);
+		cursor: help;
+	}
+	.wf-meta-item.recheck.warn .wf-recheck-text {
+		color: var(--warn);
+	}
 	.wf-evidence {
 		margin: 0 0 12px;
 		padding: 0 0 0 4px;
@@ -1606,6 +2121,52 @@
 	.wf-slot-row .a-select {
 		width: 130px;
 	}
+	.wf-slot-row.off {
+		opacity: 0.55;
+	}
+	.wf-out-check {
+		display: flex;
+		align-items: center;
+		gap: 8px;
+		flex: 1;
+		min-width: 0;
+		cursor: pointer;
+	}
+	.wf-out-check input[type='checkbox'] {
+		accent-color: var(--accent);
+	}
+	.tag-mapbtn {
+		display: inline-flex;
+		align-items: center;
+		gap: 4px;
+		cursor: pointer;
+		color: var(--error);
+		background: var(--error-dim);
+		border: 1px solid transparent;
+	}
+	.tag-mapbtn.open {
+		color: var(--accent);
+		background: var(--accent-dim);
+		border-color: var(--accent);
+	}
+	.wf-map-editor {
+		display: flex;
+		flex-direction: column;
+		gap: 8px;
+		padding: 10px 12px;
+		margin: 2px 0 6px;
+		border-radius: 7px;
+		border: 1px dashed var(--border);
+		background: var(--surface);
+	}
+	.wf-map-hint {
+		margin: 0;
+		font-size: 11.5px;
+		color: var(--text-3);
+	}
+	.wf-map-editor .form-actions {
+		justify-content: flex-end;
+	}
 	.wf-params {
 		margin: 0 0 10px;
 		font-size: 11.5px;
@@ -1634,15 +2195,15 @@
 		color: var(--error);
 	}
 	.tag-usage {
-		color: var(--accent);
-		background: var(--accent-dim);
+		color: var(--text-2);
+		background: var(--bg-4);
 	}
 	.tag-disabled {
 		color: var(--text-3);
 		background: var(--surface-3);
 	}
 	.wf-pending-note {
-		color: var(--accent);
+		color: var(--warn);
 	}
 	.wf-row.pending .wf-name {
 		color: var(--text-3);
@@ -1688,7 +2249,7 @@
 		line-height: 1.5;
 	}
 	.wf-json.invalid {
-		border-color: rgba(229, 72, 77, 0.65);
+		border-color: var(--err-line);
 	}
 	.file-btn {
 		display: inline-flex;
@@ -1707,7 +2268,7 @@
 	}
 	.file-btn:hover {
 		color: var(--text);
-		border-color: rgba(255, 255, 255, 0.24);
+		border-color: var(--line-2);
 	}
 	.file-btn input {
 		display: none;
@@ -1738,13 +2299,10 @@
 		justify-content: center;
 		flex-shrink: 0;
 	}
-	.wf-kind.image {
-		color: var(--info);
-		background: var(--info-dim);
-	}
+	.wf-kind.image,
 	.wf-kind.video {
-		color: var(--accent);
-		background: var(--accent-dim);
+		color: var(--text-2);
+		background: var(--bg-4);
 	}
 	.wf-name {
 		flex: 1;
@@ -1779,6 +2337,8 @@
 		border: 1px solid var(--border);
 		border-radius: 10px;
 		padding: 18px 20px 20px;
+		/* keep the 384px side-col the OUTER width (HEL-619) */
+		box-sizing: border-box;
 	}
 	.layout:not(.form-open) .form-col {
 		display: none;
@@ -1894,14 +2454,14 @@
 	}
 	.f-input:focus {
 		outline: none;
-		border-color: rgba(232, 163, 61, 0.6);
+		border-color: var(--accent-line);
 	}
 	.f-input:disabled {
 		color: var(--text-3);
 		cursor: not-allowed;
 	}
 	.f-input.invalid {
-		border-color: rgba(229, 72, 77, 0.65);
+		border-color: var(--err-line);
 	}
 	.f-hint {
 		display: block;
@@ -2044,7 +2604,7 @@
 			position: fixed;
 			inset: 0;
 			z-index: 790;
-			background: rgba(5, 5, 8, 0.5);
+			background: var(--overlay);
 		}
 		.wf-import-grid {
 			grid-template-columns: 1fr;

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

@@ -420,10 +420,11 @@
 		},
 	});
 
-	function setAssignment(s: Settings, role: string, value: string) {
-		const merged: Record<string, string | null> = { ...(s.agent_llm_assignments ?? {}) };
-		merged[role] = value === '' ? null : value;
-		$assignMutation.mutate(merged);
+	function setAssignment(role: string, value: string) {
+		// Single-role delta only (HEL-619): replaying the whole cached
+		// snapshot races concurrent dropdown switches — an older snapshot
+		// could overwrite a newer choice. The server merges per role.
+		$assignMutation.mutate({ [role]: value === '' ? null : value });
 	}
 
 	// ------------------------------------------------------------------
@@ -630,7 +631,7 @@
 									<select
 										class="a-select"
 										value={s.agent_llm_assignments?.[agent.role] ?? ''}
-										onchange={(e) => setAssignment(s, agent.role, e.currentTarget.value)}
+										onchange={(e) => setAssignment(agent.role, e.currentTarget.value)}
 									>
 										<option value="">{t('models.agentDefault')}</option>
 										{#each profiles as p (p.id)}
@@ -928,7 +929,7 @@
 		transition: border-color 150ms cubic-bezier(0.16, 1, 0.3, 1);
 	}
 	.card.failed {
-		border-color: rgba(229, 72, 77, 0.35);
+		border-color: color-mix(in srgb, var(--err) 35%, transparent);
 	}
 	.card-row {
 		display: flex;
@@ -945,7 +946,7 @@
 		display: inline-flex;
 		align-items: center;
 		justify-content: center;
-		color: var(--accent);
+		color: var(--text-2);
 		flex-shrink: 0;
 	}
 	.card-name {
@@ -962,13 +963,10 @@
 		font-weight: 600;
 	}
 	.tag-local,
-	.tag-lan {
-		color: var(--info);
-		background: var(--info-dim);
-	}
+	.tag-lan,
 	.tag-cloud {
-		color: var(--cloud);
-		background: var(--cloud-dim);
+		color: var(--text-2);
+		background: var(--bg-4);
 	}
 	.tag-default {
 		color: var(--accent);
@@ -1009,8 +1007,8 @@
 		background: var(--text-3);
 	}
 	.dot.amber {
-		background: var(--accent);
-		box-shadow: 0 0 10px var(--accent-glow);
+		background: var(--run);
+		box-shadow: 0 0 10px var(--run-soft);
 	}
 	.dot.breathing {
 		animation: breathe 2s ease-in-out infinite;
@@ -1035,7 +1033,7 @@
 		color: var(--error);
 	}
 	.status-text.amber {
-		color: var(--accent);
+		color: var(--run);
 	}
 	.status-text.gray {
 		color: var(--text-3);
@@ -1178,7 +1176,7 @@
 		color: var(--text);
 	}
 	.avatar.dark {
-		color: #16130a;
+		color: var(--accent-ink);
 	}
 	.agent-name {
 		font-size: 12.5px;
@@ -1195,6 +1193,9 @@
 		padding: 18px 20px 20px;
 		position: sticky;
 		top: 24px;
+		/* 384px must be the OUTER width per the a6 spec — without
+		   border-box padding+border inflate it to 426px (HEL-619). */
+		box-sizing: border-box;
 	}
 	.form-idle {
 		display: flex;
@@ -1278,14 +1279,14 @@
 	}
 	.f-input:focus {
 		outline: none;
-		border-color: rgba(232, 163, 61, 0.6);
+		border-color: var(--accent-line);
 	}
 	.f-input:disabled {
 		color: var(--text-3);
 		cursor: not-allowed;
 	}
 	.f-input.invalid {
-		border-color: rgba(229, 72, 77, 0.65);
+		border-color: var(--err-line);
 	}
 	.f-hint {
 		display: block;
@@ -1429,7 +1430,7 @@
 			position: fixed;
 			inset: 0;
 			z-index: 790;
-			background: rgba(5, 5, 8, 0.5);
+			background: var(--overlay);
 		}
 		.agents-grid {
 			grid-template-columns: repeat(3, 1fr);

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

@@ -669,7 +669,7 @@
 		color: var(--text-2);
 	}
 	.note.warn :global(.icon) {
-		color: var(--accent);
+		color: var(--warn);
 		flex-shrink: 0;
 		margin-top: 2px;
 	}

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

@@ -18,7 +18,7 @@
 	import { jobStatusInfo } from '$lib/jobStatus';
 	import { toast } from '$lib/toast';
 	import { t } from '$lib/i18n.svelte';
-	import { isStandaloneJob, jobSourceLabel } from '$lib/jobLabels';
+	import { isStandaloneJob, isWorkflowTestJob, jobSourceLabel } from '$lib/jobLabels';
 
 	/**
 	 * 生成任务页 (spec-v2 §3 nav item, HEL-612): one table summing both
@@ -167,8 +167,11 @@
 								{/if}
 							{/if}
 						</div>
-						<div class="tmain">
-							<div class="tname" title={wfName(job)}>{wfName(job)}</div>
+					<div class="tmain">
+						<div class="tname" title={wfName(job)}>
+							{#if isWorkflowTestJob(job)}<span class="tag tag-test">{t('tasks.testBadge')}</span>{/if}
+							{wfName(job)}
+						</div>
 							<div class="tmeta mono">
 								{#if projectOf(job)}{projectOf(job)} · {/if}{jobSourceLabel(job)} · {timeOf(job)}
 								{#if (job.output_paths?.length ?? 0) > 0}
@@ -309,7 +312,7 @@
 		min-height: 56px;
 	}
 	.trow.failed {
-		border-color: rgba(229, 72, 77, 0.35);
+		border-color: color-mix(in srgb, var(--err) 35%, transparent);
 	}
 
 	.tkind {
@@ -321,13 +324,10 @@
 		justify-content: center;
 		flex-shrink: 0;
 	}
-	.tkind.image {
-		color: var(--info);
-		background: var(--info-dim);
-	}
+	.tkind.image,
 	.tkind.video {
-		color: var(--accent);
-		background: var(--accent-dim);
+		color: var(--text-2);
+		background: var(--bg-4);
 	}
 
 	.tthumb {
@@ -352,6 +352,10 @@
 		min-width: 0;
 	}
 	.tname {
+		display: flex;
+		align-items: center;
+		gap: 6px;
+		min-width: 0;
 		font-size: 13px;
 		font-weight: 600;
 		color: var(--text);
@@ -405,7 +409,7 @@
 		color: var(--success);
 	}
 	.tst.run {
-		color: var(--accent);
+		color: var(--run);
 	}
 	.tst.queue {
 		color: var(--text-3);
@@ -458,6 +462,16 @@
 		opacity: 0.35;
 		cursor: default;
 	}
+	.tag-test {
+		flex-shrink: 0;
+		background: var(--accent-dim);
+		color: var(--accent);
+		font-size: 10px;
+		font-weight: 600;
+		padding: 1px 7px;
+		border-radius: 999px;
+	}
+
 	@media (max-width: 1023px) {
 		.tasks-page {
 			padding: 14px 16px 32px;

calliope-web/src/routes/workbench/[id]/+page.svelte

@@ -670,10 +670,13 @@
 		color: var(--text-2);
 		background: var(--surface-3);
 	}
-	.st-running,
+	.st-running {
+		color: var(--run);
+		background: var(--run-soft);
+	}
 	.st-draft {
-		color: var(--accent);
-		background: var(--accent-dim);
+		color: var(--warn);
+		background: var(--warn-soft);
 	}
 	.st-confirmed {
 		color: var(--success);
@@ -695,7 +698,7 @@
 		padding: 10px 14px;
 		border-radius: 8px;
 		background: var(--error-dim);
-		border: 1px solid rgba(229, 72, 77, 0.35);
+		border: 1px solid color-mix(in srgb, var(--err) 35%, transparent);
 		color: var(--error);
 		font-size: 12.5px;
 		line-height: 1.6;
@@ -706,9 +709,9 @@
 		gap: 8px;
 		padding: 10px 14px;
 		border-radius: 8px;
-		background: var(--accent-dim);
-		border: 1px solid rgba(232, 163, 61, 0.3);
-		color: var(--accent);
+		background: var(--warn-soft);
+		border: 1px solid color-mix(in srgb, var(--warn) 30%, transparent);
+		color: var(--warn);
 		font-size: 12.5px;
 	}
 	.running-banner {
@@ -766,7 +769,7 @@
 		justify-content: center;
 		font-size: 16px;
 		font-weight: 700;
-		color: #edeef0;
+		color: var(--text);
 		flex-shrink: 0;
 	}
 	.agent-copy {
@@ -833,13 +836,10 @@
 		justify-content: center;
 		flex-shrink: 0;
 	}
-	.kind-image {
-		background: var(--info-dim);
-		color: var(--info);
-	}
+	.kind-image,
 	.kind-video {
-		background: var(--cloud-dim);
-		color: var(--cloud);
+		background: var(--bg-4);
+		color: var(--text-2);
 	}
 	.job-body {
 		display: flex;
@@ -872,7 +872,7 @@
 		color: var(--success);
 	}
 	.job-state.st-running {
-		color: var(--accent);
+		color: var(--run);
 	}
 	.job-state.st-pending {
 		color: var(--text-2);
@@ -904,9 +904,11 @@
 	.flow-dot.st-confirmed {
 		background: var(--success);
 	}
-	.flow-dot.st-running,
+	.flow-dot.st-running {
+		background: var(--run);
+	}
 	.flow-dot.st-awaiting_confirm {
-		background: var(--accent);
+		background: var(--warn);
 	}
 	.flow-name {
 		font-size: 12px;
@@ -953,7 +955,7 @@
 	}
 	.wb-input:focus {
 		outline: none;
-		border-color: rgba(232, 163, 61, 0.6);
+		border-color: var(--accent-line);
 	}
 	.wb-input::placeholder {
 		color: var(--text-3);
@@ -990,7 +992,7 @@
 	}
 	.btn.ghost:hover:not(:disabled) {
 		color: var(--text);
-		border-color: rgba(255, 255, 255, 0.24);
+		border-color: var(--line-2);
 	}
 	.btn.sm {
 		padding: 6px 11px;
@@ -1024,7 +1026,7 @@
 		width: 6px;
 		height: 6px;
 		border-radius: 50%;
-		background: var(--accent);
+		background: var(--run);
 		animation: wb-page-breath 2s cubic-bezier(0.16, 1, 0.3, 1) infinite;
 	}
 	.breath.big {

calliope-web/tailwind.config.js

@@ -1,20 +1,26 @@
+// Colors and radii resolve to the design tokens in src/routes/app.css so the
+// Tailwind palette can never drift from the single source of truth.
 module.exports = {
 	content: ['./src/**/*.{html,js,svelte,ts}'],
 	theme: {
 		extend: {
 			colors: {
-				primary: '#0a0a0c',
-				surface: '#141418',
-				elevated: '#1e1e24',
-				border: '#2a2a32',
-				muted: '#71717a',
-				accent: '#8b5cf6',
-				'accent-hover': '#7c3aed',
+				primary: 'var(--bg)',
+				surface: 'var(--bg-2)',
+				elevated: 'var(--bg-3)',
+				border: 'var(--line)',
+				muted: 'var(--text-3)',
+				accent: 'var(--accent)',
+				'accent-hover': 'var(--accent-hi)',
+				ok: 'var(--ok)',
+				run: 'var(--run)',
+				err: 'var(--err)',
+				warn: 'var(--warn)',
 			},
 			borderRadius: {
-				sm: '6px',
-				md: '10px',
-				lg: '16px',
+				sm: 'var(--r-sm)',
+				md: 'var(--r-md)',
+				lg: 'var(--r-lg)',
 			},
 		},
 	},