diff --git a/comfy_cli/cql/engine.py b/comfy_cli/cql/engine.py
index d2c941e6..d0a77e88 100644
--- a/comfy_cli/cql/engine.py
+++ b/comfy_cli/cql/engine.py
@@ -50,6 +50,10 @@ class Port:
     is_link: bool = False
     enum_values: list[Any] = field(default_factory=list)  # preserves the option's real type (int combos stay int)
     options: PortOptions = field(default_factory=PortOptions)
+    # V3 dynamic combos (COMFY_DYNAMICCOMBO_V3): the raw option dicts
+    # ([{"key": ..., "inputs": {...}}]) retained for sub-input expansion.
+    # enum_values carries just the selector keys.
+    dynamic_options: list[dict] = field(default_factory=list)
 
     @property
     def is_autogrow(self) -> bool:
@@ -195,10 +199,21 @@ def can_apply(self, available: set[str]) -> bool:
 # ---------------------------------------------------------------------------
 
 
+def _is_dynamic_combo_type(type_id: str) -> bool:
+    """V3 dynamic-combo types (e.g. ``COMFY_DYNAMICCOMBO_V3``): a selector
+    widget whose chosen option contributes its own sub-inputs. Same rule the
+    UI→API converter applies (``workflow_to_api._is_widget_input``)."""
+    return type_id.startswith("COMFY_") and "COMBO" in type_id
+
+
 def _is_link(type_id: str, is_enum: bool, force_input: bool) -> bool:
     """Determine if an input participates in typed wiring (link) or is inline (widget)."""
     if is_enum:
         return False
+    # A dynamic combo is a widget port even when its options block is missing
+    # or malformed — the frontend always renders the selector inline.
+    if _is_dynamic_combo_type(type_id):
+        return False
     if type_id in _IMPLICIT_WIDGET_TYPES and not force_input and type_id != "*":
         return False
     return True
@@ -242,22 +257,30 @@ def _control_after_generate_set(val: Any) -> bool:
     return True
 
 
-def _parse_input_spec(spec: Any) -> tuple[str, bool, list[Any], PortOptions]:
-    """Returns (type_id, is_enum, enum_values, options)."""
+def _parse_input_spec(spec: Any) -> tuple[str, bool, list[Any], PortOptions, list[dict]]:
+    """Returns (type_id, is_enum, enum_values, options, dynamic_options)."""
     if isinstance(spec, str):
-        return spec, False, [], PortOptions()
+        return spec, False, [], PortOptions(), []
 
     if not isinstance(spec, list) or len(spec) == 0:
-        return "UNKNOWN", False, [], PortOptions()
+        return "UNKNOWN", False, [], PortOptions(), []
 
     opts_raw = spec[1] if len(spec) > 1 and isinstance(spec[1], dict) else {}
     port_opts = _parse_port_options(opts_raw)
 
     first = spec[0]
     if isinstance(first, str):
+        if _is_dynamic_combo_type(first):
+            # V3 dynamic combo: options are [{"key": ..., "inputs": {...}}]
+            # dicts, NOT membership choices. Expose the keys as the selector's
+            # enum and retain the raw option dicts so slot extraction / writes
+            # can expand the selected option's sub-inputs.
+            options = opts_raw.get("options")
+            dyn = [o for o in options if isinstance(o, dict) and "key" in o] if isinstance(options, list) else []
+            return first, True, [o["key"] for o in dyn], port_opts, dyn
         # V3 / partner-API combo dialect: the type is the literal string
-        # "COMBO" (or a dynamic-combo type) and the choices live in the
-        # options dict, e.g. ["COMBO", {"options": ["480p", "720p"]}].
+        # "COMBO" and the choices live in the options dict, e.g.
+        # ["COMBO", {"options": ["480p", "720p"]}].
         # Without this, dict-form combos lose their enum and validate can't
         # enum-check them — exactly the partner nodes (ByteDance, BFL, …)
         # where the choices array is the precision check.
@@ -266,14 +289,14 @@ def _parse_input_spec(spec: Any) -> tuple[str, bool, list[Any], PortOptions]:
             # Keep each option's real type: an int-valued combo (Sora-2/LTXV
             # `duration`) must stay [4, 8, 12], not ["4","8","12"], so `nodes
             # show` is truthful and agents pass the type the cloud accepts.
-            return first, True, list(options), port_opts
-        return first, False, [], port_opts
+            return first, True, list(options), port_opts, []
+        return first, False, [], port_opts, []
 
     if isinstance(first, list):
         # Same: preserve the option types for the classic list-form combo.
-        return "COMBO", True, list(first), port_opts
+        return "COMBO", True, list(first), port_opts, []
 
