fix(workflows): auto-detect project integration instead of hardcoding copilot default

CHANGELOG.md

@@ -2,6 +2,12 @@
 
 <!-- insert new changelog below this comment -->
 
+## [Unreleased]
+
+### Fixed
+
+- fix(workflows): auto-detect project integration instead of hardcoding copilot default (#2406)
+
 ## [0.8.2] - 2026-04-28
 
 ### Changed

src/specify_cli/workflows/engine.py

@@ -719,8 +719,36 @@ def _resolve_inputs(
             elif input_def.get("required", False):
                 msg = f"Required input {name!r} not provided."
                 raise ValueError(msg)
+
+        # Auto-detect integration from project config when set to "auto"
+        if resolved.get("integration") == "auto":
+            resolved["integration"] = self._resolve_integration_auto()
+
         return resolved
 
+    _INTEGRATION_JSON = ".specify/integration.json"
+    _AUTO_FALLBACK = "copilot"
+
+    def _resolve_integration_auto(self) -> str:
+        """Read the project integration from ``.specify/integration.json``.
+
+        Returns the stored integration key, or ``"copilot"`` when the
+        file is missing, unreadable, or does not contain a valid key.
+        This method is intentionally decoupled from the CLI layer
+        (no ``typer.Exit`` / ``console.print``) so the engine remains
+        independently testable.
+        """
+        path = self.project_root / self._INTEGRATION_JSON
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            return self._AUTO_FALLBACK
+        if isinstance(data, dict):
+            value = data.get("integration")
+            if isinstance(value, str) and value:
+                return value
+        return self._AUTO_FALLBACK
+
     @staticmethod
     def _coerce_input(
         name: str, value: Any, input_def: dict[str, Any]

tests/test_workflows.py

@@ -1843,3 +1843,107 @@ def test_switch_workflow(self, project_dir):
         assert state.status == RunStatus.COMPLETED
         assert "do-plan" in state.step_results
         assert "do-specify" not in state.step_results
+
+
+class TestIntegrationAutoDetect:
+    """Test auto-detection of project integration from .specify/integration.json.
+
+    When workflow inputs specify ``default: "auto"`` for the integration
+    input, the engine should resolve it by reading the project's
+    ``.specify/integration.json`` instead of hardcoding ``"copilot"``.
+
+    Regression tests for https://github.com/github/spec-kit/issues/2406.
+    """
+
+    @staticmethod
+    def _make_workflow_yaml(default_integration: str = "auto") -> str:
+        return f"""
+schema_version: "1.0"
+workflow:
+  id: "auto-test"
+  name: "Auto Test"
+  version: "1.0.0"
+inputs:
+  spec:
+    type: string
+    default: "build login"
+  integration:
+    type: string
+    default: "{default_integration}"
+steps:
+  - id: specify
+    command: speckit.specify
+    integration: "{{{{ inputs.integration }}}}"
+    input:
+      args: "{{{{ inputs.spec }}}}"
+"""
+
+    def test_resolve_inputs_auto_reads_integration_json(self, project_dir):
+        """'auto' default resolves to the integration in .specify/integration.json."""
+        from unittest.mock import patch
+        from specify_cli.workflows.engine import WorkflowEngine, WorkflowDefinition
+        from specify_cli.workflows.base import StepStatus
+
+        # Write integration.json with opencode
+        int_json = project_dir / ".specify" / "integration.json"
+        int_json.write_text(json.dumps({"integration": "opencode"}), encoding="utf-8")
+
+        definition = WorkflowDefinition.from_string(self._make_workflow_yaml())
+        engine = WorkflowEngine(project_dir)
+
+        with patch("specify_cli.workflows.steps.command.shutil.which", return_value=None):
+            state = engine.execute(definition)
+
+        # The resolved integration should be "opencode", not "auto" or "copilot"
+        step_output = state.step_results["specify"]["output"]
+        assert step_output["integration"] == "opencode"
+
+    def test_resolve_inputs_auto_no_json_falls_back_to_copilot(self, project_dir):
+        """When no integration.json exists, 'auto' falls back to 'copilot'."""
+        from unittest.mock import patch
+        from specify_cli.workflows.engine import WorkflowEngine, WorkflowDefinition
+
+        # No integration.json exists in the project_dir fixture
+        definition = WorkflowDefinition.from_string(self._make_workflow_yaml())
+        engine = WorkflowEngine(project_dir)
+
+        with patch("specify_cli.workflows.steps.command.shutil.which", return_value=None):
+            state = engine.execute(definition)
+
+        step_output = state.step_results["specify"]["output"]
+        assert step_output["integration"] == "copilot"
+
+    def test_resolve_inputs_explicit_override_ignores_auto(self, project_dir):
+        """Explicit --input integration=gemini takes precedence over auto."""
+        from unittest.mock import patch
+        from specify_cli.workflows.engine import WorkflowEngine, WorkflowDefinition
+
+        # Write integration.json with opencode (should be ignored)
+        int_json = project_dir / ".specify" / "integration.json"
+        int_json.write_text(json.dumps({"integration": "opencode"}), encoding="utf-8")
+
+        definition = WorkflowDefinition.from_string(self._make_workflow_yaml())
+        engine = WorkflowEngine(project_dir)
+
+        with patch("specify_cli.workflows.steps.command.shutil.which", return_value=None):
+            state = engine.execute(definition, {"integration": "gemini"})
+
+        step_output = state.step_results["specify"]["output"]
+        assert step_output["integration"] == "gemini"
+
+    def test_resolve_inputs_auto_with_empty_json(self, project_dir):
+        """When integration.json has no 'integration' key, fall back to 'copilot'."""
+        from unittest.mock import patch
+        from specify_cli.workflows.engine import WorkflowEngine, WorkflowDefinition
+
+        int_json = project_dir / ".specify" / "integration.json"
+        int_json.write_text(json.dumps({"version": "1.0"}), encoding="utf-8")
+
+        definition = WorkflowDefinition.from_string(self._make_workflow_yaml())
+        engine = WorkflowEngine(project_dir)
+
+        with patch("specify_cli.workflows.steps.command.shutil.which", return_value=None):
+            state = engine.execute(definition)
+
+        step_output = state.step_results["specify"]["output"]
+        assert step_output["integration"] == "copilot"

workflows/speckit/workflow.yml

@@ -18,8 +18,8 @@ inputs:
     prompt: "Describe what you want to build"
   integration:
     type: string
-    default: "copilot"
-    prompt: "Integration to use (e.g. claude, copilot, gemini)"
+    default: "auto"
+    prompt: "Integration to use (e.g. claude, copilot, gemini, or 'auto' to detect from project config)"
   scope:
     type: string
     default: "full"