fix(presets): match dependency remediation to the reason, and flag disabled

Addresses review feedback on #4250.

`specify extension add <id>` refuses an already-installed extension without
--force, so suggesting it for a version mismatch handed the user a command
that could only fail. Suggest `extension update` for a version mismatch and
`extension enable` for a disabled one, keeping `add` for a genuinely missing
extension.

A disabled extension was also treated as satisfied, because the registry entry
exists. Resolution skips disabled extensions, so the preset stays exactly as
inert as if the extension were absent, with no warning to explain it. Report
it as a distinct "disabled" reason, ahead of any version check -- enabling is
the prerequisite, and the version may be fine once it is.

Also correct the closing line, which said the extensions "will do nothing
until they are present" -- inaccurate for a disabled extension, which is
present.

Assisted-by: Claude Code (model: Claude Opus 5, autonomous)

Author: Yash-Chindam

src/specify_cli/presets/__init__.py

@@ -969,8 +969,8 @@ def find_unmet_extension_dependencies(
             One entry per unsatisfied dependency, each with ``id``, the
             requested ``version`` specifier (``None`` when unconstrained), the
             ``installed`` version (``None`` when absent), and a ``reason`` of
-            either ``"missing"`` or ``"version"``. Optional dependencies
-            (``required: false``) are never reported.
+            ``"missing"``, ``"disabled"``, or ``"version"``. Optional
+            dependencies (``required: false``) are never reported.
         """
         # Defense in depth, mirroring check_compatibility(): this method is
         # public and also reachable with a hand-built manifest object that
@@ -995,18 +995,35 @@ def find_unmet_extension_dependencies(
                 unmet.append({**dep, "installed": None, "reason": "missing"})
                 continue
 
+            installed_version = metadata.get("version")
+            installed_version = (
+                installed_version if isinstance(installed_version, str) else None
+            )
+
+            # A disabled extension is registered but contributes nothing:
+            # resolution skips it (see _collect_extension_layers), so the
+            # preset is just as inert as if it were absent. Report it before
+            # any version check -- enabling it is the prerequisite, and the
+            # version may well be fine once it is.
+            if not metadata.get("enabled", True):
+                unmet.append(
+                    {**dep, "installed": installed_version, "reason": "disabled"}
+                )
+                continue
+
             constraint = dep["version"]
             if not constraint:
                 continue
 
-            installed = metadata.get("version")
-            if not isinstance(installed, str):
+            if installed_version is None:
                 # A registry entry without a usable version cannot be compared.
                 # Treat it as satisfied rather than inventing a failure, since
-                # the extension is demonstrably installed.
+                # the extension is demonstrably installed and enabled.
                 continue
-            if not version_satisfies(installed, constraint):
-                unmet.append({**dep, "installed": installed, "reason": "version"})
+            if not version_satisfies(installed_version, constraint):
+                unmet.append(
+                    {**dep, "installed": installed_version, "reason": "version"}
+                )
 
         return unmet
 

src/specify_cli/presets/_commands.py

@@ -57,19 +57,28 @@ def _warn_unmet_extension_dependencies(manager, manifest) -> None:
     console.print("[yellow]![/yellow]  This preset depends on extensions that are not satisfied:")
     for dep in unmet:
         extension_id = _escape_markup(dep["id"])
-        if dep["reason"] == "missing":
+        reason = dep["reason"]
+        # The remediation has to match the reason. `extension add` refuses an
+        # already-installed extension without --force, so suggesting it for a
+        # disabled or out-of-date one would hand the user a command that fails.
+        if reason == "missing":
             console.print(f"    [yellow]{extension_id}[/yellow] is not installed")
+            remedy = f"specify extension add {extension_id}"
+        elif reason == "disabled":
+            console.print(f"    [yellow]{extension_id}[/yellow] is installed but disabled")
+            remedy = f"specify extension enable {extension_id}"
         else:
             console.print(
                 f"    [yellow]{extension_id}[/yellow] "
                 f"{_escape_markup(dep['installed'])} does not satisfy "
                 f"{_escape_markup(dep['version'])}"
             )
-        console.print(f"      Install with: specify extension add {extension_id}")
+            remedy = f"specify extension update {extension_id}"
+        console.print(f"      Fix with: {remedy}")
     console.print()
     console.print(
         "[dim]The preset is installed and safe to use; the parts that rely on "
-        "these extensions will do nothing until they are present.[/dim]"
+        "these extensions will do nothing until this is resolved.[/dim]"
     )
 
 

tests/test_presets.py

@@ -1158,15 +1158,15 @@ class TestPresetExtensionDependencies:
     """Test find_unmet_extension_dependencies (issue #4231)."""
 
     @staticmethod
-    def _install_extension(project_dir, extension_id, version):
+    def _install_extension(project_dir, extension_id, version, enabled=True):
         """Register an installed extension the way the extension installer does."""
         extensions_dir = project_dir / ".specify" / "extensions"
         extensions_dir.mkdir(parents=True, exist_ok=True)
         registry_path = extensions_dir / ".registry"
         data = {"schema_version": "1.0", "extensions": {}}
         if registry_path.exists():
             data = json.loads(registry_path.read_text(encoding="utf-8"))
-        data["extensions"][extension_id] = {"version": version, "enabled": True}
+        data["extensions"][extension_id] = {"version": version, "enabled": enabled}
         registry_path.write_text(json.dumps(data), encoding="utf-8")
 
     @staticmethod
@@ -1278,19 +1278,60 @@ def test_registry_entry_without_version_is_not_a_failure(
             manifest
         ) == []
 
+    def test_disabled_dependency_is_reported(
+        self, project_dir, temp_dir, valid_pack_data
+    ):
+        """A disabled extension contributes nothing, so it counts as unmet.
+
+        Resolution skips disabled extensions, leaving the preset just as inert
+        as if the extension were absent -- but the registry entry exists, so a
+        presence-only check would call it satisfied and stay silent.
+        """
+        self._install_extension(project_dir, "speckit-inventory", "0.1.0", enabled=False)
+        manifest = self._manifest(temp_dir, valid_pack_data, ["speckit-inventory"])
+
+        unmet = PresetManager(project_dir).find_unmet_extension_dependencies(manifest)
+
+        assert len(unmet) == 1
+        assert unmet[0]["reason"] == "disabled"
+        assert unmet[0]["installed"] == "0.1.0"
+
+    def test_disabled_is_reported_ahead_of_version_mismatch(
+        self, project_dir, temp_dir, valid_pack_data
+    ):
+        """Enabling is the prerequisite, so it is reported before the version."""
+        self._install_extension(project_dir, "speckit-inventory", "0.1.0", enabled=False)
+        manifest = self._manifest(
+            temp_dir, valid_pack_data,
+            [{"id": "speckit-inventory", "version": ">=9.0.0"}],
+        )
+
+        unmet = PresetManager(project_dir).find_unmet_extension_dependencies(manifest)
+
+        assert [dep["reason"] for dep in unmet] == ["disabled"]
+
     def test_multiple_dependencies_report_independently(
         self, project_dir, temp_dir, valid_pack_data
     ):
         """Each declared dependency is evaluated on its own."""
         self._install_extension(project_dir, "present-ext", "1.0.0")
+        self._install_extension(project_dir, "off-ext", "1.0.0", enabled=False)
         manifest = self._manifest(
             temp_dir, valid_pack_data,
-            ["present-ext", "absent-ext", {"id": "opt-ext", "required": False}],
+            [
+                "present-ext",
+                "absent-ext",
+                "off-ext",
+                {"id": "opt-ext", "required": False},
+            ],
         )
 
         unmet = PresetManager(project_dir).find_unmet_extension_dependencies(manifest)
 
-        assert [dep["id"] for dep in unmet] == ["absent-ext"]
+        assert [(dep["id"], dep["reason"]) for dep in unmet] == [
+            ("absent-ext", "missing"),
+            ("off-ext", "disabled"),
+        ]
 
 
 class TestRegistryPriority: