fix: inherit core scripts in wrap strategy and resolve extension commands

When strategy: wrap is used in a preset, the core template's {SCRIPT} and
{AGENT_SCRIPT} placeholders were left unresolved because _register_skills
discarded the core frontmatter after substitution. Presets that add a single
instruction around an existing command (e.g. "use Codex for the following")
now correctly inherit scripts/agent_scripts from the core so prerequisite
checks still run.

_substitute_core_template also gains extension command lookup: wrapping
speckit.<ext>.<cmd> now searches .specify/extensions/<ext>/commands/ so
{CORE_TEMPLATE} resolves for extension commands, not just built-in ones.

Also fixes two test issues flagged in code review:
- Restore the missing "reinstall" assertion in the bundled preset CLI test
- Restore AGENT_CONFIGS on the class (not the instance) after test mutation

Author: kennedy-whytech

src/specify_cli/agents.py

@@ -416,10 +416,7 @@ def register_commands(
 
             if frontmatter.get("strategy") == "wrap":
                 from .presets import _substitute_core_template
-                short_name = cmd_name
-                if short_name.startswith("speckit."):
-                    short_name = short_name[len("speckit."):]
-                body = _substitute_core_template(body, short_name, project_root, self)
+                body, _ = _substitute_core_template(body, cmd_name, project_root, self)
 
             frontmatter = self._adjust_script_paths(frontmatter)
 

src/specify_cli/presets.py

@@ -29,44 +29,60 @@
 
 def _substitute_core_template(
     body: str,
-    short_name: str,
+    cmd_name: str,
     project_root: "Path",
     registrar: "CommandRegistrar",
-) -> str:
+) -> "tuple[str, dict]":
     """Substitute {CORE_TEMPLATE} with the body of the installed core command template.
 
     Args:
         body: Preset command body (may contain {CORE_TEMPLATE} placeholder).
-        short_name: Short command name (e.g. "specify" from "speckit.specify").
+        cmd_name: Full command name (e.g. "speckit.specify" or "speckit.git.feature").
         project_root: Project root path.
         registrar: CommandRegistrar instance for parse_frontmatter.
 
     Returns:
-        Body with {CORE_TEMPLATE} replaced by core template body, or body unchanged
-        if the placeholder is absent or the core template file does not exist.
+        Tuple of (substituted_body, core_frontmatter).  Returns (body, {}) unchanged
+        when the placeholder is absent or the core template file cannot be found.
     """
     if "{CORE_TEMPLATE}" not in body:
-        return body
+        return body, {}
 
-    # Prefer the project's installed core template so project-level commands and
-    # customisations are wrapped correctly.  Fall back to the bundled core_pack or
-    # repo templates for commands that ship with the package.
-    core_file = project_root / ".specify" / "templates" / "commands" / f"{short_name}.md"
+    # Derive the filename stem used by core-pack and project template lookups.
+    # "speckit.specify"     → "specify"
+    # "speckit.git.feature" → "git-feature"
+    raw = cmd_name[len("speckit."):] if cmd_name.startswith("speckit.") else cmd_name
+    file_stem = raw.replace(".", "-")
+
+    # 1. Project-installed core template (always takes priority).
+    core_file = project_root / ".specify" / "templates" / "commands" / f"{file_stem}.md"
+
+    # 2. Extension command: speckit.<ext>.<cmd> → .specify/extensions/<ext>/commands/<cmd_name>.md
+    if not core_file.exists():
+        parts = cmd_name.split(".")
+        if len(parts) >= 3 and parts[0] == "speckit":
+            ext_id = parts[1]
+            ext_file = (
+                project_root / ".specify" / "extensions" / ext_id / "commands" / f"{cmd_name}.md"
+            )
+            if ext_file.exists():
+                core_file = ext_file
+
+    # 3. Bundled core pack, then source/editable-install repo templates.
     if not core_file.exists():
         from specify_cli import _locate_core_pack
         core_pack = _locate_core_pack()
         if core_pack is not None:
-            core_file = core_pack / "commands" / f"{short_name}.md"
+            core_file = core_pack / "commands" / f"{file_stem}.md"
         else:
-            # Source / editable install: look relative to the package root
             repo_root = Path(__file__).parent.parent.parent
-            core_file = repo_root / "templates" / "commands" / f"{short_name}.md"
+            core_file = repo_root / "templates" / "commands" / f"{file_stem}.md"
 
     if not core_file.exists():
-        return body
+        return body, {}
 
