test(workflows): restore 9 dry_run tests lost during rebase onto main

The rebase onto upstream/main (e39cb51) dropped the dry_run test cases
that were added in commits c2b23a2 and df398b0. The conflict resolution
at the from_json section inadvertently kept only the upstream from_json
content, removing all 9 dry_run test methods across TestCommandStep,
TestPromptStep, TestGateStep, and TestWorkflowEngine.

Restored:
- TestCommandStep: test_dry_run_returns_completed_without_dispatch,
  test_dry_run_uses_integration_invocation_string,
  test_dry_run_falls_back_when_integration_unknown
- TestPromptStep: test_dry_run_prompt_short_circuits
- TestGateStep: test_dry_run_skips_interactive_gate,
  test_dry_run_normalizes_non_list_options,
  test_dry_run_accepts_tuple_options,
  test_dry_run_skips_reject_sentinels_for_choice
- TestWorkflowEngine: test_dry_run_persisted_in_run_state

All 9 tests pass; remaining 14 pre-existing failures (TestWorkflowStep*
and TestWorkflowRunExitCodes/test_gate_abort) also fail on upstream/main
unmodified and are unrelated to this PR.

Author: fuleinist

tests/test_workflows.py

@@ -862,6 +862,112 @@ def test_dispatch_failure_returns_failed_status(self, tmp_path):
         assert result.output["exit_code"] == 1
 
 
+
+
+    def test_dry_run_returns_completed_without_dispatch(self, tmp_path):
+        """Dry-run mode: step returns COMPLETED and shows rendered prompt without invoking CLI."""
+        from specify_cli.workflows.steps.command import CommandStep
+        from specify_cli.workflows.base import StepContext, StepStatus
+
+        step = CommandStep()
+        ctx = StepContext(
+            inputs={"name": "login"},
+            default_integration="claude",
+            project_root=str(tmp_path),
+            dry_run=True,
+        )
+        config = {
+            "id": "test",
+            "command": "speckit.specify",
+            "input": {"args": "{{ inputs.name }}"},
+        }
+        result = step.execute(config, ctx)
+
+        assert result.status == StepStatus.COMPLETED
+        assert result.output["dry_run"] is True
+        assert result.output["dispatched"] is False
+        assert result.output["executed"] is False
+        assert result.output["command"] == "speckit.specify"
+        assert result.output["input"]["args"] == "login"
+        # No AI call was made (shutil.which would fail anyway, but dry_run short-circuits before that)
+        assert "invoke_command" in result.output
+        # The DRY RUN preview is published on both ``message`` and
+        # ``dry_run_message`` so the CLI's render loop can prefer the
+        # latter without per-step-type special-casing.
+        assert "DRY RUN" in result.output["message"]
+        assert result.output["dry_run_message"] == result.output["message"]
+    def test_dry_run_uses_integration_invocation_string(self, tmp_path):
+        """Dry-run preview uses the integration's ``build_command_invocation()``.
+
+        Markdown agents (``claude``, ``gemini``) render
+        ``/speckit.specify <args>``; skills agents (``zed``,
+        ``kiro-cli``) render ``/speckit-specify <args>``. The dry-run
+        preview must match what a real run would dispatch, not the
+        bare ``speckit.specify`` command name.
+        """
+        from specify_cli.workflows.steps.command import CommandStep
+        from specify_cli.workflows.base import StepContext
+
+        # Markdown agent — invocation keeps the dotted form.
+        step = CommandStep()
+        ctx = StepContext(
+            inputs={"name": "login"},
+            default_integration="claude",
+            project_root=str(tmp_path),
+            dry_run=True,
+        )
+        config = {
+            "id": "test",
+            "command": "speckit.specify",
+            "input": {"args": "{{ inputs.name }}"},
+        }
+        result = step.execute(config, ctx)
+        # The Claude integration renders ``/speckit-specify`` for the
+        # ``speckit.specify`` command. The preview should reference it
+        # (the bare ``speckit.specify`` token is fine too because the
+        # preview is a quoted string). What matters is the integration
+        # invocation string is present.
+        assert "/speckit-specify" in result.output["message"]
+        # And the bare ``speckit.specify`` token should NOT be the
+        # only thing shown — the slash-command form must be there too.
+        assert result.output["message"].count("speckit") >= 1
+
+        # Skills agent — invocation switches to ``/speckit.specify``.
+        ctx_skill = StepContext(
+            inputs={"name": "login"},
+            default_integration="gemini",  # markdown agent — produces /speckit.specify
+            project_root=str(tmp_path),
+            dry_run=True,
+        )
+        result_skill = step.execute(config, ctx_skill)
+        assert "/speckit.specify" in result_skill.output["message"]
+    def test_dry_run_falls_back_when_integration_unknown(self, tmp_path):
+        """Dry-run falls back to the bare command string when no integration is set.
+
+        A brand-new project may run ``workflow run --dry-run`` before
+        any integration is configured. The preview must still emit a
+        sensible message rather than crashing inside ``get_integration``.
+        """
+        from specify_cli.workflows.steps.command import CommandStep
+        from specify_cli.workflows.base import StepContext, StepStatus
+
+        step = CommandStep()
+        ctx = StepContext(
+            inputs={"name": "login"},
+            default_integration=None,  # no integration configured
+            project_root=str(tmp_path),
+            dry_run=True,
+        )
+        config = {
+            "id": "test",
+            "command": "speckit.specify",
+            "input": {"args": "{{ inputs.name }}"},
+        }
+        result = step.execute(config, ctx)
+        assert result.status == StepStatus.COMPLETED
+        # Falls back to the bare ``command`` name in the preview.
+        assert "speckit.specify" in result.output["message"]
+        assert "DRY RUN" in result.output["message"]
 class TestPromptStep:
     """Test the prompt step type."""
 
