fix(workflows): validate non-mapping 'options' in command step (#3493)

The `command` step's `execute()` merges `options` into a dict via
`options.update(step_options)`, but `validate()` did not check the type
and the merge was gated only on truthiness (`if step_options`). A
workflow with `options: [1, 2]` or `options: "foo"` therefore passed
validation and crashed at runtime with:

    TypeError: cannot convert dictionary update sequence element #0 to a sequence

Follow the pattern already applied by the shell / while-loop / do-while
validators and by the sibling `input`-validation change in #3492: reject
the non-mapping value in `validate()` with a message that names the
field, and defensively guard the `.update()` in `execute()` so a caller
that skips `WorkflowEngine.validate()` fails cleanly rather than raising
an internal `dict.update` traceback.

Fixes #3493

Author: thejesh23

src/specify_cli/workflows/steps/command/__init__.py

@@ -47,10 +47,14 @@ def execute(self, config: dict[str, Any], context: StepContext) -> StepResult:
         if model and isinstance(model, str) and "{{" in model:
             model = evaluate_expression(model, context)
 
-        # Merge options (workflow defaults ← step overrides)
+        # Merge options (workflow defaults ← step overrides). A non-mapping
+        # ``options`` (list, string, ``null``) is a config error; ``validate()``
+        # catches this at load time, but guard here so a caller that bypasses
+        # ``WorkflowEngine.validate()`` still fails cleanly instead of raising
+        # an internal ``TypeError``/``ValueError`` from ``dict.update``.
         options = dict(context.default_options)
         step_options = config.get("options", {})
-        if step_options:
+        if isinstance(step_options, dict) and step_options:
             options.update(step_options)
 
         # Attempt CLI dispatch
@@ -155,4 +159,13 @@ def validate(self, config: dict[str, Any]) -> list[str]:
             errors.append(
                 f"Command step {config.get('id', '?')!r} is missing 'command' field."
             )
+        if "options" in config and not isinstance(config["options"], dict):
+            # ``execute`` merges ``options`` into a dict via ``dict.update``;
+            # a non-mapping value (list, string) would raise ``TypeError`` or
+            # ``ValueError`` there. Reject at validation so the failure surfaces
+            # at load time with a message that points at the field.
+            errors.append(
+                f"Command step {config.get('id', '?')!r}: 'options' must be a "
+                f"mapping, got {type(config['options']).__name__}."
+            )
         return errors

tests/test_workflows.py

@@ -953,6 +953,50 @@ def test_validate_missing_command(self):
         errors = step.validate({"id": "test"})
         assert any("missing 'command'" in e for e in errors)
 
+    def test_validate_rejects_non_mapping_options(self):
+        """`options: [...]` / string / null must fail validation, not crash at run.
+
+        Before the fix, execute() called ``dict.update(step_options)`` and
+        raised ``TypeError``/``ValueError`` for a non-mapping value,
+        bypassing validate().
+        """
+        from specify_cli.workflows.steps.command import CommandStep
+
+        step = CommandStep()
+        for bad in ([1, 2], "foo"):
+            errors = step.validate({"id": "t", "command": "/x", "options": bad})
+            assert any("'options' must be a mapping" in e for e in errors), (
+                f"expected mapping error for options={bad!r}, got {errors!r}"
+            )
+
+    def test_execute_non_mapping_options_does_not_crash(self):
+        """execute() must fail cleanly when validate() is bypassed.
+
+        Some callers skip ``WorkflowEngine.validate()``. In that path, a
+        non-mapping ``options`` used to raise ``TypeError: cannot convert
+        dictionary update sequence element #0 to a sequence`` from
+        ``dict.update``. Now it is skipped and the step reports the usual
+        dispatch failure.
+        """
+        from unittest.mock import patch
+        from specify_cli.workflows.steps.command import CommandStep
+        from specify_cli.workflows.base import StepContext, StepStatus
+
+        step = CommandStep()
+        ctx = StepContext(
+            default_integration="claude",
+            default_options={"max-tokens": 8000},
+            project_root="/tmp",
+        )
+        with patch("specify_cli.workflows.steps.command.shutil.which", return_value=None):
+            result = step.execute(
+                {"id": "t", "command": "/speckit.plan", "options": [1, 2]},
+                ctx,
+            )
+        assert result.status == StepStatus.FAILED
+        # Workflow defaults still applied; malformed step-level override discarded.
+        assert result.output["options"] == {"max-tokens": 8000}
+
     def test_step_override_integration(self):
         from unittest.mock import patch
         from specify_cli.workflows.steps.command import CommandStep