Merge branch 'main' into feature/add-forgecode-agent-support

2026-07-08 23:59:55 +08:00 · 2026-04-02 20:52:57 +02:00
parent 90a1845c13 663d679f3b
commit 769a87fd2f
53 changed files with 3248 additions and 3655 deletions
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -0,0 +1,10 @@
+"""Shared test helpers for the Spec Kit test suite."""
+
+import re
+
+_ANSI_ESCAPE_RE = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]")
+
+
+def strip_ansi(text: str) -> str:
+    """Remove ANSI escape codes from Rich-formatted CLI output."""
+    return _ANSI_ESCAPE_RE.sub("", text)
--- a/tests/integrations/test_cli.py
+++ b/tests/integrations/test_cli.py
@@ -3,26 +3,24 @@
 import json
 import os

-import pytest
-

 class TestInitIntegrationFlag:
-    def test_integration_and_ai_mutually_exclusive(self):
+    def test_integration_and_ai_mutually_exclusive(self, tmp_path):
        from typer.testing import CliRunner
        from specify_cli import app
        runner = CliRunner()
        result = runner.invoke(app, [
-            "init", "test-project", "--ai", "claude", "--integration", "copilot",
+            "init", str(tmp_path / "test-project"), "--ai", "claude", "--integration", "copilot",
        ])
        assert result.exit_code != 0
        assert "mutually exclusive" in result.output

-    def test_unknown_integration_rejected(self):
+    def test_unknown_integration_rejected(self, tmp_path):
        from typer.testing import CliRunner
        from specify_cli import app
        runner = CliRunner()
        result = runner.invoke(app, [
-            "init", "test-project", "--integration", "nonexistent",
+            "init", str(tmp_path / "test-project"), "--integration", "nonexistent",
        ])
        assert result.exit_code != 0
        assert "Unknown integration" in result.output
@@ -75,9 +73,38 @@ class TestInitIntegrationFlag:
        finally:
            os.chdir(old_cwd)
        assert result.exit_code == 0
-        assert "--integration copilot" in result.output
        assert (project / ".github" / "agents" / "speckit.plan.agent.md").exists()

+    def test_ai_claude_here_preserves_preexisting_commands(self, tmp_path):
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        project = tmp_path / "claude-here-existing"
+        project.mkdir()
+        commands_dir = project / ".claude" / "skills"
+        commands_dir.mkdir(parents=True)
+        skill_dir = commands_dir / "speckit-specify"
+        skill_dir.mkdir(parents=True)
+        command_file = skill_dir / "SKILL.md"
+        command_file.write_text("# preexisting command\n", encoding="utf-8")
+
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(project)
+            runner = CliRunner()
+            result = runner.invoke(app, [
+                "init", "--here", "--force", "--ai", "claude", "--ai-skills", "--script", "sh", "--no-git", "--ignore-agent-tools",
+            ], catch_exceptions=False)
+        finally:
+            os.chdir(old_cwd)
+
+        assert result.exit_code == 0, result.output
+        assert command_file.exists()
+        # init replaces skills (not additive); verify the file has valid skill content
+        assert command_file.exists()
+        assert "speckit-specify" in command_file.read_text(encoding="utf-8")
+        assert (project / ".claude" / "skills" / "speckit-plan" / "SKILL.md").exists()
+
    def test_shared_infra_skips_existing_files(self, tmp_path):
        """Pre-existing shared files are not overwritten by _install_shared_infra."""
        from typer.testing import CliRunner
--- a/tests/integrations/test_integration_agy.py
+++ b/tests/integrations/test_integration_agy.py
@@ -0,0 +1,27 @@
+"""Tests for AgyIntegration (Antigravity)."""
+
+from .test_integration_base_skills import SkillsIntegrationTests
+
+
+class TestAgyIntegration(SkillsIntegrationTests):
+    KEY = "agy"
+    FOLDER = ".agent/"
+    COMMANDS_SUBDIR = "skills"
+    REGISTRAR_DIR = ".agent/skills"
+    CONTEXT_FILE = "AGENTS.md"
+
+
+class TestAgyAutoPromote:
+    """--ai agy auto-promotes to integration path."""
+
+    def test_ai_agy_without_ai_skills_auto_promotes(self, tmp_path):
+        """--ai agy should work the same as --integration agy."""
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        runner = CliRunner()
+        target = tmp_path / "test-proj"
+        result = runner.invoke(app, ["init", str(target), "--ai", "agy", "--no-git", "--script", "sh"])
+
+        assert result.exit_code == 0, f"init --ai agy failed: {result.output}"
+        assert (target / ".agent" / "skills" / "speckit-plan" / "SKILL.md").exists()
--- a/tests/integrations/test_integration_base_markdown.py
+++ b/tests/integrations/test_integration_base_markdown.py
@@ -176,7 +176,9 @@ class MarkdownIntegrationTests:
        finally:
            os.chdir(old_cwd)
        assert result.exit_code == 0, f"init --ai {self.KEY} failed: {result.output}"
-        assert f"--integration {self.KEY}" in result.output
+        i = get_integration(self.KEY)
+        cmd_dir = i.commands_dest(project)
+        assert cmd_dir.is_dir(), f"--ai {self.KEY} did not create commands directory"

    def test_integration_flag_creates_files(self, tmp_path):
        from typer.testing import CliRunner
--- a/tests/integrations/test_integration_base_skills.py
+++ b/tests/integrations/test_integration_base_skills.py
@@ -0,0 +1,404 @@
+"""Reusable test mixin for standard SkillsIntegration subclasses.
+
+Each per-agent test file sets ``KEY``, ``FOLDER``, ``COMMANDS_SUBDIR``,
+``REGISTRAR_DIR``, and ``CONTEXT_FILE``, then inherits all verification
+logic from ``SkillsIntegrationTests``.
+
+Mirrors ``MarkdownIntegrationTests`` / ``TomlIntegrationTests`` closely,
+adapted for the ``speckit-<name>/SKILL.md`` skills layout.
+"""
+
+import os
+
+import yaml
+
+from specify_cli.integrations import INTEGRATION_REGISTRY, get_integration
+from specify_cli.integrations.base import SkillsIntegration
+from specify_cli.integrations.manifest import IntegrationManifest
+
+
+class SkillsIntegrationTests:
+    """Mixin — set class-level constants and inherit these tests.
+
+    Required class attrs on subclass::
+
+        KEY: str              — integration registry key
+        FOLDER: str           — e.g. ".agents/"
+        COMMANDS_SUBDIR: str  — e.g. "skills"
+        REGISTRAR_DIR: str    — e.g. ".agents/skills"
+        CONTEXT_FILE: str     — e.g. "AGENTS.md"
+    """
+
+    KEY: str
+    FOLDER: str
+    COMMANDS_SUBDIR: str
+    REGISTRAR_DIR: str
+    CONTEXT_FILE: str
+
+    # -- Registration -----------------------------------------------------
+
+    def test_registered(self):
+        assert self.KEY in INTEGRATION_REGISTRY
+        assert get_integration(self.KEY) is not None
+
+    def test_is_skills_integration(self):
+        assert isinstance(get_integration(self.KEY), SkillsIntegration)
+
+    # -- Config -----------------------------------------------------------
+
+    def test_config_folder(self):
+        i = get_integration(self.KEY)
+        assert i.config["folder"] == self.FOLDER
+
+    def test_config_commands_subdir(self):
+        i = get_integration(self.KEY)
+        assert i.config["commands_subdir"] == self.COMMANDS_SUBDIR
+
+    def test_registrar_config(self):
+        i = get_integration(self.KEY)
+        assert i.registrar_config["dir"] == self.REGISTRAR_DIR
+        assert i.registrar_config["format"] == "markdown"
+        assert i.registrar_config["args"] == "$ARGUMENTS"
+        assert i.registrar_config["extension"] == "/SKILL.md"
+
+    def test_context_file(self):
+        i = get_integration(self.KEY)
+        assert i.context_file == self.CONTEXT_FILE
+
+    # -- Setup / teardown -------------------------------------------------
+
+    def test_setup_creates_files(self, tmp_path):
+        i = get_integration(self.KEY)
+        m = IntegrationManifest(self.KEY, tmp_path)
+        created = i.setup(tmp_path, m)
+        assert len(created) > 0
+        skill_files = [f for f in created if "scripts" not in f.parts]
+        for f in skill_files:
+            assert f.exists()
+            assert f.name == "SKILL.md"
+            assert f.parent.name.startswith("speckit-")
+
+    def test_setup_writes_to_correct_directory(self, tmp_path):
+        i = get_integration(self.KEY)
+        m = IntegrationManifest(self.KEY, tmp_path)
+        created = i.setup(tmp_path, m)
+        expected_dir = i.skills_dest(tmp_path)
+        assert expected_dir.exists(), f"Expected directory {expected_dir} was not created"
+        skill_files = [f for f in created if "scripts" not in f.parts]
+        assert len(skill_files) > 0, "No skill files were created"
+        for f in skill_files:
+            # Each SKILL.md is in speckit-<name>/ under the skills directory
+            assert f.resolve().parent.parent == expected_dir.resolve(), (
+                f"{f} is not under {expected_dir}"
+            )
+
+    def test_skill_directory_structure(self, tmp_path):
+        """Each command produces speckit-<name>/SKILL.md."""
+        i = get_integration(self.KEY)
+        m = IntegrationManifest(self.KEY, tmp_path)
+        created = i.setup(tmp_path, m)
+        skill_files = [f for f in created if "scripts" not in f.parts]
+
+        expected_commands = {
+            "analyze", "checklist", "clarify", "constitution",
+            "implement", "plan", "specify", "tasks", "taskstoissues",
+        }
+
+        # Derive command names from the skill directory names
+        actual_commands = set()
+        for f in skill_files:
+            skill_dir_name = f.parent.name  # e.g. "speckit-plan"
+            assert skill_dir_name.startswith("speckit-")
+            actual_commands.add(skill_dir_name.removeprefix("speckit-"))
+
+        assert actual_commands == expected_commands
+
+    def test_skill_frontmatter_structure(self, tmp_path):
+        """SKILL.md must have name, description, compatibility, metadata."""
+        i = get_integration(self.KEY)
+        m = IntegrationManifest(self.KEY, tmp_path)
+        created = i.setup(tmp_path, m)
+        skill_files = [f for f in created if "scripts" not in f.parts]
+
+        for f in skill_files:
+            content = f.read_text(encoding="utf-8")
+            assert content.startswith("---\n"), f"{f} missing frontmatter"
+            parts = content.split("---", 2)
+            fm = yaml.safe_load(parts[1])
+            assert "name" in fm, f"{f} frontmatter missing 'name'"
+            assert "description" in fm, f"{f} frontmatter missing 'description'"
+            assert "compatibility" in fm, f"{f} frontmatter missing 'compatibility'"
+            assert "metadata" in fm, f"{f} frontmatter missing 'metadata'"
+            assert fm["metadata"]["author"] == "github-spec-kit"
+            assert "source" in fm["metadata"]
+
+    def test_skill_uses_template_descriptions(self, tmp_path):
+        """SKILL.md should use the original template description for ZIP parity."""
+        i = get_integration(self.KEY)
+        m = IntegrationManifest(self.KEY, tmp_path)
+        created = i.setup(tmp_path, m)
+        skill_files = [f for f in created if "scripts" not in f.parts]
+
+        for f in skill_files:
+            content = f.read_text(encoding="utf-8")
+            parts = content.split("---", 2)
+            fm = yaml.safe_load(parts[1])
+            # Description must be a non-empty string (from the template)
+            assert isinstance(fm["description"], str)
+            assert len(fm["description"]) > 0, f"{f} has empty description"
+
+    def test_templates_are_processed(self, tmp_path):
+        """Skill body must have placeholders replaced, not raw templates."""
+        i = get_integration(self.KEY)
+        m = IntegrationManifest(self.KEY, tmp_path)
+        created = i.setup(tmp_path, m)
+        skill_files = [f for f in created if "scripts" not in f.parts]
+        assert len(skill_files) > 0
+        for f in skill_files:
+            content = f.read_text(encoding="utf-8")
+            assert "{SCRIPT}" not in content, f"{f.name} has unprocessed {{SCRIPT}}"
+            assert "__AGENT__" not in content, f"{f.name} has unprocessed __AGENT__"
+            assert "{ARGS}" not in content, f"{f.name} has unprocessed {{ARGS}}"
+
+    def test_skill_body_has_content(self, tmp_path):
+        """Each SKILL.md body should contain template content after the frontmatter."""
+        i = get_integration(self.KEY)
+        m = IntegrationManifest(self.KEY, tmp_path)
+        created = i.setup(tmp_path, m)
+        skill_files = [f for f in created if "scripts" not in f.parts]
+        for f in skill_files:
+            content = f.read_text(encoding="utf-8")
+            # Body is everything after the second ---
+            parts = content.split("---", 2)
+            body = parts[2].strip() if len(parts) >= 3 else ""
+            assert len(body) > 0, f"{f} has empty body"
+
+    def test_all_files_tracked_in_manifest(self, tmp_path):
+        i = get_integration(self.KEY)
+        m = IntegrationManifest(self.KEY, tmp_path)
+        created = i.setup(tmp_path, m)
+        for f in created:
+            rel = f.resolve().relative_to(tmp_path.resolve()).as_posix()
+            assert rel in m.files, f"{rel} not tracked in manifest"
+
+    def test_install_uninstall_roundtrip(self, tmp_path):
+        i = get_integration(self.KEY)
+        m = IntegrationManifest(self.KEY, tmp_path)
+        created = i.install(tmp_path, m)
+        assert len(created) > 0
+        m.save()
+        for f in created:
+            assert f.exists()
+        removed, skipped = i.uninstall(tmp_path, m)
+        assert len(removed) == len(created)
+        assert skipped == []
+
+    def test_modified_file_survives_uninstall(self, tmp_path):
+        i = get_integration(self.KEY)
+        m = IntegrationManifest(self.KEY, tmp_path)
+        created = i.install(tmp_path, m)
+        m.save()
+        modified_file = created[0]
+        modified_file.write_text("user modified this", encoding="utf-8")
+        removed, skipped = i.uninstall(tmp_path, m)
+        assert modified_file.exists()
+        assert modified_file in skipped
+
+    def test_pre_existing_skills_not_removed(self, tmp_path):
+        """Pre-existing non-speckit skills should be left untouched."""
+        i = get_integration(self.KEY)
+        skills_dir = i.skills_dest(tmp_path)
+        foreign_dir = skills_dir / "other-tool"
+        foreign_dir.mkdir(parents=True)
+        (foreign_dir / "SKILL.md").write_text("# Foreign skill\n")
+
+        m = IntegrationManifest(self.KEY, tmp_path)
+        i.setup(tmp_path, m)
+
+        assert (foreign_dir / "SKILL.md").exists(), "Foreign skill was removed"
+
+    # -- Scripts ----------------------------------------------------------
+
+    def test_setup_installs_update_context_scripts(self, tmp_path):
+        i = get_integration(self.KEY)
+        m = IntegrationManifest(self.KEY, tmp_path)
+        i.setup(tmp_path, m)
+        scripts_dir = tmp_path / ".specify" / "integrations" / self.KEY / "scripts"
+        assert scripts_dir.is_dir(), f"Scripts directory not created for {self.KEY}"
+        assert (scripts_dir / "update-context.sh").exists()
+        assert (scripts_dir / "update-context.ps1").exists()
+
+    def test_scripts_tracked_in_manifest(self, tmp_path):
+        i = get_integration(self.KEY)
+        m = IntegrationManifest(self.KEY, tmp_path)
+        i.setup(tmp_path, m)
+        script_rels = [k for k in m.files if "update-context" in k]
+        assert len(script_rels) >= 2
+
+    def test_sh_script_is_executable(self, tmp_path):
+        i = get_integration(self.KEY)
+        m = IntegrationManifest(self.KEY, tmp_path)
+        i.setup(tmp_path, m)
+        sh = tmp_path / ".specify" / "integrations" / self.KEY / "scripts" / "update-context.sh"
+        assert os.access(sh, os.X_OK)
+
+    # -- CLI auto-promote -------------------------------------------------
+
+    def test_ai_flag_auto_promotes(self, tmp_path):
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        project = tmp_path / f"promote-{self.KEY}"
+        project.mkdir()
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(project)
+            runner = CliRunner()
+            result = runner.invoke(app, [
+                "init", "--here", "--ai", self.KEY, "--script", "sh", "--no-git",
+                "--ignore-agent-tools",
+            ], catch_exceptions=False)
+        finally:
+            os.chdir(old_cwd)
+        assert result.exit_code == 0, f"init --ai {self.KEY} failed: {result.output}"
+        i = get_integration(self.KEY)
+        skills_dir = i.skills_dest(project)
+        assert skills_dir.is_dir(), f"--ai {self.KEY} did not create skills directory"
+
+    def test_integration_flag_creates_files(self, tmp_path):
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        project = tmp_path / f"int-{self.KEY}"
+        project.mkdir()
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(project)
+            runner = CliRunner()
+            result = runner.invoke(app, [
+                "init", "--here", "--integration", self.KEY, "--script", "sh", "--no-git",
+                "--ignore-agent-tools",
+            ], catch_exceptions=False)
+        finally:
+            os.chdir(old_cwd)
+        assert result.exit_code == 0, f"init --integration {self.KEY} failed: {result.output}"
+        i = get_integration(self.KEY)
+        skills_dir = i.skills_dest(project)
+        assert skills_dir.is_dir(), f"Skills directory {skills_dir} not created"
+
+    # -- IntegrationOption ------------------------------------------------
+
+    def test_options_include_skills_flag(self):
+        i = get_integration(self.KEY)
+        opts = i.options()
+        skills_opts = [o for o in opts if o.name == "--skills"]
+        assert len(skills_opts) == 1
+        assert skills_opts[0].is_flag is True
+
+    # -- Complete file inventory ------------------------------------------
+
+    _SKILL_COMMANDS = [
+        "analyze", "checklist", "clarify", "constitution",
+        "implement", "plan", "specify", "tasks", "taskstoissues",
+    ]
+
+    def _expected_files(self, script_variant: str) -> list[str]:
+        """Build the full expected file list for a given script variant."""
+        i = get_integration(self.KEY)
+        skills_prefix = i.config["folder"].rstrip("/") + "/" + i.config.get("commands_subdir", "skills")
+
+        files = []
+        # Skill files
+        for cmd in self._SKILL_COMMANDS:
+            files.append(f"{skills_prefix}/speckit-{cmd}/SKILL.md")
+        # Integration metadata
+        files += [
+            ".specify/init-options.json",
+            ".specify/integration.json",
+            f".specify/integrations/{self.KEY}.manifest.json",
+            f".specify/integrations/{self.KEY}/scripts/update-context.ps1",
+            f".specify/integrations/{self.KEY}/scripts/update-context.sh",
+            ".specify/integrations/speckit.manifest.json",
+            ".specify/memory/constitution.md",
+        ]
+        # Script variant
+        if script_variant == "sh":
+            files += [
+                ".specify/scripts/bash/check-prerequisites.sh",
+                ".specify/scripts/bash/common.sh",
+                ".specify/scripts/bash/create-new-feature.sh",
+                ".specify/scripts/bash/setup-plan.sh",
+                ".specify/scripts/bash/update-agent-context.sh",
+            ]
+        else:
+            files += [
+                ".specify/scripts/powershell/check-prerequisites.ps1",
+                ".specify/scripts/powershell/common.ps1",
+                ".specify/scripts/powershell/create-new-feature.ps1",
+                ".specify/scripts/powershell/setup-plan.ps1",
+                ".specify/scripts/powershell/update-agent-context.ps1",
+            ]
+        # Templates
+        files += [
+            ".specify/templates/agent-file-template.md",
+            ".specify/templates/checklist-template.md",
+            ".specify/templates/constitution-template.md",
+            ".specify/templates/plan-template.md",
+            ".specify/templates/spec-template.md",
+            ".specify/templates/tasks-template.md",
+        ]
+        return sorted(files)
+
+    def test_complete_file_inventory_sh(self, tmp_path):
+        """Every file produced by specify init --integration <key> --script sh."""
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        project = tmp_path / f"inventory-sh-{self.KEY}"
+        project.mkdir()
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(project)
+            result = CliRunner().invoke(app, [
+                "init", "--here", "--integration", self.KEY,
+                "--script", "sh", "--no-git", "--ignore-agent-tools",
+            ], catch_exceptions=False)
+        finally:
+            os.chdir(old_cwd)
+        assert result.exit_code == 0, f"init failed: {result.output}"
+        actual = sorted(
+            p.relative_to(project).as_posix()
+            for p in project.rglob("*") if p.is_file()
+        )
+        expected = self._expected_files("sh")
+        assert actual == expected, (
+            f"Missing: {sorted(set(expected) - set(actual))}\n"
+            f"Extra: {sorted(set(actual) - set(expected))}"
+        )
+
+    def test_complete_file_inventory_ps(self, tmp_path):
+        """Every file produced by specify init --integration <key> --script ps."""
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        project = tmp_path / f"inventory-ps-{self.KEY}"
+        project.mkdir()
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(project)
+            result = CliRunner().invoke(app, [
+                "init", "--here", "--integration", self.KEY,
+                "--script", "ps", "--no-git", "--ignore-agent-tools",
+            ], catch_exceptions=False)
+        finally:
+            os.chdir(old_cwd)
+        assert result.exit_code == 0, f"init failed: {result.output}"
+        actual = sorted(
+            p.relative_to(project).as_posix()
+            for p in project.rglob("*") if p.is_file()
+        )
+        expected = self._expected_files("ps")
+        assert actual == expected, (
+            f"Missing: {sorted(set(expected) - set(actual))}\n"
+            f"Extra: {sorted(set(actual) - set(expected))}"
+        )
--- a/tests/integrations/test_integration_base_toml.py
+++ b/tests/integrations/test_integration_base_toml.py
@@ -226,7 +226,9 @@ class TomlIntegrationTests:
        finally:
            os.chdir(old_cwd)
        assert result.exit_code == 0, f"init --ai {self.KEY} failed: {result.output}"