@@ -1036,6 +1142,39 @@ def test_validate_valid(self):
         assert errors == []
 
 
+
+
+    def test_dry_run_prompt_short_circuits(self, tmp_path):
+        """PromptStep must honor ``context.dry_run`` — the same contract
+        as CommandStep / GateStep. Without this, a workflow with
+        ``type: prompt`` makes real AI calls even in dry-run mode."""
+        from specify_cli.workflows.steps.prompt import PromptStep
+        from specify_cli.workflows.base import StepContext, StepStatus
+
+        step = PromptStep()
+        ctx = StepContext(
+            inputs={"file": "auth.py"},
+            default_integration="claude",
+            project_root=str(tmp_path),
+            dry_run=True,
+        )
+        config = {
+            "id": "review",
+            "type": "prompt",
+            "prompt": "Review {{ inputs.file }} for security issues",
+        }
+        result = step.execute(config, ctx)
+
+        assert result.status == StepStatus.COMPLETED
+        assert result.output["dry_run"] is True
+        assert result.output["executed"] is False
+        assert result.output["dispatched"] is False
+        assert result.output["exit_code"] == 0
+        # The dry-run preview lives on both message and dry_run_message.
+        assert "DRY RUN" in result.output["message"]
+        assert result.output["dry_run_message"] == result.output["message"]
+        # The rendered prompt must surface in the preview.
+        assert "auth.py" in result.output["message"]
 class TestShellStep:
     """Test the shell step type."""
 
@@ -1556,6 +1695,92 @@ def test_templated_show_file_resolving_to_non_string_is_coerced(self):
         assert result.output["show_file"] == "123"
 
 