-    return "UNKNOWN", False, [], port_opts
+    return "UNKNOWN", False, [], port_opts, []
 
 
 def _is_scalar_choice(v: Any) -> bool:
@@ -301,7 +324,7 @@ def _parse_inputs(raw: dict, order: list[str] | None, required: bool) -> list[Po
     ports: list[Port] = []
     for name in _ordered_names(raw, order):
         spec = raw[name]
-        type_id, is_enum, enum_values, opts = _parse_input_spec(spec)
+        type_id, is_enum, enum_values, opts, dynamic_options = _parse_input_spec(spec)
         ports.append(
             Port(
                 name=name,
@@ -310,6 +333,7 @@ def _parse_inputs(raw: dict, order: list[str] | None, required: bool) -> list[Po
                 is_link=_is_link(type_id, is_enum, opts.force_input),
                 enum_values=enum_values,
                 options=opts,
+                dynamic_options=dynamic_options,
             )
         )
     return ports
@@ -696,6 +720,10 @@ def category_tree(self) -> dict:
     # -- Widget order --
 
     def widget_order(self, class_name: str) -> list[str]:
+        """Value-independent widget order. A dynamic combo contributes only its
+        selector slot; use ``widget_order_for_node`` when the node's current
+        ``widgets_values`` are available so the selected option's sub-inputs
+        expand into their real positions."""
         m = self._nodes.get(class_name)
         if m is None:
             return []
@@ -708,6 +736,17 @@ def widget_order(self, class_name: str) -> list[str]:
                 order.append("control_after_generate")
         return order
 
+    def widget_order_for_node(self, class_name: str, widgets_values: list[Any] | None) -> list[str]:
+        """Value-aware widget order: like ``widget_order`` but at each dynamic
+        combo the current selector (read from its positional slot) picks an
+        option whose widget-like sub-inputs are expanded in place as
+        ``<name>.<sub>`` — matching how the frontend inlines the selected
+        option's sub-values into the flat positional ``widgets_values``."""
+        m = self._nodes.get(class_name)
+        if m is None:
+            return []
+        return [e.name for e in _expand_widget_entries(m, widgets_values or [])]
+
     # -- Validation --
 
     def validate_workflow(self, workflow: dict[str, Any]) -> dict[str, Any]:
@@ -1335,38 +1374,128 @@ def _subgraph_defs_by_id(workflow: dict) -> dict[str, dict]:
     return by_id
 
 
+# A dynamic combo may nest another dynamic combo among its sub-inputs. Real
+# schemas are one or two levels deep; the cap defends the expansion walk
+# against a pathological/malicious object_info entry.
+_MAX_DYNAMIC_COMBO_DEPTH = 16
+
+
+@dataclass
+class _WidgetEntry:
+    """One positional ``widgets_values`` slot in a node's value-aware order.
+
+    ``port`` is ``None`` for a ``control_after_generate`` marker slot (it has
+    no schema port). ``owner`` is the dotted name of the dynamic combo whose
+    selected option contributed this entry (``None`` for top-level inputs) —
+    used to size a combo's sub-span when its selector changes.
+    """
+
+    name: str
+    port: Port | None
+    owner: str | None
+
+
+def _sub_port_from_spec(name: str, sub_spec: Any, required: bool) -> Port:
+    """Build a Port for a dynamic-combo option sub-input, applying the same
+    widget-vs-link rules as top-level parsing."""
+    type_id, is_enum, enum_values, opts, dynamic_options = _parse_input_spec(sub_spec)
+    return Port(
+        name=name,
+        type=type_id,
+        required=required,
+        is_link=_is_link(type_id, is_enum, opts.force_input),
+        enum_values=enum_values,
+        options=opts,
+        dynamic_options=dynamic_options,
+    )
+
+
+def _dynamic_combo_sub_ports(dynamic_options: list[dict], selector: Any, prefix: str) -> list[Port]:
+    """The selected option's sub-inputs as Ports, dotted under ``prefix``.
+
+    Returns ``[]`` when the selector matches no option or the option block is
+    malformed. Connection-only sub-inputs (e.g. ``COMFY_AUTOGROW_V3`` image
+    lists) are included with ``is_link=True`` so callers can skip them.
+    """
+    option = next((o for o in dynamic_options if o.get("key") == selector), None)
+    if option is None:
+        return []
+    sub_def = option.get("inputs")
+    if not isinstance(sub_def, dict):
+        return []
+    ports: list[Port] = []
+    for section in ("required", "optional"):
+        section_def = sub_def.get(section) or {}
+        if not isinstance(section_def, dict):
+            continue
+        for sub_name, sub_spec in section_def.items():
+            ports.append(_sub_port_from_spec(f"{prefix}.{sub_name}", sub_spec, section == "required"))
+    return ports
+
+
+def _expand_widget_entries(m: Morphism, widgets_values: list[Any]) -> list[_WidgetEntry]:
+    """Flatten a node's widget ports into one entry per ``widgets_values`` slot.
+
+    Walks declared ports in order; at a dynamic combo it reads the current
+    selector from that combo's own positional slot and expands the matching
+    option's widget-like sub-inputs in place (recursing for nested dynamic
+    combos; connection sub-inputs contribute no slot). A control-flagged input
+    — top-level or sub — is followed by its ``control_after_generate`` marker
+    slot, exactly as the frontend serializes it.
+    """
+    entries: list[_WidgetEntry] = []
+
+    def emit(name: str, port: Port, owner: str | None, depth: int) -> None:
+        entries.append(_WidgetEntry(name=name, port=port, owner=owner))
+        if port.dynamic_options and _is_dynamic_combo_type(port.type):
+            if depth >= _MAX_DYNAMIC_COMBO_DEPTH:
+                return
+            idx = len(entries) - 1
+            selector = widgets_values[idx] if idx < len(widgets_values) else port.options.default
+            for sub in _dynamic_combo_sub_ports(port.dynamic_options, selector, name):
+                if sub.is_link:
+                    continue
+                emit(sub.name, sub, name, depth + 1)
+        elif port.options.control_after_generate:
+            entries.append(_WidgetEntry(name="control_after_generate", port=None, owner=owner))
+
+    for p in m.inputs:
+        if p.is_link:
+            continue
+        emit(p.name, p, None, 0)
+    return entries
+
+
 def _node_widget_slots(node: dict, prefix: str, graph: Graph) -> list[dict]:
     """Surface a regular node's widget inputs as slots under ``prefix``.
 
     ``prefix`` is the addressable node path (``"3"`` at top level, ``"10/9"``
     inside a subgraph). Returns one slot per widget input the schema knows
-    about. Returns ``[]`` for nodes whose type isn't in object_info.
+    about — including a dynamic combo's selector (enum = its option keys) and
+    the selected option's ``<name>.<sub>`` sub-inputs. Returns ``[]`` for
+    nodes whose type isn't in object_info.
     """
     node_type = node.get("type", "")
     m = graph.node(node_type)
     if m is None:
         return []
-    order = graph.widget_order(node_type)
     widgets = node.get("widgets_values") or []
     slots: list[dict] = []
-    for port in m.inputs:
-        if port.is_link:
-            continue
-        try:
-            idx = order.index(port.name)
-        except ValueError:
+    for idx, entry in enumerate(_expand_widget_entries(m, widgets)):
+        if entry.port is None:  # control_after_generate marker — not a slot
             continue
         current = widgets[idx] if idx < len(widgets) else None
-        slots.append(
-            {
-                "address": f"{prefix}.{port.name}",
-                "name": port.name,
-                "type": port.type,
-                "current_value": current,
-                "instance_id": prefix,
-                "node_type": node_type,
-            }
-        )
+        slot = {
+            "address": f"{prefix}.{entry.name}",
+            "name": entry.name,
+            "type": entry.port.type,
+            "current_value": current,
+            "instance_id": prefix,
+            "node_type": node_type,
+        }
+        if entry.port.enum_values:
+            slot["enum"] = list(entry.port.enum_values)
+        slots.append(slot)
     return slots
 
 
@@ -1496,12 +1625,12 @@ def _resolve_proxy_value(instance: dict, subgraph: dict, input_name: str, graph:
             if not isinstance(inode, dict) or str(inode.get("id", "")) != interior_id:
                 continue
             interior_class = inode.get("type", "")
-            order = graph.widget_order(interior_class)
+            widgets = inode.get("widgets_values") or []
+            order = graph.widget_order_for_node(interior_class, widgets)
             try:
                 idx = order.index(name)
             except ValueError:
                 return _UNRESOLVED
-            widgets = inode.get("widgets_values") or []
             return widgets[idx] if idx < len(widgets) else _UNRESOLVED
         break
     return _UNRESOLVED
@@ -1513,28 +1642,47 @@ def _write_widget(node: dict, input_name: str, value: Any, graph: Graph, *, exte
     Validates against the node's schema and returns catalog warnings. ``extend``
     pads a short widget list for top-level direct edits (matches prior behavior);
     interior subgraph nodes always carry a full widget list and are not padded.
+
+    Dynamic combos: the positional order is value-aware, so a selected option's
+    sub-inputs (``model.size_preset``) address their real slots. Writing the
+    selector itself to a different option rebuilds the node's sub-widget roster
+    (see ``_write_dynamic_combo_selector``); a ``<combo>.<sub>`` address that
+    doesn't exist under the current selector returns a warning without writing.
     """
     node_type = node.get("type", "")
     m = graph.node(node_type)
     if m is None:
         raise ValueError(f"unknown node type {node_type!r} for node {node.get('id')}")
-    order = graph.widget_order(node_type)
+    widgets = node.get("widgets_values") or []
+    order = graph.widget_order_for_node(node_type, widgets)
     try:
         widget_idx = order.index(input_name)
     except ValueError:
+        warning = _unknown_dynamic_sub_warning(m, input_name, order, widgets)
+        if warning is not None:
+            return [warning]
         avail = [n for n in order if n != "control_after_generate"]
         raise ValueError(
             f"widget {input_name!r} not found on {node_type}; "
             f"available widgets: {', '.join(avail) if avail else '(none — all inputs are links)'}"
         )
-    widgets = node.get("widgets_values") or []
+
+    entries = _expand_widget_entries(m, widgets)
+    port = next((e.port for e in entries if e.name == input_name), None)
+    if port is None:
+        # Marker slot or an order override without matching entries (tests
+        # monkeypatch widget_order_for_node) — fall back to the declared port.
+        port = next((p for p in m.inputs if p.name == input_name), None)
+
+    if port is not None and _is_dynamic_combo_type(port.type) and port.dynamic_options:
+        return _write_dynamic_combo_selector(node, port, input_name, widget_idx, value, entries, extend=extend)
+
     if widget_idx >= len(widgets):
         if not extend:
             raise ValueError(f"widget index {widget_idx} out of range for {node_type}")
         widgets.extend([None] * (widget_idx + 1 - len(widgets)))
 
     warnings: list[dict] = []
-    port = next((p for p in m.inputs if p.name == input_name), None)
     if port:
         err = port.validate_shape(value)
         if err:
@@ -1546,6 +1694,120 @@ def _write_widget(node: dict, input_name: str, value: Any, graph: Graph, *, exte
     return warnings
 
 
+def _unknown_dynamic_sub_warning(m: Morphism, input_name: str, order: list[str], widgets: list[Any]) -> dict | None:
+    """Warning dict for a ``<combo>.<sub>`` address not present under the
+    combo's CURRENT selector, or ``None`` when ``input_name`` isn't a
+    dynamic-combo sub-address (caller falls through to the hard error)."""
+    if "." not in input_name:
+        return None
+    base = input_name.split(".", 1)[0]
+    base_port = next((p for p in m.inputs if p.name == base), None)
+    if base_port is None or not _is_dynamic_combo_type(base_port.type) or base not in order:
+        return None
+    base_idx = order.index(base)
+    selector = widgets[base_idx] if base_idx < len(widgets) else None
+    valid = [n for n in order if n.startswith(f"{base}.")]
+    return {
+        "code": "unknown_dynamic_sub_input",
+        "field": input_name,
+        "message": (
+            f"{input_name!r} does not exist under the current {base}={selector!r} selection; nothing was written"
+        ),
+        "hint": (
+            f"valid {base}.* addresses: {', '.join(valid)}"
+            if valid
+            else f"{base}={selector!r} has no widget sub-inputs"
+        )
+        + f" — set {base}=<option> first to switch rosters",
+        "valid_addresses": valid,
+    }
+
+
+def _write_dynamic_combo_selector(
+    node: dict, port: Port, input_name: str, widget_idx: int, value: Any, entries: list[_WidgetEntry], *, extend: bool
+) -> list[dict]:
+    """Write a dynamic combo's selector, rebuilding the sub-widget roster when
+    the selected option changes.
+
+    The frontend inlines the selected option's widget sub-values right after
+    the selector in ``widgets_values``, so switching options changes how many
+    positional slots the combo owns. We keep every value before the combo,
+    write the new selector, fill the new option's widget sub-inputs from schema
+    defaults (option sub-spec ``default``; first enum option for combos), and
+    keep the trailing values (seed/marker/watermark/…) aligned after them.
+    """
+    widgets = node.get("widgets_values") or []
+    if value not in port.enum_values:
+        valid = ", ".join(repr(k) for k in port.enum_values)
+        raise ValueError(f"{input_name}: {value!r} is not a known option; valid options: {valid}")
+
+    current = widgets[widget_idx] if widget_idx < len(widgets) else None
+    if value == current:
+        # Same option — the roster is unchanged; plain in-place write.
+        if widget_idx >= len(widgets):
+            if not extend:
+                raise ValueError(f"widget index {widget_idx} out of range for {node.get('type')}")
+            widgets.extend([None] * (widget_idx + 1 - len(widgets)))
+        widgets[widget_idx] = value
+        node["widgets_values"] = widgets
+        return []
+
+    # Sub-entries owned (directly or via nesting) by this combo sit contiguously
+    # after it; their count is the positional span the OLD roster occupied.
+    old_span = sum(
+        1
+        for e in entries[widget_idx + 1 :]
+        if e.owner and (e.owner == input_name or e.owner.startswith(f"{input_name}."))
+    )
+    head = list(widgets[:widget_idx])
+    if len(head) < widget_idx:
+        head.extend([None] * (widget_idx - len(head)))
+    tail = list(widgets[widget_idx + 1 + old_span :])
+    new_subs, new_names = _dynamic_combo_default_values(port.dynamic_options, value, input_name)
+    node["widgets_values"] = head + [value] + new_subs + tail
+    return [
+        {
+            "code": "dynamic_combo_roster_rebuilt",
+            "field": input_name,
+            "message": (
+                f"{input_name}: {current!r} → {value!r} changed the sub-widget roster; "
+                f"replaced {old_span} sub-value(s) with {len(new_subs)} schema default(s) "
+                f"({', '.join(new_names) if new_names else 'none'}) — "
+                f"values before and after the combo were preserved"
+            ),
+        }
+    ]
+
+
+def _dynamic_combo_default_values(
+    dynamic_options: list[dict], selector: Any, prefix: str, depth: int = 0
+) -> tuple[list[Any], list[str]]:
+    """Schema-default ``widgets_values`` for the selected option's widget
+    sub-inputs (positional, including nested combos' expansions and
+    ``control_after_generate`` markers). Returns (values, dotted_names)."""
+    values: list[Any] = []
+    names: list[str] = []
+    for sub in _dynamic_combo_sub_ports(dynamic_options, selector, prefix):
+        if sub.is_link:
+            continue
+        default = sub.options.default
+        if default is None and sub.enum_values:
+            default = sub.enum_values[0]
+        values.append(default)
+        names.append(sub.name)
+        if _is_dynamic_combo_type(sub.type) and sub.dynamic_options:
+            if depth < _MAX_DYNAMIC_COMBO_DEPTH:
+                nested_values, nested_names = _dynamic_combo_default_values(
+                    sub.dynamic_options, default, sub.name, depth + 1
+                )
+                values.extend(nested_values)
+                names.extend(nested_names)
+        elif sub.options.control_after_generate:
+            values.append("fixed")
+            names.append("control_after_generate")
+    return values, names
+
+
 def _resolve_node_path(workflow: dict, segments: list[str], defs_by_id: dict[str, dict]) -> dict:
     """Walk a ``/``-separated node path into (possibly nested) subgraphs.
 
diff --git a/tests/comfy_cli/command/test_workflow_slots.py b/tests/comfy_cli/command/test_workflow_slots.py
index 56e7566a..442ee680 100644
--- a/tests/comfy_cli/command/test_workflow_slots.py
+++ b/tests/comfy_cli/command/test_workflow_slots.py
@@ -155,6 +155,18 @@ def _subgraph_workflow() -> dict:
     return json.loads((_FIXTURES / "subgraph_template_ui.json").read_text(encoding="utf-8"))
 
 
+def _seedream_graph():
+    """Graph built from the vendored ByteDance Seedream object_info (the node's
+    ``model`` input is a COMFY_DYNAMICCOMBO_V3 whose options carry sub-inputs)."""
+    oi = json.loads((_FIXTURES / "object_info_bytedance_seedream_v2.json").read_text(encoding="utf-8"))
+    return Graph.from_object_info(oi)
+
+
+def _seedream_workflow() -> dict:
+    """The pristine Seedream 5.0 Pro t2i template exactly as the frontend ships it."""
+    return json.loads((_FIXTURES / "seedream_5_0_pro_t2i_ui.json").read_text(encoding="utf-8"))
+
+
 @pytest.fixture
 def patched_graph(monkeypatch):
     monkeypatch.setattr(workflow_cmd, "_get_graph", lambda *a, **kw: _fake_graph())
@@ -165,6 +177,11 @@ def patched_subgraph_graph(monkeypatch):
     monkeypatch.setattr(workflow_cmd, "_get_graph", lambda *a, **kw: _subgraph_graph())
 
 
+@pytest.fixture
+def patched_seedream_graph(monkeypatch):
+    monkeypatch.setattr(workflow_cmd, "_get_graph", lambda *a, **kw: _seedream_graph())
+
+
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------
@@ -641,6 +658,145 @@ def test_vary_over_nested_prompt(self, patched_subgraph_graph, tmp_path, capsys)
         assert prompts == ["cat", "dog", "fox"]
 
 
+# ---------------------------------------------------------------------------
+# Dynamic combos (COMFY_DYNAMICCOMBO_V3) — pristine ByteDance Seedream template
+# ---------------------------------------------------------------------------
+#
+# The frontend inlines the selected option's widget sub-values into the flat
+# positional widgets_values right after the selector, so slot extraction and
+# the set-slot/vary write path must expand the dynamic combo or every widget
+# after it mislabels/miswrites (1.seed reading the model name, 1.seed=42
+# silently clobbering the model selector).
+#
+# Pristine template widgets_values layout (index → slot):
+#   0 prompt · 1 model selector · 2 model.size_preset · 3 model.width
+#   4 model.height · 5 seed · 6 control_after_generate · 7 watermark
+#   (thinking is optional and unserialized → index 8, absent)
+
+
+class TestSlotsDynamicCombo:
+    def test_slots_expand_dynamic_combo_sub_inputs(self, patched_seedream_graph, tmp_path, capsys):
+        path = _write_workflow(tmp_path, _seedream_workflow())
+        env = _run(["slots", str(path)], capsys)
+        assert env["ok"] is True
+        by_addr = {s["address"]: s for s in env["data"]["slots"]}
+        assert "1.prompt" in by_addr
+
+        model = by_addr["1.model"]
+        assert model["type"] == "COMFY_DYNAMICCOMBO_V3"
+        assert model["current_value"] == "seedream 5.0 pro"
+        assert "seedream 5.0 pro" in model["enum"]
+
+        preset = by_addr["1.model.size_preset"]
+        assert "(1K) 1024x1024 (1:1)" in preset["enum"]
+        assert preset["current_value"] == "(1K) 1024x1024 (1:1)"
+
+        assert by_addr["1.model.width"]["type"] == "INT"
+        assert by_addr["1.model.width"]["current_value"] == 2048
+        assert by_addr["1.model.height"]["type"] == "INT"
+        assert by_addr["1.model.height"]["current_value"] == 2048
+
+        seed = by_addr["1.seed"]
+        assert seed["type"] == "INT"
+        assert seed["current_value"] == 0, "1.seed must read its own slot, not the model selector"
+
+        assert by_addr["1.watermark"]["type"] == "BOOLEAN"
+        assert by_addr["1.watermark"]["current_value"] is False
+        assert "1.thinking" in by_addr
+
+    def test_slots_connection_sub_inputs_not_exposed(self, patched_seedream_graph, tmp_path, capsys):
+        """Autogrow/connection sub-inputs consume no widgets_values slot and
+        must not surface as slots."""
+        path = _write_workflow(tmp_path, _seedream_workflow())
+        env = _run(["slots", str(path)], capsys)
+        addrs = {s["address"] for s in env["data"]["slots"]}
+        assert "1.model.images" not in addrs
+
+
+class TestSetSlotDynamicCombo:
+    def test_set_seed_does_not_clobber_model_selector(self, patched_seedream_graph, tmp_path, capsys):
+        path = _write_workflow(tmp_path, _seedream_workflow())
+        env = _run(["set-slot", str(path), "1.seed=42"], capsys)
+        assert env["ok"] is True, env
+        wv = json.loads(path.read_text())["nodes"][0]["widgets_values"]
+        assert wv[5] == 42
+        assert wv[1] == "seedream 5.0 pro", "selector must be untouched by a seed write"
+
+    def test_set_sub_input_writes_its_own_slot(self, patched_seedream_graph, tmp_path, capsys):
+        path = _write_workflow(tmp_path, _seedream_workflow())
+        env = _run(["set-slot", str(path), '1.model.size_preset="Custom"'], capsys)
+        assert env["ok"] is True, env
+        wv = json.loads(path.read_text())["nodes"][0]["widgets_values"]
+        assert wv[2] == "Custom"
+        assert wv[1] == "seedream 5.0 pro"
+
+    def test_selector_change_rebuilds_roster(self, patched_seedream_graph, tmp_path, capsys):
+        original = _seedream_workflow()["nodes"][0]["widgets_values"]
+        path = _write_workflow(tmp_path, _seedream_workflow())
+        env = _run(["set-slot", str(path), '1.model="seedream 5.0 lite"'], capsys)
+        assert env["ok"] is True, env
+        warnings = env["data"]["warnings"]
+        assert any(w.get("code") == "dynamic_combo_roster_rebuilt" for w in warnings), warnings
+
+        wv = json.loads(path.read_text())["nodes"][0]["widgets_values"]
+        # lite adds max_images + fail_on_partial → roster grows by 2.
+        assert len(wv) == len(original) + 2
+        assert wv[0] == original[0], "prompt preserved"
+        assert wv[1] == "seedream 5.0 lite"
+        # lite defaults: size_preset (first enum), width, height, max_images, fail_on_partial.
+        assert wv[2:7] == ["(1K) 1024x1024 (1:1)", 2048, 2048, 1, False]
+        # trailing values (seed / control marker / watermark) preserved + realigned.
+        assert wv[7:] == [0, "randomize", False]
+
+        # The rebuilt roster is addressable: the lite-only sub-slots now exist.
+        env = _run(["slots", str(path)], capsys)
+        addrs = {s["address"]: s["current_value"] for s in env["data"]["slots"]}
+        assert addrs["1.model.max_images"] == 1
+        assert addrs["1.model.fail_on_partial"] is False
+        assert addrs["1.seed"] == 0
+
+    def test_unknown_sub_address_warns_without_writing(self, patched_seedream_graph, tmp_path, capsys):
+        original = _seedream_workflow()["nodes"][0]["widgets_values"]
+        path = _write_workflow(tmp_path, _seedream_workflow())
+        # max_images only exists under the lite/4.5 selectors, not the current pro one.
+        env = _run(["set-slot", str(path), "1.model.max_images=5"], capsys)
+        assert env["ok"] is True, env
+        warnings = env["data"]["warnings"]
+        w = next((w for w in warnings if w.get("code") == "unknown_dynamic_sub_input"), None)
+        assert w is not None, warnings
+        assert "model.size_preset" in (w.get("valid_addresses") or [])
+        wv = json.loads(path.read_text())["nodes"][0]["widgets_values"]
+        assert wv == original, "an unknown sub-address must not mutate widgets_values"
+
+    def test_unknown_selector_option_rejected(self, patched_seedream_graph, tmp_path, capsys):
+        path = _write_workflow(tmp_path, _seedream_workflow())
+        env = _run(["set-slot", str(path), '1.model="no-such-model"'], capsys)
+        assert env["ok"] is False
+        assert "valid options" in env["error"]["message"]
+
+
+class TestVaryDynamicCombo:
+    def test_vary_over_sub_input(self, patched_seedream_graph, tmp_path, capsys):
+        path = _write_workflow(tmp_path, _seedream_workflow())
+        out_dir = tmp_path / "out"
+        env = _run(
+            [
+                "vary",
+                str(path),
+                "--slot",
+                '1.model.size_preset=["Custom","(2K) 2048x2048 (1:1)"]',
+                "--out-dir",
+                str(out_dir),
+            ],
+            capsys,
+        )
+        assert env["ok"] is True
+        presets = []
+        for f in sorted(out_dir.glob("*.json")):
+            presets.append(json.loads(f.read_text())["nodes"][0]["widgets_values"][2])
+        assert presets == ["Custom", "(2K) 2048x2048 (1:1)"]
+
+
 # ---------------------------------------------------------------------------
 # stale cache envelope — workflow slots/set-slot/vary surface stale flag
 # ---------------------------------------------------------------------------
diff --git a/tests/comfy_cli/cql/test_engine.py b/tests/comfy_cli/cql/test_engine.py
index b35adf4d..dfdecd70 100644
--- a/tests/comfy_cli/cql/test_engine.py
+++ b/tests/comfy_cli/cql/test_engine.py
@@ -305,6 +305,131 @@ def test_unknown_node_returns_empty(self, graph: Graph):
         assert order == []
 
 
+# ===========================================================================
+# TestWidgetOrderDynamicCombo
+# ===========================================================================
+
+
+def _dynamic_combo_object_info() -> dict:
+    """A COMFY_DYNAMICCOMBO_V3 node with a nested dynamic combo among one
+    option's sub-inputs, plus connection-only subs that own no value slot."""
+    return {
+        "DynNode": {
+            "input": {
+                "required": {
+                    "prompt": ["STRING", {"default": ""}],
+                    "model": [
+                        "COMFY_DYNAMICCOMBO_V3",
+                        {
+                            "options": [
+                                {
+                                    "key": "alpha",
+                                    "inputs": {
+                                        "required": {
+                                            "size": ["COMBO", {"options": ["S", "M"]}],
+                                            "width": ["INT", {"default": 512}],
+                                            "images": ["COMFY_AUTOGROW_V3", {"min": 0}],
+                                        }
+                                    },
+                                },
+                                {
+                                    "key": "beta",
+                                    "inputs": {
+                                        "required": {
+                                            "mode": [
+                                                "COMFY_DYNAMICCOMBO_V3",
+                                                {
+                                                    "options": [
+                                                        {
+                                                            "key": "fast",
+                                                            "inputs": {"required": {"steps": ["INT", {"default": 4}]}},
+                                                        },
+                                                        {
+                                                            "key": "slow",
+                                                            "inputs": {
+                                                                "required": {
+                                                                    "steps": ["INT", {"default": 50}],
+                                                                    "refine": ["BOOLEAN", {"default": True}],
+                                                                }
+                                                            },
+                                                        },
+                                                    ]
+                                                },
+                                            ],
+                                        }
+                                    },
+                                },
+                            ]
+                        },
+                    ],
+                    "seed": ["INT", {"default": 0, "control_after_generate": True}],
+                },
+            },
+            "input_order": {"required": ["prompt", "model", "seed"]},
+            "output": ["IMAGE"],
+            "output_name": ["IMAGE"],
+            "category": "test",
+            "display_name": "DynNode",
+            "python_module": "nodes",
+        }
+    }
+
+
+class TestWidgetOrderDynamicCombo:
+    """Value-aware order expansion for COMFY_DYNAMICCOMBO_V3 ports."""
+
+    @pytest.fixture
+    def dyn_graph(self) -> Graph:
+        return Graph.from_object_info(_dynamic_combo_object_info())
+
+    def test_dynamic_combo_is_widget_not_link(self, dyn_graph: Graph):
+        m = dyn_graph.node("DynNode")
+        model = next(p for p in m.inputs if p.name == "model")
+        assert model.is_link is False
+        assert model.enum_values == ["alpha", "beta"]
+        assert len(model.dynamic_options) == 2
+
+    def test_value_independent_order_has_selector_only(self, dyn_graph: Graph):
+        assert dyn_graph.widget_order("DynNode") == ["prompt", "model", "seed", "control_after_generate"]
+
+    def test_value_aware_order_expands_selected_option(self, dyn_graph: Graph):
+        order = dyn_graph.widget_order_for_node("DynNode", ["p", "alpha", "S", 512, 0, "fixed"])
+        # connection-only sub (COMFY_AUTOGROW_V3 images) contributes no slot.
+        assert order == ["prompt", "model", "model.size", "model.width", "seed", "control_after_generate"]
+
+    def test_value_aware_order_recurses_nested_dynamic_combo(self, dyn_graph: Graph):
+        order = dyn_graph.widget_order_for_node("DynNode", ["p", "beta", "slow", 50, True, 0, "fixed"])
+        assert order == [
+            "prompt",
+            "model",
+            "model.mode",
+            "model.mode.steps",
+            "model.mode.refine",
+            "seed",
+            "control_after_generate",
+        ]
+
+    def test_unknown_selector_expands_nothing(self, dyn_graph: Graph):
+        order = dyn_graph.widget_order_for_node("DynNode", ["p", "gone", 0, "fixed"])
+        assert order == ["prompt", "model", "seed", "control_after_generate"]
+
+    def test_nested_selector_change_rebuilds_inner_roster(self, dyn_graph: Graph):
+        wf = {"nodes": [{"id": 1, "type": "DynNode", "widgets_values": ["p", "beta", "fast", 4, 7, "fixed"]}]}
+        out, warnings = dyn_graph.apply_slots(wf, {"1.model.mode": "slow"})
+        assert [w["code"] for w in warnings] == ["dynamic_combo_roster_rebuilt"]
+        # fast's [steps=4] roster is replaced by slow's defaults [steps=50, refine=True];
+        # the trailing seed + control marker stay aligned.
+        assert out["nodes"][0]["widgets_values"] == ["p", "beta", "slow", 50, True, 7, "fixed"]
+
+    def test_outer_selector_change_replaces_nested_span(self, dyn_graph: Graph):
+        wf = {"nodes": [{"id": 1, "type": "DynNode", "widgets_values": ["p", "beta", "slow", 50, True, 7, "fixed"]}]}
+        out, warnings = dyn_graph.apply_slots(wf, {"1.model": "alpha"})
+        assert [w["code"] for w in warnings] == ["dynamic_combo_roster_rebuilt"]
+        # the whole nested span (mode, mode.steps, mode.refine) is replaced by
+        # alpha's defaults (size first-enum, width default).
+        assert out["nodes"][0]["widgets_values"] == ["p", "alpha", "S", 512, 7, "fixed"]
+
+
 # ===========================================================================
 # TestTraversal
 # ===========================================================================
@@ -1385,12 +1510,12 @@ class _FakeMeta:
         inputs = []  # no declared inputs -> _write_widget skips shape/catalog validation
 
     real_node = graph.node
-    real_order = graph.widget_order
+    real_order = graph.widget_order_for_node
     monkeypatch.setattr(graph, "node", lambda nt: _FakeMeta() if nt == "DottedWidgetNode" else real_node(nt))
     monkeypatch.setattr(
         graph,
-        "widget_order",
-        lambda nt: ["images.image0"] if nt == "DottedWidgetNode" else real_order(nt),
+        "widget_order_for_node",
+        lambda nt, wv: ["images.image0"] if nt == "DottedWidgetNode" else real_order(nt, wv),
     )
 
     wf = {