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

src/specify_cli/workflows/engine.py

@@ -82,6 +82,8 @@ def from_string(cls, content: str) -> WorkflowDefinition:
 # ID format: lowercase alphanumeric with hyphens
 _ID_PATTERN = re.compile(r"^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$")
 
+_INTEGRATION_JSON = ".specify/integration.json"
+
 # Valid step types (matching STEP_REGISTRY keys)
 def _get_valid_step_types() -> set[str]:
     """Return valid step types from the registry, with a built-in fallback."""
@@ -715,12 +717,49 @@ def _resolve_inputs(
                     name, provided[name], input_def
                 )
             elif "default" in input_def:
-                resolved[name] = input_def["default"]
+                resolved[name] = self._resolve_default(name, input_def["default"])
             elif input_def.get("required", False):
                 msg = f"Required input {name!r} not provided."
                 raise ValueError(msg)
+
+        if resolved.get("integration") == "auto":
+            resolved["integration"] = self._load_project_integration()
         return resolved
 
+    def _resolve_default(self, name: str, default: Any) -> Any:
+        """Resolve special default sentinels against project state.
+
+        For the ``integration`` input, ``"auto"`` resolves to the integration
+        recorded in ``.specify/integration.json`` so workflows dispatch to the
+        AI the project was actually initialized with.
+        """
+        if name == "integration" and default == "auto":
+            return self._load_project_integration()
+        return default
+
+    def _load_project_integration(self) -> str:
+        """Read the active integration key from ``.specify/integration.json``.
+
+        Returns the stored integration string, or ``"copilot"`` when the file is
+        missing, unreadable, or does not contain a valid non-empty key.
+        The ``"copilot"`` fallback preserves backwards compatibility for projects
+        that predate the introduction of ``.specify/integration.json``.
+        """
+        path = self.project_root / _INTEGRATION_JSON
+        if not path.is_file():
+            return "copilot"
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+            return "copilot"
+        if isinstance(data, dict):
+            value = data.get("integration")
+            if isinstance(value, str):
+                value = value.strip()
+                if value and value != "auto":
+                    return value
+        return "copilot"
+
     @staticmethod
     def _coerce_input(
         name: str, value: Any, input_def: dict[str, Any]

tests/test_workflows.py

@@ -1843,3 +1843,174 @@ 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
+
+
+# ---------------------------------------------------------------------------
+# Integration auto-detection tests
+# ---------------------------------------------------------------------------
+
+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_integration_auto_default_uses_project_integration(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
+
+        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)
+
+        step_output = state.step_results["specify"]["output"]
+        assert step_output["integration"] == "opencode"
+
+    def test_integration_auto_default_falls_back_to_copilot_when_no_json(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
+
+        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_integration_explicit_input_overrides_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
+
+        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_integration_explicit_auto_uses_project_integration(self, project_dir):
+        """Explicit --input integration=auto resolves from integration.json."""
+        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({"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": "auto"})
+
+        step_output = state.step_results["specify"]["output"]
+        assert step_output["integration"] == "opencode"
+
+    def test_integration_auto_ignores_malformed_integration_json(self, project_dir):
+        """When integration.json contains invalid JSON, 'auto' falls 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("{invalid json content", 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"
+
+    def test_integration_auto_falls_back_on_oserror(self, project_dir):
+        """When integration.json is unreadable (OSError), 'auto' falls 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({"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
+            ),
+            patch.object(Path, "read_text", side_effect=OSError("Permission denied")),
+        ):
+            state = engine.execute(definition)
+
+        step_output = state.step_results["specify"]["output"]
+        assert step_output["integration"] == "copilot"
+
+    def test_integration_auto_ignores_whitespace_only_value(self, project_dir):
+        """When integration.json has a whitespace-only value, 'auto' falls 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({"integration": "   "}), 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

@@ -8,8 +8,6 @@ workflow:
 
 requires:
   speckit_version: ">=0.7.2"
-  integrations:
-    any: ["copilot", "claude", "gemini"]
 
 inputs:
   spec:
@@ -18,8 +16,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, opencode, or 'auto' to detect from project config)"
   scope:
     type: string
     default: "full"