fix: render extension skills for target agent, not just active agent (#2948)

Extension skill rendering was previously scoped only to the active
agent (init-options.json's 'ai' field), even when
register_enabled_extensions_for_agent was called for a different,
non-active agent (e.g. after 'integration install <agent>
--skills' or 'integration upgrade <agent>' for a secondary
integration). This meant a skills-mode agent that wasn't the
active one received command files instead of skills.

Changes:
- Add is_agent_skills_enabled() in _init_options.py: resolves
  per-agent skills-mode from .specify/integration.json's
  integration_settings[agent].parsed_options.skills, falling back
  to the legacy global init-options ai_skills flag for the active
  agent.
- ExtensionManager._get_skills_dir() now accepts an optional
  agent_name and resolves the skills directory for that specific
  agent instead of always using the active agent.
- ExtensionManager._register_extension_skills() now accepts and
  threads through agent_name.
- register_enabled_extensions_for_agent() now computes
  skills_mode_active per the target agent_name (not the active
  agent), and always attempts skill registration for that agent
  (matching the prior best-effort error handling), while still
  skipping duplicate command-file registration when the target is
  in skills mode.

Verified manually: 'specify integration upgrade copilot --force'
with a non-active, skills-mode Copilot integration now renders
.github/skills/speckit-git-*/SKILL.md files instead of command
files, with no change to the active agent's own skills.

Test suite: 616/616 extension-related tests pass. Full suite has
44 pre-existing failures unrelated to this change (Windows
symlink-privilege and PowerShell path-resolution issues,
confirmed present on main via git stash).

Author: Nimraakram12

src/specify_cli/_init_options.py

@@ -34,3 +34,28 @@ def load_init_options(project_path: Path) -> dict[str, Any]:
 def is_ai_skills_enabled(opts: Mapping[str, Any] | None) -> bool:
     """Return True only when init options explicitly enable AI skills."""
     return isinstance(opts, Mapping) and opts.get("ai_skills") is True
+
+
+def is_agent_skills_enabled(project_path: Path, agent_name: str, opts: Mapping[str, Any] | None) -> bool:
+    """Return True when *agent_name* should render extension skills.
+
+    Prefers the per-agent ``skills`` flag recorded in
+    ``.specify/integration.json`` (``integration_settings[agent_name].parsed_options.skills``),
+    which reflects the ``--skills`` option passed to that specific agent's
+    install/upgrade/switch. Falls back to the legacy global
+    ``init-options.json`` ``ai_skills`` flag only when *agent_name* is the
+    active agent recorded there (pre-multi-install behaviour).
+    """
+    from .integration_state import try_read_integration_json, integration_setting
+
+    state, _error = try_read_integration_json(project_path)
+    if state:
+        setting = integration_setting(state, agent_name)
+        parsed = setting.get("parsed_options")
+        if isinstance(parsed, Mapping) and "skills" in parsed:
+            return parsed.get("skills") is True
+
+    if isinstance(opts, Mapping) and opts.get("ai") == agent_name:
+        return is_ai_skills_enabled(opts)
+
+    return False

src/specify_cli/extensions/__init__.py

@@ -910,8 +910,15 @@ def _ignore(directory: str, entries: List[str]) -> Set[str]:
 
         return _ignore
 
-    def _get_skills_dir(self) -> Optional[Path]:
-        """Return the active skills directory for extension skill registration.
+    def _get_skills_dir(self, agent_name: Optional[str] = None) -> Optional[Path]:
+        """Return the skills directory for extension skill registration.
+
+        When *agent_name* is given, resolves the skills directory and
+        skills-enabled state for that specific agent (using per-agent
+        settings in ``.specify/integration.json``), so skill rendering
+        works correctly for non-active agents (#2948). When omitted,
+        falls back to the previous behaviour of using the active agent
+        from init-options.
 
         Delegates to :func:`resolve_active_skills_dir` which reads
         init-options, applies the Kimi native-skills fallback, and
@@ -926,6 +933,8 @@ def _get_skills_dir(self) -> Optional[Path]:
             load_init_options,
             resolve_active_skills_dir,
         )
+        from .._init_options import is_agent_skills_enabled
+        from .. import _get_skills_dir as resolve_agent_skills_dir
 
         def _ensure_usable(skills_dir: Path) -> Optional[Path]:
             try:
@@ -943,26 +952,42 @@ def _ensure_usable(skills_dir: Path) -> Optional[Path]:
                 return None
             return skills_dir
 
-        try:
-            skills_dir = resolve_active_skills_dir(self.project_root)
-        except (ValueError, OSError) as exc:
-            _print_cli_warning(
-                "resolve",
-                "skills directory",
-                None,
-                exc,
-                continuing="Continuing without skill registration.",
-            )
-            return None
-        if skills_dir is None:
-            return None
-
         opts = load_init_options(self.project_root)
         if not isinstance(opts, dict):
-            return _ensure_usable(skills_dir)
-        selected_ai = opts.get("ai")
-        if not isinstance(selected_ai, str) or not selected_ai:
-            return _ensure_usable(skills_dir)
+            opts = {}
+
+        if agent_name is None:
+            try:
+                skills_dir = resolve_active_skills_dir(self.project_root)
+            except (ValueError, OSError) as exc:
+                _print_cli_warning(
+                    "resolve",
+                    "skills directory",
+                    None,
+                    exc,
+                    continuing="Continuing without skill registration.",
+                )
+                return None
+            if skills_dir is None:
+                return None
+            selected_ai = opts.get("ai")
+            if not isinstance(selected_ai, str) or not selected_ai:
+                return _ensure_usable(skills_dir)
+        else:
+            if not is_agent_skills_enabled(self.project_root, agent_name, opts):
+                return None
+            try:
+                skills_dir = resolve_agent_skills_dir(self.project_root, agent_name)
+            except (ValueError, OSError) as exc:
+                _print_cli_warning(
+                    "resolve",
+                    "skills directory",
+                    None,
+                    exc,
+                    continuing="Continuing without skill registration.",
+                )
+                return None
+            selected_ai = agent_name
 
         from ..agents import CommandRegistrar
 
@@ -980,6 +1005,7 @@ def _register_extension_skills(
         manifest: ExtensionManifest,
         extension_dir: Path,
         link_outputs: bool = False,
+        agent_name: Optional[str] = None,
     ) -> List[str]:
         """Generate SKILL.md files for extension commands as agent skills.
 
@@ -997,11 +1023,12 @@ def _register_extension_skills(
         Returns:
             List of skill names that were created (for registry storage).
         """
-        skills_dir = self._get_skills_dir()
+        skills_dir = self._get_skills_dir(agent_name)
         if not skills_dir:
             return []
 
         from .. import load_init_options
+        from .._init_options import is_agent_skills_enabled
         from ..agents import CommandRegistrar
         from ..integrations import get_integration
         from ..integrations.base import IntegrationBase
@@ -1010,13 +1037,13 @@ def _register_extension_skills(
         opts = load_init_options(self.project_root)
         if not isinstance(opts, dict):
             opts = {}
-        selected_ai = opts.get("ai")
+        selected_ai = agent_name if agent_name else opts.get("ai")
         if not isinstance(selected_ai, str) or not selected_ai:
             return []
         registrar = CommandRegistrar()
         agent_config = registrar.AGENT_CONFIGS.get(selected_ai, {})
         integration = get_integration(selected_ai)
-        ai_skills_enabled = is_ai_skills_enabled(opts)
+        ai_skills_enabled = is_agent_skills_enabled(self.project_root, selected_ai, opts)
 
         def _resolve_command_ref_tokens(body: str) -> str:
             """Resolve explicit command-ref tokens with the active skill style."""
@@ -1731,17 +1758,16 @@ def unregister_agent_artifacts(self, agent_name: str) -> None:
     def register_enabled_extensions_for_agent(self, agent_name: str) -> None:
         """Register installed, enabled extensions for ``agent_name``.
 
-        Command-file registration is scoped to the explicit ``agent_name``
-        argument, so this method can be used after install, upgrade, or switch.
-        Extension skill rendering is still scoped to the active ``ai`` /
-        ``ai_skills`` settings in init-options, so non-active skills-mode
-        targets receive command files here. Per-agent skills parity is tracked
-        separately in #2948.
+        Both command-file and skill registration are scoped to the explicit
+        ``agent_name`` argument, so this method can be used after install,
+        upgrade, or switch and renders skills correctly for any enabled
+        skills-mode agent, not just the active one (#2948).
         """
         if not agent_name:
             return
 
         from .. import load_init_options
+        from .._init_options import is_agent_skills_enabled
 
         registrar = CommandRegistrar()
         agent_config = registrar.AGENT_CONFIGS.get(agent_name)
@@ -1750,10 +1776,11 @@ def register_enabled_extensions_for_agent(self, agent_name: str) -> None:
             init_options = {}
 
         active_agent = init_options.get("ai")
-        ai_skills_enabled = is_ai_skills_enabled(init_options)
+        ai_skills_enabled = is_agent_skills_enabled(
+            self.project_root, agent_name, init_options
+        )
         skills_mode_active = (
-            active_agent == agent_name
-            and ai_skills_enabled
+            ai_skills_enabled
             and bool(agent_config)
             and agent_config.get("extension") != "/SKILL.md"
         )
@@ -1793,46 +1820,42 @@ def register_enabled_extensions_for_agent(self, agent_name: str) -> None:
                     if new_registered != registered_commands:
                         updates["registered_commands"] = new_registered
 
-                # Extension *skills* are only ever rendered for the active agent:
-                # `_register_extension_skills` resolves the skills dir and
-                # frontmatter from init-options["ai"], ignoring ``agent_name``.
-                # When this method runs for a non-active agent — as install/upgrade
-                # now do for a secondary integration (#2886) — the skills pass would
-                # re-render the *active* agent's extension skills as a side effect,
-                # resurrecting skill files the user deliberately deleted. Skip it
-                # unless the target is the active agent; `switch` is unaffected
-                # because it activates the target before registering. (Rendering
-                # skills for a non-active target is tracked separately in #2948.)
-                if agent_name == active_agent:
-                    try:
-                        registered_skills = self._register_extension_skills(
-                            manifest, ext_dir
+                # Extension skills are rendered whenever *agent_name* itself
+                # has skills mode enabled (checked via per-agent settings in
+                # `.specify/integration.json`, falling back to the legacy
+                # global init-options for the active agent). This makes
+                # skill rendering agent-aware instead of only ever
+                # targeting the active agent (#2948), while still avoiding
+                # unrelated side effects on other installed agents.
+                try:
+                    registered_skills = self._register_extension_skills(
+                        manifest, ext_dir, agent_name=agent_name
+                    )
+                except Exception as skills_err:
+                    # Skills are a companion artifact.  If command registration
+                    # already succeeded, still persist it so later cleanup can
+                    # find those command files.
+                    from .. import _print_cli_warning
+
+                    _print_cli_warning(
+                        "register extension skills for",
+                        "extension",
+                        ext_id,
+                        skills_err,
+                        continuing=(
+                            "Continuing with available registration results for this "
+                            "extension and the remaining extensions."
+                        ),
+                    )
+                else:
+                    if registered_skills:
+                        existing_skills = self._valid_name_list(
+                            metadata.get("registered_skills", [])
                         )
-                    except Exception as skills_err:
-                        # Skills are a companion artifact.  If command registration
-                        # already succeeded, still persist it so later cleanup can
-                        # find those command files.
-                        from .. import _print_cli_warning
-
-                        _print_cli_warning(
-                            "register extension skills for",
-                            "extension",
-                            ext_id,
-                            skills_err,
-                            continuing=(
-                                "Continuing with available registration results for this "
-                                "extension and the remaining extensions."
-                            ),
+                        merged_skills = list(
+                            dict.fromkeys(existing_skills + registered_skills)
                         )
-                    else:
-                        if registered_skills:
-                            existing_skills = self._valid_name_list(
-                                metadata.get("registered_skills", [])
-                            )
-                            merged_skills = list(
-                                dict.fromkeys(existing_skills + registered_skills)
-                            )
-                            updates["registered_skills"] = merged_skills
+                        updates["registered_skills"] = merged_skills
 
                 if updates:
                     self.registry.update(ext_id, updates)

src/specify_cli/integrations/_helpers.py

@@ -402,14 +402,12 @@ def _register_extensions_for_agent(
     integration has no extension side effects until it is selected or upgraded.
     See issue #2886.
 
-    Known limitation: extension *skill* rendering is scoped to the active
-    agent (init-options track a single ``ai`` / ``ai_skills`` pair). A
-    skills-mode agent registered while it is *not* the active agent (e.g.
-    Copilot ``--skills`` registered while non-active) therefore
-    receives command files rather than skills here — matching ``extension
-    add``'s multi-agent behavior. ``use`` / ``switch`` avoid this because they
-    make the target the active agent first. Per-agent skills parity is tracked in
-    #2948.
+    Extension *skill* rendering is scoped to ``agent_key`` itself (using
+    per-agent settings in ``.specify/integration.json`` when available, with
+    a fallback to the legacy global init-options for the active agent), so a
+    skills-mode agent registered while it is not the active agent (e.g.
+    Copilot ``--skills`` registered while non-active) still receives skill
+    files here instead of only command files (#2948).
 
     Best-effort: never aborts the surrounding integration operation. Callers
     invoke it *after* the use/upgrade/switch transaction has committed so a