fix: also render skills for non-active agents via 'extension add' (#2948)

Addresses PR review feedback: install_from_directory() (the
'extension add' / dev-install path) still called
_register_extension_skills() with no agent_name, so it remained
scoped to only the active agent, unlike
register_enabled_extensions_for_agent() which was already fixed
to target a specific agent.

Changes:
- Add ExtensionManager._register_extension_skills_for_installed_agents(),
  which renders skills for the active agent (legacy single-agent
  projects) plus every agent listed in
  .specify/integration.json's installed_integrations, for whichever
  of those are individually in skills mode. Failures for one agent
  are warned and do not block the others.
- install_from_directory() now calls this helper instead of a
  single active-agent-only call.
- _get_skills_dir()'s agent_name branch now mirrors
  resolve_active_skills_dir()'s safety checks
  (_ensure_safe_shared_directory symlink/containment/is-a-directory
  validation, plus the Kimi native-skills-dir-must-already-exist
  fallback) instead of resolving the naive per-agent path
  unchecked — fixes a regression this exposed in the Hermes
  marker-file detection test and restores exact parity with the
  active-agent path.

Tests:
- Added TestNonActiveAgentSkillRegistration with 3 new tests
  covering register_enabled_extensions_for_agent for a non-active
  skills-mode agent, isolation from the active agent's own skills,
  and extension add rendering skills for all installed
  skills-mode agents.
- pytest tests/ -k extension: 619/619 pass (616 previous + 3 new).
- Manually verified: 'specify extension add git' with Claude
  active and Copilot installed in --skills mode now renders
  SKILL.md files for both agents ('5 agent skill(s)
  auto-registered'), with no change to Claude's own skills.
- git diff --check: clean, no whitespace errors.

Author: Nimraakram12

src/specify_cli/extensions/__init__.py

@@ -974,10 +974,29 @@ def _ensure_usable(skills_dir: Path) -> Optional[Path]:
             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):
+            from ..shared_infra import _ensure_safe_shared_directory
+
+            ai_skills_enabled = is_agent_skills_enabled(
+                self.project_root, agent_name, opts
+            )
+            if not ai_skills_enabled and agent_name != "kimi":
                 return None
             try:
                 skills_dir = resolve_agent_skills_dir(self.project_root, agent_name)
+                if not ai_skills_enabled:
+                    # Kimi native-skills fallback: only use the directory if
+                    # it already exists; do not create it on demand.
+                    if not skills_dir.is_dir():
+                        return None
+                    _ensure_safe_shared_directory(
+                        self.project_root, skills_dir,
+                        create=False, context="agent skills directory",
+                    )
+                else:
+                    _ensure_safe_shared_directory(
+                        self.project_root, skills_dir,
+                        context="agent skills directory",
+                    )
             except (ValueError, OSError) as exc:
                 _print_cli_warning(
                     "resolve",
@@ -1191,6 +1210,73 @@ def _replacement(match: re.Match[str]) -> str:
 
         return written
 
+    def _register_extension_skills_for_installed_agents(
+        self,
+        manifest: ExtensionManifest,
+        extension_dir: Path,
+        link_outputs: bool = False,
+    ) -> List[str]:
+        """Render extension skills for every skills-mode agent detected.
+
+        Used by paths (like ``extension add``) that register an extension
+        for all agents at once, rather than a single explicit target agent.
+        Checks the active agent (legacy single-agent projects) plus every
+        agent recorded in ``.specify/integration.json``'s installed
+        integrations, and renders skills for whichever of those have skills
+        mode enabled for them specifically, instead of only the active
+        agent (#2948).
+        """
+        from .. import load_init_options
+        from ..integration_state import (
+            try_read_integration_json,
+            installed_integration_keys,
+        )
+
+        opts = load_init_options(self.project_root)
+        if not isinstance(opts, dict):
+            opts = {}
+
+        candidate_agents: List[str] = []
+        active_agent = opts.get("ai")
+        if isinstance(active_agent, str) and active_agent:
+            candidate_agents.append(active_agent)
+
+        state, _error = try_read_integration_json(self.project_root)
+        if state:
+            for key in installed_integration_keys(state):
+                if key not in candidate_agents:
+                    candidate_agents.append(key)
+
+        combined: List[str] = []
+        seen = set()
+        for agent_name in candidate_agents:
+            try:
+                agent_skills = self._register_extension_skills(
+                    manifest,
+                    extension_dir,
+                    link_outputs=link_outputs,
+                    agent_name=agent_name,
+                )
+            except Exception as skills_err:
+                from .. import _print_cli_warning
+                _print_cli_warning(
+                    "register extension skills for",
+                    "extension",
+                    manifest.id,
+                    skills_err,
+                    continuing=(
+                        "Continuing with available registration results for "
+                        "this extension and the remaining agents."
+                    ),
+                )
+                continue
+            for skill_name in agent_skills:
+                if skill_name not in seen:
+                    seen.add(skill_name)
+                    combined.append(skill_name)
+
+        return combined
+
     @staticmethod
     def _is_expected_dev_symlink(skill_file: Path, cache_file: Path) -> bool:
         """Return True when an existing skill file links to its dev cache."""
@@ -1475,9 +1561,11 @@ def install_from_directory(
                 create_missing_active_skills_dir=True,
             )
 
-        # Auto-register extension commands as agent skills when skills mode
-        # was used during project initialisation (feature parity).
-        registered_skills = self._register_extension_skills(
+        # Auto-register extension commands as agent skills for every
+        # skills-mode agent detected (active agent plus any other
+        # installed integrations in skills mode), not just the active
+        # agent (#2948).
+        registered_skills = self._register_extension_skills_for_installed_agents(
             manifest, dest_dir, link_outputs=link_commands
         )
 

tests/test_extension_skills.py

@@ -219,6 +219,40 @@ def no_skills_project(project_dir):
     return project_dir
 
 
+def _create_integration_json(
+    project_root: Path,
+    *,
+    default_agent: str,
+    installed: list,
+    skills_by_agent: dict,
+):
+    """Write a .specify/integration.json with per-agent skills settings.
+
+    ``skills_by_agent`` maps agent key -> bool for
+    ``integration_settings[agent].parsed_options.skills``.
+    """
+    specify_dir = project_root / ".specify"
+    specify_dir.mkdir(parents=True, exist_ok=True)
+    settings = {}
+    for agent in installed:
+        entry = {"script": "sh", "invoke_separator": "-"}
+        if agent in skills_by_agent:
+            entry["raw_options"] = "--skills" if skills_by_agent[agent] else ""
+            entry["parsed_options"] = {"skills": skills_by_agent[agent]}
+        settings[agent] = entry
+    payload = {
+        "version": "0.1.0",
+        "integration_state_schema": 1,
+        "installed_integrations": installed,
+        "integration_settings": settings,
+        "integration": default_agent,
+        "default_integration": default_agent,
+    }
+    (specify_dir / "integration.json").write_text(
+        json.dumps(payload), encoding="utf-8"
+    )
+
+
 # ===== ExtensionManager._get_skills_dir Tests =====
 
 class TestExtensionManagerGetSkillsDir:
@@ -1906,3 +1940,97 @@ def test_remove_cleans_up_when_ai_skills_toggled(self, skills_project, extension
         assert result is True
         assert not (skills_dir / "speckit-test-ext-hello").exists()
         assert not (skills_dir / "speckit-test-ext-world").exists()
+
+
+# ===== Per-agent (non-active) skills mode tests (#2948) =====
+class TestNonActiveAgentSkillRegistration:
+    """Skills should render for any skills-mode agent, not just the active one."""
+
+    def test_register_enabled_extensions_for_agent_renders_non_active_agent_skills(
+        self, project_dir, extension_dir
+    ):
+        """upgrade/install-style registration should target the given agent."""
+        _create_init_options(project_dir, ai="claude", ai_skills=False)
+        _create_integration_json(
+            project_dir,
+            default_agent="claude",
+            installed=["claude", "copilot"],
+            skills_by_agent={"copilot": True},
+        )
+        copilot_skills_dir = _create_skills_dir(project_dir, ai="copilot")
+
+        manager = ExtensionManager(project_dir)
+        manager.install_from_directory(
+            extension_dir, "0.1.0", register_commands=False
+        )
+        manifest = manager.get_extension("test-ext")
+
+        manager.register_enabled_extensions_for_agent("copilot")
+
+        metadata = manager.registry.get(manifest.id)
+        assert "speckit-test-ext-hello" in metadata["registered_skills"]
+        assert (
+            copilot_skills_dir / "speckit-test-ext-hello" / "SKILL.md"
+        ).exists()
+
+    def test_register_enabled_extensions_for_agent_does_not_affect_active_agent(
+        self, project_dir, extension_dir
+    ):
+        """Rendering skills for a non-active agent must not touch the active agent's own skills."""
+        _create_init_options(project_dir, ai="claude", ai_skills=True)
+        claude_skills_dir = _create_skills_dir(project_dir, ai="claude")
+        _create_integration_json(
+            project_dir,
+            default_agent="claude",
+            installed=["claude", "copilot"],
+            skills_by_agent={"copilot": True},
+        )
+        copilot_skills_dir = _create_skills_dir(project_dir, ai="copilot")
+
+        manager = ExtensionManager(project_dir)
+        manager.install_from_directory(
+            extension_dir, "0.1.0", register_commands=False
+        )
+
+        # Simulate the user deleting the claude skill files before re-running
+        # registration for a different (copilot) agent.
+        claude_skill_dir = claude_skills_dir / "speckit-test-ext-hello"
+        shutil.rmtree(claude_skill_dir)
+        assert not claude_skill_dir.exists()
+
+        manager.register_enabled_extensions_for_agent("copilot")
+
+        # Copilot's skills were rendered...
+        assert (
+            copilot_skills_dir / "speckit-test-ext-hello" / "SKILL.md"
+        ).exists()
+        # ...but claude's deleted skill was not resurrected.
+        assert not claude_skill_dir.exists()
+
+    def test_extension_add_renders_skills_for_all_installed_skills_mode_agents(
+        self, project_dir, extension_dir
+    ):
+        """extension add should render skills for every installed skills-mode agent."""
+        _create_init_options(project_dir, ai="claude", ai_skills=True)
+        claude_skills_dir = _create_skills_dir(project_dir, ai="claude")
+        _create_integration_json(
+            project_dir,
+            default_agent="claude",
+            installed=["claude", "copilot"],
+            skills_by_agent={"copilot": True},
+        )
+        copilot_skills_dir = _create_skills_dir(project_dir, ai="copilot")
+
+        manager = ExtensionManager(project_dir)
+        manifest = manager.install_from_directory(
+            extension_dir, "0.1.0", register_commands=False
+        )
+
+        metadata = manager.registry.get(manifest.id)
+        assert "speckit-test-ext-hello" in metadata["registered_skills"]
+        assert (
+            claude_skills_dir / "speckit-test-ext-hello" / "SKILL.md"
+        ).exists()
+        assert (
+            copilot_skills_dir / "speckit-test-ext-hello" / "SKILL.md"
+        ).exists()