refactor: allow workflow run without project when given a YAML file path

Instead of adding --workflow to init, make `specify workflow run ./file.yml`
work without requiring a .specify/ project directory. When the source is a
YAML file that exists on disk, cwd is used as the project root. When it's a
workflow ID, the .specify/ project requirement is preserved.

Author: Copilot

src/specify_cli/__init__.py

@@ -2727,7 +2727,16 @@ def workflow_run(
     """Run a workflow from an installed ID or local YAML path."""
     from .workflows.engine import WorkflowEngine
 
-    project_root = _require_specify_project()
+    source_path = Path(source)
+    is_file_source = source_path.suffix in (".yml", ".yaml") and source_path.exists()
+
+    if is_file_source:
+        # When running a YAML file directly, use cwd as project root
+        # without requiring a .specify/ project directory.
+        project_root = Path.cwd()
+    else:
+        project_root = _require_specify_project()
+
     engine = WorkflowEngine(project_root)
     engine.on_step_start = lambda sid, label: console.print(f"  \u25b8 [{sid}] {label} \u2026")
 

src/specify_cli/commands/init.py

@@ -113,7 +113,6 @@ def init(
         branch_numbering: str = typer.Option(None, "--branch-numbering", help="Branch numbering strategy: 'sequential' (001, 002, …, 1000, … — expands past 999 automatically) or 'timestamp' (YYYYMMDD-HHMMSS)"),
         integration: str = typer.Option(None, "--integration", help="Use the new integration system (e.g. --integration copilot). Mutually exclusive with --ai."),
         integration_options: str = typer.Option(None, "--integration-options", help='Options for the integration (e.g. --integration-options="--commands-dir .myagent/cmds")'),
-        workflow: str = typer.Option(None, "--workflow", help="Run a workflow YAML file after project initialization"),
     ):
         """
         Initialize a new Specify project.
@@ -674,45 +673,6 @@ def init(
         console.print(tracker.render())
         console.print("\n[bold green]Project ready.[/bold green]")
 
-        if workflow:
-            workflow_path = Path(workflow)
-            if not workflow_path.is_absolute():
-                workflow_path = Path.cwd() / workflow_path
-            if not workflow_path.exists():
-                console.print(f"[red]Error:[/red] Workflow file not found: {workflow}")
-                raise typer.Exit(1)
-            console.print(f"\n[bold cyan]Running post-init workflow:[/bold cyan] {workflow}")
-            try:
-                from ..workflows.engine import WorkflowEngine
-                engine = WorkflowEngine(project_path)
-                engine.on_step_start = lambda sid, label: console.print(f"  ▸ [{sid}] {label} …")
-                definition = engine.load_workflow(str(workflow_path))
-                errors = engine.validate(definition)
-                if errors:
-                    console.print("[red]Workflow validation failed:[/red]")
-                    for err in errors:
-                        console.print(f"  • {err}")
-                    raise typer.Exit(1)
-                state = engine.execute(definition)
-                status_colors = {
-                    "completed": "green",
-                    "paused": "yellow",
-                    "failed": "red",
-                    "aborted": "red",
-                }
-                color = status_colors.get(state.status.value, "white")
-                console.print(f"\n[{color}]Workflow status: {state.status.value}[/{color}]")
-                if state.status.value == "paused":
-                    console.print(f"\nResume with: [cyan]specify workflow resume {state.run_id}[/cyan]")
-                elif state.status.value in ("failed", "aborted"):
-                    console.print("[red]Post-init workflow did not complete successfully.[/red]")
-                    raise typer.Exit(1)
-            except (typer.Exit, SystemExit):
-                raise
-            except Exception as wf_exc:
-                console.print(f"[red]Post-init workflow failed:[/red] {wf_exc}")
-                raise typer.Exit(1)
-
         agent_config = AGENT_CONFIG.get(selected_ai)
         if agent_config:
             agent_folder = ai_commands_dir if selected_ai == "generic" else agent_config["folder"]

tests/test_init_workflow.py

@@ -0,0 +1,120 @@
+"""Tests for running workflow YAML files without a project."""
+
+import os
+
+import yaml
+
+
+class TestWorkflowRunWithoutProject:
+    """Tests that specify workflow run works with YAML files without .specify/ dir."""
+
+    def test_workflow_run_yaml_without_project(self, tmp_path):
+        """Running a .yml file should work without a .specify/ directory."""
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        runner = CliRunner()
+
+        # Create a minimal workflow YAML with a shell step
+        workflow_file = tmp_path / "test-workflow.yml"
+        workflow_content = {
+            "schema_version": "1.0",
+            "workflow": {
+                "id": "standalone-test",
+                "name": "Standalone Test",
+                "version": "1.0.0",
+                "description": "A workflow that runs without a project",
+            },
+            "steps": [
+                {
+                    "id": "create-marker",
+                    "type": "shell",
+                    "run": "echo done > marker.txt",
+                },
+            ],
+        }
+        workflow_file.write_text(yaml.dump(workflow_content), encoding="utf-8")
+
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(tmp_path)
+            result = runner.invoke(app, [
+                "workflow", "run", str(workflow_file),
+            ], catch_exceptions=False)
+        finally:
+            os.chdir(old_cwd)
+        assert result.exit_code == 0, f"workflow run failed: {result.output}"
+        assert "completed" in result.output
+        assert (tmp_path / "marker.txt").exists()
+
+    def test_workflow_run_id_still_requires_project(self, tmp_path):
+        """Running a workflow by ID should still require a .specify/ directory."""
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        runner = CliRunner()
+
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(tmp_path)
+            result = runner.invoke(app, [
+                "workflow", "run", "some-workflow-id",
+            ], catch_exceptions=False)
+        finally:
+            os.chdir(old_cwd)
+        assert result.exit_code != 0
+        assert "Not a spec-kit project" in result.output
+
+    def test_workflow_run_missing_yaml_file(self, tmp_path):
+        """Running a non-existent .yml file should still require a project."""
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        runner = CliRunner()
+
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(tmp_path)
+            result = runner.invoke(app, [
+                "workflow", "run", "nonexistent.yml",
+            ], catch_exceptions=False)
+        finally:
+            os.chdir(old_cwd)
+        # non-existent .yml files fall through to project check or file-not-found
+        assert result.exit_code != 0
+
+    def test_workflow_run_failing_yaml_without_project(self, tmp_path):
+        """A failing workflow YAML should report failure status."""
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        runner = CliRunner()
+
+        workflow_file = tmp_path / "fail-workflow.yml"
+        workflow_content = {
+            "schema_version": "1.0",
+            "workflow": {
+                "id": "fail-test",
+                "name": "Fail Test",
+                "version": "1.0.0",
+                "description": "A workflow that fails",
+            },
+            "steps": [
+                {
+                    "id": "fail-step",
+                    "type": "shell",
+                    "run": "exit 1",
+                },
+            ],
+        }
+        workflow_file.write_text(yaml.dump(workflow_content), encoding="utf-8")
+
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(tmp_path)
+            result = runner.invoke(app, [
+                "workflow", "run", str(workflow_file),
+            ], catch_exceptions=False)
+        finally:
+            os.chdir(old_cwd)
+        assert "failed" in result.output.lower()