chore: bump version to 0.7.1

* ci: add windows-latest to test matrix

Add windows-latest to the pytest job OS matrix so tests run on both
Ubuntu and Windows for all Python versions.

Closes #2232

* test: skip bash-specific tests on Windows

Add sys.platform skip markers to all test classes and methods that
execute bash scripts via subprocess, so they are skipped on Windows
where bash is not available. Mixed classes with both bash and pwsh
tests have markers on individual bash methods only.

* test: fix 3 Windows-specific test failures

- test_manifest: use platform-appropriate absolute path (C:\ on Windows
  vs /tmp on POSIX) since /tmp is not absolute on Windows
- test_extensions: add agent_scripts.ps entry and platform-conditional
  assertions for codex skill fallback variant test
- test_timestamp_branches: use json.dumps() instead of f-string to
  properly escape Windows backslash paths in feature.json

* test: extract requires_bash marker and fix PS test skip

Address PR review feedback:
- Define a reusable requires_bash marker in conftest.py and use it
  across all 3 test files instead of repeating the skipif inline
- Move test_powershell_scanner_uses_long_tryparse_for_large_prefixes
  into its own TestSequentialBranchPowerShell class so it is not
  incorrectly skipped on Windows by the class-level bash marker

* test: use runtime bash check instead of platform check

Replace sys.platform == 'win32' with an actual bash invocation test
to handle environments where bash exists but is non-functional (e.g.,
WSL stub on Windows without an installed distro).

* test: reject WSL bash, accept only MSYS/MINGW on Windows

On Windows, verify uname -s reports MSYS, MINGW, or CYGWIN so the WSL
launcher (System32\bash.exe) is rejected — it cannot handle native
Windows paths used by test fixtures. Add SPECKIT_TEST_BASH=1 env var
escape hatch to force-enable bash tests in non-standard setups.

* ci: add comment explaining Windows bash test behavior

* test: early-reject WSL launcher, fix remaining f-string JSON

- Check resolved bash path for System32 before spawning any subprocess
  to avoid WSL init prompts and timeout during test collection
- Convert remaining feature_json f-string writes to json.dumps() so
  paths with backslashes produce valid JSON on Windows

* test: use bare 'bash' for detection to match test invocation

On Windows, subprocess.run(['bash', ...]) uses CreateProcess which
searches System32 before PATH — finding WSL bash even when
shutil.which('bash') returns Git-for-Windows. Probe with bare 'bash'
(same as test helpers) so the detection matches actual test behavior.

.github/workflows/test.yml

@@ -27,9 +27,10 @@ jobs:
         run: uvx ruff check src/
 
   pytest:
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
     strategy:
       matrix:
+        os: [ubuntu-latest, windows-latest]
         python-version: ["3.11", "3.12", "3.13"]
     steps:
       - name: Checkout
@@ -46,5 +47,9 @@ jobs:
       - name: Install dependencies
         run: uv sync --extra test
 
+      # On windows-latest, bash tests auto-skip unless Git-for-Windows
+      # bash (MSYS2/MINGW) is detected. The WSL launcher is rejected
+      # because it cannot handle native Windows paths in test fixtures.
+      # See tests/conftest.py::_has_working_bash() for details.
       - name: Run tests
         run: uv run pytest

CHANGELOG.md

@@ -2,6 +2,32 @@
 
 <!-- insert new changelog below this comment -->
 
