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

src/specify_cli/__init__.py

@@ -43,6 +43,7 @@
 
 from packaging.version import InvalidVersion, Version
 from typing import Any, Optional
+from specify_cli.paths import INIT_OPTIONS_FILE
 
 import typer
 from rich.console import Console
@@ -901,10 +902,6 @@ def ensure_constitution_from_template(project_path: Path, tracker: StepTracker |
         else:
             console.print(f"[yellow]Warning: Could not initialize constitution: {e}[/yellow]")
 
-
-INIT_OPTIONS_FILE = ".specify/init-options.json"
-
-
 def save_init_options(project_path: Path, options: dict[str, Any]) -> None:
     """Persist the CLI options used during ``specify init``.
 
@@ -1298,7 +1295,6 @@ def init(
                 raw_options=integration_options,
             )
             manifest.save()
-
             integration_settings = _with_integration_setting(
                 {},
                 resolved_integration.key,
@@ -1922,8 +1918,6 @@ def get_speckit_version() -> str:
     add_completion=False,
 )
 integration_app.add_typer(integration_catalog_app, name="catalog")
-
-
 def _read_integration_json(project_root: Path) -> dict[str, Any]:
     """Load ``.specify/integration.json``. Returns normalized state when present."""
     path = project_root / INTEGRATION_JSON

src/specify_cli/paths.py

@@ -0,0 +1,8 @@
+"""Shared path constants for specify_cli.
+
+This module is intentionally dependency-free (no typer, no rich, no workflows)
+so it can be safely imported from anywhere in the package without side effects.
+"""
+
+SPECIFY_DIR = ".specify"
+INIT_OPTIONS_FILE = f"{SPECIFY_DIR}/init-options.json"

src/specify_cli/workflows/engine.py

@@ -20,6 +20,11 @@
 import yaml
 
 from .base import RunStatus, StepContext, StepResult, StepStatus
+from specify_cli.integration_state import (
+    INTEGRATION_JSON as _INTEGRATION_JSON,
+    default_integration_key as _default_integration_key,
+)
+from specify_cli.paths import INIT_OPTIONS_FILE as _INIT_OPTIONS_FILE
 
 
 # -- Workflow Definition --------------------------------------------------
@@ -424,7 +429,9 @@ def execute(
 
         context = StepContext(
             inputs=resolved_inputs,
-            default_integration=definition.default_integration,
+            default_integration=self._resolve_workflow_integration(
+                definition.default_integration
+            ),
             default_model=definition.default_model,
             default_options=definition.default_options,
             project_root=str(self.project_root),
@@ -472,7 +479,9 @@ def resume(self, run_id: str) -> RunState:
         context = StepContext(
             inputs=state.inputs,
             steps=state.step_results,
-            default_integration=definition.default_integration,
+            default_integration=self._resolve_workflow_integration(
+                definition.default_integration
+            ),
             default_model=definition.default_model,
             default_options=definition.default_options,
             project_root=str(self.project_root),
@@ -711,16 +720,96 @@ def _resolve_inputs(
             if not isinstance(input_def, dict):
                 continue
             if name in provided:
-                resolved[name] = self._coerce_input(
-                    name, provided[name], input_def
-                )
+                value = provided[name]
+                # Resolve "auto" sentinel before enum validation so workflows
+                # with a constrained enum (e.g. enum: [claude, copilot]) don't
+                # reject the sentinel before it can be expanded.
+                if name == "integration" and value == "auto":
+                    value = self._resolve_default(name, value)
+                resolved[name] = self._coerce_input(name, value, 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)
         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 project metadata 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 _resolve_workflow_integration(self, integration: str | None) -> str | None:
+        """Resolve the workflow-level integration sentinel.
+
+        If the workflow YAML sets ``workflow.integration: auto``, the string
+        ``"auto"`` is stored in ``WorkflowDefinition.default_integration``.
+        This helper expands that sentinel to the project integration so it
+        never leaks into ``StepContext`` or step dispatch.
+        """
+        if integration == "auto":
+            return self._resolve_default("integration", "auto")
+        return integration
+
+    def _load_project_integration(self) -> str:
+        """Read the active integration key from project metadata.
+
+        The primary source is ``.specify/integration.json``. If that file is
+        missing or invalid, fall back to ``.specify/init-options.json`` for
+        older projects or partially migrated state, checking ``integration``
+        first and then ``ai``. Returns ``"copilot"`` only when neither source
+        contains a valid non-empty integration key.
+        """
+
+        def _read_init_options(path: Path, *keys: str) -> str | None:
+            """Read a key from a legacy init-options JSON file."""
+            if not path.is_file():
+                return None
+            try:
+                data = json.loads(path.read_text(encoding="utf-8"))
+            except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+                return None
+            if not isinstance(data, dict):
+                return None
+            for key in keys:
+                value = data.get(key)
+                if isinstance(value, str):
+                    value = value.strip()
+                    if value and value != "auto":
+                        return value
+            return None
+
+        # Primary source: .specify/integration.json — use the shared normalized
+        # reader so both "integration" and "default_integration" fields are
+        # handled and future schema versions are respected.
+        json_path = self.project_root / _INTEGRATION_JSON
+        if json_path.is_file():
+            try:
+                data = json.loads(json_path.read_text(encoding="utf-8"))
+            except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+                data = None
+            if isinstance(data, dict):
+                key = _default_integration_key(data)
+                if key and key != "auto":
+                    return key
+
+        # Secondary source: .specify/init-options.json for older projects.
+        integration = _read_init_options(
+            self.project_root / _INIT_OPTIONS_FILE,
+            "integration",
+            "ai",
+        )
+        if integration is not None:
+            return integration
+
+        return "copilot"
+
     @staticmethod
     def _coerce_input(
         name: str, value: Any, input_def: dict[str, Any]