fix(workflows): address Copilot review feedback on integration auto-detect

Issue 1 (engine.py:726): Explicit --input integration=auto was rejected by
enum validation before the sentinel could be resolved. Move the auto-resolution
to before _coerce_input() so enum-constrained inputs also accept 'auto'.

Issue 2 (engine.py:737): workflow.integration: auto in the YAML was stored
raw as 'auto' in WorkflowDefinition.default_integration and leaked into
StepContext, causing step dispatch to look for an 'auto' CLI. Add
_resolve_workflow_integration() helper and use it at both StepContext
construction sites.

Issue 3 (engine.py:779): _load_project_integration() only queried the legacy
'integration' field. Newer state files may carry 'default_integration' as the
canonical key. Replace the custom inner reader for integration.json with a
call to the shared default_integration_key() from integration_state, which
handles both fields and their precedence correctly.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Markus

src/specify_cli/workflows/engine.py

@@ -20,7 +20,10 @@
 import yaml
 
 from .base import RunStatus, StepContext, StepResult, StepStatus
-from specify_cli.integration_state import INTEGRATION_JSON as _INTEGRATION_JSON
+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
 
 
@@ -426,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),
@@ -474,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),
@@ -713,17 +720,18 @@ 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] = self._resolve_default(name, input_def["default"])
             elif input_def.get("required", False):
                 msg = f"Required input {name!r} not provided."
                 raise ValueError(msg)
-        # Also resolve "auto" sentinel when explicitly supplied by the caller
-        if resolved.get("integration") == "auto":
-            resolved["integration"] = self._resolve_default("integration", "auto")
         return resolved
 
     def _resolve_default(self, name: str, default: Any) -> Any:
@@ -737,6 +745,18 @@ def _resolve_default(self, name: str, default: Any) -> Any:
             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.
 
@@ -747,7 +767,8 @@ def _load_project_integration(self) -> str:
         contains a valid non-empty integration key.
         """
 
-        def _read_integration(path: Path, *keys: str) -> str | None:
+        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:
@@ -760,17 +781,26 @@ def _read_integration(path: Path, *keys: str) -> str | None:
                 value = data.get(key)
                 if isinstance(value, str):
                     value = value.strip()
-                    if value and value != "auto":  # skip "auto" to avoid circular resolution
+                    if value and value != "auto":
                         return value
             return None
 
-        integration = _read_integration(
-            self.project_root / _INTEGRATION_JSON, "integration"
-        )
-        if integration is not None:
-            return integration
-
-        integration = _read_integration(
+        # 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",

tests/test_workflows.py

@@ -2022,3 +2022,67 @@ def test_integration_auto_integration_json_takes_priority(self, project_dir):
         )
         engine = WorkflowEngine(project_dir)
         assert engine._load_project_integration() == "gemini"
+
+    def test_integration_explicit_auto_with_enum_constraint(self, project_dir):
+        """Explicit --input integration=auto works even when enum excludes 'auto'.
+
+        Issue: enum validation in _coerce_input() ran before the auto-sentinel
+        was resolved, so enum: [claude, copilot] rejected the 'auto' value.
+        """
+        from specify_cli.workflows.engine import WorkflowEngine, WorkflowDefinition
+
+        (project_dir / ".specify" / "integration.json").write_text(
+            '{"integration": "claude"}', encoding="utf-8"
+        )
+        engine = WorkflowEngine(project_dir)
+        yaml_str = """
+schema_version: "1.0"
+workflow:
+  id: "enum-auto-test"
+  name: "Enum Auto Test"
+  version: "1.0.0"
+inputs:
+  integration:
+    type: string
+    enum: ["claude", "copilot"]
+    default: "auto"
+steps:
+  - id: echo
+    type: shell
+    run: "echo {{ inputs.integration }}"
+"""
+        definition = WorkflowDefinition.from_string(yaml_str)
+        # Explicit "auto" must resolve to "claude" without raising on the enum
+        resolved = engine._resolve_inputs(definition, {"integration": "auto"})
+        assert resolved["integration"] == "claude"
+
+    def test_workflow_level_integration_auto_resolves_in_context(self, project_dir):
+        """workflow.integration: auto is resolved before reaching StepContext.
+
+        Issue: definition.default_integration was passed raw as 'auto' into
+        StepContext, causing step dispatch to look for an 'auto' CLI.
+        """
+        from specify_cli.workflows.engine import WorkflowEngine
+
+        (project_dir / ".specify" / "integration.json").write_text(
+            '{"integration": "opencode"}', encoding="utf-8"
+        )
+        engine = WorkflowEngine(project_dir)
+        resolved = engine._resolve_workflow_integration("auto")
+        assert resolved == "opencode"
+
+    def test_integration_auto_reads_default_integration_field(self, project_dir):
+        """integration.json with 'default_integration' key is resolved correctly.
+
+        Issue: _load_project_integration() only queried the legacy 'integration'
+        field; state files written with the newer 'default_integration' field
+        (as produced by default_integration_key()) were silently ignored.
+        """
+        from specify_cli.workflows.engine import WorkflowEngine
+
+        (project_dir / ".specify" / "integration.json").write_text(
+            '{"default_integration": "gemini", "integration_state_schema": 1}',
+            encoding="utf-8",
+        )
+        engine = WorkflowEngine(project_dir)
+        assert engine._load_project_integration() == "gemini"