+## [0.7.1] - 2026-04-15
+
+### Changed
+
+- ci: add windows-latest to test matrix (#2233)
+- docs: remove deprecated --skip-tls references from local-development guide (#2231)
+- fix: allow Claude to chain skills for hook execution (#2227)
+- docs: merge TESTING.md into CONTRIBUTING.md, remove TESTING.md (#2228)
+- Add agent-assign extension to community catalog (#2030)
+- fix: unofficial PyPI warning (#1982) and legacy extension command name auto-correction (#2017) (#2027)
+- feat: register architect-preview in community catalog (#2214)
+- chore: deprecate --ai flag in favor of --integration on specify init (#2218)
+- chore: release 0.7.0, begin 0.7.1.dev0 development (#2217)
+
+## [0.7.0] - 2026-04-14
+
+### Changed
+
+- Add workflow engine with catalog system (#2158)
+- docs(catalog): add claude-ask-questions to community preset catalog (#2191)
+- Add SFSpeckit — Salesforce SDD Extension (#2208)
+- feat(scripts): optional single-segment branch prefix for gitflow (#2202)
+- chore: release 0.6.2, begin 0.6.3.dev0 development (#2205)
+- Add Worktrees extension to community catalog (#2207)
+- feat: Update catalog.community.json for preset-fiction-book-writing (#2199)
+
 ## [0.6.2] - 2026-04-13
 
 ### Changed

CONTRIBUTING.md

@@ -44,8 +44,7 @@ On [GitHub Codespaces](https://github.com/features/codespaces) it's even simpler
 1. Push to your fork and submit a pull request
 1. Wait for your pull request to be reviewed and merged.
 
-For the detailed test workflow, command-selection prompt, and PR reporting template, see [`TESTING.md`](./TESTING.md).
-Activate the project virtual environment (see the Setup block in [`TESTING.md`](./TESTING.md)), then install the CLI from your working tree (`uv pip install -e .` after `uv sync --extra test`) or otherwise ensure the shell uses the local `specify` binary before running the manual slash-command tests described below.
+Activate the project virtual environment (see [Testing setup](#testing-setup) below), then install the CLI from your working tree (`uv pip install -e .` after `uv sync --extra test`) or otherwise ensure the shell uses the local `specify` binary before running the manual slash-command tests described below.
 
 Here are a few things you can do that will increase the likelihood of your pull request being accepted:
 
@@ -69,34 +68,99 @@ When working on spec-kit:
 
 For the smoothest review experience, validate changes in this order:
 
-1. **Run focused automated checks first** — use the quick verification commands in [`TESTING.md`](./TESTING.md) to catch packaging, scaffolding, and configuration regressions early.
-2. **Run manual workflow tests second** — if your change affects slash commands or the developer workflow, follow [`TESTING.md`](./TESTING.md) to choose the right commands, run them in an agent, and capture results for your PR.
-3. **Use local release packages when debugging packaged output** — if you need to inspect the exact files CI-style packaging produces, generate local release packages as described below.
+1. **Run focused automated checks first** — use the quick verification commands [below](#automated-checks) to catch scaffolding and configuration regressions early.
+2. **Run manual workflow tests second** — if your change affects slash commands or the developer workflow, follow the [manual testing](#manual-testing) section to choose the right commands, run them in an agent, and capture results for your PR.
 
-### Testing template and command changes locally
+### Automated checks
 
-Running `uv run specify init` pulls released packages, which won’t include your local changes.  
-To test your templates, commands, and other changes locally, follow these steps:
+#### Agent configuration and wiring consistency
 
-1. **Create release packages**
+```bash
+uv run python -m pytest tests/test_agent_config_consistency.py -q
+```
 
-   Run the following command to generate the local packages:
+Run this when you change agent metadata, context update scripts, or integration wiring.
 
-   ```bash
-   ./.github/workflows/scripts/create-release-packages.sh v1.0.0
-   ```
+### Manual testing
 
-2. **Copy the relevant package to your test project**
+#### Testing setup
 
-   ```bash
-   cp -r .genreleases/sdd-copilot-package-sh/. <path-to-test-project>/
-   ```
+```bash
+# Install the project and test dependencies from your local branch
+cd <spec-kit-repo>
+uv sync --extra test
+source .venv/bin/activate  # On Windows (CMD): .venv\Scripts\activate  |  (PowerShell): .venv\Scripts\Activate.ps1
+uv pip install -e .
+# Ensure the `specify` binary in this environment points at your working tree so the agent runs the branch you're testing.
 
-3. **Open and test the agent**
+# Initialize a test project using your local changes
+uv run specify init <temp-dir>/speckit-test --ai <agent> --offline
+cd <temp-dir>/speckit-test
 
-   Navigate to your test project folder and open the agent to verify your implementation.
+# Open in your agent
+```
 
-If you only need to validate generated file structure and content before doing manual agent testing, start with the focused automated checks in [`TESTING.md`](./TESTING.md). Keep this section for the cases where you need to inspect the exact packaged output locally.
+#### Manual testing process
+
+Any change that affects a slash command's behavior requires manually testing that command through an AI agent and submitting results with the PR.
+
+1. **Identify affected commands** — use the [prompt below](#determining-which-tests-to-run) to have your agent analyze your changed files and determine which commands need testing.
+2. **Set up a test project** — scaffold from your local branch (see [Testing setup](#testing-setup)).
+3. **Run each affected command** — invoke it in your agent, verify it completes successfully, and confirm it produces the expected output (files created, scripts executed, artifacts populated).
+4. **Run prerequisites first** — commands that depend on earlier commands (e.g., `/speckit.tasks` requires `/speckit.plan` which requires `/speckit.specify`) must be run in order.
+5. **Report results** — paste the [reporting template](#reporting-results) into your PR with pass/fail for each command tested.
+
+#### Reporting results
+
+Paste this into your PR:
+
+~~~markdown
+## Manual test results
+
+**Agent**: [e.g., GitHub Copilot in VS Code]  |  **OS/Shell**: [e.g., macOS/zsh]
+
+| Command tested | Notes |
+|----------------|-------|
+| `/speckit.command` | |
+~~~
+
+#### Determining which tests to run
+
+Copy this prompt into your agent. Include the agent's response (selected tests plus a brief explanation of the mapping) in your PR.
+
+~~~text
+Read CONTRIBUTING.md, then run `git diff --name-only main` to get my changed files.
+For each changed file, determine which slash commands it affects by reading
+the command templates in templates/commands/ to understand what each command
+invokes. Use these mapping rules:
+
+- templates/commands/X.md → the command it defines
+- scripts/bash/Y.sh or scripts/powershell/Y.ps1 → every command that invokes that script (grep templates/commands/ for the script name). Also check transitive dependencies: if the changed script is sourced by other scripts (e.g., common.sh is sourced by create-new-feature.sh, check-prerequisites.sh, setup-plan.sh, update-agent-context.sh), then every command invoking those downstream scripts is also affected
+- templates/Z-template.md → every command that consumes that template during execution
+- src/specify_cli/*.py → CLI commands (`specify init`, `specify check`, `specify extension *`, `specify preset *`); test the affected CLI command and, for init/scaffolding changes, at minimum test /speckit.specify
+- extensions/X/commands/* → the extension command it defines
+- extensions/X/scripts/* → every extension command that invokes that script
+- extensions/X/extension.yml or config-template.yml → every command in that extension. Also check if the manifest defines hooks (look for `hooks:` entries like `before_specify`, `after_implement`, etc.) — if so, the core commands those hooks attach to are also affected
+- presets/*/* → test preset scaffolding via `specify init` with the preset
+- pyproject.toml → packaging/bundling; test `specify init` and verify bundled assets
+
+Include prerequisite tests (e.g., T5 requires T3 requires T1).
+
+Output in this format:
+
+### Test selection reasoning
+
+| Changed file | Affects | Test | Why |
+|---|---|---|---|
+| (path) | (command) | T# | (reason) |
+
+### Required tests
+
+Number each test sequentially (T1, T2, ...). List prerequisite tests first.
+
+- T1: /speckit.command — (reason)
+- T2: /speckit.command — (reason)
+~~~
 
 ## AI contributions in Spec Kit
 

DEVELOPMENT.md

@@ -11,8 +11,7 @@ Spec Kit is a toolkit for spec-driven development. At its core, it is a coordina
 | [spec-driven.md](spec-driven.md)                           | End-to-end explanation of the Spec-Driven Development workflow supported by Spec Kit. |
 | [RELEASE-PROCESS.md](.github/workflows/RELEASE-PROCESS.md) | Release workflow, versioning rules, and changelog generation process.                 |
 | [docs/index.md](docs/index.md)                             | Entry point to the `docs/` documentation set.                                         |
-| [CONTRIBUTING.md](CONTRIBUTING.md)                         | Contribution process, review expectations, and required development practices.        |
-| [TESTING.md](TESTING.md)                                   | Validation strategy and testing procedures.                                           |
+| [CONTRIBUTING.md](CONTRIBUTING.md)                         | Contribution process, review expectations, testing, and required development practices. |
 
 **Main repository components:**
 

README.md

@@ -50,6 +50,8 @@ Spec-Driven Development **flips the script** on traditional software development
 
 Choose your preferred installation method:
 
+> **Important:** The only official, maintained packages for Spec Kit are published from this GitHub repository. Any packages with the same name on PyPI are **not** affiliated with this project and are not maintained by the Spec Kit maintainers. Always install directly from GitHub as shown below.
+
 #### Option 1: Persistent Installation (Recommended)
 
 Install once and use everywhere. Pin a specific release tag for stability (check [Releases](https://github.com/github/spec-kit/releases) for the latest):
@@ -62,7 +64,13 @@ uv tool install specify-cli --from git+https://github.com/github/spec-kit.git@vX
 uv tool install specify-cli --from git+https://github.com/github/spec-kit.git
 ```
 
-Then use the tool directly:
+Then verify the correct version is installed:
+
+```bash
+specify version
+```
+
+And use the tool directly:
 
 ```bash
 # Create new project
@@ -182,7 +190,9 @@ The following community-contributed extensions are available in [`catalog.commun
 
 | Extension | Purpose | Category | Effect | URL |
 |-----------|---------|----------|--------|-----|
+| Agent Assign | Assign specialized Claude Code agents to spec-kit tasks for targeted execution | `process` | Read+Write | [spec-kit-agent-assign](https://github.com/xymelon/spec-kit-agent-assign) |
 | AI-Driven Engineering (AIDE) | A structured 7-step workflow for building new projects from scratch with AI assistants — from vision through implementation | `process` | Read+Write | [aide](https://github.com/mnriem/spec-kit-extensions/tree/main/aide) |
+| Architect Impact Previewer | Predicts architectural impact, complexity, and risks of proposed changes before implementation. | `visibility` | Read-only | [spec-kit-architect-preview](https://github.com/UmmeHabiba1312/spec-kit-architect-preview) |
 | Archive Extension | Archive merged features into main project memory. | `docs` | Read+Write | [spec-kit-archive](https://github.com/stn1slv/spec-kit-archive) |
 | Azure DevOps Integration | Sync user stories and tasks to Azure DevOps work items using OAuth authentication | `integration` | Read+Write | [spec-kit-azure-devops](https://github.com/pragya247/spec-kit-azure-devops) |
 | Branch Convention | Configurable branch and folder naming conventions for /specify with presets and custom patterns | `process` | Read+Write | [spec-kit-branch-convention](https://github.com/Quratulain-bilal/spec-kit-branch-convention) |

TESTING.md

@@ -1,133 +0,0 @@
-# Testing Guide
-
-This document is the detailed testing companion to [`CONTRIBUTING.md`](./CONTRIBUTING.md).
-
-Use it for three things:
-
-1. running quick automated checks before manual testing,
-2. manually testing affected slash commands through an AI agent, and
-3. capturing the results in a PR-friendly format.
-
-Any change that affects a slash command's behavior requires manually testing that command through an AI agent and submitting results with the PR.
-
-## Recommended order
-
-1. **Sync your environment** — install the project and test dependencies.
-2. **Run focused automated checks** — especially for packaging, scaffolding, agent config, and generated-file changes.
-3. **Run manual agent tests** — for any affected slash commands.
-4. **Paste results into your PR** — include both command-selection reasoning and manual test results.
-
-## Quick automated checks
-
-Run these before manual testing when your change affects packaging, scaffolding, templates, release artifacts, or agent wiring.
-
-### Environment setup
-
-```bash
-cd <spec-kit-repo>
-uv sync --extra test
-source .venv/bin/activate  # On Windows (CMD): .venv\Scripts\activate  |  (PowerShell): .venv\Scripts\Activate.ps1
-```
-
-### Generated package structure and content
-
-```bash
-uv run python -m pytest tests/test_core_pack_scaffold.py -q
-```
-
-This validates the generated files that CI-style packaging depends on, including directory layout, file names, frontmatter/TOML validity, placeholder replacement, `.specify/` path rewrites, and parity with `create-release-packages.sh`.
-
-### Agent configuration and release wiring consistency
-
-```bash
-uv run python -m pytest tests/test_agent_config_consistency.py -q
-```
-
-Run this when you change agent metadata, release scripts, context update scripts, or artifact naming.
-
-### Optional single-agent packaging spot check
-
-```bash
-AGENTS=copilot SCRIPTS=sh ./.github/workflows/scripts/create-release-packages.sh v1.0.0
-```
-
-Inspect `.genreleases/sdd-copilot-package-sh/` and the matching ZIP in `.genreleases/` when you want to review the exact packaged output for one agent/script combination.
-
-## Manual testing process
-
-1. **Identify affected commands** — use the [prompt below](#determining-which-tests-to-run) to have your agent analyze your changed files and determine which commands need testing.
-2. **Set up a test project** — scaffold from your local branch (see [Setup](#setup)).
-3. **Run each affected command** — invoke it in your agent, verify it completes successfully, and confirm it produces the expected output (files created, scripts executed, artifacts populated).
-4. **Run prerequisites first** — commands that depend on earlier commands (e.g., `/speckit.tasks` requires `/speckit.plan` which requires `/speckit.specify`) must be run in order.
-5. **Report results** — paste the [reporting template](#reporting-results) into your PR with pass/fail for each command tested.
-
-## Setup
-
-```bash
-# Install the project and test dependencies from your local branch
-cd <spec-kit-repo>
-uv sync --extra test
-source .venv/bin/activate  # On Windows (CMD): .venv\Scripts\activate  |  (PowerShell): .venv\Scripts\Activate.ps1
-uv pip install -e .
-# Ensure the `specify` binary in this environment points at your working tree so the agent runs the branch you're testing.
-
-# Initialize a test project using your local changes
-uv run specify init /tmp/speckit-test --ai <agent> --offline
-cd /tmp/speckit-test
-
-# Open in your agent
-```
-
-If you are testing the packaged output rather than the live source tree, create a local release package first as described in [`CONTRIBUTING.md`](./CONTRIBUTING.md).
-
-## Reporting results
-
-Paste this into your PR:
-
-~~~markdown
-## Manual test results
-
-**Agent**: [e.g., GitHub Copilot in VS Code]  |  **OS/Shell**: [e.g., macOS/zsh]
-
-| Command tested | Notes |
-|----------------|-------|
-| `/speckit.command` | |
-~~~
-
-## Determining which tests to run
-
-Copy this prompt into your agent. Include the agent's response (selected tests plus a brief explanation of the mapping) in your PR.
-
-~~~text
-Read TESTING.md, then run `git diff --name-only main` to get my changed files.
-For each changed file, determine which slash commands it affects by reading
-the command templates in templates/commands/ to understand what each command
-invokes. Use these mapping rules:
-
-- templates/commands/X.md → the command it defines
-- scripts/bash/Y.sh or scripts/powershell/Y.ps1 → every command that invokes that script (grep templates/commands/ for the script name). Also check transitive dependencies: if the changed script is sourced by other scripts (e.g., common.sh is sourced by create-new-feature.sh, check-prerequisites.sh, setup-plan.sh, update-agent-context.sh), then every command invoking those downstream scripts is also affected
-- templates/Z-template.md → every command that consumes that template during execution
-- src/specify_cli/*.py → CLI commands (`specify init`, `specify check`, `specify extension *`, `specify preset *`); test the affected CLI command and, for init/scaffolding changes, at minimum test /speckit.specify
-- extensions/X/commands/* → the extension command it defines
-- extensions/X/scripts/* → every extension command that invokes that script
-- extensions/X/extension.yml or config-template.yml → every command in that extension. Also check if the manifest defines hooks (look for `hooks:` entries like `before_specify`, `after_implement`, etc.) — if so, the core commands those hooks attach to are also affected
-- presets/*/* → test preset scaffolding via `specify init` with the preset
-- pyproject.toml → packaging/bundling; test `specify init` and verify bundled assets
-
-Include prerequisite tests (e.g., T5 requires T3 requires T1).
-
-Output in this format:
-
-### Test selection reasoning
-
-| Changed file | Affects | Test | Why |
-|---|---|---|---|
-| (path) | (command) | T# | (reason) |
-
-### Required tests
-
-Number each test sequentially (T1, T2, ...). List prerequisite tests first.
-
-- T1: /speckit.command — (reason)
-- T2: /speckit.command — (reason)
-~~~

docs/installation.md

@@ -10,6 +10,8 @@
 
 ## Installation
 
+> **Important:** The only official, maintained packages for Spec Kit come from the [github/spec-kit](https://github.com/github/spec-kit) GitHub repository. Any packages with the same name available on PyPI (e.g. `specify-cli` on pypi.org) are **not** affiliated with this project and are not maintained by the Spec Kit maintainers. For normal installs, use the GitHub-based commands shown below. For offline or air-gapped environments, locally built wheels created from this repository are also valid.
+
 ### Initialize a New Project
 
 The easiest way to get started is to initialize a new project. Pin a specific release tag for stability (check [Releases](https://github.com/github/spec-kit/releases) for the latest):
@@ -69,6 +71,14 @@ uvx --from git+https://github.com/github/spec-kit.git@vX.Y.Z specify init <proje
 
 ## Verification
 
+After installation, run the following command to confirm the correct version is installed:
+
+```bash
+specify version
+```
+
+This helps verify you are running the official Spec Kit build from GitHub, not an unrelated package with the same name.
+
 After initialization, you should see the following commands available in your AI agent:
 
 - `/speckit.specify` - Create specifications

docs/local-development.md

@@ -128,16 +128,14 @@ python -m src.specify_cli init --here --ai claude --ignore-agent-tools --script
 
 Or copy only the modified CLI portion if you want a lighter sandbox.
 
-## 9. Debug Network / TLS Skips
+## 9. Debug Network / TLS Issues
 
-If you need to bypass TLS validation while experimenting:
-
-```bash
-specify check --skip-tls
-specify init demo --skip-tls --ai gemini --ignore-agent-tools --script ps
-```
-
-(Use only for local experimentation.)
+> **Deprecated:** The `--skip-tls` flag is a no-op and has no effect.
+> It was previously used to bypass TLS validation during local testing.
+> If you encounter TLS errors (e.g., on a corporate network), configure your
+> environment's certificate store or proxy instead.
+>
+> For example, set `SSL_CERT_FILE` or configure `HTTPS_PROXY` / `HTTP_PROXY`.
 
 ## 10. Rapid Edit Loop Summary
 
@@ -166,7 +164,7 @@ rm -rf .venv dist build *.egg-info
 | Scripts not executable (Linux) | Re-run init or `chmod +x scripts/*.sh` |
 | Git step skipped | You passed `--no-git` or Git not installed |
 | Wrong script type downloaded | Pass `--script sh` or `--script ps` explicitly |
-| TLS errors on corporate network | Try `--skip-tls` (not for production) |
+| TLS errors on corporate network | Configure your environment's certificate store or proxy. The `--skip-tls` flag is deprecated and has no effect. |
 
 ## 13. Next Steps
 

extensions/catalog.community.json

@@ -1,6 +1,6 @@
 {
   "schema_version": "1.0",
-  "updated_at": "2026-04-13T23:01:30Z",
+  "updated_at": "2026-04-14T21:30:00Z",
   "catalog_url": "https://raw.githubusercontent.com/github/spec-kit/main/extensions/catalog.community.json",
   "extensions": {
     "aide": {
@@ -36,6 +36,70 @@
       "created_at": "2026-03-18T00:00:00Z",
       "updated_at": "2026-03-18T00:00:00Z"
     },
+    "agent-assign": {
+      "name": "Agent Assign",
+      "id": "agent-assign",
+      "description": "Assign specialized Claude Code agents to spec-kit tasks for targeted execution",
+      "author": "xuyang",
+      "version": "1.0.0",
+      "download_url": "https://github.com/xymelon/spec-kit-agent-assign/archive/refs/tags/v1.0.0.zip",
+      "repository": "https://github.com/xymelon/spec-kit-agent-assign",
+      "homepage": "https://github.com/xymelon/spec-kit-agent-assign",
+      "documentation": "https://github.com/xymelon/spec-kit-agent-assign/blob/main/README.md",
+      "changelog": "https://github.com/xymelon/spec-kit-agent-assign/blob/main/CHANGELOG.md",
+      "license": "MIT",
+      "requires": {
+        "speckit_version": ">=0.3.0"
+      },
+      "provides": {
+        "commands": 3,
+        "hooks": 1
+      },
+      "tags": [
+        "agent",
+        "automation",
+        "implementation",
+        "multi-agent",
+        "task-routing"
+      ],
+      "verified": false,
+      "downloads": 0,
+      "stars": 0,
+      "created_at": "2026-03-31T00:00:00Z",
+      "updated_at": "2026-03-31T00:00:00Z"
+    },
+    "architect-preview": {
+      "name": "Architect Impact Previewer",
+      "id": "architect-preview",
+      "description": "Predicts architectural impact, complexity, and risks of proposed changes before implementation.",
+      "author": "Umme Habiba",
+      "version": "1.0.0",
+      "download_url": "https://github.com/UmmeHabiba1312/spec-kit-architect-preview/archive/refs/tags/v1.0.0.zip",
+      "repository": "https://github.com/UmmeHabiba1312/spec-kit-architect-preview",
+      "homepage": "https://github.com/UmmeHabiba1312/spec-kit-architect-preview",
+      "documentation": "https://github.com/UmmeHabiba1312/spec-kit-architect-preview/blob/main/README.md",
+      "changelog": "https://github.com/UmmeHabiba1312/spec-kit-architect-preview/blob/main/CHANGELOG.md",
+      "license": "MIT",
+      "requires": {
+        "speckit_version": ">=0.1.0"
+      },
+      "provides": {
+        "commands": 1,
+        "hooks": 0
+      },
+      "tags": [
+        "architecture",
+        "analysis",
+        "risk-assessment",
+        "planning",
+        "preview"
+      ],
+      "verified": false,
+      "downloads": 0,
+      "stars": 0,
+      "created_at": "2026-04-14T00:00:00Z",
+      "updated_at": "2026-04-14T00:00:00Z"
+    },
     "archive": {
       "name": "Archive Extension",
       "id": "archive",

extensions/git/scripts/bash/auto-commit.sh

@@ -137,4 +137,4 @@ fi
 _git_out=$(git add . 2>&1) || { echo "[specify] Error: git add failed: $_git_out" >&2; exit 1; }
 _git_out=$(git commit -q -m "$_commit_msg" 2>&1) || { echo "[specify] Error: git commit failed: $_git_out" >&2; exit 1; }
 
-echo "✓ Changes committed ${_phase} ${_command_name}" >&2
+echo "[OK] Changes committed ${_phase} ${_command_name}" >&2

extensions/git/scripts/powershell/auto-commit.ps1

@@ -146,4 +146,4 @@ try {
     exit 1
 }
 
-Write-Host "✓ Changes committed $phase $commandName"
+Write-Host "[OK] Changes committed $phase $commandName"

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "specify-cli"
-version = "0.6.3.dev0"
+version = "0.7.1"
 description = "Specify CLI, part of GitHub Spec Kit. A tool to bootstrap your projects for Spec-Driven Development (SDD)."
 requires-python = ">=3.11"
 dependencies = [

src/specify_cli/__init__.py

@@ -33,6 +33,7 @@ import shutil
 import json
 import json5
 import stat
+import shlex
 import yaml
 from pathlib import Path
 from typing import Any, Optional
@@ -92,6 +93,36 @@ def _build_ai_assistant_help() -> str:
     return base_help + " Use " + aliases_text + "."
 AI_ASSISTANT_HELP = _build_ai_assistant_help()
 
+
+def _build_integration_equivalent(
+    integration_key: str,
+    ai_commands_dir: str | None = None,
+) -> str:
+    """Build the modern --integration equivalent for legacy --ai usage."""
+
+    parts = [f"--integration {integration_key}"]
+    if integration_key == "generic" and ai_commands_dir:
+        parts.append(
+            f'--integration-options="--commands-dir {shlex.quote(ai_commands_dir)}"'
+        )
+    return " ".join(parts)
+
+
+def _build_ai_deprecation_warning(
+    integration_key: str,
+    ai_commands_dir: str | None = None,
+) -> str:
+    """Build the legacy --ai deprecation warning message."""
+
+    replacement = _build_integration_equivalent(
+        integration_key,
+        ai_commands_dir=ai_commands_dir,
+    )
+    return (
+        "[bold]--ai[/bold] is deprecated and will no longer be available in version 1.0.0 or later.\n\n"
+        f"Use [bold]{replacement}[/bold] instead."
+    )
+
 SCRIPT_TYPE_CHOICES = {"sh": "POSIX Shell (bash/zsh)", "ps": "PowerShell"}
 
 CLAUDE_LOCAL_PATH = Path.home() / ".claude" / "local" / "claude"
@@ -957,6 +988,7 @@ def init(
     """
 
     show_banner()
+    ai_deprecation_warning: str | None = None
 
     # Detect when option values are likely misinterpreted flags (parameter ordering issue)
     if ai_assistant and ai_assistant.startswith("--"):
@@ -995,6 +1027,10 @@ def init(
         if not resolved_integration:
             console.print(f"[red]Error:[/red] Unknown agent '{ai_assistant}'. Choose from: {', '.join(sorted(INTEGRATION_REGISTRY))}")
             raise typer.Exit(1)
+        ai_deprecation_warning = _build_ai_deprecation_warning(
+            resolved_integration.key,
+            ai_commands_dir=ai_commands_dir,
+        )
 
     # Deprecation warnings for --ai-skills and --ai-commands-dir (only when
     # an integration has been resolved from --ai or --integration)
@@ -1428,6 +1464,16 @@ def init(
             console.print()
             console.print(security_notice)
 
+    if ai_deprecation_warning:
+        deprecation_notice = Panel(
+            ai_deprecation_warning,
+            title="[bold red]Deprecation Warning[/bold red]",
+            border_style="red",
+            padding=(1, 2),
+        )
+        console.print()
+        console.print(deprecation_notice)
+
     steps_lines = []
     if not here:
         steps_lines.append(f"1. Go to the project folder: [cyan]cd {project_name}[/cyan]")
@@ -3272,6 +3318,10 @@ def extension_add(
         console.print("\n[green]✓[/green] Extension installed successfully!")
         console.print(f"\n[bold]{manifest.name}[/bold] (v{manifest.version})")
         console.print(f"  {manifest.description}")
+
+        for warning in manifest.warnings:
+            console.print(f"\n[yellow]⚠  Compatibility warning:[/yellow] {warning}")
+
         console.print("\n[bold cyan]Provided commands:[/bold cyan]")
         for cmd in manifest.commands:
             console.print(f"  • {cmd['name']} - {cmd.get('description', '')}")
@@ -3325,15 +3375,28 @@ def extension_remove(
 
     # Get extension info for command and skill counts
     ext_manifest = manager.get_extension(extension_id)
-    cmd_count = len(ext_manifest.commands) if ext_manifest else 0
     reg_meta = manager.registry.get(extension_id)
+    # Derive cmd_count from the registry's registered_commands (includes aliases)
+    # rather than from the manifest (primary commands only). Use max() across
+    # agents to get the per-agent count; sum() would double-count since users
+    # think in logical commands, not per-agent file counts.
+    # Use get() without a default so we can distinguish "key missing" (fall back
+    # to manifest) from "key present but empty dict" (zero commands registered).
+    registered_commands = reg_meta.get("registered_commands") if isinstance(reg_meta, dict) else None
+    if isinstance(registered_commands, dict):
+        cmd_count = max(
+            (len(v) for v in registered_commands.values() if isinstance(v, list)),
+            default=0,
+        )
+    else:
+        cmd_count = len(ext_manifest.commands) if ext_manifest else 0
     raw_skills = reg_meta.get("registered_skills") if reg_meta else None
     skill_count = len(raw_skills) if isinstance(raw_skills, list) else 0
 
     # Confirm removal
     if not force:
         console.print("\n[yellow]⚠  This will remove:[/yellow]")
-        console.print(f"   • {cmd_count} commands from AI agent")
+        console.print(f"   • {cmd_count} command{'s' if cmd_count != 1 else ''} per agent")
         if skill_count:
             console.print(f"   • {skill_count} agent skill(s)")
         console.print(f"   • Extension directory: .specify/extensions/{extension_id}/")

src/specify_cli/agents.py

@@ -317,11 +317,6 @@ class CommandRegistrar:
                 "source": source,
             },
         }
-        if agent_name == "claude":
-            # Claude skills should be user-invocable (accessible via /command)
-            # and only run when explicitly invoked (not auto-triggered by the model).
-            skill_frontmatter["user-invocable"] = True
-            skill_frontmatter["disable-model-invocation"] = True
         return skill_frontmatter
 
     @staticmethod
@@ -660,6 +655,15 @@ class CommandRegistrar:
                 cmd_file = commands_dir / f"{output_name}{agent_config['extension']}"
                 if cmd_file.exists():
                     cmd_file.unlink()
+                    # For SKILL.md agents each command lives in its own subdirectory
+                    # (e.g. .agents/skills/speckit-ext-cmd/SKILL.md). Remove the
+                    # parent dir when it becomes empty to avoid orphaned directories.
+                    parent = cmd_file.parent
+                    if parent != commands_dir and parent.exists():
+                        try:
+                            parent.rmdir()  # no-op if dir still has other files
+                        except OSError:
+                            pass
 
                 if agent_name == "copilot":
                     prompt_file = (

src/specify_cli/extensions.py

@@ -132,6 +132,7 @@ class ExtensionManifest:
             ValidationError: If manifest is invalid
         """
         self.path = manifest_path
+        self.warnings: List[str] = []
         self.data = self._load_yaml(manifest_path)
         self._validate()
 
@@ -217,17 +218,98 @@ class ExtensionManifest:
                         f"Hook '{hook_name}' missing required 'command' field"
                     )
 
-        # Validate commands (if present)
+        # Validate commands; track renames so hook references can be rewritten.
+        rename_map: Dict[str, str] = {}
         for cmd in commands:
+            if not isinstance(cmd, dict):
+                raise ValidationError(
+                    "Each command entry in 'provides.commands' must be a mapping"
+                )
             if "name" not in cmd or "file" not in cmd:
                 raise ValidationError("Command missing 'name' or 'file'")
 
             # Validate command name format
-            if EXTENSION_COMMAND_NAME_PATTERN.match(cmd["name"]) is None:
+            if not EXTENSION_COMMAND_NAME_PATTERN.match(cmd["name"]):
+                corrected = self._try_correct_command_name(cmd["name"], ext["id"])
+                if corrected:
+                    self.warnings.append(
+                        f"Command name '{cmd['name']}' does not follow the required pattern "
+                        f"'speckit.{{extension}}.{{command}}'. Registering as '{corrected}'. "
+                        f"The extension author should update the manifest to use this name."
+                    )
+                    rename_map[cmd["name"]] = corrected
+                    cmd["name"] = corrected
+                else:
+                    raise ValidationError(
+                        f"Invalid command name '{cmd['name']}': "
+                        "must follow pattern 'speckit.{extension}.{command}'"
+                    )
+
+            # Validate alias types; no pattern enforcement on aliases — they are
+            # intentionally free-form to preserve community extension compatibility
+            # (e.g. 'speckit.verify' short aliases used by existing extensions).
+            aliases = cmd.get("aliases")
+            if aliases is None:
+                cmd["aliases"] = []
+                aliases = []
+            if not isinstance(aliases, list):
                 raise ValidationError(
-                    f"Invalid command name '{cmd['name']}': "
-                    "must follow pattern 'speckit.{extension}.{command}'"
+                    f"Aliases for command '{cmd['name']}' must be a list"
                 )
+            for alias in aliases:
+                if not isinstance(alias, str):
+                    raise ValidationError(
+                        f"Aliases for command '{cmd['name']}' must be strings"
+                    )
+
+        # Rewrite any hook command references that pointed at a renamed command or
+        # an alias-form ref (ext.cmd → speckit.ext.cmd).  Always emit a warning when
+        # the reference is changed so extension authors know to update the manifest.
+        for hook_name, hook_data in self.data.get("hooks", {}).items():
+            if not isinstance(hook_data, dict):
+                raise ValidationError(
+                    f"Hook '{hook_name}' must be a mapping, got {type(hook_data).__name__}"
+                )
+            command_ref = hook_data.get("command")
+            if not isinstance(command_ref, str):
+                continue
+            # Step 1: apply any rename from the auto-correction pass.
+            after_rename = rename_map.get(command_ref, command_ref)
+            # Step 2: lift alias-form '{ext_id}.cmd' to canonical 'speckit.{ext_id}.cmd'.
+            parts = after_rename.split(".")
+            if len(parts) == 2 and parts[0] == ext["id"]:
+                final_ref = f"speckit.{ext['id']}.{parts[1]}"
+            else:
+                final_ref = after_rename
+            if final_ref != command_ref:
+                hook_data["command"] = final_ref
+                self.warnings.append(
+                    f"Hook '{hook_name}' referenced command '{command_ref}'; "
+                    f"updated to canonical form '{final_ref}'. "
+                    f"The extension author should update the manifest."
+                )
+
+    @staticmethod
+    def _try_correct_command_name(name: str, ext_id: str) -> Optional[str]:
+        """Try to auto-correct a non-conforming command name to the required pattern.
+
+        Handles the two legacy formats used by community extensions:
+          - 'speckit.command'  → 'speckit.{ext_id}.command'
+          - '{ext_id}.command' → 'speckit.{ext_id}.command'
+
+        The 'X.Y' form is only corrected when X matches ext_id to ensure the
+        result passes the install-time namespace check. Any other prefix is
+        uncorrectable and will produce a ValidationError at the call site.
+
+        Returns the corrected name, or None if no safe correction is possible.
+        """
+        parts = name.split('.')
+        if len(parts) == 2:
+            if parts[0] == 'speckit' or parts[0] == ext_id:
+                candidate = f"speckit.{ext_id}.{parts[1]}"
+                if EXTENSION_COMMAND_NAME_PATTERN.match(candidate):
+                    return candidate
+        return None
 
     @property
     def id(self) -> str:
@@ -768,6 +850,7 @@ class ExtensionManager:
 
         from . import load_init_options
         from .agents import CommandRegistrar
+        from .integrations import get_integration
         import yaml
 
         written: List[str] = []
@@ -778,6 +861,7 @@ class ExtensionManager:
         if not isinstance(selected_ai, str) or not selected_ai:
             return []
         registrar = CommandRegistrar()
+        integration = get_integration(selected_ai)
 
         for cmd_info in manifest.commands:
             cmd_name = cmd_info["name"]
@@ -857,6 +941,10 @@ class ExtensionManager:
                 f"# {title_name} Skill\n\n"
                 f"{body}\n"
             )
+            if integration is not None and hasattr(integration, "post_process_skill_content"):
+                skill_content = integration.post_process_skill_content(
+                    skill_content
+                )
 
             skill_file.write_text(skill_content, encoding="utf-8")
             written.append(skill_name)

src/specify_cli/integrations/base.py

@@ -1102,6 +1102,16 @@ class SkillsIntegration(IntegrationBase):
             invocation = f"{invocation} {args}"
         return invocation
 
+    def post_process_skill_content(self, content: str) -> str:
+        """Post-process a SKILL.md file's content after generation.
+
+        Called by external skill generators (presets, extensions) to let
+        the integration inject agent-specific frontmatter or body
+        transformations.  The default implementation returns *content*
+        unchanged.  Subclasses may override — see ``ClaudeIntegration``.
+        """
+        return content
+
     def setup(
         self,
         project_root: Path,

src/specify_cli/integrations/claude/__init__.py

@@ -5,11 +5,21 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Any
 
+import re
+
 import yaml
 
 from ..base import SkillsIntegration
 from ..manifest import IntegrationManifest
 
+# Note injected into hook sections so Claude maps dot-notation command
+# names (from extensions.yml) to the hyphenated skill names it uses.
+_HOOK_COMMAND_NOTE = (
+    "- When constructing slash commands from hook command names, "
+    "replace dots (`.`) with hyphens (`-`). "
+    "For example, `speckit.git.commit` → `/speckit-git-commit`.\n"
+)
+
 # Mapping of command template stem → argument-hint text shown inline
 # when a user invokes the slash command in Claude Code.
 ARGUMENT_HINTS: dict[str, str] = {
@@ -148,6 +158,43 @@ class ClaudeIntegration(SkillsIntegration):
             out.append(line)
         return "".join(out)
 
+    @staticmethod
+    def _inject_hook_command_note(content: str) -> str:
+        """Insert a dot-to-hyphen note before each hook output instruction.
+
+        Targets the line ``- For each executable hook, output the following``
+        and inserts the note on the line before it, matching its indentation.
+        Skips if the note is already present.
+        """
+        if "replace dots" in content:
+            return content
+
+        def repl(m: re.Match[str]) -> str:
+            indent = m.group(1)
+            instruction = m.group(2)
+            eol = m.group(3)
+            return (
+                indent
+                + _HOOK_COMMAND_NOTE.rstrip("\n")
+                + eol
+                + indent
+                + instruction
+                + eol
+            )
+
+        return re.sub(
+            r"(?m)^(\s*)(- For each executable hook, output the following[^\r\n]*)(\r\n|\n|$)",
+            repl,
+            content,
+        )
+
+    def post_process_skill_content(self, content: str) -> str:
+        """Inject Claude-specific frontmatter flags and hook notes."""
+        updated = self._inject_frontmatter_flag(content, "user-invocable")
+        updated = self._inject_frontmatter_flag(updated, "disable-model-invocation", "false")
+        updated = self._inject_hook_command_note(updated)
+        return updated
+
     def setup(
         self,
         project_root: Path,
@@ -155,7 +202,7 @@ class ClaudeIntegration(SkillsIntegration):
         parsed_options: dict[str, Any] | None = None,
         **opts: Any,
     ) -> list[Path]:
-        """Install Claude skills, then inject user-invocable, disable-model-invocation, and argument-hint."""
+        """Install Claude skills, then inject Claude-specific flags and argument-hints."""
         created = super().setup(project_root, manifest, parsed_options, **opts)
 
         # Post-process generated skill files
@@ -173,11 +220,7 @@ class ClaudeIntegration(SkillsIntegration):
             content_bytes = path.read_bytes()
             content = content_bytes.decode("utf-8")
 
-            # Inject user-invocable: true (Claude skills are accessible via /command)
-            updated = self._inject_frontmatter_flag(content, "user-invocable")
-
-            # Inject disable-model-invocation: true (Claude skills run only when invoked)
-            updated = self._inject_frontmatter_flag(updated, "disable-model-invocation")
+            updated = self.post_process_skill_content(content)
 
             # Inject argument-hint if available for this skill
             skill_dir_name = path.parent.name  # e.g. "speckit-plan"

src/specify_cli/presets.py

@@ -707,6 +707,7 @@ class PresetManager:
 
         from . import SKILL_DESCRIPTIONS, load_init_options
         from .agents import CommandRegistrar
+        from .integrations import get_integration
 
         init_opts = load_init_options(self.project_root)
         if not isinstance(init_opts, dict):
@@ -716,6 +717,7 @@ class PresetManager:
             return []
         ai_skills_enabled = bool(init_opts.get("ai_skills"))
         registrar = CommandRegistrar()
+        integration = get_integration(selected_ai)
         agent_config = registrar.AGENT_CONFIGS.get(selected_ai, {})
         # Native skill agents (e.g. codex/kimi/agy/trae) materialize brand-new
         # preset skills in _register_commands() because their detected agent
@@ -789,6 +791,10 @@ class PresetManager:
                     f"# Speckit {skill_title} Skill\n\n"
                     f"{body}\n"
                 )
+                if integration is not None and hasattr(integration, "post_process_skill_content"):
+                    skill_content = integration.post_process_skill_content(
+                        skill_content
+                    )
 
                 skill_file = skill_subdir / "SKILL.md"
                 skill_file.write_text(skill_content, encoding="utf-8")
@@ -816,6 +822,7 @@ class PresetManager:
 
         from . import SKILL_DESCRIPTIONS, load_init_options
         from .agents import CommandRegistrar
+        from .integrations import get_integration
 
         # Locate core command templates from the project's installed templates
         core_templates_dir = self.project_root / ".specify" / "templates" / "commands"
@@ -824,6 +831,7 @@ class PresetManager:
             init_opts = {}
         selected_ai = init_opts.get("ai")
         registrar = CommandRegistrar()
+        integration = get_integration(selected_ai) if isinstance(selected_ai, str) else None
         extension_restore_index = self._build_extension_skill_restore_index()
 
         for skill_name in skill_names:
@@ -877,6 +885,10 @@ class PresetManager:
                     f"# Speckit {skill_title} Skill\n\n"
                     f"{body}\n"
                 )
+                if integration is not None and hasattr(integration, "post_process_skill_content"):
+                    skill_content = integration.post_process_skill_content(
+                        skill_content
+                    )
                 skill_file.write_text(skill_content, encoding="utf-8")
                 continue
 
@@ -906,6 +918,10 @@ class PresetManager:
                     f"# {title_name} Skill\n\n"
                     f"{body}\n"
                 )
+                if integration is not None and hasattr(integration, "post_process_skill_content"):
+                    skill_content = integration.post_process_skill_content(
+                        skill_content
+                    )
                 skill_file.write_text(skill_content, encoding="utf-8")
             else:
                 # No core or extension template — remove the skill entirely

tests/conftest.py

@@ -1,10 +1,68 @@
 """Shared test helpers for the Spec Kit test suite."""
 
+import os
 import re
+import shutil
+import subprocess
+import sys
+
+import pytest
 
 _ANSI_ESCAPE_RE = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]")
 
 
+def _has_working_bash() -> bool:
+    """Check whether a functional native bash is available.
+
+    On Windows, ``subprocess.run(["bash", ...])`` uses CreateProcess,
+    which searches System32 *before* PATH — so it may find the WSL
+    launcher even when Git-for-Windows bash appears first in PATH via
+    ``shutil.which``.  We therefore probe with bare ``"bash"`` (the
+    same way test helpers invoke it) to get an accurate result.
+
+    On Windows, only Git-for-Windows bash (MSYS2/MINGW) is accepted.
+    The WSL launcher is rejected because it runs in a separate Linux
+    filesystem and cannot handle native Windows paths used by the
+    test fixtures.
+
+    Set SPECKIT_TEST_BASH=1 to force-enable bash tests regardless.
+    """
+    if os.environ.get("SPECKIT_TEST_BASH") == "1":
+        return True
+    if shutil.which("bash") is None:
+        return False
+    # Probe with bare "bash" — same as the test helpers — so that
+    # Windows CreateProcess resolution order is respected.
+    try:
+        r = subprocess.run(
+            ["bash", "-c", "echo ok"],
+            capture_output=True, text=True, timeout=5,
+        )
+        if r.returncode != 0 or "ok" not in r.stdout:
+            return False
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+    # On Windows, verify we have MSYS/MINGW bash (Git for Windows),
+    # not the WSL launcher which can't handle native paths.
+    if sys.platform == "win32":
+        try:
+            u = subprocess.run(
+                ["bash", "-c", "uname -s"],
+                capture_output=True, text=True, timeout=5,
+            )
+            kernel = u.stdout.strip().upper()
+            if not any(k in kernel for k in ("MSYS", "MINGW", "CYGWIN")):
+                return False
+        except (OSError, subprocess.TimeoutExpired):
+            return False
+    return True
+
+
+requires_bash = pytest.mark.skipif(
+    not _has_working_bash(), reason="working bash not available"
+)
+
+
 def strip_ansi(text: str) -> str:
     """Remove ANSI escape codes from Rich-formatted CLI output."""
     return _ANSI_ESCAPE_RE.sub("", text)

tests/extensions/git/test_git_extension.py

@@ -18,6 +18,8 @@ from pathlib import Path
 
 import pytest
 
+from tests.conftest import requires_bash
+
 PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent.parent
 EXT_DIR = PROJECT_ROOT / "extensions" / "git"
 EXT_BASH = EXT_DIR / "scripts" / "bash"
@@ -211,6 +213,7 @@ class TestGitExtensionInstall:
 # ── initialize-repo.sh Tests ─────────────────────────────────────────────────
 
 
+@requires_bash
 class TestInitializeRepoBash:
     def test_initializes_git_repo(self, tmp_path: Path):
         """initialize-repo.sh creates a git repo with initial commit."""
@@ -269,6 +272,7 @@ class TestInitializeRepoPowerShell:
 # ── create-new-feature.sh Tests ──────────────────────────────────────────────
 
 
+@requires_bash
 class TestCreateFeatureBash:
     def test_creates_branch_sequential(self, tmp_path: Path):
         """Extension create-new-feature.sh creates sequential branch."""
@@ -376,6 +380,7 @@ class TestCreateFeaturePowerShell:
 # ── auto-commit.sh Tests ─────────────────────────────────────────────────────
 
 
+@requires_bash
 class TestAutoCommitBash:
     def test_disabled_by_default(self, tmp_path: Path):
         """auto-commit.sh exits silently when config is all false."""
@@ -491,6 +496,34 @@ class TestAutoCommitBash:
         result = _run_bash("auto-commit.sh", project)
         assert result.returncode != 0
 
+    def test_success_message_uses_ok_prefix(self, tmp_path: Path):
+        """auto-commit.sh success message uses [OK] (not Unicode)."""
+        project = _setup_project(tmp_path)
+        _write_config(project, (
+            "auto_commit:\n"
+            "  default: false\n"
+            "  after_specify:\n"
+            "    enabled: true\n"
+        ))
+        (project / "new-file.txt").write_text("content")
+        result = _run_bash("auto-commit.sh", project, "after_specify")
+        assert result.returncode == 0
+        assert "[OK] Changes committed" in result.stderr
+
+    def test_success_message_no_unicode_checkmark(self, tmp_path: Path):
+        """auto-commit.sh must not use Unicode checkmark in output."""
+        project = _setup_project(tmp_path)
+        _write_config(project, (
+            "auto_commit:\n"
+            "  default: false\n"
+            "  after_plan:\n"
+            "    enabled: true\n"
+        ))
+        (project / "new-file.txt").write_text("content")
+        result = _run_bash("auto-commit.sh", project, "after_plan")
+        assert result.returncode == 0
+        assert "\u2713" not in result.stderr, "Must not use Unicode checkmark"
+
 
 @pytest.mark.skipif(not HAS_PWSH, reason="pwsh not available")
 class TestAutoCommitPowerShell:
@@ -523,10 +556,39 @@ class TestAutoCommitPowerShell:
         )
         assert "ps commit" in log.stdout
 
+    def test_success_message_uses_ok_prefix(self, tmp_path: Path):
+        """auto-commit.ps1 success message uses [OK] (not Unicode)."""
+        project = _setup_project(tmp_path)
+        _write_config(project, (
+            "auto_commit:\n"
+            "  default: false\n"
+            "  after_specify:\n"
+            "    enabled: true\n"
+        ))
+        (project / "new-file.txt").write_text("content")
+        result = _run_pwsh("auto-commit.ps1", project, "after_specify")
+        assert result.returncode == 0
+        assert "[OK] Changes committed" in result.stdout
+
+    def test_success_message_no_unicode_checkmark(self, tmp_path: Path):
+        """auto-commit.ps1 must not use Unicode checkmark in output."""
+        project = _setup_project(tmp_path)
+        _write_config(project, (
+            "auto_commit:\n"
+            "  default: false\n"
+            "  after_plan:\n"
+            "    enabled: true\n"
+        ))
+        (project / "new-file.txt").write_text("content")
+        result = _run_pwsh("auto-commit.ps1", project, "after_plan")
+        assert result.returncode == 0
+        assert "\u2713" not in result.stdout, "Must not use Unicode checkmark"
+
 
 # ── git-common.sh Tests ──────────────────────────────────────────────────────
 
 
+@requires_bash
 class TestGitCommonBash:
     def test_has_git_true(self, tmp_path: Path):
         """has_git returns 0 in a git repo."""

tests/integrations/test_cli.py

@@ -5,6 +5,14 @@ import os
 
 import yaml
 
+from tests.conftest import strip_ansi
+
+
+def _normalize_cli_output(output: str) -> str:
+    output = strip_ansi(output)
+    output = " ".join(output.split())
+    return output.strip()
+
 
 class TestInitIntegrationFlag:
     def test_integration_and_ai_mutually_exclusive(self, tmp_path):
@@ -77,6 +85,59 @@ class TestInitIntegrationFlag:
         assert result.exit_code == 0
         assert (project / ".github" / "agents" / "speckit.plan.agent.md").exists()
 
+    def test_ai_emits_deprecation_warning_with_integration_replacement(self, tmp_path):
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        project = tmp_path / "warn-ai"
+        project.mkdir()
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(project)
+            runner = CliRunner()
+            result = runner.invoke(app, [
+                "init", "--here", "--ai", "copilot", "--script", "sh", "--no-git",
+            ], catch_exceptions=False)
+        finally:
+            os.chdir(old_cwd)
+
+        normalized_output = _normalize_cli_output(result.output)
+        assert result.exit_code == 0, result.output
+        assert "Deprecation Warning" in normalized_output
+        assert "--ai" in normalized_output
+        assert "deprecated" in normalized_output
+        assert "no longer be available" in normalized_output
+        assert "1.0.0" in normalized_output
+        assert "--integration copilot" in normalized_output
+        assert normalized_output.index("Deprecation Warning") < normalized_output.index("Next Steps")
+        assert (project / ".github" / "agents" / "speckit.plan.agent.md").exists()
+
+    def test_ai_generic_warning_suggests_integration_options_equivalent(self, tmp_path):
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        project = tmp_path / "warn-generic"
+        project.mkdir()
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(project)
+            runner = CliRunner()
+            result = runner.invoke(app, [
+                "init", "--here", "--ai", "generic", "--ai-commands-dir", ".myagent/commands",
+                "--script", "sh", "--no-git",
+            ], catch_exceptions=False)
+        finally:
+            os.chdir(old_cwd)
+
+        normalized_output = _normalize_cli_output(result.output)
+        assert result.exit_code == 0, result.output
+        assert "Deprecation Warning" in normalized_output
+        assert "--integration generic" in normalized_output
+        assert "--integration-options" in normalized_output
+        assert ".myagent/commands" in normalized_output
+        assert normalized_output.index("Deprecation Warning") < normalized_output.index("Next Steps")
+        assert (project / ".myagent" / "commands" / "speckit.plan.md").exists()
+
     def test_ai_claude_here_preserves_preexisting_commands(self, tmp_path):
         from typer.testing import CliRunner
         from specify_cli import app

tests/integrations/test_integration_claude.py

@@ -59,7 +59,7 @@ class TestClaudeIntegration:
         parsed = yaml.safe_load(parts[1])
         assert parsed["name"] == "speckit-plan"
         assert parsed["user-invocable"] is True
-        assert parsed["disable-model-invocation"] is True
+        assert parsed["disable-model-invocation"] is False
         assert parsed["metadata"]["source"] == "templates/commands/plan.md"
 
     def test_setup_installs_update_context_scripts(self, tmp_path):
@@ -179,7 +179,7 @@ class TestClaudeIntegration:
         assert skill_file.exists()
         skill_content = skill_file.read_text(encoding="utf-8")
         assert "user-invocable: true" in skill_content
-        assert "disable-model-invocation: true" in skill_content
+        assert "disable-model-invocation: false" in skill_content
 
         init_options = json.loads(
             (project / ".specify" / "init-options.json").read_text(encoding="utf-8")
@@ -280,7 +280,7 @@ class TestClaudeIntegration:
         assert "preset:claude-skill-command" in content
         assert "name: speckit-research" in content
         assert "user-invocable: true" in content
-        assert "disable-model-invocation: true" in content
+        assert "disable-model-invocation: false" in content
 
         metadata = manager.registry.get("claude-skill-command")
         assert "speckit-research" in metadata.get("registered_skills", [])
@@ -400,3 +400,115 @@ class TestClaudeArgumentHints:
         lines = result.splitlines()
         hint_count = sum(1 for ln in lines if ln.startswith("argument-hint:"))
         assert hint_count == 1
+
+
+class TestClaudeDisableModelInvocation:
+    """Verify disable-model-invocation is false for Claude skills."""
+
+    def test_setup_sets_disable_model_invocation_false(self, tmp_path):
+        """Generated SKILL.md files must have disable-model-invocation: false."""
+        i = get_integration("claude")
+        m = IntegrationManifest("claude", tmp_path)
+        created = i.setup(tmp_path, m, script_type="sh")
+        skill_files = [f for f in created if f.name == "SKILL.md"]
+        assert len(skill_files) > 0
+        for f in skill_files:
+            content = f.read_text(encoding="utf-8")
+            parts = content.split("---", 2)
+            parsed = yaml.safe_load(parts[1])
+            assert parsed["disable-model-invocation"] is False, (
+                f"{f.parent.name}: expected disable-model-invocation: false"
+            )
+
+    def test_disable_model_invocation_not_true(self, tmp_path):
+        """No Claude skill should have disable-model-invocation: true."""
+        i = get_integration("claude")
+        m = IntegrationManifest("claude", tmp_path)
+        created = i.setup(tmp_path, m, script_type="sh")
+        for f in created:
+            if f.name != "SKILL.md":
+                continue
+            content = f.read_text(encoding="utf-8")
+            assert "disable-model-invocation: true" not in content, (
+                f"{f.parent.name}: must not have disable-model-invocation: true"
+            )
+
+    def test_non_claude_agents_lack_disable_model_invocation(self, tmp_path):
+        """Non-Claude skill agents should not get disable-model-invocation."""
+        from specify_cli.agents import CommandRegistrar
+
+        fm = CommandRegistrar.build_skill_frontmatter(
+            "codex", "speckit-plan", "desc", "templates/commands/plan.md"
+        )
+        assert "disable-model-invocation" not in fm
+        assert "user-invocable" not in fm
+
+    def test_non_claude_post_process_is_identity(self, tmp_path):
+        """Non-Claude integrations should not modify skill content."""
+        codex = get_integration("codex")
+        if codex is None:
+            return  # codex not registered in this build
+        content = "---\nname: test\n---\nBody"
+        assert codex.post_process_skill_content(content) == content
+
+
+class TestClaudeHookCommandNote:
+    """Verify dot-to-hyphen normalization note is injected in hook sections."""
+
+    def test_hook_note_injected_in_skills_with_hooks(self, tmp_path):
+        """Skills that have hook sections should get the normalization note."""
+        i = get_integration("claude")
+        m = IntegrationManifest("claude", tmp_path)
+        created = i.setup(tmp_path, m, script_type="sh")
+        specify_skill = tmp_path / ".claude/skills/speckit-specify/SKILL.md"
+        assert specify_skill.exists()
+        content = specify_skill.read_text(encoding="utf-8")
+        # specify.md has hook sections
+        assert "replace dots" in content, (
+            "speckit-specify should have dot-to-hyphen hook note"
+        )
+
+    def test_hook_note_not_in_skills_without_hooks(self, tmp_path):
+        """Skills without hook sections should not get the note."""
+        from specify_cli.integrations.claude import ClaudeIntegration
+
+        content = "---\nname: test\ndescription: test\n---\n\nNo hooks here.\n"
+        result = ClaudeIntegration._inject_hook_command_note(content)
+        assert "replace dots" not in result
+
+    def test_hook_note_idempotent(self, tmp_path):
+        """Injecting the note twice should not duplicate it."""
+        from specify_cli.integrations.claude import ClaudeIntegration
+
+        content = (
+            "---\nname: test\n---\n\n"
+            "- For each executable hook, output the following based on its flag:\n"
+        )
+        once = ClaudeIntegration._inject_hook_command_note(content)
+        twice = ClaudeIntegration._inject_hook_command_note(once)
+        assert once == twice, "Hook note injection should be idempotent"
+
+    def test_hook_note_preserves_indentation(self, tmp_path):
+        """The injected note should match the indentation of the target line."""
+        from specify_cli.integrations.claude import ClaudeIntegration
+
+        content = (
+            "---\nname: test\n---\n\n"
+            "   - For each executable hook, output the following\n"
+        )
+        result = ClaudeIntegration._inject_hook_command_note(content)
+        lines = result.splitlines()
+        note_line = [l for l in lines if "replace dots" in l][0]
+        assert note_line.startswith("   "), "Note should preserve indentation"
+
+    def test_post_process_injects_all_claude_flags(self):
+        """post_process_skill_content should inject all Claude-specific fields."""
+        i = get_integration("claude")
+        content = (
+            "---\nname: test\ndescription: test\n---\n\n"
+            "- For each executable hook, output the following\n"
+        )
+        result = i.post_process_skill_content(content)
+        assert "user-invocable: true" in result
+        assert "disable-model-invocation: false" in result
+        assert "replace dots" in result

tests/integrations/test_manifest.py

@@ -2,6 +2,7 @@
 
 import hashlib
 import json
+import sys
 
 import pytest
 
@@ -41,8 +42,9 @@ class TestManifestPathTraversal:
 
     def test_record_file_rejects_absolute_path(self, tmp_path):
         m = IntegrationManifest("test", tmp_path)
+        abs_path = "C:\\tmp\\escape.txt" if sys.platform == "win32" else "/tmp/escape.txt"
         with pytest.raises(ValueError, match="Absolute paths"):
-            m.record_file("/tmp/escape.txt", "bad")
+            m.record_file(abs_path, "bad")
 
     def test_record_existing_rejects_parent_traversal(self, tmp_path):
         escape = tmp_path.parent / "escape.txt"

tests/test_cursor_frontmatter.py

@@ -12,6 +12,8 @@ import textwrap
 
 import pytest
 
+from tests.conftest import requires_bash
+
 SCRIPT_PATH = os.path.join(
     os.path.dirname(__file__),
     os.pardir,
@@ -73,6 +75,7 @@ class TestScriptFrontmatterPattern:
 
 
 @requires_git
+@requires_bash
 class TestCursorFrontmatterIntegration:
     """Integration tests using a real git repo."""
 

tests/test_extension_skills.py

@@ -269,7 +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
+        assert parsed["disable-model-invocation"] is False
 
     def test_no_skills_when_ai_skills_disabled(self, no_skills_project, extension_dir):
         """No skills should be created when ai_skills is false."""

tests/test_extensions.py

@@ -11,6 +11,7 @@ Tests cover:
 
 import pytest
 import json
+import platform
 import tempfile
 import shutil
 import tomllib
@@ -243,7 +244,7 @@ class TestExtensionManifest:
             ExtensionManifest(manifest_path)
 
     def test_invalid_command_name(self, temp_dir, valid_manifest_data):
-        """Test manifest with invalid command name format."""
+        """Test manifest with command name that cannot be auto-corrected raises ValidationError."""
         import yaml
 
         valid_manifest_data["provides"]["commands"][0]["name"] = "invalid-name"
@@ -255,6 +256,83 @@ class TestExtensionManifest:
         with pytest.raises(ValidationError, match="Invalid command name"):
             ExtensionManifest(manifest_path)
 
+    def test_command_name_autocorrect_speckit_prefix(self, temp_dir, valid_manifest_data):
+        """Test that 'speckit.command' is auto-corrected to 'speckit.{ext_id}.command'."""
+        import yaml
+
+        valid_manifest_data["provides"]["commands"][0]["name"] = "speckit.hello"
+
+        manifest_path = temp_dir / "extension.yml"
+        with open(manifest_path, 'w') as f:
+            yaml.dump(valid_manifest_data, f)
+
+        manifest = ExtensionManifest(manifest_path)
+
+        assert manifest.commands[0]["name"] == "speckit.test-ext.hello"
+        assert len(manifest.warnings) == 1
+        assert "speckit.hello" in manifest.warnings[0]
+        assert "speckit.test-ext.hello" in manifest.warnings[0]
+
+    def test_command_name_autocorrect_matching_ext_id_prefix(self, temp_dir, valid_manifest_data):
+        """Test that '{ext_id}.command' is auto-corrected to 'speckit.{ext_id}.command'."""
+        import yaml
+
+        # Set ext_id to match the legacy namespace so correction is valid
+        valid_manifest_data["extension"]["id"] = "docguard"
+        valid_manifest_data["provides"]["commands"][0]["name"] = "docguard.guard"
+
+        manifest_path = temp_dir / "extension.yml"
+        with open(manifest_path, 'w') as f:
+            yaml.dump(valid_manifest_data, f)
+
+        manifest = ExtensionManifest(manifest_path)
+
+        assert manifest.commands[0]["name"] == "speckit.docguard.guard"
+        assert len(manifest.warnings) == 1
+        assert "docguard.guard" in manifest.warnings[0]
+        assert "speckit.docguard.guard" in manifest.warnings[0]
+
+    def test_command_name_mismatched_namespace_not_corrected(self, temp_dir, valid_manifest_data):
+        """Test that 'X.command' is NOT corrected when X doesn't match ext_id."""
+        import yaml
+
+        # ext_id is "test-ext" but command uses a different namespace
+        valid_manifest_data["provides"]["commands"][0]["name"] = "docguard.guard"
+
+        manifest_path = temp_dir / "extension.yml"
+        with open(manifest_path, 'w') as f:
+            yaml.dump(valid_manifest_data, f)
+
+        with pytest.raises(ValidationError, match="Invalid command name"):
+            ExtensionManifest(manifest_path)
+
+    def test_alias_free_form_accepted(self, temp_dir, valid_manifest_data):
+        """Aliases are free-form — a 'speckit.command' alias must be accepted unchanged."""
+        import yaml
+
+        valid_manifest_data["provides"]["commands"][0]["aliases"] = ["speckit.hello"]
+
+        manifest_path = temp_dir / "extension.yml"
+        with open(manifest_path, 'w') as f:
+            yaml.dump(valid_manifest_data, f)
+
+        manifest = ExtensionManifest(manifest_path)
+
+        assert manifest.commands[0]["aliases"] == ["speckit.hello"]
+        assert manifest.warnings == []
+
+    def test_valid_command_name_has_no_warnings(self, temp_dir, valid_manifest_data):
+        """Test that a correctly-named command produces no warnings."""
+        import yaml
+
+        manifest_path = temp_dir / "extension.yml"
+        with open(manifest_path, 'w') as f:
+            yaml.dump(valid_manifest_data, f)
+
+        manifest = ExtensionManifest(manifest_path)
+
+        assert manifest.warnings == []
+
     def test_no_commands_no_hooks(self, temp_dir, valid_manifest_data):
         """Test manifest with no commands and no hooks provided."""
         import yaml
@@ -317,6 +395,19 @@ class TestExtensionManifest:
         with pytest.raises(ValidationError, match="Invalid hooks"):
             ExtensionManifest(manifest_path)
 
+    def test_non_dict_hook_entry_raises_validation_error(self, temp_dir, valid_manifest_data):
+        """Non-mapping hook entries must raise ValidationError, not silently skip."""
+        import yaml
+
+        valid_manifest_data["hooks"]["after_tasks"] = "speckit.test-ext.hello"
+
+        manifest_path = temp_dir / "extension.yml"
+        with open(manifest_path, 'w') as f:
+            yaml.dump(valid_manifest_data, f)
+
+        with pytest.raises(ValidationError, match="Invalid hook 'after_tasks'"):
+            ExtensionManifest(manifest_path)
+
     def test_manifest_hash(self, extension_dir):
         """Test manifest hash calculation."""
         manifest_path = extension_dir / "extension.yml"
@@ -686,8 +777,8 @@ class TestExtensionManager:
         with pytest.raises(ValidationError, match="conflicts with core command namespace"):
             manager.install_from_directory(ext_dir, "0.1.0", register_commands=False)
 
-    def test_install_accepts_short_alias(self, temp_dir, project_dir):
-        """Install should accept legacy short aliases for community extension compat."""
+    def test_install_accepts_free_form_alias(self, temp_dir, project_dir):
+        """Aliases are free-form — a short 'speckit.shortcut' alias must be preserved unchanged."""
         import yaml
 
         ext_dir = temp_dir / "alias-shortcut"
@@ -718,8 +809,10 @@ class TestExtensionManager:
         (ext_dir / "commands" / "cmd.md").write_text("---\ndescription: Test\n---\n\nBody")
 
         manager = ExtensionManager(project_dir)
-        # Should not raise — short aliases are allowed
-        manager.install_from_directory(ext_dir, "0.1.0", register_commands=False)
+        manifest = manager.install_from_directory(ext_dir, "0.1.0", register_commands=False)
+
+        assert manifest.commands[0]["aliases"] == ["speckit.shortcut"]
+        assert manifest.warnings == []
 
     def test_install_rejects_namespace_squatting(self, temp_dir, project_dir):
         """Install should reject commands and aliases outside the extension namespace."""
@@ -1360,6 +1453,7 @@ scripts:
   ps: ../../scripts/powershell/setup-plan.ps1 -Json
 agent_scripts:
   sh: ../../scripts/bash/update-agent-context.sh __AGENT__
+  ps: ../../scripts/powershell/update-agent-context.ps1 __AGENT__
 ---
 
 Run {SCRIPT}
@@ -1381,8 +1475,12 @@ Then {AGENT_SCRIPT}
         content = skill_file.read_text()
         assert "{SCRIPT}" not in content
         assert "{AGENT_SCRIPT}" not in content
-        assert '.specify/scripts/bash/setup-plan.sh --json "$ARGUMENTS"' in content
-        assert ".specify/scripts/bash/update-agent-context.sh codex" in content
+        if platform.system().lower().startswith("win"):
+            assert ".specify/scripts/powershell/setup-plan.ps1 -Json" in content
+            assert ".specify/scripts/powershell/update-agent-context.ps1 codex" in content
+        else:
+            assert '.specify/scripts/bash/setup-plan.sh --json "$ARGUMENTS"' in content
+            assert ".specify/scripts/bash/update-agent-context.sh codex" in content
 
     def test_codex_skill_registration_handles_non_dict_init_options(
         self, project_dir, temp_dir
@@ -1619,6 +1717,54 @@ Then {AGENT_SCRIPT}
         prompts_dir = project_dir / ".github" / "prompts"
         assert not prompts_dir.exists()
 
+    def test_unregister_skill_removes_parent_directory(self, project_dir, temp_dir):
+        """Unregistering a SKILL.md command should remove the empty parent subdirectory."""
+        import yaml
+
+        ext_dir = temp_dir / "cleanup-ext"
+        ext_dir.mkdir()
+        (ext_dir / "commands").mkdir()
+
+        manifest_data = {
+            "schema_version": "1.0",
+            "extension": {
+                "id": "cleanup-ext",
+                "name": "Cleanup Extension",
+                "version": "1.0.0",
+                "description": "Test",
+            },
+            "requires": {"speckit_version": ">=0.1.0"},
+            "provides": {
+                "commands": [
+                    {
+                        "name": "speckit.cleanup-ext.run",
+                        "file": "commands/run.md",
+                        "description": "Run",
+                    }
+                ]
+            },
+        }
+        with open(ext_dir / "extension.yml", "w") as f:
+            yaml.dump(manifest_data, f)
+        (ext_dir / "commands" / "run.md").write_text("---\ndescription: Run\n---\n\nBody")
+
+        skills_dir = project_dir / ".agents" / "skills"
+        skills_dir.mkdir(parents=True)
+
+        registrar = CommandRegistrar()
+        from specify_cli.extensions import ExtensionManifest
+        manifest = ExtensionManifest(ext_dir / "extension.yml")
+        registered = registrar.register_commands_for_agent("codex", manifest, ext_dir, project_dir)
+
+        skill_subdir = skills_dir / "speckit-cleanup-ext-run"
+        assert skill_subdir.exists(), "Skill subdirectory should exist after registration"
+        assert (skill_subdir / "SKILL.md").exists()
+
+        registrar.unregister_commands({"codex": ["speckit.cleanup-ext.run"]}, project_dir)
+
+        assert not (skill_subdir / "SKILL.md").exists(), "SKILL.md should be removed"
+        assert not skill_subdir.exists(), "Empty parent subdirectory should be removed"
+
 
 # ===== Utility Function Tests =====
 
@@ -3853,3 +3999,58 @@ class TestHookInvocationRendering:
         assert "Executing: `/<missing command>`" in message
         assert "EXECUTE_COMMAND: <missing command>" in message
         assert "EXECUTE_COMMAND_INVOCATION: /<missing command>" in message
+
+
+class TestExtensionRemoveCLI:
+    """CLI tests for `specify extension remove` confirmation prompt wording."""
+
+    def _install_ext(self, project_dir, ext_dir):
+        """Install extension and return the manager."""
+        manager = ExtensionManager(project_dir)
+        manager.install_from_directory(ext_dir, "0.1.0", register_commands=False)
+        return manager
+
+    def test_remove_confirmation_singular_command(self, tmp_path, extension_dir):
+        """Confirmation prompt should say '1 command' (singular) when one command registered."""
+        from typer.testing import CliRunner
+        from unittest.mock import patch
+        from specify_cli import app
+
+        project_dir = tmp_path / "project"
+        project_dir.mkdir()
+        (project_dir / ".specify").mkdir()
+
+        manager = self._install_ext(project_dir, extension_dir)
+        # Inject registered_commands with 1 entry so cmd_count == 1
+        manager.registry.update("test-ext", {"registered_commands": {"claude": ["speckit.test-ext.hello"]}})
+
+        runner = CliRunner()
+        with patch.object(Path, "cwd", return_value=project_dir):
+            result = runner.invoke(
+                app, ["extension", "remove", "test-ext"], input="n\n", catch_exceptions=False
+            )
+
+        assert "1 command" in result.output
+        assert "1 commands" not in result.output
+
+    def test_remove_confirmation_plural_commands(self, tmp_path, extension_dir):
+        """Confirmation prompt should say '2 commands' (plural) when two commands registered."""
+        from typer.testing import CliRunner
+        from unittest.mock import patch
+        from specify_cli import app
+
+        project_dir = tmp_path / "project"
+        project_dir.mkdir()
+        (project_dir / ".specify").mkdir()
+
+        manager = self._install_ext(project_dir, extension_dir)
+        # Inject registered_commands with 2 entries so cmd_count == 2
+        manager.registry.update("test-ext", {"registered_commands": {"claude": ["speckit.test-ext.hello", "speckit.test-ext.run"]}})
+
+        runner = CliRunner()
+        with patch.object(Path, "cwd", return_value=project_dir):
+            result = runner.invoke(
+                app, ["extension", "remove", "test-ext"], input="n\n", catch_exceptions=False
+            )
+
+        assert "2 commands" in result.output

tests/test_presets.py

@@ -1175,8 +1175,7 @@ class TestPresetCatalog:
         """Test search with cached catalog data."""
         from unittest.mock import patch
 
-        # Only use the default catalog to prevent fetching the community catalog from the network
-        monkeypatch.setenv("SPECKIT_PRESET_CATALOG_URL", PresetCatalog.DEFAULT_CATALOG_URL)
+        monkeypatch.delenv("SPECKIT_PRESET_CATALOG_URL", raising=False)
         catalog = PresetCatalog(project_dir)
         catalog.cache_dir.mkdir(parents=True, exist_ok=True)
 
@@ -1976,7 +1975,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
+        assert "disable-model-invocation: false" in content
 
         # Verify it was recorded in registry
         metadata = manager.registry.get("self-test")
@@ -2058,7 +2057,7 @@ 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
+        assert "disable-model-invocation: false" 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."""

tests/test_timestamp_branches.py

@@ -13,6 +13,8 @@ from pathlib import Path
 
 import pytest
 
+from tests.conftest import requires_bash
+
 PROJECT_ROOT = Path(__file__).resolve().parent.parent
 CREATE_FEATURE = PROJECT_ROOT / "scripts" / "bash" / "create-new-feature.sh"
 CREATE_FEATURE_PS = PROJECT_ROOT / "scripts" / "powershell" / "create-new-feature.ps1"
@@ -149,6 +151,7 @@ def source_and_call(func_call: str, env: dict | None = None) -> subprocess.Compl
 # ── Timestamp Branch Tests ───────────────────────────────────────────────────
 
 
+@requires_bash
 class TestTimestampBranch:
     def test_timestamp_creates_branch(self, git_repo: Path):
         """Test 1: --timestamp creates branch with YYYYMMDD-HHMMSS prefix."""
@@ -194,6 +197,7 @@ class TestTimestampBranch:
 # ── Sequential Branch Tests ──────────────────────────────────────────────────
 
 
+@requires_bash
 class TestSequentialBranch:
     def test_sequential_default_with_existing_specs(self, git_repo: Path):
         """Test 2: Sequential default with existing specs."""
@@ -232,6 +236,8 @@ class TestSequentialBranch:
                 branch = line.split(":", 1)[1].strip()
         assert branch == "1001-next-feat", f"expected 1001-next-feat, got: {branch}"
 
+
+class TestSequentialBranchPowerShell:
     def test_powershell_scanner_uses_long_tryparse_for_large_prefixes(self):
         """PowerShell scanner should parse large prefixes without [int] casts."""
         content = CREATE_FEATURE_PS.read_text(encoding="utf-8")
@@ -242,6 +248,7 @@ class TestSequentialBranch:
 # ── check_feature_branch Tests ───────────────────────────────────────────────
 
 
+@requires_bash
 class TestCheckFeatureBranch:
     def test_accepts_timestamp_branch(self):
         """Test 6: check_feature_branch accepts timestamp branch."""
@@ -306,6 +313,7 @@ class TestCheckFeatureBranch:
 # ── find_feature_dir_by_prefix Tests ─────────────────────────────────────────
 
 
+@requires_bash
 class TestFindFeatureDirByPrefix:
     def test_timestamp_branch(self, tmp_path: Path):
         """Test 10: find_feature_dir_by_prefix with timestamp branch."""
@@ -356,6 +364,7 @@ class TestFindFeatureDirByPrefix:
 
 
 class TestGetFeaturePathsSinglePrefix:
+    @requires_bash
     def test_bash_specify_feature_prefixed_resolves_by_prefix(self, tmp_path: Path):
         """get_feature_paths: SPECIFY_FEATURE with one optional prefix uses effective name for lookup."""
         (tmp_path / ".specify").mkdir()
@@ -399,6 +408,7 @@ class TestGetFeaturePathsSinglePrefix:
 # ── get_current_branch Tests ─────────────────────────────────────────────────
 
 
+@requires_bash
 class TestGetCurrentBranch:
     def test_env_var(self):
         """Test 12: get_current_branch returns SPECIFY_FEATURE env var."""
@@ -409,6 +419,7 @@ class TestGetCurrentBranch:
 # ── No-git Tests ─────────────────────────────────────────────────────────────
 
 
+@requires_bash
 class TestNoGitTimestamp:
     def test_no_git_timestamp(self, no_git_dir: Path):
         """Test 13: No-git repo + timestamp creates spec dir with warning."""
@@ -422,6 +433,7 @@ class TestNoGitTimestamp:
 # ── E2E Flow Tests ───────────────────────────────────────────────────────────
 
 
+@requires_bash
 class TestE2EFlow:
     def test_e2e_timestamp(self, git_repo: Path):
         """Test 14: E2E timestamp flow — branch, dir, validation."""
@@ -455,6 +467,7 @@ class TestE2EFlow:
 # ── Allow Existing Branch Tests ──────────────────────────────────────────────
 
 
+@requires_bash
 class TestAllowExistingBranch:
     def test_allow_existing_switches_to_branch(self, git_repo: Path):
         """T006: Pre-create branch, verify script switches to it."""
@@ -655,6 +668,7 @@ class TestGitExtensionParity:
 # ── Dry-Run Tests ────────────────────────────────────────────────────────────
 
 
+@requires_bash
 class TestDryRun:
     def test_dry_run_sequential_outputs_name(self, git_repo: Path):
         """T009: Dry-run computes correct branch name with existing specs."""
@@ -984,6 +998,7 @@ class TestPowerShellDryRun:
 # ── GIT_BRANCH_NAME Override Tests ──────────────────────────────────────────
 
 
+@requires_bash
 class TestGitBranchNameOverrideBash:
     """Tests for GIT_BRANCH_NAME env var override in extension create-new-feature.sh."""
 
@@ -1088,6 +1103,7 @@ class TestGitBranchNameOverridePowerShell:
 class TestFeatureDirectoryResolution:
     """Tests for SPECIFY_FEATURE_DIRECTORY and .specify/feature.json resolution."""
 
+    @requires_bash
     def test_env_var_overrides_branch_lookup(self, git_repo: Path):
         """SPECIFY_FEATURE_DIRECTORY env var takes priority over branch-based lookup."""
         custom_dir = git_repo / "my-custom-specs" / "my-feature"
@@ -1110,6 +1126,7 @@ class TestFeatureDirectoryResolution:
         else:
             pytest.fail("FEATURE_DIR not found in output")
 
+    @requires_bash
     def test_feature_json_overrides_branch_lookup(self, git_repo: Path):
         """feature.json feature_directory takes priority over branch-based lookup."""
         custom_dir = git_repo / "specs" / "custom-feature"
@@ -1117,7 +1134,7 @@ class TestFeatureDirectoryResolution:
 
         feature_json = git_repo / ".specify" / "feature.json"
         feature_json.write_text(
-            f'{{"feature_directory": "{custom_dir}"}}\n',
+            json.dumps({"feature_directory": str(custom_dir)}) + "\n",
             encoding="utf-8",
         )
 
@@ -1136,6 +1153,7 @@ class TestFeatureDirectoryResolution:
         else:
             pytest.fail("FEATURE_DIR not found in output")
 
+    @requires_bash
     def test_env_var_takes_priority_over_feature_json(self, git_repo: Path):
         """Env var wins over feature.json."""
         env_dir = git_repo / "specs" / "env-feature"
@@ -1145,7 +1163,7 @@ class TestFeatureDirectoryResolution:
 
         feature_json = git_repo / ".specify" / "feature.json"
         feature_json.write_text(
-            f'{{"feature_directory": "{json_dir}"}}\n',
+            json.dumps({"feature_directory": str(json_dir)}) + "\n",
             encoding="utf-8",
         )
 
@@ -1165,6 +1183,7 @@ class TestFeatureDirectoryResolution:
         else:
             pytest.fail("FEATURE_DIR not found in output")
 
+    @requires_bash
     def test_fallback_to_branch_lookup(self, git_repo: Path):
         """Without env var or feature.json, falls back to branch-based lookup."""
         subprocess.run(["git", "checkout", "-q", "-b", "001-test-feat"], cwd=git_repo, check=True)
@@ -1219,7 +1238,7 @@ class TestFeatureDirectoryResolution:
 
         feature_json = git_repo / ".specify" / "feature.json"
         feature_json.write_text(
-            f'{{"feature_directory": "{custom_dir}"}}\n',
+            json.dumps({"feature_directory": str(custom_dir)}) + "\n",
             encoding="utf-8",
         )