-        assert f"--integration {self.KEY}" in result.output
+        i = get_integration(self.KEY)
+        cmd_dir = i.commands_dest(project)
+        assert cmd_dir.is_dir(), f"--ai {self.KEY} did not create commands directory"

    def test_integration_flag_creates_files(self, tmp_path):
        from typer.testing import CliRunner
--- a/tests/integrations/test_integration_claude.py
+++ b/tests/integrations/test_integration_claude.py
@@ -1,11 +1,281 @@
 """Tests for ClaudeIntegration."""

-from .test_integration_base_markdown import MarkdownIntegrationTests
+import json
+import os
+from unittest.mock import patch
+
+import yaml
+
+from specify_cli.integrations import INTEGRATION_REGISTRY, get_integration
+from specify_cli.integrations.base import IntegrationBase
+from specify_cli.integrations.manifest import IntegrationManifest


-class TestClaudeIntegration(MarkdownIntegrationTests):
-    KEY = "claude"
-    FOLDER = ".claude/"
-    COMMANDS_SUBDIR = "commands"
-    REGISTRAR_DIR = ".claude/commands"
-    CONTEXT_FILE = "CLAUDE.md"
+class TestClaudeIntegration:
+    def test_registered(self):
+        assert "claude" in INTEGRATION_REGISTRY
+        assert get_integration("claude") is not None
+
+    def test_is_base_integration(self):
+        assert isinstance(get_integration("claude"), IntegrationBase)
+
+    def test_config_uses_skills(self):
+        integration = get_integration("claude")
+        assert integration.config["folder"] == ".claude/"
+        assert integration.config["commands_subdir"] == "skills"
+
+    def test_registrar_config_uses_skill_layout(self):
+        integration = get_integration("claude")
+        assert integration.registrar_config["dir"] == ".claude/skills"
+        assert integration.registrar_config["format"] == "markdown"
+        assert integration.registrar_config["args"] == "$ARGUMENTS"
+        assert integration.registrar_config["extension"] == "/SKILL.md"
+
+    def test_context_file(self):
+        integration = get_integration("claude")
+        assert integration.context_file == "CLAUDE.md"
+
+    def test_setup_creates_skill_files(self, tmp_path):
+        integration = get_integration("claude")
+        manifest = IntegrationManifest("claude", tmp_path)
+        created = integration.setup(tmp_path, manifest, script_type="sh")
+
+        skill_files = [path for path in created if path.name == "SKILL.md"]
+        assert skill_files
+
+        skills_dir = tmp_path / ".claude" / "skills"
+        assert skills_dir.is_dir()
+
+        plan_skill = skills_dir / "speckit-plan" / "SKILL.md"
+        assert plan_skill.exists()
+
+        content = plan_skill.read_text(encoding="utf-8")
+        assert "{SCRIPT}" not in content
+        assert "{ARGS}" not in content
+        assert "__AGENT__" not in content
+
+        parts = content.split("---", 2)
+        parsed = yaml.safe_load(parts[1])
+        assert parsed["name"] == "speckit-plan"
+        assert parsed["disable-model-invocation"] is True
+        assert parsed["metadata"]["source"] == "templates/commands/plan.md"
+
+    def test_setup_installs_update_context_scripts(self, tmp_path):
+        integration = get_integration("claude")
+        manifest = IntegrationManifest("claude", tmp_path)
+        created = integration.setup(tmp_path, manifest, script_type="sh")
+
+        scripts_dir = tmp_path / ".specify" / "integrations" / "claude" / "scripts"
+        assert scripts_dir.is_dir()
+        assert (scripts_dir / "update-context.sh").exists()
+        assert (scripts_dir / "update-context.ps1").exists()
+
+        tracked = {path.resolve().relative_to(tmp_path.resolve()).as_posix() for path in created}
+        assert ".specify/integrations/claude/scripts/update-context.sh" in tracked
+        assert ".specify/integrations/claude/scripts/update-context.ps1" in tracked
+
+    def test_ai_flag_auto_promotes_and_enables_skills(self, tmp_path):
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        project = tmp_path / "claude-promote"
+        project.mkdir()
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(project)
+            runner = CliRunner()
+            result = runner.invoke(
+                app,
+                [
+                    "init",
+                    "--here",
+                    "--ai",
+                    "claude",
+                    "--script",
+                    "sh",
+                    "--no-git",
+                    "--ignore-agent-tools",
+                ],
+                catch_exceptions=False,
+            )
+        finally:
+            os.chdir(old_cwd)
+
+        assert result.exit_code == 0, result.output
+        assert (project / ".claude" / "skills" / "speckit-plan" / "SKILL.md").exists()
+        assert not (project / ".claude" / "commands").exists()
+
+        init_options = json.loads(
+            (project / ".specify" / "init-options.json").read_text(encoding="utf-8")
+        )
+        assert init_options["ai"] == "claude"
+        assert init_options["ai_skills"] is True
+        assert init_options["integration"] == "claude"
+
+    def test_integration_flag_creates_skill_files(self, tmp_path):
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        project = tmp_path / "claude-integration"
+        project.mkdir()
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(project)
+            runner = CliRunner()
+            result = runner.invoke(
+                app,
+                [
+                    "init",
+                    "--here",
+                    "--integration",
+                    "claude",
+                    "--script",
+                    "sh",
+                    "--no-git",
+                    "--ignore-agent-tools",
+                ],
+                catch_exceptions=False,
+            )
+        finally:
+            os.chdir(old_cwd)
+
+        assert result.exit_code == 0, result.output
+        assert (project / ".claude" / "skills" / "speckit-specify" / "SKILL.md").exists()
+        assert (project / ".specify" / "integrations" / "claude.manifest.json").exists()
+
+    def test_interactive_claude_selection_uses_integration_path(self, tmp_path):
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        project = tmp_path / "claude-interactive"
+        project.mkdir()
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(project)
+            runner = CliRunner()
+            with patch("specify_cli.select_with_arrows", return_value="claude"):
+                result = runner.invoke(
+                    app,
+                    [
+                        "init",
+                        "--here",
+                        "--script",
+                        "sh",
+                        "--no-git",
+                        "--ignore-agent-tools",
+                    ],
+                    catch_exceptions=False,
+                )
+        finally:
+            os.chdir(old_cwd)
+
+        assert result.exit_code == 0, result.output
+        assert (project / ".specify" / "integration.json").exists()
+        assert (project / ".specify" / "integrations" / "claude.manifest.json").exists()
+
+        skill_file = project / ".claude" / "skills" / "speckit-plan" / "SKILL.md"
+        assert skill_file.exists()
+        assert "disable-model-invocation: true" in skill_file.read_text(encoding="utf-8")
+
+        init_options = json.loads(
+            (project / ".specify" / "init-options.json").read_text(encoding="utf-8")
+        )
+        assert init_options["ai"] == "claude"
+        assert init_options["ai_skills"] is True
+        assert init_options["integration"] == "claude"
+
+    def test_claude_init_remains_usable_when_converter_fails(self, tmp_path):
+        """Claude init should succeed even without install_ai_skills."""
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        runner = CliRunner()
+        target = tmp_path / "fail-proj"
+
+        result = runner.invoke(
+            app,
+            ["init", str(target), "--ai", "claude", "--script", "sh", "--no-git", "--ignore-agent-tools"],
+        )
+
+        assert result.exit_code == 0
+        assert (target / ".claude" / "skills" / "speckit-specify" / "SKILL.md").exists()
+
+    def test_claude_hooks_render_skill_invocation(self, tmp_path):
+        from specify_cli.extensions import HookExecutor
+
+        project = tmp_path / "claude-hooks"
+        project.mkdir()
+        init_options = project / ".specify" / "init-options.json"
+        init_options.parent.mkdir(parents=True, exist_ok=True)
+        init_options.write_text(json.dumps({"ai": "claude", "ai_skills": True}))
+
+        hook_executor = HookExecutor(project)
+        message = hook_executor.format_hook_message(
+            "before_plan",
+            [
+                {
+                    "extension": "test-ext",
+                    "command": "speckit.plan",
+                    "optional": False,
+                }
+            ],
+        )
+
+        assert "Executing: `/speckit-plan`" in message
+        assert "EXECUTE_COMMAND: speckit.plan" in message
+        assert "EXECUTE_COMMAND_INVOCATION: /speckit-plan" in message
+
+    def test_claude_preset_creates_new_skill_without_commands_dir(self, tmp_path):
+        from specify_cli import save_init_options
+        from specify_cli.presets import PresetManager
+
+        project = tmp_path / "claude-preset-skill"
+        project.mkdir()
+        save_init_options(project, {"ai": "claude", "ai_skills": True, "script": "sh"})
+
+        skills_dir = project / ".claude" / "skills"
+        skills_dir.mkdir(parents=True, exist_ok=True)
+
+        preset_dir = tmp_path / "claude-skill-command"
+        preset_dir.mkdir()
+        (preset_dir / "commands").mkdir()
+        (preset_dir / "commands" / "speckit.research.md").write_text(
+            "---\n"
+            "description: Research workflow\n"
+            "---\n\n"
+            "preset:claude-skill-command\n"
+        )
+        manifest_data = {
+            "schema_version": "1.0",
+            "preset": {
+                "id": "claude-skill-command",
+                "name": "Claude Skill Command",
+                "version": "1.0.0",
+                "description": "Test",
+            },
+            "requires": {"speckit_version": ">=0.1.0"},
+            "provides": {
+                "templates": [
+                    {
+                        "type": "command",
+                        "name": "speckit.research",
+                        "file": "commands/speckit.research.md",
+                    }
+                ]
+            },
+        }
+        with open(preset_dir / "preset.yml", "w") as f:
+            yaml.dump(manifest_data, f)
+
+        manager = PresetManager(project)
+        manager.install_from_directory(preset_dir, "0.1.5")
+
+        skill_file = skills_dir / "speckit-research" / "SKILL.md"
+        assert skill_file.exists()
+        content = skill_file.read_text(encoding="utf-8")
+        assert "preset:claude-skill-command" in content
+        assert "name: speckit-research" in content
+        assert "disable-model-invocation: true" in content
+
+        metadata = manager.registry.get("claude-skill-command")
+        assert "speckit-research" in metadata.get("registered_skills", [])
--- a/tests/integrations/test_integration_codex.py
+++ b/tests/integrations/test_integration_codex.py
@@ -0,0 +1,27 @@
+"""Tests for CodexIntegration."""
+
+from .test_integration_base_skills import SkillsIntegrationTests
+
+
+class TestCodexIntegration(SkillsIntegrationTests):
+    KEY = "codex"
+    FOLDER = ".agents/"
+    COMMANDS_SUBDIR = "skills"
+    REGISTRAR_DIR = ".agents/skills"
+    CONTEXT_FILE = "AGENTS.md"
+
+
+class TestCodexAutoPromote:
+    """--ai codex auto-promotes to integration path."""
+
+    def test_ai_codex_without_ai_skills_auto_promotes(self, tmp_path):
+        """--ai codex should work the same as --integration codex."""
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        runner = CliRunner()
+        target = tmp_path / "test-proj"
+        result = runner.invoke(app, ["init", str(target), "--ai", "codex", "--no-git", "--ignore-agent-tools", "--script", "sh"])
+
+        assert result.exit_code == 0, f"init --ai codex failed: {result.output}"
+        assert (target / ".agents" / "skills" / "speckit-plan" / "SKILL.md").exists()
--- a/tests/integrations/test_integration_generic.py
+++ b/tests/integrations/test_integration_generic.py
@@ -0,0 +1,311 @@
+"""Tests for GenericIntegration."""
+
+import os
+
+import pytest
+
+from specify_cli.integrations import get_integration
+from specify_cli.integrations.base import MarkdownIntegration
+from specify_cli.integrations.manifest import IntegrationManifest
+
+
+class TestGenericIntegration:
+    """Tests for GenericIntegration — requires --commands-dir option."""
+
+    # -- Registration -----------------------------------------------------
+
+    def test_registered(self):
+        from specify_cli.integrations import INTEGRATION_REGISTRY
+        assert "generic" in INTEGRATION_REGISTRY
+
+    def test_is_markdown_integration(self):
+        assert isinstance(get_integration("generic"), MarkdownIntegration)
+
+    # -- Config -----------------------------------------------------------
+
+    def test_config_folder_is_none(self):
+        i = get_integration("generic")
+        assert i.config["folder"] is None
+
+    def test_config_requires_cli_false(self):
+        i = get_integration("generic")
+        assert i.config["requires_cli"] is False
+
+    def test_context_file_is_none(self):
+        i = get_integration("generic")
+        assert i.context_file is None
+
+    # -- Options ----------------------------------------------------------
+
+    def test_options_include_commands_dir(self):
+        i = get_integration("generic")
+        opts = i.options()
+        assert len(opts) == 1
+        assert opts[0].name == "--commands-dir"
+        assert opts[0].required is True
+        assert opts[0].is_flag is False
+
+    # -- Setup / teardown -------------------------------------------------
+
+    def test_setup_requires_commands_dir(self, tmp_path):
+        i = get_integration("generic")
+        m = IntegrationManifest("generic", tmp_path)
+        with pytest.raises(ValueError, match="--commands-dir is required"):
+            i.setup(tmp_path, m, parsed_options={})
+
+    def test_setup_requires_nonempty_commands_dir(self, tmp_path):
+        i = get_integration("generic")
+        m = IntegrationManifest("generic", tmp_path)
+        with pytest.raises(ValueError, match="--commands-dir is required"):
+            i.setup(tmp_path, m, parsed_options={"commands_dir": ""})
+
+    def test_setup_writes_to_correct_directory(self, tmp_path):
+        i = get_integration("generic")
+        m = IntegrationManifest("generic", tmp_path)
+        created = i.setup(
+            tmp_path, m,
+            parsed_options={"commands_dir": ".myagent/commands"},
+        )
+        expected_dir = tmp_path / ".myagent" / "commands"
+        assert expected_dir.exists(), f"Expected directory {expected_dir} was not created"
+        cmd_files = [f for f in created if "scripts" not in f.parts]
+        assert len(cmd_files) > 0, "No command files were created"
+        for f in cmd_files:
+            assert f.resolve().parent == expected_dir.resolve(), (
+                f"{f} is not under {expected_dir}"
+            )
+
+    def test_setup_creates_md_files(self, tmp_path):
+        i = get_integration("generic")
+        m = IntegrationManifest("generic", tmp_path)
+        created = i.setup(
+            tmp_path, m,
+            parsed_options={"commands_dir": ".custom/cmds"},
+        )
+        cmd_files = [f for f in created if "scripts" not in f.parts]
+        assert len(cmd_files) > 0
+        for f in cmd_files:
+            assert f.name.startswith("speckit.")
+            assert f.name.endswith(".md")
+
+    def test_templates_are_processed(self, tmp_path):
+        i = get_integration("generic")
+        m = IntegrationManifest("generic", tmp_path)
+        created = i.setup(
+            tmp_path, m,
+            parsed_options={"commands_dir": ".custom/cmds"},
+        )
+        cmd_files = [f for f in created if "scripts" not in f.parts]
+        for f in cmd_files:
+            content = f.read_text(encoding="utf-8")
+            assert "{SCRIPT}" not in content, f"{f.name} has unprocessed {{SCRIPT}}"
+            assert "__AGENT__" not in content, f"{f.name} has unprocessed __AGENT__"
+            assert "{ARGS}" not in content, f"{f.name} has unprocessed {{ARGS}}"
+
+    def test_all_files_tracked_in_manifest(self, tmp_path):
+        i = get_integration("generic")
+        m = IntegrationManifest("generic", tmp_path)
+        created = i.setup(
+            tmp_path, m,
+            parsed_options={"commands_dir": ".custom/cmds"},
+        )
+        for f in created:
+            rel = f.resolve().relative_to(tmp_path.resolve()).as_posix()
+            assert rel in m.files, f"{rel} not tracked in manifest"
+
+    def test_install_uninstall_roundtrip(self, tmp_path):
+        i = get_integration("generic")
+        m = IntegrationManifest("generic", tmp_path)
+        created = i.install(
+            tmp_path, m,
+            parsed_options={"commands_dir": ".custom/cmds"},
+        )
+        assert len(created) > 0
+        m.save()
+        for f in created:
+            assert f.exists()
+        removed, skipped = i.uninstall(tmp_path, m)
+        assert len(removed) == len(created)
+        assert skipped == []
+
+    def test_modified_file_survives_uninstall(self, tmp_path):
+        i = get_integration("generic")
+        m = IntegrationManifest("generic", tmp_path)
+        created = i.install(
+            tmp_path, m,
+            parsed_options={"commands_dir": ".custom/cmds"},
+        )
+        m.save()
+        modified = created[0]
+        modified.write_text("user modified this", encoding="utf-8")
+        removed, skipped = i.uninstall(tmp_path, m)
+        assert modified.exists()
+        assert modified in skipped
+
+    def test_different_commands_dirs(self, tmp_path):
+        """Generic should work with various user-specified paths."""
+        for path in [".agent/commands", "tools/ai-cmds", ".custom/prompts"]:
+            project = tmp_path / path.replace("/", "-")
+            project.mkdir()
+            i = get_integration("generic")
+            m = IntegrationManifest("generic", project)
+            created = i.setup(
+                project, m,
+                parsed_options={"commands_dir": path},
+            )
+            expected = project / path
+            assert expected.is_dir(), f"Dir {expected} not created for {path}"
+            cmd_files = [f for f in created if "scripts" not in f.parts]
+            assert len(cmd_files) > 0
+
+    # -- Scripts ----------------------------------------------------------
+
+    def test_setup_installs_update_context_scripts(self, tmp_path):
+        i = get_integration("generic")
+        m = IntegrationManifest("generic", tmp_path)
+        i.setup(tmp_path, m, parsed_options={"commands_dir": ".custom/cmds"})
+        scripts_dir = tmp_path / ".specify" / "integrations" / "generic" / "scripts"
+        assert scripts_dir.is_dir(), "Scripts directory not created for generic"
+        assert (scripts_dir / "update-context.sh").exists()
+        assert (scripts_dir / "update-context.ps1").exists()
+
+    def test_scripts_tracked_in_manifest(self, tmp_path):
+        i = get_integration("generic")
+        m = IntegrationManifest("generic", tmp_path)
+        i.setup(tmp_path, m, parsed_options={"commands_dir": ".custom/cmds"})
+        script_rels = [k for k in m.files if "update-context" in k]
+        assert len(script_rels) >= 2
+
+    def test_sh_script_is_executable(self, tmp_path):
+        i = get_integration("generic")
+        m = IntegrationManifest("generic", tmp_path)
+        i.setup(tmp_path, m, parsed_options={"commands_dir": ".custom/cmds"})
+        sh = tmp_path / ".specify" / "integrations" / "generic" / "scripts" / "update-context.sh"
+        assert os.access(sh, os.X_OK)
+
+    # -- CLI --------------------------------------------------------------
+
+    def test_cli_generic_without_commands_dir_fails(self, tmp_path):
+        """--integration generic without --ai-commands-dir should fail."""
+        from typer.testing import CliRunner
+        from specify_cli import app
+        runner = CliRunner()
+        result = runner.invoke(app, [
+            "init", str(tmp_path / "test-generic"), "--integration", "generic",
+            "--script", "sh", "--no-git",
+        ])
+        # Generic requires --commands-dir / --ai-commands-dir
+        # The integration path validates via setup()
+        assert result.exit_code != 0
+
+    def test_complete_file_inventory_sh(self, tmp_path):
+        """Every file produced by specify init --integration generic --ai-commands-dir ... --script sh."""
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        project = tmp_path / "inventory-generic-sh"
+        project.mkdir()
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(project)
+            result = CliRunner().invoke(app, [
+                "init", "--here", "--integration", "generic",
+                "--ai-commands-dir", ".myagent/commands",
+                "--script", "sh", "--no-git",
+            ], catch_exceptions=False)
+        finally:
+            os.chdir(old_cwd)
+        assert result.exit_code == 0, f"init failed: {result.output}"
+        actual = sorted(
+            p.relative_to(project).as_posix()
+            for p in project.rglob("*") if p.is_file()
+        )
+        expected = sorted([
+            ".myagent/commands/speckit.analyze.md",
+            ".myagent/commands/speckit.checklist.md",
+            ".myagent/commands/speckit.clarify.md",
+            ".myagent/commands/speckit.constitution.md",
+            ".myagent/commands/speckit.implement.md",
+            ".myagent/commands/speckit.plan.md",
+            ".myagent/commands/speckit.specify.md",
+            ".myagent/commands/speckit.tasks.md",
+            ".myagent/commands/speckit.taskstoissues.md",
+            ".specify/init-options.json",
+            ".specify/integration.json",
+            ".specify/integrations/generic.manifest.json",
+            ".specify/integrations/generic/scripts/update-context.ps1",
+            ".specify/integrations/generic/scripts/update-context.sh",
+            ".specify/integrations/speckit.manifest.json",
+            ".specify/memory/constitution.md",
+            ".specify/scripts/bash/check-prerequisites.sh",
+            ".specify/scripts/bash/common.sh",
+            ".specify/scripts/bash/create-new-feature.sh",
+            ".specify/scripts/bash/setup-plan.sh",
+            ".specify/scripts/bash/update-agent-context.sh",
+            ".specify/templates/agent-file-template.md",
+            ".specify/templates/checklist-template.md",
+            ".specify/templates/constitution-template.md",
+            ".specify/templates/plan-template.md",
+            ".specify/templates/spec-template.md",
+            ".specify/templates/tasks-template.md",
+        ])
+        assert actual == expected, (
+            f"Missing: {sorted(set(expected) - set(actual))}\n"
+            f"Extra: {sorted(set(actual) - set(expected))}"
+        )
+
+    def test_complete_file_inventory_ps(self, tmp_path):
+        """Every file produced by specify init --integration generic --ai-commands-dir ... --script ps."""
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        project = tmp_path / "inventory-generic-ps"
+        project.mkdir()
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(project)
+            result = CliRunner().invoke(app, [
+                "init", "--here", "--integration", "generic",
+                "--ai-commands-dir", ".myagent/commands",
+                "--script", "ps", "--no-git",
+            ], catch_exceptions=False)
+        finally:
+            os.chdir(old_cwd)
+        assert result.exit_code == 0, f"init failed: {result.output}"
+        actual = sorted(
+            p.relative_to(project).as_posix()
+            for p in project.rglob("*") if p.is_file()
+        )
+        expected = sorted([
+            ".myagent/commands/speckit.analyze.md",
+            ".myagent/commands/speckit.checklist.md",
+            ".myagent/commands/speckit.clarify.md",
+            ".myagent/commands/speckit.constitution.md",
+            ".myagent/commands/speckit.implement.md",
+            ".myagent/commands/speckit.plan.md",
+            ".myagent/commands/speckit.specify.md",
+            ".myagent/commands/speckit.tasks.md",
+            ".myagent/commands/speckit.taskstoissues.md",
+            ".specify/init-options.json",
+            ".specify/integration.json",
+            ".specify/integrations/generic.manifest.json",
+            ".specify/integrations/generic/scripts/update-context.ps1",
+            ".specify/integrations/generic/scripts/update-context.sh",
+            ".specify/integrations/speckit.manifest.json",
+            ".specify/memory/constitution.md",
+            ".specify/scripts/powershell/check-prerequisites.ps1",
+            ".specify/scripts/powershell/common.ps1",
+            ".specify/scripts/powershell/create-new-feature.ps1",
+            ".specify/scripts/powershell/setup-plan.ps1",
+            ".specify/scripts/powershell/update-agent-context.ps1",
+            ".specify/templates/agent-file-template.md",
+            ".specify/templates/checklist-template.md",
+            ".specify/templates/constitution-template.md",
+            ".specify/templates/plan-template.md",
+            ".specify/templates/spec-template.md",
+            ".specify/templates/tasks-template.md",
+        ])
+        assert actual == expected, (
+            f"Missing: {sorted(set(expected) - set(actual))}\n"
+            f"Extra: {sorted(set(actual) - set(expected))}"
+        )
--- a/tests/integrations/test_integration_kimi.py
+++ b/tests/integrations/test_integration_kimi.py
@@ -0,0 +1,149 @@
+"""Tests for KimiIntegration — skills integration with legacy migration."""
+
+from specify_cli.integrations import get_integration
+from specify_cli.integrations.kimi import _migrate_legacy_kimi_dotted_skills
+from specify_cli.integrations.manifest import IntegrationManifest
+
+from .test_integration_base_skills import SkillsIntegrationTests
+
+
+class TestKimiIntegration(SkillsIntegrationTests):
+    KEY = "kimi"
+    FOLDER = ".kimi/"
+    COMMANDS_SUBDIR = "skills"
+    REGISTRAR_DIR = ".kimi/skills"
+    CONTEXT_FILE = "KIMI.md"
+
+
+class TestKimiOptions:
+    """Kimi declares --skills and --migrate-legacy options."""
+
+    def test_migrate_legacy_option(self):
+        i = get_integration("kimi")
+        opts = i.options()
+        migrate_opts = [o for o in opts if o.name == "--migrate-legacy"]
+        assert len(migrate_opts) == 1
+        assert migrate_opts[0].is_flag is True
+        assert migrate_opts[0].default is False
+
+
+class TestKimiLegacyMigration:
+    """Test Kimi dotted → hyphenated skill directory migration."""
+
+    def test_migrate_dotted_to_hyphenated(self, tmp_path):
+        skills_dir = tmp_path / ".kimi" / "skills"
+        legacy = skills_dir / "speckit.plan"
+        legacy.mkdir(parents=True)
+        (legacy / "SKILL.md").write_text("# Plan Skill\n")
+
+        migrated, removed = _migrate_legacy_kimi_dotted_skills(skills_dir)
+
+        assert migrated == 1
+        assert removed == 0
+        assert not legacy.exists()
+        assert (skills_dir / "speckit-plan" / "SKILL.md").exists()
+
+    def test_skip_when_target_exists_different_content(self, tmp_path):
+        skills_dir = tmp_path / ".kimi" / "skills"
+        legacy = skills_dir / "speckit.plan"
+        legacy.mkdir(parents=True)
+        (legacy / "SKILL.md").write_text("# Old\n")
+
+        target = skills_dir / "speckit-plan"
+        target.mkdir(parents=True)
+        (target / "SKILL.md").write_text("# New (different)\n")
+
+        migrated, removed = _migrate_legacy_kimi_dotted_skills(skills_dir)
+
+        assert migrated == 0
+        assert removed == 0
+        assert legacy.exists()
+        assert target.exists()
+
+    def test_remove_when_target_exists_same_content(self, tmp_path):
+        skills_dir = tmp_path / ".kimi" / "skills"
+        content = "# Identical\n"
+        legacy = skills_dir / "speckit.plan"
+        legacy.mkdir(parents=True)
+        (legacy / "SKILL.md").write_text(content)
+
+        target = skills_dir / "speckit-plan"
+        target.mkdir(parents=True)
+        (target / "SKILL.md").write_text(content)
+
+        migrated, removed = _migrate_legacy_kimi_dotted_skills(skills_dir)
+
+        assert migrated == 0
+        assert removed == 1
+        assert not legacy.exists()
+        assert target.exists()
+
+    def test_preserve_legacy_with_extra_files(self, tmp_path):
+        skills_dir = tmp_path / ".kimi" / "skills"
+        content = "# Same\n"
+        legacy = skills_dir / "speckit.plan"
+        legacy.mkdir(parents=True)
+        (legacy / "SKILL.md").write_text(content)
+        (legacy / "extra.md").write_text("user file")
+
+        target = skills_dir / "speckit-plan"
+        target.mkdir(parents=True)
+        (target / "SKILL.md").write_text(content)
+
+        migrated, removed = _migrate_legacy_kimi_dotted_skills(skills_dir)
+
+        assert migrated == 0
+        assert removed == 0
+        assert legacy.exists()
+
+    def test_nonexistent_dir_returns_zeros(self, tmp_path):
+        migrated, removed = _migrate_legacy_kimi_dotted_skills(
+            tmp_path / ".kimi" / "skills"
+        )
+        assert migrated == 0
+        assert removed == 0
+
+    def test_setup_with_migrate_legacy_option(self, tmp_path):
+        """KimiIntegration.setup() with --migrate-legacy migrates dotted dirs."""
+        i = get_integration("kimi")
+
+        skills_dir = tmp_path / ".kimi" / "skills"
+        legacy = skills_dir / "speckit.oldcmd"
+        legacy.mkdir(parents=True)
+        (legacy / "SKILL.md").write_text("# Legacy\n")
+
+        m = IntegrationManifest("kimi", tmp_path)
+        i.setup(tmp_path, m, parsed_options={"migrate_legacy": True})
+
+        assert not legacy.exists()
+        assert (skills_dir / "speckit-oldcmd" / "SKILL.md").exists()
+        # New skills from templates should also exist
+        assert (skills_dir / "speckit-specify" / "SKILL.md").exists()
+
+
+class TestKimiNextSteps:
+    """CLI output tests for kimi next-steps display."""
+
+    def test_next_steps_show_skill_invocation(self, tmp_path):
+        """Kimi next-steps guidance should display /skill:speckit-* usage."""
+        import os
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        project = tmp_path / "kimi-next-steps"
+        project.mkdir()
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(project)
+            runner = CliRunner()
+            result = runner.invoke(app, [
+                "init", "--here", "--ai", "kimi", "--no-git",
+                "--ignore-agent-tools", "--script", "sh",
+            ], catch_exceptions=False)
+        finally:
+            os.chdir(old_cwd)
+
+        assert result.exit_code == 0
+        assert "/skill:speckit-constitution" in result.output
+        assert "/speckit.constitution" not in result.output
+        assert "Optional skills that you can use for your specs" in result.output
--- a/tests/integrations/test_integration_kiro_cli.py
+++ b/tests/integrations/test_integration_kiro_cli.py
@@ -1,5 +1,7 @@
 """Tests for KiroCliIntegration."""