+
+
+    def test_dry_run_skips_interactive_gate(self, tmp_path):
+        """Dry-run mode: gate step returns COMPLETED without pausing for user input."""
+        from specify_cli.workflows.steps.gate import GateStep
+        from specify_cli.workflows.base import StepContext, StepStatus
+
+        step = GateStep()
+        ctx = StepContext(dry_run=True)
+        config = {
+            "id": "review",
+            "message": "Review the spec.",
+            "options": ["approve", "reject"],
+            "on_reject": "abort",
+        }
+        result = step.execute(config, ctx)
+        assert result.status == StepStatus.COMPLETED
+        # Dry-run output must be marked so the CLI prints it (mirrors
+        # CommandStep's output['dry_run'] = True contract).
+        assert result.output["dry_run"] is True
+        # The original ``message`` is preserved so downstream
+        # ``{{ steps.<id>.output.message }}`` references still resolve
+        # to the gate prompt; the DRY RUN preview is published on
+        # ``dry_run_message`` for the CLI rendering loop.
+        assert result.output["message"] == "Review the spec."
+        assert "DRY RUN" in result.output["dry_run_message"]
+        assert result.output["choice"] == "approve"
+    def test_dry_run_normalizes_non_list_options(self, tmp_path):
+        """A workflow that bypasses validation may set ``options`` to a
+        non-list (string, dict, scalar).  ``GateStep`` must coerce
+        gracefully instead of indexing into a string or raising."""
+        from specify_cli.workflows.steps.gate import GateStep
+        from specify_cli.workflows.base import StepContext, StepStatus
+
+        step = GateStep()
+        ctx = StepContext(dry_run=True)
+        for bad_options in (None, "approve,reject", {"approve": True}, 42, ""):
+            config = {
+                "id": "review",
+                "message": "Review the spec.",
+                "options": bad_options,
+            }
+            result = step.execute(config, ctx)
+            assert result.status == StepStatus.COMPLETED
+            assert result.output["options"] == []
+            assert result.output["choice"] is None
+    def test_dry_run_accepts_tuple_options(self, tmp_path):
+        """``options`` may be a tuple (Sequence but not list).  GateStep
+        should accept any non-str Sequence, not just list."""
+        from specify_cli.workflows.steps.gate import GateStep
+        from specify_cli.workflows.base import StepContext, StepStatus
+
+        step = GateStep()
+        ctx = StepContext(dry_run=True)
+        config = {
+            "id": "review",
+            "message": "Review the spec.",
+            "options": ("approve", "reject"),
+        }
+        result = step.execute(config, ctx)
+        assert result.status == StepStatus.COMPLETED
+        assert result.output["options"] == ["approve", "reject"]
+        assert result.output["choice"] == "approve"
+    def test_dry_run_skips_reject_sentinels_for_choice(self, tmp_path):
+        """In dry-run, ``choice`` should not be a reject/abort sentinel
+        that would unintentionally steer downstream branching."""
+        from specify_cli.workflows.steps.gate import GateStep
+        from specify_cli.workflows.base import StepContext, StepStatus
+
+        step = GateStep()
+        ctx = StepContext(dry_run=True)
+        # First option is the reject sentinel — the dry-run must skip it
+        # and fall through to the first non-sentinel option.
+        config = {
+            "id": "review",
+            "message": "Review the spec.",
+            "options": ["reject", "approve", "skip"],
+        }
+        result = step.execute(config, ctx)
+        assert result.status == StepStatus.COMPLETED
+        assert result.output["choice"] == "approve"
+
+        # All options are sentinels — leave choice as None (neutral).
+        config["options"] = ["reject", "abort"]
+        result = step.execute(config, ctx)
+        assert result.output["choice"] is None
 class TestIfThenStep:
     """Test the if/then/else step type."""
 
@@ -2954,6 +3179,32 @@ def test_while_loop_multi_step_body_inter_step_refs(self, project_dir):
 # "workflow doesn't reference it" backward-compat path.
 
 
+
+
+    def test_dry_run_persisted_in_run_state(self, project_dir):
+        """Dry-run flag must be saved into RunState so resume() can restore it."""
+        from specify_cli.workflows.engine import RunState, WorkflowEngine, WorkflowDefinition
+
+        yaml_str = """
+schema_version: "1.0"
+workflow:
+  id: "dryrun-persist"
+  name: "Dry Run Persist"
+  version: "1.0.0"
+steps:
+  - id: only
+    type: gate
+    message: "Continue?"
+    options: ["yes", "no"]
+"""
+        definition = WorkflowDefinition.from_string(yaml_str)
+        engine = WorkflowEngine(project_dir)
+        state = engine.execute(definition, dry_run=True, run_id="dr-persist")
+
+        assert state.dry_run is True
+
+        reloaded = RunState.load("dr-persist", project_dir)
+        assert reloaded.dry_run is True
 class TestContextRunId:
     """End-to-end tests for `{{ context.run_id }}` in workflow YAML."""