-    _, core_body = registrar.parse_frontmatter(core_file.read_text(encoding="utf-8"))
-    return body.replace("{CORE_TEMPLATE}", core_body)
+    core_frontmatter, core_body = registrar.parse_frontmatter(core_file.read_text(encoding="utf-8"))
+    return body.replace("{CORE_TEMPLATE}", core_body), core_frontmatter
 
 
 @dataclass
@@ -802,7 +818,15 @@ def _register_skills(
             frontmatter, body = registrar.parse_frontmatter(content)
 
             if frontmatter.get("strategy") == "wrap":
-                body = _substitute_core_template(body, short_name, self.project_root, registrar)
+                body, core_fm = _substitute_core_template(body, cmd_name, self.project_root, registrar)
+                # Inherit script keys from the core template when the preset doesn't
+                # define its own — required so {SCRIPT}/{AGENT_SCRIPT} placeholders
+                # embedded in the substituted core body still resolve correctly.
+                if core_fm:
+                    frontmatter = dict(frontmatter)
+                    for key in ("scripts", "agent_scripts"):
+                        if key not in frontmatter and key in core_fm:
+                            frontmatter[key] = core_fm[key]
 
             original_desc = frontmatter.get("description", "")
             enhanced_desc = SKILL_DESCRIPTIONS.get(

tests/test_presets.py

@@ -3043,6 +3043,7 @@ def test_bundled_preset_missing_locally_cli_error(self, project_dir):
         assert result.exit_code == 1
         output = strip_ansi(result.output).lower()
         assert "bundled" in output, result.output
+        assert "reinstall" in output, result.output
 
 
 class TestWrapStrategy:
@@ -3062,7 +3063,7 @@ def test_substitute_core_template_replaces_placeholder(self, project_dir):
 
         registrar = CommandRegistrar()
         body = "## Pre-Logic\n\nBefore stuff.\n\n{CORE_TEMPLATE}\n\n## Post-Logic\n\nAfter stuff.\n"
-        result = _substitute_core_template(body, "specify", project_dir, registrar)
+        result, _ = _substitute_core_template(body, "speckit.specify", project_dir, registrar)
 
         assert "{CORE_TEMPLATE}" not in result
         assert "# Core Specify" in result
@@ -3080,7 +3081,7 @@ def test_substitute_core_template_no_op_when_placeholder_absent(self, project_di
 
         registrar = CommandRegistrar()
         body = "## No placeholder here.\n"
-        result = _substitute_core_template(body, "specify", project_dir, registrar)
+        result, _ = _substitute_core_template(body, "speckit.specify", project_dir, registrar)
         assert result == body
 
     def test_substitute_core_template_no_op_when_core_missing(self, project_dir):
@@ -3090,9 +3091,10 @@ def test_substitute_core_template_no_op_when_core_missing(self, project_dir):
 
         registrar = CommandRegistrar()
         body = "Pre.\n\n{CORE_TEMPLATE}\n\nPost.\n"
-        result = _substitute_core_template(body, "nonexistent", project_dir, registrar)
+        result, core_fm = _substitute_core_template(body, "speckit.nonexistent", project_dir, registrar)
         assert result == body
         assert "{CORE_TEMPLATE}" in result
+        assert core_fm == {}
 
     def test_register_commands_substitutes_core_template_for_wrap_strategy(self, project_dir):
         """register_commands substitutes {CORE_TEMPLATE} when strategy: wrap."""
@@ -3136,7 +3138,7 @@ def test_register_commands_substitutes_core_template_for_wrap_strategy(self, pro
                 project_dir / "preset", project_dir
             )
         finally:
-            registrar.AGENT_CONFIGS = original
+            CommandRegistrar.AGENT_CONFIGS = original
 
         written = (agent_dir / "speckit.specify.md").read_text()
         assert "{CORE_TEMPLATE}" not in written
@@ -3176,3 +3178,105 @@ def test_end_to_end_wrap_via_self_test_preset(self, project_dir):
         assert "# Core Wrap-Test Body" in written
         assert "preset:self-test wrap-pre" in written
         assert "preset:self-test wrap-post" in written
+
+    def test_substitute_core_template_returns_core_frontmatter(self, project_dir):
+        """_substitute_core_template returns core frontmatter as second tuple element."""
+        from specify_cli.presets import _substitute_core_template
+        from specify_cli.agents import CommandRegistrar
+
+        core_dir = project_dir / ".specify" / "templates" / "commands"
+        core_dir.mkdir(parents=True, exist_ok=True)
+        (core_dir / "specify.md").write_text(
+            "---\ndescription: core\nscripts:\n  sh: scripts/bash/setup.sh\n---\n\n# Core Specify\n"
+        )
+
+        registrar = CommandRegistrar()
+        body = "{CORE_TEMPLATE}\n\n## Post\n"
+        result_body, core_fm = _substitute_core_template(body, "speckit.specify", project_dir, registrar)
+
+        assert "{CORE_TEMPLATE}" not in result_body
+        assert "# Core Specify" in result_body
+        assert core_fm.get("scripts") == {"sh": "scripts/bash/setup.sh"}
+
+    def test_substitute_core_template_no_core_returns_empty_frontmatter(self, project_dir):
+        """Returns empty dict as frontmatter when core template does not exist."""
+        from specify_cli.presets import _substitute_core_template
+        from specify_cli.agents import CommandRegistrar
+
+        registrar = CommandRegistrar()
+        body = "{CORE_TEMPLATE}\n\n## Post\n"
+        result_body, core_fm = _substitute_core_template(body, "speckit.nonexistent", project_dir, registrar)
+
+        assert result_body == body
+        assert core_fm == {}
+
+    def test_substitute_core_template_resolves_extension_command(self, project_dir):
+        """_substitute_core_template resolves {CORE_TEMPLATE} from an extension command directory."""
+        from specify_cli.presets import _substitute_core_template
+        from specify_cli.agents import CommandRegistrar
+
+        # Simulate an installed extension
+        ext_cmd_dir = project_dir / ".specify" / "extensions" / "git" / "commands"
+        ext_cmd_dir.mkdir(parents=True, exist_ok=True)
+        (ext_cmd_dir / "speckit.git.feature.md").write_text(
+            "---\ndescription: git feature core\nhandoffs:\n  - label: Next\n    agent: speckit.plan\n---\n\n# Core Git Feature\n"
+        )
+
+        registrar = CommandRegistrar()
+        body = "## Pre\n\n{CORE_TEMPLATE}\n\n## Post\n"
+        result_body, core_fm = _substitute_core_template(
+            body, "speckit.git.feature", project_dir, registrar
+        )
+
+        assert "{CORE_TEMPLATE}" not in result_body
+        assert "# Core Git Feature" in result_body
+        assert core_fm.get("handoffs") is not None
+
+    def test_wrap_strategy_inherits_core_scripts_in_skills(self, project_dir):
+        """_register_skills merges core scripts into preset frontmatter for {SCRIPT} resolution."""
+        import json
+        from specify_cli.presets import PresetManager
+        from pathlib import Path
+
+        # Set up core command template with scripts frontmatter
+        core_dir = project_dir / ".specify" / "templates" / "commands"
+        core_dir.mkdir(parents=True, exist_ok=True)
+        (core_dir / "specify.md").write_text(
+            "---\ndescription: core specify\nscripts:\n  sh: scripts/bash/check.sh\n---\n\n"
+            "Run: {SCRIPT}\n\n# Core Specify\n"
+        )
+
+        # Write init-options
+        (project_dir / ".specify" / "init-options.json").write_text(
+            json.dumps({"ai": "claude", "ai_skills": True})
+        )
+
+        # Create a preset with a wrap command that has no scripts of its own
+        preset_dir = project_dir / "test-preset"
+        (preset_dir / "commands").mkdir(parents=True)
+        (preset_dir / "commands" / "speckit.specify.md").write_text(
+            "---\ndescription: preset wrap\nstrategy: wrap\n---\n\n{CORE_TEMPLATE}\n\n## Post\n"
+        )
+        (preset_dir / "preset.yml").write_text(
+            "schema_version: '1.0'\n"
+            "preset:\n  id: test-scripts-preset\n  name: Test\n  version: 1.0.0\n"
+            "  description: Test\n  author: test\n"
+            "requires:\n  speckit_version: '>=0.5.0'\n"
+            "provides:\n  templates:\n"
+            "    - type: command\n      name: speckit.specify\n"
+            "      file: commands/speckit.specify.md\n      description: wrap\n"
+        )
+
+        # Create the skill dir so _register_skills will overwrite it
+        skills_dir = project_dir / ".claude" / "skills" / "speckit-specify"
+        skills_dir.mkdir(parents=True)
+        (skills_dir / "SKILL.md").write_text("---\nname: speckit-specify\n---\n\nold\n")
+
+        manager = PresetManager(project_dir)
+        manager.install_from_directory(preset_dir, "1.0.0")
+
+        written = (skills_dir / "SKILL.md").read_text()
+        # {SCRIPT} should have been resolved using the core template's scripts
+        assert "{SCRIPT}" not in written
+        assert "scripts/bash/check.sh" in written
+