+import os
+
 from .test_integration_base_markdown import MarkdownIntegrationTests


@@ -9,3 +11,29 @@ class TestKiroCliIntegration(MarkdownIntegrationTests):
    COMMANDS_SUBDIR = "prompts"
    REGISTRAR_DIR = ".kiro/prompts"
    CONTEXT_FILE = "AGENTS.md"
+
+
+class TestKiroAlias:
+    """--ai kiro alias normalizes to kiro-cli and auto-promotes."""
+
+    def test_kiro_alias_normalized_to_kiro_cli(self, tmp_path):
+        """--ai kiro should normalize to canonical kiro-cli and auto-promote."""
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        target = tmp_path / "kiro-alias-proj"
+        target.mkdir()
+
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(target)
+            runner = CliRunner()
+            result = runner.invoke(app, [
+                "init", "--here", "--ai", "kiro",
+                "--ignore-agent-tools", "--script", "sh", "--no-git",
+            ], catch_exceptions=False)
+        finally:
+            os.chdir(old_cwd)
+
+        assert result.exit_code == 0
+        assert (target / ".kiro" / "prompts" / "speckit.plan.md").exists()
--- a/tests/integrations/test_registry.py
+++ b/tests/integrations/test_registry.py
@@ -11,13 +11,17 @@ from specify_cli.integrations.base import MarkdownIntegration
 from .conftest import StubIntegration


-# Every integration key that must be registered (Stage 2 + Stage 3).
+# Every integration key that must be registered (Stage 2 + Stage 3 + Stage 4 + Stage 5).
 ALL_INTEGRATION_KEYS = [
    "copilot",
    # Stage 3 — standard markdown integrations
    "claude", "qwen", "opencode", "junie", "kilocode", "auggie",
    "roo", "codebuddy", "qodercli", "amp", "shai", "bob", "trae",
    "pi", "iflow", "kiro-cli", "windsurf", "vibe", "cursor-agent",
+    # Stage 4 — TOML integrations
+    "gemini", "tabnine",
+    # Stage 5 — skills, generic & option-driven integrations
+    "codex", "kimi", "agy", "generic",
 ]


@@ -61,9 +65,16 @@ class TestRegistryCompleteness:


 class TestRegistrarKeyAlignment:
-    """Every integration key must have a matching AGENT_CONFIGS entry."""
+    """Every integration key must have a matching AGENT_CONFIGS entry.

-    @pytest.mark.parametrize("key", ALL_INTEGRATION_KEYS)
+    ``generic`` is excluded because it has no fixed directory — its
+    output path comes from ``--commands-dir`` at runtime.
+    """
+
+    @pytest.mark.parametrize(
+        "key",
+        [k for k in ALL_INTEGRATION_KEYS if k != "generic"],
+    )
    def test_integration_key_in_registrar(self, key):
        from specify_cli.agents import CommandRegistrar
        assert key in CommandRegistrar.AGENT_CONFIGS, (
--- a/tests/test_agent_config_consistency.py
+++ b/tests/test_agent_config_consistency.py
@@ -1,4 +1,4 @@
-"""Consistency checks for agent configuration across runtime and packaging scripts."""
+"""Consistency checks for agent configuration across runtime surfaces."""

 import re
 from pathlib import Path
@@ -41,52 +41,6 @@ class TestAgentConfigConsistency:
        assert AGENT_CONFIG["codex"]["folder"] == ".agents/"
        assert AGENT_CONFIG["codex"]["commands_subdir"] == "skills"

-    def test_release_agent_lists_include_kiro_cli_and_exclude_q(self):
-        """Bash and PowerShell release scripts should agree on agent key set for Kiro."""
-        sh_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.sh").read_text(encoding="utf-8")
-        ps_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.ps1").read_text(encoding="utf-8")
-
-        sh_match = re.search(r"ALL_AGENTS=\(([^)]*)\)", sh_text)
-        assert sh_match is not None
-        sh_agents = sh_match.group(1).split()
-
-        ps_match = re.search(r"\$AllAgents = @\(([^)]*)\)", ps_text)
-        assert ps_match is not None
-        ps_agents = re.findall(r"'([^']+)'", ps_match.group(1))
-
-        assert "kiro-cli" in sh_agents
-        assert "kiro-cli" in ps_agents
-        assert "shai" in sh_agents
-        assert "shai" in ps_agents
-        assert "agy" in sh_agents
-        assert "agy" in ps_agents
-        assert "q" not in sh_agents
-        assert "q" not in ps_agents
-
-    def test_release_ps_switch_has_shai_and_agy_generation(self):
-        """PowerShell release builder must generate files for shai and agy agents."""
-        ps_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.ps1").read_text(encoding="utf-8")
-
-        assert re.search(r"'shai'\s*\{.*?\.shai/commands", ps_text, re.S) is not None
-        assert re.search(r"'agy'\s*\{.*?\.agent/commands", ps_text, re.S) is not None
-
-    def test_release_sh_switch_has_shai_and_agy_generation(self):
-        """Bash release builder must generate files for shai and agy agents."""
-        sh_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.sh").read_text(encoding="utf-8")
-
-        assert re.search(r"shai\)\s*\n.*?\.shai/commands", sh_text, re.S) is not None
-        assert re.search(r"agy\)\s*\n.*?\.agent/commands", sh_text, re.S) is not None
-
-    def test_release_scripts_generate_codex_skills(self):
-        """Release scripts should generate Codex skills in .agents/skills."""
-        sh_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.sh").read_text(encoding="utf-8")
-        ps_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.ps1").read_text(encoding="utf-8")
-
-        assert ".agents/skills" in sh_text
-        assert ".agents/skills" in ps_text
-        assert re.search(r"codex\)\s*\n.*?create_skills.*?\.agents/skills.*?\"-\"", sh_text, re.S) is not None
-        assert re.search(r"'codex'\s*\{.*?\.agents/skills.*?New-Skills.*?-Separator '-'", ps_text, re.S) is not None
-
    def test_init_ai_help_includes_roo_and_kiro_alias(self):
        """CLI help text for --ai should stay in sync with agent config and alias guidance."""
        assert "roo" in AI_ASSISTANT_HELP
@@ -102,22 +56,6 @@ class TestAgentConfigConsistency:
        assert "sha256sum -c -" in post_create_text
        assert "KIRO_SKIP_KIRO_INSTALLER_VERIFY" not in post_create_text

-    def test_release_output_targets_kiro_prompt_dir(self):
-        """Packaging and release scripts should no longer emit amazonq artifacts."""
-        sh_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.sh").read_text(encoding="utf-8")
-        ps_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.ps1").read_text(encoding="utf-8")
-        gh_release_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-github-release.sh").read_text(encoding="utf-8")
-
-        assert ".kiro/prompts" in sh_text
-        assert ".kiro/prompts" in ps_text
-        assert ".amazonq/prompts" not in sh_text
-        assert ".amazonq/prompts" not in ps_text
-
-        assert "spec-kit-template-kiro-cli-sh-" in gh_release_text
-        assert "spec-kit-template-kiro-cli-ps-" in gh_release_text
-        assert "spec-kit-template-q-sh-" not in gh_release_text
-        assert "spec-kit-template-q-ps-" not in gh_release_text
-
    def test_agent_context_scripts_use_kiro_cli(self):
        """Agent context scripts should advertise kiro-cli and not legacy q agent key."""
        bash_text = (REPO_ROOT / "scripts" / "bash" / "update-agent-context.sh").read_text(encoding="utf-8")
@@ -149,38 +87,6 @@ class TestAgentConfigConsistency:
        assert cfg["args"] == "{{args}}"
        assert cfg["extension"] == ".toml"

-    def test_release_agent_lists_include_tabnine(self):
-        """Bash and PowerShell release scripts should include tabnine in agent lists."""
-        sh_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.sh").read_text(encoding="utf-8")
-        ps_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.ps1").read_text(encoding="utf-8")
-
-        sh_match = re.search(r"ALL_AGENTS=\(([^)]*)\)", sh_text)
-        assert sh_match is not None
-        sh_agents = sh_match.group(1).split()
-
-        ps_match = re.search(r"\$AllAgents = @\(([^)]*)\)", ps_text)
-        assert ps_match is not None
-        ps_agents = re.findall(r"'([^']+)'", ps_match.group(1))
-
-        assert "tabnine" in sh_agents
-        assert "tabnine" in ps_agents
-
-    def test_release_scripts_generate_tabnine_toml_commands(self):
-        """Release scripts should generate TOML commands for tabnine in .tabnine/agent/commands."""
-        sh_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.sh").read_text(encoding="utf-8")
-        ps_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.ps1").read_text(encoding="utf-8")
-
-        assert ".tabnine/agent/commands" in sh_text
-        assert ".tabnine/agent/commands" in ps_text
-        assert re.search(r"'tabnine'\s*\{.*?\.tabnine/agent/commands", ps_text, re.S) is not None
-
-    def test_github_release_includes_tabnine_packages(self):
-        """GitHub release script should include tabnine template packages."""
-        gh_release_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-github-release.sh").read_text(encoding="utf-8")
-
-        assert "spec-kit-template-tabnine-sh-" in gh_release_text
-        assert "spec-kit-template-tabnine-ps-" in gh_release_text
-
    def test_agent_context_scripts_include_tabnine(self):
        """Agent context scripts should support tabnine agent type."""
        bash_text = (REPO_ROOT / "scripts" / "bash" / "update-agent-context.sh").read_text(encoding="utf-8")
@@ -213,22 +119,6 @@ class TestAgentConfigConsistency:
        assert kimi_cfg["dir"] == ".kimi/skills"
        assert kimi_cfg["extension"] == "/SKILL.md"

-    def test_kimi_in_release_agent_lists(self):
-        """Bash and PowerShell release scripts should include kimi in agent lists."""
-        sh_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.sh").read_text(encoding="utf-8")
-        ps_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.ps1").read_text(encoding="utf-8")
-
-        sh_match = re.search(r"ALL_AGENTS=\(([^)]*)\)", sh_text)
-        assert sh_match is not None
-        sh_agents = sh_match.group(1).split()
-
-        ps_match = re.search(r"\$AllAgents = @\(([^)]*)\)", ps_text)
-        assert ps_match is not None
-        ps_agents = re.findall(r"'([^']+)'", ps_match.group(1))
-
-        assert "kimi" in sh_agents
-        assert "kimi" in ps_agents
-
    def test_kimi_in_powershell_validate_set(self):
        """PowerShell update-agent-context script should include 'kimi' in ValidateSet."""
        ps_text = (REPO_ROOT / "scripts" / "powershell" / "update-agent-context.ps1").read_text(encoding="utf-8")
@@ -239,13 +129,6 @@ class TestAgentConfigConsistency:

        assert "kimi" in validate_set_values

-    def test_kimi_in_github_release_output(self):
-        """GitHub release script should include kimi template packages."""
-        gh_release_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-github-release.sh").read_text(encoding="utf-8")
-
-        assert "spec-kit-template-kimi-sh-" in gh_release_text
-        assert "spec-kit-template-kimi-ps-" in gh_release_text
-
    def test_ai_help_includes_kimi(self):
        """CLI help text for --ai should include kimi."""
        assert "kimi" in AI_ASSISTANT_HELP
@@ -270,38 +153,6 @@ class TestAgentConfigConsistency:
        assert trae_cfg["args"] == "$ARGUMENTS"
        assert trae_cfg["extension"] == ".md"

-    def test_trae_in_release_agent_lists(self):
-        """Bash and PowerShell release scripts should include trae in agent lists."""
-        sh_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.sh").read_text(encoding="utf-8")
-        ps_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.ps1").read_text(encoding="utf-8")
-
-        sh_match = re.search(r"ALL_AGENTS=\(([^)]*)\)", sh_text)
-        assert sh_match is not None
-        sh_agents = sh_match.group(1).split()
-
-        ps_match = re.search(r"\$AllAgents = @\(([^)]*)\)", ps_text)
-        assert ps_match is not None
-        ps_agents = re.findall(r"'([^']+)'", ps_match.group(1))
-
-        assert "trae" in sh_agents
-        assert "trae" in ps_agents
-
-    def test_trae_in_release_scripts_generate_commands(self):
-        """Release scripts should generate markdown commands for trae in .trae/rules."""
-        sh_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.sh").read_text(encoding="utf-8")
-        ps_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.ps1").read_text(encoding="utf-8")
-
-        assert ".trae/rules" in sh_text
-        assert ".trae/rules" in ps_text
-        assert re.search(r"'trae'\s*\{.*?\.trae/rules", ps_text, re.S) is not None
-
-    def test_trae_in_github_release_output(self):
-        """GitHub release script should include trae template packages."""
-        gh_release_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-github-release.sh").read_text(encoding="utf-8")
-
-        assert "spec-kit-template-trae-sh-" in gh_release_text
-        assert "spec-kit-template-trae-ps-" in gh_release_text
-
    def test_trae_in_agent_context_scripts(self):
        """Agent context scripts should support trae agent type."""
        bash_text = (REPO_ROOT / "scripts" / "bash" / "update-agent-context.sh").read_text(encoding="utf-8")
@@ -347,32 +198,6 @@ class TestAgentConfigConsistency:
        assert pi_cfg["args"] == "$ARGUMENTS"
        assert pi_cfg["extension"] == ".md"

-    def test_pi_in_release_agent_lists(self):
-        """Bash and PowerShell release scripts should include pi in agent lists."""
-        sh_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.sh").read_text(encoding="utf-8")
-        ps_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.ps1").read_text(encoding="utf-8")
-
-        sh_match = re.search(r"ALL_AGENTS=\(([^)]*)\)", sh_text)
-        assert sh_match is not None
-        sh_agents = sh_match.group(1).split()
-
-        ps_match = re.search(r"\$AllAgents = @\(([^)]*)\)", ps_text)
-        assert ps_match is not None
-        ps_agents = re.findall(r"'([^']+)'", ps_match.group(1))
-
-        assert "pi" in sh_agents
-        assert "pi" in ps_agents
-
-    def test_release_scripts_generate_pi_prompt_templates(self):
-        """Release scripts should generate Markdown prompt templates for pi in .pi/prompts."""
-        sh_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.sh").read_text(encoding="utf-8")
-        ps_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.ps1").read_text(encoding="utf-8")
-
-        assert ".pi/prompts" in sh_text
-        assert ".pi/prompts" in ps_text
-        assert re.search(r"pi\)\s*\n.*?\.pi/prompts", sh_text, re.S) is not None
-        assert re.search(r"'pi'\s*\{.*?\.pi/prompts", ps_text, re.S) is not None
-
    def test_pi_in_powershell_validate_set(self):
        """PowerShell update-agent-context script should include 'pi' in ValidateSet."""
        ps_text = (REPO_ROOT / "scripts" / "powershell" / "update-agent-context.ps1").read_text(encoding="utf-8")
@@ -383,13 +208,6 @@ class TestAgentConfigConsistency:

        assert "pi" in validate_set_values

-    def test_pi_in_github_release_output(self):
-        """GitHub release script should include pi template packages."""
-        gh_release_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-github-release.sh").read_text(encoding="utf-8")
-
-        assert "spec-kit-template-pi-sh-" in gh_release_text
-        assert "spec-kit-template-pi-ps-" in gh_release_text
-
    def test_agent_context_scripts_include_pi(self):
        """Agent context scripts should support pi agent type."""
        bash_text = (REPO_ROOT / "scripts" / "bash" / "update-agent-context.sh").read_text(encoding="utf-8")
@@ -422,38 +240,6 @@ class TestAgentConfigConsistency:
        assert cfg["iflow"]["format"] == "markdown"
        assert cfg["iflow"]["args"] == "$ARGUMENTS"

-    def test_iflow_in_release_agent_lists(self):
-        """Bash and PowerShell release scripts should include iflow in agent lists."""
-        sh_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.sh").read_text(encoding="utf-8")
-        ps_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.ps1").read_text(encoding="utf-8")
-
-        sh_match = re.search(r"ALL_AGENTS=\(([^)]*)\)", sh_text)
-        assert sh_match is not None
-        sh_agents = sh_match.group(1).split()
-
-        ps_match = re.search(r"\$AllAgents = @\(([^)]*)\)", ps_text)
-        assert ps_match is not None
-        ps_agents = re.findall(r"'([^']+)'", ps_match.group(1))
-
-        assert "iflow" in sh_agents
-        assert "iflow" in ps_agents
-
-    def test_iflow_in_release_scripts_build_variant(self):
-        """Release scripts should generate Markdown commands for iflow in .iflow/commands."""
-        sh_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.sh").read_text(encoding="utf-8")
-        ps_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-release-packages.ps1").read_text(encoding="utf-8")
-
-        assert ".iflow/commands" in sh_text
-        assert ".iflow/commands" in ps_text
-        assert re.search(r"'iflow'\s*\{.*?\.iflow/commands", ps_text, re.S) is not None
-
-    def test_iflow_in_github_release_output(self):
-        """GitHub release script should include iflow template packages."""
-        gh_release_text = (REPO_ROOT / ".github" / "workflows" / "scripts" / "create-github-release.sh").read_text(encoding="utf-8")
-
-        assert "spec-kit-template-iflow-sh-" in gh_release_text
-        assert "spec-kit-template-iflow-ps-" in gh_release_text
-
    def test_iflow_in_agent_context_scripts(self):
        """Agent context scripts should support iflow agent type."""
        bash_text = (REPO_ROOT / "scripts" / "bash" / "update-agent-context.sh").read_text(encoding="utf-8")
--- a/tests/test_ai_skills.py
+++ b/tests/test_ai_skills.py
--- a/tests/test_branch_numbering.py
+++ b/tests/test_branch_numbering.py
@@ -30,18 +30,13 @@ class TestSaveBranchNumbering:
        saved = json.loads((tmp_path / ".specify/init-options.json").read_text())
        assert saved["branch_numbering"] == "sequential"

-    def test_branch_numbering_defaults_to_sequential(self, tmp_path: Path, monkeypatch):
+    def test_branch_numbering_defaults_to_sequential(self, tmp_path: Path):
        from typer.testing import CliRunner
        from specify_cli import app

-        def _fake_download(project_path, *args, **kwargs):
-            Path(project_path).mkdir(parents=True, exist_ok=True)
-
-        monkeypatch.setattr("specify_cli.download_and_extract_template", _fake_download)
-
        project_dir = tmp_path / "proj"
        runner = CliRunner()
-        result = runner.invoke(app, ["init", str(project_dir), "--ai", "claude", "--ignore-agent-tools"])
+        result = runner.invoke(app, ["init", str(project_dir), "--ai", "claude", "--ignore-agent-tools", "--no-git", "--script", "sh"])
        assert result.exit_code == 0

        saved = json.loads((project_dir / ".specify/init-options.json").read_text())
@@ -56,34 +51,24 @@ class TestBranchNumberingValidation:
        from specify_cli import app

        runner = CliRunner()
-        result = runner.invoke(app, ["init", str(tmp_path / "proj"), "--ai", "claude", "--branch-numbering", "foobar"])
+        result = runner.invoke(app, ["init", str(tmp_path / "proj"), "--ai", "claude", "--branch-numbering", "foobar", "--ignore-agent-tools"])
        assert result.exit_code == 1
        assert "Invalid --branch-numbering" in result.output

-    def test_valid_branch_numbering_sequential(self, tmp_path: Path, monkeypatch):
+    def test_valid_branch_numbering_sequential(self, tmp_path: Path):
        from typer.testing import CliRunner
        from specify_cli import app

-        def _fake_download(project_path, *args, **kwargs):
-            Path(project_path).mkdir(parents=True, exist_ok=True)
-
-        monkeypatch.setattr("specify_cli.download_and_extract_template", _fake_download)
-
        runner = CliRunner()
-        result = runner.invoke(app, ["init", str(tmp_path / "proj"), "--ai", "claude", "--branch-numbering", "sequential", "--ignore-agent-tools"])
+        result = runner.invoke(app, ["init", str(tmp_path / "proj"), "--ai", "claude", "--branch-numbering", "sequential", "--ignore-agent-tools", "--no-git", "--script", "sh"])
        assert result.exit_code == 0
        assert "Invalid --branch-numbering" not in (result.output or "")

-    def test_valid_branch_numbering_timestamp(self, tmp_path: Path, monkeypatch):
+    def test_valid_branch_numbering_timestamp(self, tmp_path: Path):
        from typer.testing import CliRunner
        from specify_cli import app

-        def _fake_download(project_path, *args, **kwargs):
-            Path(project_path).mkdir(parents=True, exist_ok=True)
-
-        monkeypatch.setattr("specify_cli.download_and_extract_template", _fake_download)
-
        runner = CliRunner()
-        result = runner.invoke(app, ["init", str(tmp_path / "proj"), "--ai", "claude", "--branch-numbering", "timestamp", "--ignore-agent-tools"])
+        result = runner.invoke(app, ["init", str(tmp_path / "proj"), "--ai", "claude", "--branch-numbering", "timestamp", "--ignore-agent-tools", "--no-git", "--script", "sh"])
        assert result.exit_code == 0
        assert "Invalid --branch-numbering" not in (result.output or "")
--- a/tests/test_extension_skills.py
+++ b/tests/test_extension_skills.py
@@ -41,14 +41,14 @@ def _create_init_options(project_root: Path, ai: str = "claude", ai_skills: bool
 def _create_skills_dir(project_root: Path, ai: str = "claude") -> Path:
    """Create and return the expected skills directory for the given agent."""
    # Match the logic in _get_skills_dir() from specify_cli
-    from specify_cli import AGENT_CONFIG, DEFAULT_SKILLS_DIR
+    from specify_cli import AGENT_CONFIG

    agent_config = AGENT_CONFIG.get(ai, {})
    agent_folder = agent_config.get("folder", "")
    if agent_folder:
        skills_dir = project_root / agent_folder.rstrip("/") / "skills"
    else:
-        skills_dir = project_root / DEFAULT_SKILLS_DIR
+        skills_dir = project_root / ".agents" / "skills"

    skills_dir.mkdir(parents=True, exist_ok=True)
    return skills_dir
@@ -269,6 +269,7 @@ class TestExtensionSkillRegistration:
        assert isinstance(parsed, dict)
        assert parsed["name"] == "speckit-test-ext-hello"
        assert "description" in parsed
+        assert parsed["disable-model-invocation"] is True

    def test_no_skills_when_ai_skills_disabled(self, no_skills_project, extension_dir):
        """No skills should be created when ai_skills is false."""
--- a/tests/test_extensions.py
+++ b/tests/test_extensions.py
@@ -16,6 +16,7 @@ import shutil
 from pathlib import Path
 from datetime import datetime, timezone

+from tests.conftest import strip_ansi
 from specify_cli.extensions import (
    CatalogEntry,
    CORE_COMMAND_NAMES,
@@ -1016,7 +1017,7 @@ $ARGUMENTS
    def test_register_commands_for_claude(self, extension_dir, project_dir):
        """Test registering commands for Claude agent."""
        # Create .claude directory
-        claude_dir = project_dir / ".claude" / "commands"
+        claude_dir = project_dir / ".claude" / "skills"
        claude_dir.mkdir(parents=True)

        ExtensionManager(project_dir)  # Initialize manager (side effects only)
@@ -1033,13 +1034,12 @@ $ARGUMENTS
        assert "speckit.test-ext.hello" in registered

        # Check command file was created
-        cmd_file = claude_dir / "speckit.test-ext.hello.md"
+        cmd_file = claude_dir / "speckit-test-ext-hello" / "SKILL.md"
        assert cmd_file.exists()

        content = cmd_file.read_text()
        assert "description: Test hello command" in content
-        assert "<!-- Extension: test-ext -->" in content
-        assert "<!-- Config: .specify/extensions/test-ext/ -->" in content
+        assert "test-ext" in content

    def test_command_with_aliases(self, project_dir, temp_dir):
        """Test registering a command with aliases."""
@@ -1077,7 +1077,7 @@ $ARGUMENTS
        (ext_dir / "commands").mkdir()
        (ext_dir / "commands" / "cmd.md").write_text("---\ndescription: Test\n---\n\nTest")

-        claude_dir = project_dir / ".claude" / "commands"
+        claude_dir = project_dir / ".claude" / "skills"
        claude_dir.mkdir(parents=True)

        manifest = ExtensionManifest(ext_dir / "extension.yml")
@@ -1087,8 +1087,8 @@ $ARGUMENTS
        assert len(registered) == 2
        assert "speckit.ext-alias.cmd" in registered
        assert "speckit.ext-alias.shortcut" in registered
-        assert (claude_dir / "speckit.ext-alias.cmd.md").exists()
-        assert (claude_dir / "speckit.ext-alias.shortcut.md").exists()
+        assert (claude_dir / "speckit-ext-alias-cmd" / "SKILL.md").exists()
+        assert (claude_dir / "speckit-ext-alias-shortcut" / "SKILL.md").exists()

    def test_unregister_commands_for_codex_skills_uses_mapped_names(self, project_dir):
        """Codex skill cleanup should use the same mapped names as registration."""
@@ -1465,7 +1465,7 @@ Then {AGENT_SCRIPT}

        content = cmd_file.read_text()
        assert "description: Test hello command" in content
-        assert "<!-- Extension: test-ext -->" in content
+        assert "test-ext" in content

    def test_copilot_companion_prompt_created(self, extension_dir, project_dir):
        """Test that companion .prompt.md files are created in .github/prompts/."""
@@ -1540,7 +1540,7 @@ Then {AGENT_SCRIPT}

    def test_non_copilot_agent_no_companion_file(self, extension_dir, project_dir):
        """Test that non-copilot agents do NOT create .prompt.md files."""
-        claude_dir = project_dir / ".claude" / "commands"
+        claude_dir = project_dir / ".claude" / "skills"
        claude_dir.mkdir(parents=True)

        manifest = ExtensionManifest(extension_dir / "extension.yml")
@@ -1591,7 +1591,7 @@ class TestIntegration:
    def test_full_install_and_remove_workflow(self, extension_dir, project_dir):
        """Test complete installation and removal workflow."""
        # Create Claude directory
-        (project_dir / ".claude" / "commands").mkdir(parents=True)
+        (project_dir / ".claude" / "skills").mkdir(parents=True)

        manager = ExtensionManager(project_dir)

@@ -1609,7 +1609,7 @@ class TestIntegration:
        assert installed[0]["id"] == "test-ext"

        # Verify command registered
-        cmd_file = project_dir / ".claude" / "commands" / "speckit.test-ext.hello.md"
+        cmd_file = project_dir / ".claude" / "skills" / "speckit-test-ext-hello" / "SKILL.md"
        assert cmd_file.exists()

        # Verify registry has registered commands (now a dict keyed by agent)
@@ -3007,7 +3007,7 @@ class TestExtensionUpdateCLI:
        project_dir = tmp_path / "project"
        project_dir.mkdir()
        (project_dir / ".specify").mkdir()
-        (project_dir / ".claude" / "commands").mkdir(parents=True)
+        (project_dir / ".claude" / "skills").mkdir(parents=True)

        manager = ExtensionManager(project_dir)
        v1_dir = self._create_extension_source(tmp_path, "1.0.0", include_config=True)
@@ -3056,7 +3056,7 @@ class TestExtensionUpdateCLI:
        project_dir = tmp_path / "project"
        project_dir.mkdir()
        (project_dir / ".specify").mkdir()
-        (project_dir / ".claude" / "commands").mkdir(parents=True)
+        (project_dir / ".claude" / "skills").mkdir(parents=True)

        manager = ExtensionManager(project_dir)
        v1_dir = self._create_extension_source(tmp_path, "1.0.0")
@@ -3067,14 +3067,16 @@ class TestExtensionUpdateCLI:

        registered_commands = backup_registry_entry.get("registered_commands", {})
        command_files = []
-        registrar = CommandRegistrar()
+        from specify_cli.agents import CommandRegistrar as AgentRegistrar
+        agent_registrar = AgentRegistrar()
        for agent_name, cmd_names in registered_commands.items():
-            if agent_name not in registrar.AGENT_CONFIGS:
+            if agent_name not in agent_registrar.AGENT_CONFIGS:
                continue
-            agent_cfg = registrar.AGENT_CONFIGS[agent_name]
+            agent_cfg = agent_registrar.AGENT_CONFIGS[agent_name]
            commands_dir = project_dir / agent_cfg["dir"]
            for cmd_name in cmd_names:
-                cmd_path = commands_dir / f"{cmd_name}{agent_cfg['extension']}"
+                output_name = AgentRegistrar._compute_output_name(agent_name, cmd_name, agent_cfg)
+                cmd_path = commands_dir / f"{output_name}{agent_cfg['extension']}"
                command_files.append(cmd_path)

        assert command_files, "Expected at least one registered command file"
@@ -3126,11 +3128,12 @@ class TestExtensionListCLI:
            result = runner.invoke(app, ["extension", "list"])

        assert result.exit_code == 0, result.output
+        plain = strip_ansi(result.output)
        # Verify the extension ID is shown in the output
-        assert "test-ext" in result.output
+        assert "test-ext" in plain
        # Verify name and version are also shown
-        assert "Test Extension" in result.output
-        assert "1.0.0" in result.output
+        assert "Test Extension" in plain
+        assert "1.0.0" in plain


 class TestExtensionPriority:
@@ -3360,7 +3363,8 @@ class TestExtensionPriorityCLI:
            result = runner.invoke(app, ["extension", "list"])

        assert result.exit_code == 0, result.output
-        assert "Priority: 7" in result.output
+        plain = strip_ansi(result.output)
+        assert "Priority: 7" in plain

    def test_set_priority_changes_priority(self, extension_dir, project_dir):
        """Test set-priority command changes extension priority."""
@@ -3381,7 +3385,8 @@ class TestExtensionPriorityCLI:
            result = runner.invoke(app, ["extension", "set-priority", "test-ext", "5"])

        assert result.exit_code == 0, result.output
-        assert "priority changed: 10 → 5" in result.output
+        plain = strip_ansi(result.output)
+        assert "priority changed: 10 → 5" in plain

        # Reload registry to see updated value
        manager2 = ExtensionManager(project_dir)
@@ -3403,7 +3408,8 @@ class TestExtensionPriorityCLI:
            result = runner.invoke(app, ["extension", "set-priority", "test-ext", "5"])

        assert result.exit_code == 0, result.output
-        assert "already has priority 5" in result.output
+        plain = strip_ansi(result.output)
+        assert "already has priority 5" in plain

    def test_set_priority_invalid_value(self, extension_dir, project_dir):
        """Test set-priority rejects invalid priority values."""
--- a/tests/test_presets.py
+++ b/tests/test_presets.py
@@ -20,6 +20,7 @@ from datetime import datetime, timezone

 import yaml

+from tests.conftest import strip_ansi
 from specify_cli.presets import (
    PresetManifest,
    PresetRegistry,
@@ -1771,19 +1772,20 @@ class TestSelfTestPreset:
        assert "preset:self-test" in content

    def test_self_test_registers_commands_for_claude(self, project_dir):
-        """Test that installing self-test registers commands in .claude/commands/."""
-        # Create Claude agent directory to simulate Claude being set up
-        claude_dir = project_dir / ".claude" / "commands"
+        """Test that installing self-test registers skills in .claude/skills/."""
+        # Create Claude skills directory to simulate Claude being set up
+        claude_dir = project_dir / ".claude" / "skills"
        claude_dir.mkdir(parents=True)

        manager = PresetManager(project_dir)
        manager.install_from_directory(SELF_TEST_PRESET_DIR, "0.1.5")

-        # Check the command was registered
-        cmd_file = claude_dir / "speckit.specify.md"
-        assert cmd_file.exists(), "Command not registered in .claude/commands/"
+        # Check the skill was registered
+        cmd_file = claude_dir / "speckit-specify" / "SKILL.md"
+        assert cmd_file.exists(), "Skill not registered in .claude/skills/"
        content = cmd_file.read_text()
-        assert "preset:self-test" in content
+        assert "self-test" in content
+        assert "source:" in content  # skill frontmatter includes metadata.source

    def test_self_test_registers_commands_for_gemini(self, project_dir):
        """Test that installing self-test registers commands in .gemini/commands/ as TOML."""
@@ -1803,13 +1805,13 @@ class TestSelfTestPreset:

    def test_self_test_unregisters_commands_on_remove(self, project_dir):
        """Test that removing self-test cleans up registered commands."""
-        claude_dir = project_dir / ".claude" / "commands"
+        claude_dir = project_dir / ".claude" / "skills"
        claude_dir.mkdir(parents=True)

        manager = PresetManager(project_dir)
        manager.install_from_directory(SELF_TEST_PRESET_DIR, "0.1.5")

-        cmd_file = claude_dir / "speckit.specify.md"
+        cmd_file = claude_dir / "speckit-specify" / "SKILL.md"
        assert cmd_file.exists()

        manager.remove("self-test")
@@ -1825,7 +1827,7 @@ class TestSelfTestPreset:

    def test_extension_command_skipped_when_extension_missing(self, project_dir, temp_dir):
        """Test that extension command overrides are skipped if the extension isn't installed."""
-        claude_dir = project_dir / ".claude" / "commands"
+        claude_dir = project_dir / ".claude" / "skills"
        claude_dir.mkdir(parents=True)

        preset_dir = temp_dir / "ext-override-preset"
@@ -1868,7 +1870,7 @@ class TestSelfTestPreset:

    def test_extension_command_registered_when_extension_present(self, project_dir, temp_dir):
        """Test that extension command overrides ARE registered when the extension is installed."""
-        claude_dir = project_dir / ".claude" / "commands"
+        claude_dir = project_dir / ".claude" / "skills"
        claude_dir.mkdir(parents=True)
        (project_dir / ".specify" / "extensions" / "fakeext").mkdir(parents=True)

@@ -1904,8 +1906,8 @@ class TestSelfTestPreset:
        manager = PresetManager(project_dir)
        manager.install_from_directory(preset_dir, "0.1.5")

-        cmd_file = claude_dir / "speckit.fakeext.cmd.md"
-        assert cmd_file.exists(), "Command not registered despite extension being present"
+        cmd_file = claude_dir / "speckit-fakeext-cmd" / "SKILL.md"
+        assert cmd_file.exists(), "Skill not registered despite extension being present"


 # ===== Init Options and Skills Tests =====
@@ -1963,7 +1965,7 @@ class TestPresetSkills:
        self._create_skill(skills_dir, "speckit-specify")

        # Also create the claude commands dir so commands get registered
-        (project_dir / ".claude" / "commands").mkdir(parents=True, exist_ok=True)
+        (project_dir / ".claude" / "skills").mkdir(parents=True, exist_ok=True)

        # Install self-test preset (has a command override for speckit.specify)
        manager = PresetManager(project_dir)
@@ -1974,6 +1976,7 @@ class TestPresetSkills:
        assert skill_file.exists()
        content = skill_file.read_text()
        assert "preset:self-test" in content, "Skill should reference preset source"
+        assert "disable-model-invocation: true" in content

        # Verify it was recorded in registry
        metadata = manager.registry.get("self-test")
@@ -1981,12 +1984,10 @@ class TestPresetSkills:

    def test_skill_not_updated_when_ai_skills_disabled(self, project_dir, temp_dir):
        """When --ai-skills was NOT used, preset install should not touch skills."""
-        self._write_init_options(project_dir, ai="claude", ai_skills=False)
-        skills_dir = project_dir / ".claude" / "skills"
+        self._write_init_options(project_dir, ai="qwen", ai_skills=False)
+        skills_dir = project_dir / ".qwen" / "skills"
        self._create_skill(skills_dir, "speckit-specify", body="untouched")

-        (project_dir / ".claude" / "commands").mkdir(parents=True, exist_ok=True)
-
        manager = PresetManager(project_dir)
        SELF_TEST_DIR = Path(__file__).parent.parent / "presets" / "self-test"
        manager.install_from_directory(SELF_TEST_DIR, "0.1.5")
@@ -2017,18 +2018,16 @@ class TestPresetSkills:

    def test_skill_not_updated_without_init_options(self, project_dir, temp_dir):
        """When no init-options.json exists, preset install should not touch skills."""
-        skills_dir = project_dir / ".claude" / "skills"
+        skills_dir = project_dir / ".qwen" / "skills"
        self._create_skill(skills_dir, "speckit-specify", body="untouched")

-        (project_dir / ".claude" / "commands").mkdir(parents=True, exist_ok=True)
-
        manager = PresetManager(project_dir)
        SELF_TEST_DIR = Path(__file__).parent.parent / "presets" / "self-test"
        manager.install_from_directory(SELF_TEST_DIR, "0.1.5")

        skill_file = skills_dir / "speckit-specify" / "SKILL.md"
-        content = skill_file.read_text()
-        assert "untouched" in content
+        file_content = skill_file.read_text()
+        assert "untouched" in file_content

    def test_skill_restored_on_preset_remove(self, project_dir, temp_dir):
        """When a preset is removed, skills should be restored from core templates."""
@@ -2036,7 +2035,7 @@ class TestPresetSkills:
        skills_dir = project_dir / ".claude" / "skills"
        self._create_skill(skills_dir, "speckit-specify")

-        (project_dir / ".claude" / "commands").mkdir(parents=True, exist_ok=True)
+        (project_dir / ".claude" / "skills").mkdir(parents=True, exist_ok=True)

        # Set up core command template in the project so restoration works
        core_cmds = project_dir / ".specify" / "templates" / "commands"
@@ -2059,13 +2058,14 @@ class TestPresetSkills:
        content = skill_file.read_text()
        assert "preset:self-test" not in content, "Preset content should be gone"
        assert "templates/commands/specify.md" in content, "Should reference core template"
+        assert "disable-model-invocation: true" in content

    def test_skill_restored_on_remove_resolves_script_placeholders(self, project_dir):
        """Core restore should resolve {SCRIPT}/{ARGS} placeholders like other skill paths."""
        self._write_init_options(project_dir, ai="claude", ai_skills=True, script="sh")
        skills_dir = project_dir / ".claude" / "skills"
        self._create_skill(skills_dir, "speckit-specify", body="old")
-        (project_dir / ".claude" / "commands").mkdir(parents=True, exist_ok=True)
+        (project_dir / ".claude" / "skills").mkdir(parents=True, exist_ok=True)

        core_cmds = project_dir / ".specify" / "templates" / "commands"
        core_cmds.mkdir(parents=True, exist_ok=True)
@@ -2091,13 +2091,11 @@ class TestPresetSkills:

    def test_skill_not_overridden_when_skill_path_is_file(self, project_dir):
        """Preset install should skip non-directory skill targets."""
-        self._write_init_options(project_dir, ai="claude")
-        skills_dir = project_dir / ".claude" / "skills"
+        self._write_init_options(project_dir, ai="qwen")
+        skills_dir = project_dir / ".qwen" / "skills"
        skills_dir.mkdir(parents=True, exist_ok=True)
        (skills_dir / "speckit-specify").write_text("not-a-directory")

-        (project_dir / ".claude" / "commands").mkdir(parents=True, exist_ok=True)
-
        manager = PresetManager(project_dir)
        SELF_TEST_DIR = Path(__file__).parent.parent / "presets" / "self-test"
        manager.install_from_directory(SELF_TEST_DIR, "0.1.5")
@@ -2111,8 +2109,6 @@ class TestPresetSkills:
        self._write_init_options(project_dir, ai="claude")
        # Don't create skills dir — simulate --ai-skills never created them

-        (project_dir / ".claude" / "commands").mkdir(parents=True, exist_ok=True)
-
        manager = PresetManager(project_dir)
        SELF_TEST_DIR = Path(__file__).parent.parent / "presets" / "self-test"
        manager.install_from_directory(SELF_TEST_DIR, "0.1.5")
@@ -2349,6 +2345,55 @@ class TestPresetSkills:
        metadata = manager.registry.get("self-test")
        assert "speckit-specify" in metadata.get("registered_skills", [])

+    def test_kimi_new_skill_created_even_when_ai_skills_disabled(self, project_dir, temp_dir):
+        """Kimi native skills should still receive brand-new preset commands."""
+        self._write_init_options(project_dir, ai="kimi", ai_skills=False)
+        skills_dir = project_dir / ".kimi" / "skills"
+        skills_dir.mkdir(parents=True, exist_ok=True)
+
+        preset_dir = temp_dir / "kimi-new-skill"
+        preset_dir.mkdir()
+        (preset_dir / "commands").mkdir()
+        (preset_dir / "commands" / "speckit.research.md").write_text(
+            "---\n"
+            "description: Kimi research workflow\n"
+            "---\n\n"
+            "preset:kimi-new-skill\n"
+        )
+        manifest_data = {
+            "schema_version": "1.0",
+            "preset": {
+                "id": "kimi-new-skill",
+                "name": "Kimi New Skill",
+                "version": "1.0.0",
+                "description": "Test",
+            },
+            "requires": {"speckit_version": ">=0.1.0"},
+            "provides": {
+                "templates": [
+                    {
+                        "type": "command",
+                        "name": "speckit.research",
+                        "file": "commands/speckit.research.md",
+                    }
+                ]
+            },
+        }
+        with open(preset_dir / "preset.yml", "w") as f:
+            yaml.dump(manifest_data, f)
+
+        manager = PresetManager(project_dir)
+        manager.install_from_directory(preset_dir, "0.1.5")
+
+        skill_file = skills_dir / "speckit-research" / "SKILL.md"
+        assert skill_file.exists()
+        content = skill_file.read_text()
+        assert "preset:kimi-new-skill" in content
+        assert "name: speckit-research" in content
+
+        metadata = manager.registry.get("kimi-new-skill")
+        assert "speckit-research" in metadata.get("registered_skills", [])
+
    def test_kimi_preset_skill_override_resolves_script_placeholders(self, project_dir, temp_dir):
        """Kimi preset skill overrides should resolve placeholders and rewrite project paths."""
        self._write_init_options(project_dir, ai="kimi", ai_skills=False, script="sh")
@@ -2401,22 +2446,78 @@ class TestPresetSkills:
        assert ".specify/memory/constitution.md" in content
        assert "for kimi" in content

+    def test_agy_skill_restored_on_preset_remove(self, project_dir, temp_dir):
+        """Agy preset removal should restore native skills instead of deleting them."""
+        self._write_init_options(project_dir, ai="agy", ai_skills=True)
+        skills_dir = project_dir / ".agent" / "skills"
+        self._create_skill(skills_dir, "speckit-specify", body="before override")
+
+        core_command = project_dir / ".specify" / "templates" / "commands" / "specify.md"
+        core_command.write_text(
+            "---\n"
+            "description: Restored core specify workflow\n"
+            "---\n\n"
+            "restored core body\n"
+        )
+
+        preset_dir = temp_dir / "agy-override"
+        preset_dir.mkdir()
+        (preset_dir / "commands").mkdir()
+        (preset_dir / "commands" / "speckit.specify.md").write_text(
+            "---\n"
+            "description: Agy override\n"
+            "---\n\n"
+            "preset agy body\n"
+        )
+        manifest_data = {
+            "schema_version": "1.0",
+            "preset": {
+                "id": "agy-override",
+                "name": "Agy Override",
+                "version": "1.0.0",
+                "description": "Test",
+            },
+            "requires": {"speckit_version": ">=0.1.0"},
+            "provides": {
+                "templates": [
+                    {
+                        "type": "command",
+                        "name": "speckit.specify",
+                        "file": "commands/speckit.specify.md",
+                    }
+                ]
+            },
+        }
+        with open(preset_dir / "preset.yml", "w") as f:
+            yaml.dump(manifest_data, f)
+
+        manager = PresetManager(project_dir)
+        manager.install_from_directory(preset_dir, "0.1.5")
+
+        skill_file = skills_dir / "speckit-specify" / "SKILL.md"
+        assert "preset agy body" in skill_file.read_text()
+
+        assert manager.remove("agy-override") is True
+        assert skill_file.exists()
+        restored = skill_file.read_text()
+        assert "restored core body" in restored
+        assert "name: speckit-specify" in restored
+
    def test_preset_skill_registration_handles_non_dict_init_options(self, project_dir, temp_dir):
        """Non-dict init-options payloads should not crash preset install/remove flows."""
        init_options = project_dir / ".specify" / "init-options.json"
        init_options.parent.mkdir(parents=True, exist_ok=True)
        init_options.write_text("[]")

-        skills_dir = project_dir / ".claude" / "skills"
+        skills_dir = project_dir / ".qwen" / "skills"
        self._create_skill(skills_dir, "speckit-specify", body="untouched")
-        (project_dir / ".claude" / "commands").mkdir(parents=True, exist_ok=True)

        manager = PresetManager(project_dir)
        self_test_dir = Path(__file__).parent.parent / "presets" / "self-test"
        manager.install_from_directory(self_test_dir, "0.1.5")

-        content = (skills_dir / "speckit-specify" / "SKILL.md").read_text()
-        assert "untouched" in content
+        skill_content = (skills_dir / "speckit-specify" / "SKILL.md").read_text()
+        assert "untouched" in skill_content


 class TestPresetSetPriority:
@@ -2441,7 +2542,8 @@ class TestPresetSetPriority:
            result = runner.invoke(app, ["preset", "set-priority", "test-pack", "5"])

        assert result.exit_code == 0, result.output
-        assert "priority changed: 10 → 5" in result.output
+        plain = strip_ansi(result.output)
+        assert "priority changed: 10 → 5" in plain

        # Reload registry to see updated value
        manager2 = PresetManager(project_dir)
@@ -2463,7 +2565,8 @@ class TestPresetSetPriority:
            result = runner.invoke(app, ["preset", "set-priority", "test-pack", "5"])

        assert result.exit_code == 0, result.output
-        assert "already has priority 5" in result.output
+        plain = strip_ansi(result.output)
+        assert "already has priority 5" in plain

    def test_set_priority_invalid_value(self, project_dir, pack_dir):
        """Test set-priority rejects invalid priority values."""
--- a/tests/test_timestamp_branches.py
+++ b/tests/test_timestamp_branches.py
@@ -186,11 +186,26 @@ class TestCheckFeatureBranch:
        result = source_and_call('check_feature_branch "main" "true"')
        assert result.returncode != 0

+    def test_accepts_four_digit_sequential_branch(self):
+        """check_feature_branch accepts 4+ digit sequential branch."""
+        result = source_and_call('check_feature_branch "1234-feat" "true"')
+        assert result.returncode == 0
+
    def test_rejects_partial_timestamp(self):
        """Test 9: check_feature_branch rejects 7-digit date."""
        result = source_and_call('check_feature_branch "2026031-143022-feat" "true"')
        assert result.returncode != 0

+    def test_rejects_timestamp_without_slug(self):
+        """check_feature_branch rejects timestamp-like branch missing trailing slug."""
+        result = source_and_call('check_feature_branch "20260319-143022" "true"')
+        assert result.returncode != 0
+
+    def test_rejects_7digit_timestamp_without_slug(self):
+        """check_feature_branch rejects 7-digit date + 6-digit time without slug."""
+        result = source_and_call('check_feature_branch "2026031-143022" "true"')
+        assert result.returncode != 0
+

 # ── find_feature_dir_by_prefix Tests ─────────────────────────────────────────

@@ -214,6 +229,15 @@ class TestFindFeatureDirByPrefix:
        assert result.returncode == 0
        assert result.stdout.strip() == f"{tmp_path}/specs/20260319-143022-original-feat"

+    def test_four_digit_sequential_prefix(self, tmp_path: Path):
+        """find_feature_dir_by_prefix resolves 4+ digit sequential prefix."""
+        (tmp_path / "specs" / "1000-original-feat").mkdir(parents=True)
+        result = source_and_call(
+            f'find_feature_dir_by_prefix "{tmp_path}" "1000-different-name"'
+        )
+        assert result.returncode == 0
+        assert result.stdout.strip() == f"{tmp_path}/specs/1000-original-feat"
+

 # ── get_current_branch Tests ─────────────────────────────────────────────────

@@ -412,3 +436,341 @@ class TestAllowExistingBranchPowerShell:
        assert "-AllowExistingBranch" in contents
        # Ensure the flag is referenced in script logic, not just declared
        assert "AllowExistingBranch" in contents.replace("-AllowExistingBranch", "")
+
+
+# ── Dry-Run Tests ────────────────────────────────────────────────────────────
+
+
+class TestDryRun:
+    def test_dry_run_sequential_outputs_name(self, git_repo: Path):
+        """T009: Dry-run computes correct branch name with existing specs."""
+        (git_repo / "specs" / "001-first-feat").mkdir(parents=True)
+        (git_repo / "specs" / "002-second-feat").mkdir(parents=True)
+        result = run_script(
+            git_repo, "--dry-run", "--short-name", "new-feat", "New feature"
+        )
+        assert result.returncode == 0, result.stderr
+        branch = None
+        for line in result.stdout.splitlines():
+            if line.startswith("BRANCH_NAME:"):
+                branch = line.split(":", 1)[1].strip()
+        assert branch == "003-new-feat", f"expected 003-new-feat, got: {branch}"
+
+    def test_dry_run_no_branch_created(self, git_repo: Path):
+        """T010: Dry-run does not create a git branch."""
+        result = run_script(
+            git_repo, "--dry-run", "--short-name", "no-branch", "No branch feature"
+        )
+        assert result.returncode == 0, result.stderr
+        branches = subprocess.run(
+            ["git", "branch", "--list", "*no-branch*"],
+            cwd=git_repo,
+            capture_output=True,
+            text=True,
+        )
+        assert branches.returncode == 0, f"'git branch --list' failed: {branches.stderr}"
+        assert branches.stdout.strip() == "", "branch should not exist after dry-run"
+
+    def test_dry_run_no_spec_dir_created(self, git_repo: Path):
+        """T011: Dry-run does not create any directories (including root specs/)."""
+        specs_root = git_repo / "specs"
+        if specs_root.exists():
+            shutil.rmtree(specs_root)
+        assert not specs_root.exists(), "specs/ should not exist before dry-run"
+
+        result = run_script(
+            git_repo, "--dry-run", "--short-name", "no-dir", "No dir feature"
+        )
+        assert result.returncode == 0, result.stderr
+        assert not specs_root.exists(), "specs/ should not be created during dry-run"
+
+    def test_dry_run_empty_repo(self, git_repo: Path):
+        """T012: Dry-run returns 001 prefix when no existing specs or branches."""
+        result = run_script(
+            git_repo, "--dry-run", "--short-name", "first", "First feature"
+        )
+        assert result.returncode == 0, result.stderr
+        branch = None
+        for line in result.stdout.splitlines():
+            if line.startswith("BRANCH_NAME:"):
+                branch = line.split(":", 1)[1].strip()
+        assert branch == "001-first", f"expected 001-first, got: {branch}"
+
+    def test_dry_run_with_short_name(self, git_repo: Path):
+        """T013: Dry-run with --short-name produces expected name."""
+        (git_repo / "specs" / "001-existing").mkdir(parents=True)
+        (git_repo / "specs" / "002-existing").mkdir(parents=True)
+        (git_repo / "specs" / "003-existing").mkdir(parents=True)
+        result = run_script(
+            git_repo, "--dry-run", "--short-name", "user-auth", "Add user authentication"
+        )
+        assert result.returncode == 0, result.stderr
+        branch = None
+        for line in result.stdout.splitlines():
+            if line.startswith("BRANCH_NAME:"):
+                branch = line.split(":", 1)[1].strip()
+        assert branch == "004-user-auth", f"expected 004-user-auth, got: {branch}"
+
+    def test_dry_run_then_real_run_match(self, git_repo: Path):
+        """T014: Dry-run name matches subsequent real creation."""
+        (git_repo / "specs" / "001-existing").mkdir(parents=True)
+        # Dry-run first
+        dry_result = run_script(
+            git_repo, "--dry-run", "--short-name", "match-test", "Match test"
+        )
+        assert dry_result.returncode == 0, dry_result.stderr
+        dry_branch = None
+        for line in dry_result.stdout.splitlines():
+            if line.startswith("BRANCH_NAME:"):
+                dry_branch = line.split(":", 1)[1].strip()
+        # Real run
+        real_result = run_script(
+            git_repo, "--short-name", "match-test", "Match test"
+        )
+        assert real_result.returncode == 0, real_result.stderr
+        real_branch = None
+        for line in real_result.stdout.splitlines():
+            if line.startswith("BRANCH_NAME:"):
+                real_branch = line.split(":", 1)[1].strip()
+        assert dry_branch == real_branch, f"dry={dry_branch} != real={real_branch}"
+
+    def test_dry_run_accounts_for_remote_branches(self, git_repo: Path):
+        """Dry-run queries remote refs via ls-remote (no fetch) for accurate numbering."""
+        (git_repo / "specs" / "001-existing").mkdir(parents=True)
+
+        # Set up a bare remote and push (use subdirs of git_repo for isolation)
+        remote_dir = git_repo / "test-remote.git"
+        subprocess.run(
+            ["git", "init", "--bare", str(remote_dir)],
+            check=True, capture_output=True,
+        )
+        subprocess.run(
+            ["git", "remote", "add", "origin", str(remote_dir)],
+            check=True, cwd=git_repo, capture_output=True,
+        )
+        subprocess.run(
+            ["git", "push", "-u", "origin", "HEAD"],
+            check=True, cwd=git_repo, capture_output=True,
+        )
+
+        # Clone into a second copy, create a higher-numbered branch, push it
+        second_clone = git_repo / "test-second-clone"
+        subprocess.run(
+            ["git", "clone", str(remote_dir), str(second_clone)],
+            check=True, capture_output=True,
+        )
+        subprocess.run(
+            ["git", "config", "user.email", "test@example.com"],
+            cwd=second_clone, check=True, capture_output=True,
+        )
+        subprocess.run(
+            ["git", "config", "user.name", "Test User"],
+            cwd=second_clone, check=True, capture_output=True,
+        )
+        # Create branch 005 on the remote (higher than local 001)
+        subprocess.run(
+            ["git", "checkout", "-b", "005-remote-only"],
+            cwd=second_clone, check=True, capture_output=True,
+        )
+        subprocess.run(
+            ["git", "push", "origin", "005-remote-only"],
+            cwd=second_clone, check=True, capture_output=True,
+        )
+
+        # Primary repo: dry-run should see 005 via ls-remote and return 006
+        dry_result = run_script(
+            git_repo, "--dry-run", "--short-name", "remote-test", "Remote test"
+        )
+        assert dry_result.returncode == 0, dry_result.stderr
+        dry_branch = None
+        for line in dry_result.stdout.splitlines():
+            if line.startswith("BRANCH_NAME:"):
+                dry_branch = line.split(":", 1)[1].strip()
+        assert dry_branch == "006-remote-test", f"expected 006-remote-test, got: {dry_branch}"
+
+    def test_dry_run_json_includes_field(self, git_repo: Path):
+        """T015: JSON output includes DRY_RUN field when --dry-run is active."""
+        import json
+
+        result = run_script(
+            git_repo, "--dry-run", "--json", "--short-name", "json-test", "JSON test"
+        )
+        assert result.returncode == 0, result.stderr
+        data = json.loads(result.stdout)
+        assert "DRY_RUN" in data, f"DRY_RUN missing from JSON: {data}"
+        assert data["DRY_RUN"] is True
+
+    def test_dry_run_json_absent_without_flag(self, git_repo: Path):
+        """T016: Normal JSON output does NOT include DRY_RUN field."""
+        import json
+
+        result = run_script(
+            git_repo, "--json", "--short-name", "no-dry", "No dry run"
+        )
+        assert result.returncode == 0, result.stderr
+        data = json.loads(result.stdout)
+        assert "DRY_RUN" not in data, f"DRY_RUN should not be in normal JSON: {data}"
+
+    def test_dry_run_with_timestamp(self, git_repo: Path):
+        """T017: Dry-run works with --timestamp flag."""
+        result = run_script(
+            git_repo, "--dry-run", "--timestamp", "--short-name", "ts-feat", "Timestamp feature"
+        )
+        assert result.returncode == 0, result.stderr
+        branch = None
+        for line in result.stdout.splitlines():
+            if line.startswith("BRANCH_NAME:"):
+                branch = line.split(":", 1)[1].strip()
+        assert branch is not None, "no BRANCH_NAME in output"
+        assert re.match(r"^\d{8}-\d{6}-ts-feat$", branch), f"unexpected: {branch}"
+        # Verify no side effects
+        branches = subprocess.run(
+            ["git", "branch", "--list", f"*ts-feat*"],
+            cwd=git_repo,
+            capture_output=True,
+            text=True,
+        )
+        assert branches.returncode == 0, f"'git branch --list' failed: {branches.stderr}"
+        assert branches.stdout.strip() == ""
+
+    def test_dry_run_with_number(self, git_repo: Path):
+        """T018: Dry-run works with --number flag."""
+        result = run_script(
+            git_repo, "--dry-run", "--number", "42", "--short-name", "num-feat", "Number feature"
+        )
+        assert result.returncode == 0, result.stderr
+        branch = None
+        for line in result.stdout.splitlines():
+            if line.startswith("BRANCH_NAME:"):
+                branch = line.split(":", 1)[1].strip()
+        assert branch == "042-num-feat", f"expected 042-num-feat, got: {branch}"
+
+    def test_dry_run_no_git(self, no_git_dir: Path):
+        """T019: Dry-run works in non-git directory."""
+        (no_git_dir / "specs" / "001-existing").mkdir(parents=True)
+        result = run_script(
+            no_git_dir, "--dry-run", "--short-name", "no-git-dry", "No git dry run"
+        )
+        assert result.returncode == 0, result.stderr
+        branch = None
+        for line in result.stdout.splitlines():
+            if line.startswith("BRANCH_NAME:"):
+                branch = line.split(":", 1)[1].strip()
+        assert branch == "002-no-git-dry", f"expected 002-no-git-dry, got: {branch}"
+        # Verify no spec dir created
+        spec_dirs = [
+            d.name
+            for d in (no_git_dir / "specs").iterdir()
+            if d.is_dir() and "no-git-dry" in d.name
+        ]
+        assert len(spec_dirs) == 0
+
+
+# ── PowerShell Dry-Run Tests ─────────────────────────────────────────────────
+
+
+def _has_pwsh() -> bool:
+    """Check if pwsh is available."""
+    try:
+        subprocess.run(["pwsh", "--version"], capture_output=True, check=True)
+        return True
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        return False
+
+
+def run_ps_script(cwd: Path, *args: str) -> subprocess.CompletedProcess:
+    """Run create-new-feature.ps1 from the temp repo's scripts directory."""
+    script = cwd / "scripts" / "powershell" / "create-new-feature.ps1"
+    cmd = ["pwsh", "-NoProfile", "-File", str(script), *args]
+    return subprocess.run(cmd, cwd=cwd, capture_output=True, text=True)
+
+
+@pytest.fixture
+def ps_git_repo(tmp_path: Path) -> Path:
+    """Create a temp git repo with PowerShell scripts and .specify dir."""
+    subprocess.run(["git", "init", "-q"], cwd=tmp_path, check=True)
+    subprocess.run(
+        ["git", "config", "user.email", "test@example.com"], cwd=tmp_path, check=True
+    )
+    subprocess.run(
+        ["git", "config", "user.name", "Test User"], cwd=tmp_path, check=True
+    )
+    subprocess.run(
+        ["git", "commit", "--allow-empty", "-m", "init", "-q"],
+        cwd=tmp_path,
+        check=True,
+    )
+    ps_dir = tmp_path / "scripts" / "powershell"
+    ps_dir.mkdir(parents=True)
+    shutil.copy(CREATE_FEATURE_PS, ps_dir / "create-new-feature.ps1")
+    common_ps = PROJECT_ROOT / "scripts" / "powershell" / "common.ps1"
+    shutil.copy(common_ps, ps_dir / "common.ps1")
+    (tmp_path / ".specify" / "templates").mkdir(parents=True)
+    return tmp_path
+
+
+@pytest.mark.skipif(not _has_pwsh(), reason="pwsh not available")
+class TestPowerShellDryRun:
+    def test_ps_dry_run_outputs_name(self, ps_git_repo: Path):
+        """PowerShell -DryRun computes correct branch name."""
+        (ps_git_repo / "specs" / "001-first").mkdir(parents=True)
+        result = run_ps_script(
+            ps_git_repo, "-DryRun", "-ShortName", "ps-feat", "PS feature"
+        )
+        assert result.returncode == 0, result.stderr
+        branch = None
+        for line in result.stdout.splitlines():
+            if line.startswith("BRANCH_NAME:"):
+                branch = line.split(":", 1)[1].strip()
+        assert branch == "002-ps-feat", f"expected 002-ps-feat, got: {branch}"
+
+    def test_ps_dry_run_no_branch_created(self, ps_git_repo: Path):
+        """PowerShell -DryRun does not create a git branch."""
+        result = run_ps_script(
+            ps_git_repo, "-DryRun", "-ShortName", "no-ps-branch", "No branch"
+        )
+        assert result.returncode == 0, result.stderr
+        branches = subprocess.run(
+            ["git", "branch", "--list", "*no-ps-branch*"],
+            cwd=ps_git_repo,
+            capture_output=True,
+            text=True,
+        )
+        assert branches.returncode == 0, f"'git branch --list' failed: {branches.stderr}"
+        assert branches.stdout.strip() == "", "branch should not exist after dry-run"
+
+    def test_ps_dry_run_no_spec_dir_created(self, ps_git_repo: Path):
+        """PowerShell -DryRun does not create specs/ directory."""
+        specs_root = ps_git_repo / "specs"
+        if specs_root.exists():
+            shutil.rmtree(specs_root)
+        assert not specs_root.exists()
+
+        result = run_ps_script(
+            ps_git_repo, "-DryRun", "-ShortName", "no-ps-dir", "No dir"
+        )
+        assert result.returncode == 0, result.stderr
+        assert not specs_root.exists(), "specs/ should not be created during dry-run"
+
+    def test_ps_dry_run_json_includes_field(self, ps_git_repo: Path):
+        """PowerShell -DryRun JSON output includes DRY_RUN field."""
+        import json
+
+        result = run_ps_script(
+            ps_git_repo, "-DryRun", "-Json", "-ShortName", "ps-json", "JSON test"
+        )
+        assert result.returncode == 0, result.stderr
+        data = json.loads(result.stdout)
+        assert "DRY_RUN" in data, f"DRY_RUN missing from JSON: {data}"
+        assert data["DRY_RUN"] is True
+
+    def test_ps_dry_run_json_absent_without_flag(self, ps_git_repo: Path):
+        """PowerShell normal JSON output does NOT include DRY_RUN field."""
+        import json
+
+        result = run_ps_script(
+            ps_git_repo, "-Json", "-ShortName", "ps-no-dry", "No dry run"
+        )
+        assert result.returncode == 0, result.stderr
+        data = json.loads(result.stdout)
+        assert "DRY_RUN" not in data, f"DRY_RUN should not be in normal JSON: {data}"