chore: bump version to 0.2.0

CHANGELOG.md

@@ -7,21 +7,6 @@ Recent changes to the Specify CLI and templates are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.2.1] - 2026-03-09
-
-### Added
-
-- feat(templates): Pluggable template system with template packs, catalog, and resolver
-- Template pack manifest (`template-pack.yml`) with validation for artifact, command, and script types
-- `TemplatePackManifest`, `TemplatePackRegistry`, `TemplatePackManager`, `TemplateCatalog`, `TemplateResolver` classes in `src/specify_cli/templates.py`
-- CLI commands: `specify template search`, `specify template add`, `specify template list`, `specify template remove`, `specify template resolve`
-- `--template` option for `specify init` to install template packs during initialization
-- `resolve_template()` / `Resolve-Template` helpers in bash and PowerShell common scripts
-- Template resolution priority stack: overrides → packs → extensions → core
-- Template catalog files (`templates/catalog.json`, `templates/catalog.community.json`)
-- Template pack scaffold directory (`templates/template/`)
-- Scripts updated to use template resolution instead of hardcoded paths
-
 ## [0.2.0] - 2026-03-09
 
 ### Changed

pyproject.toml

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

scripts/bash/common.sh

@@ -154,44 +154,3 @@ EOF
 check_file() { [[ -f "$1" ]] && echo "  ✓ $2" || echo "  ✗ $2"; }
 check_dir() { [[ -d "$1" && -n $(ls -A "$1" 2>/dev/null) ]] && echo "  ✓ $2" || echo "  ✗ $2"; }
 
-# Resolve a template name to a file path using the priority stack:
-#   1. .specify/templates/overrides/
-#   2. .specify/templates/packs/<pack-id>/templates/
-#   3. .specify/extensions/<ext-id>/templates/
-#   4. .specify/templates/ (core)
-resolve_template() {
-    local template_name="$1"
-    local repo_root="$2"
-    local base="$repo_root/.specify/templates"
-
-    # Priority 1: Project overrides
-    local override="$base/overrides/${template_name}.md"
-    [ -f "$override" ] && echo "$override" && return 0
-
-    # Priority 2: Installed packs (by directory order)
-    local packs_dir="$base/packs"
-    if [ -d "$packs_dir" ]; then
-        for pack in "$packs_dir"/*/; do
-            [ -d "$pack" ] || continue
-            local candidate="$pack/templates/${template_name}.md"
-            [ -f "$candidate" ] && echo "$candidate" && return 0
-        done
-    fi
-
-    # Priority 3: Extension-provided templates
-    local ext_dir="$repo_root/.specify/extensions"
-    if [ -d "$ext_dir" ]; then
-        for ext in "$ext_dir"/*/; do
-            [ -d "$ext" ] || continue
-            local candidate="$ext/templates/${template_name}.md"
-            [ -f "$candidate" ] && echo "$candidate" && return 0
-        done
-    fi
-
-    # Priority 4: Core templates
-    local core="$base/${template_name}.md"
-    [ -f "$core" ] && echo "$core" && return 0
-
-    return 1
-}
-

scripts/bash/create-new-feature.sh

@@ -166,7 +166,6 @@ clean_branch_name() {
 # to searching for repository markers so the workflow still functions in repositories that
 # were initialised with --no-git.
 SCRIPT_DIR="$(CDPATH="" cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "$SCRIPT_DIR/common.sh"
 
 if git rev-parse --show-toplevel >/dev/null 2>&1; then
     REPO_ROOT=$(git rev-parse --show-toplevel)
@@ -297,9 +296,9 @@ fi
 FEATURE_DIR="$SPECS_DIR/$BRANCH_NAME"
 mkdir -p "$FEATURE_DIR"
 
-TEMPLATE=$(resolve_template "spec-template" "$REPO_ROOT")
+TEMPLATE="$REPO_ROOT/.specify/templates/spec-template.md"
 SPEC_FILE="$FEATURE_DIR/spec.md"
-if [ -n "$TEMPLATE" ] && [ -f "$TEMPLATE" ]; then cp "$TEMPLATE" "$SPEC_FILE"; else touch "$SPEC_FILE"; fi
+if [ -f "$TEMPLATE" ]; then cp "$TEMPLATE" "$SPEC_FILE"; else touch "$SPEC_FILE"; fi
 
 # Set the SPECIFY_FEATURE environment variable for the current session
 export SPECIFY_FEATURE="$BRANCH_NAME"

scripts/bash/setup-plan.sh

@@ -37,12 +37,12 @@ check_feature_branch "$CURRENT_BRANCH" "$HAS_GIT" || exit 1
 mkdir -p "$FEATURE_DIR"
 
 # Copy plan template if it exists
-TEMPLATE=$(resolve_template "plan-template" "$REPO_ROOT")
-if [[ -n "$TEMPLATE" ]] && [[ -f "$TEMPLATE" ]]; then
+TEMPLATE="$REPO_ROOT/.specify/templates/plan-template.md"
+if [[ -f "$TEMPLATE" ]]; then
     cp "$TEMPLATE" "$IMPL_PLAN"
     echo "Copied plan template to $IMPL_PLAN"
 else
-    echo "Warning: Plan template not found"
+    echo "Warning: Plan template not found at $TEMPLATE"
     # Create a basic plan file if template doesn't exist
     touch "$IMPL_PLAN"
 fi

scripts/powershell/common.ps1

@@ -135,45 +135,3 @@ function Test-DirHasFiles {
     }
 }
 
-# Resolve a template name to a file path using the priority stack:
-#   1. .specify/templates/overrides/
-#   2. .specify/templates/packs/<pack-id>/templates/
-#   3. .specify/extensions/<ext-id>/templates/
-#   4. .specify/templates/ (core)
-function Resolve-Template {
-    param(
-        [Parameter(Mandatory=$true)][string]$TemplateName,
-        [Parameter(Mandatory=$true)][string]$RepoRoot
-    )
-
-    $base = Join-Path $RepoRoot '.specify/templates'
-
-    # Priority 1: Project overrides
-    $override = Join-Path $base "overrides/$TemplateName.md"
-    if (Test-Path $override) { return $override }
-
-    # Priority 2: Installed packs (by directory order)
-    $packsDir = Join-Path $base 'packs'
-    if (Test-Path $packsDir) {
-        foreach ($pack in Get-ChildItem -Path $packsDir -Directory -ErrorAction SilentlyContinue) {
-            $candidate = Join-Path $pack.FullName "templates/$TemplateName.md"
-            if (Test-Path $candidate) { return $candidate }
-        }
-    }
-
-    # Priority 3: Extension-provided templates
-    $extDir = Join-Path $RepoRoot '.specify/extensions'
-    if (Test-Path $extDir) {
-        foreach ($ext in Get-ChildItem -Path $extDir -Directory -ErrorAction SilentlyContinue) {
-            $candidate = Join-Path $ext.FullName "templates/$TemplateName.md"
-            if (Test-Path $candidate) { return $candidate }
-        }
-    }
-
-    # Priority 4: Core templates
-    $core = Join-Path $base "$TemplateName.md"
-    if (Test-Path $core) { return $core }
-
-    return $null
-}
-

scripts/powershell/create-new-feature.ps1

@@ -141,9 +141,6 @@ if (-not $fallbackRoot) {
     exit 1
 }
 
-# Load common functions (includes Resolve-Template)
-. "$PSScriptRoot/common.ps1"
-
 try {
     $repoRoot = git rev-parse --show-toplevel 2>$null
     if ($LASTEXITCODE -eq 0) {
@@ -279,9 +276,9 @@ if ($hasGit) {
 $featureDir = Join-Path $specsDir $branchName
 New-Item -ItemType Directory -Path $featureDir -Force | Out-Null
 
-$template = Resolve-Template -TemplateName 'spec-template' -RepoRoot $repoRoot
+$template = Join-Path $repoRoot '.specify/templates/spec-template.md'
 $specFile = Join-Path $featureDir 'spec.md'
-if ($template -and (Test-Path $template)) { 
+if (Test-Path $template) { 
     Copy-Item $template $specFile -Force 
 } else { 
     New-Item -ItemType File -Path $specFile | Out-Null 

scripts/powershell/setup-plan.ps1

@@ -32,12 +32,12 @@ if (-not (Test-FeatureBranch -Branch $paths.CURRENT_BRANCH -HasGit $paths.HAS_GI
 New-Item -ItemType Directory -Path $paths.FEATURE_DIR -Force | Out-Null
 
 # Copy plan template if it exists, otherwise note it or create empty file
-$template = Resolve-Template -TemplateName 'plan-template' -RepoRoot $paths.REPO_ROOT
-if ($template -and (Test-Path $template)) { 
+$template = Join-Path $paths.REPO_ROOT '.specify/templates/plan-template.md'
+if (Test-Path $template) { 
     Copy-Item $template $paths.IMPL_PLAN -Force
     Write-Output "Copied plan template to $($paths.IMPL_PLAN)"
 } else {
-    Write-Warning "Plan template not found"
+    Write-Warning "Plan template not found at $template"
     # Create a basic plan file if template doesn't exist
     New-Item -ItemType File -Path $paths.IMPL_PLAN -Force | Out-Null
 }

src/specify_cli/__init__.py

@@ -1272,7 +1272,6 @@ def init(
     debug: bool = typer.Option(False, "--debug", help="Show verbose diagnostic output for network and extraction failures"),
     github_token: str = typer.Option(None, "--github-token", help="GitHub token to use for API requests (or set GH_TOKEN or GITHUB_TOKEN environment variable)"),
     ai_skills: bool = typer.Option(False, "--ai-skills", help="Install Prompt.MD templates as agent skills (requires --ai)"),
-    template: str = typer.Option(None, "--template", help="Install a template pack during initialization (by pack ID)"),
 ):
     """
     Initialize a new Specify project from the latest template.
@@ -1301,7 +1300,6 @@ def init(
         specify init my-project --ai claude --ai-skills   # Install agent skills
         specify init --here --ai gemini --ai-skills
         specify init my-project --ai generic --ai-commands-dir .myagent/commands/  # Unsupported agent
-        specify init my-project --ai claude --template healthcare-compliance  # With template pack
     """
 
     show_banner()
@@ -1544,27 +1542,6 @@ def init(
             else:
                 tracker.skip("git", "--no-git flag")
 
-            # Install template pack if specified
-            if template:
-                try:
-                    from .templates import TemplatePackManager, TemplateCatalog, TemplateError
-                    tmpl_manager = TemplatePackManager(project_path)
-                    speckit_ver = get_speckit_version()
-
-                    # Try local directory first, then catalog
-                    local_path = Path(template).resolve()
-                    if local_path.is_dir() and (local_path / "template-pack.yml").exists():
-                        tmpl_manager.install_from_directory(local_path, speckit_ver)
-                    else:
-                        tmpl_catalog = TemplateCatalog(project_path)
-                        try:
-                            zip_path = tmpl_catalog.download_pack(template)
-                            tmpl_manager.install_from_zip(zip_path, speckit_ver)
-                        except TemplateError:
-                            console.print(f"[yellow]Warning:[/yellow] Template pack '{template}' not found in catalog. Skipping.")
-                except Exception as tmpl_err:
-                    console.print(f"[yellow]Warning:[/yellow] Failed to install template pack: {tmpl_err}")
-
             tracker.complete("final", "project ready")
         except Exception as e:
             tracker.error("final", str(e))
@@ -1802,13 +1779,6 @@ catalog_app = typer.Typer(
 )
 extension_app.add_typer(catalog_app, name="catalog")
 
-template_app = typer.Typer(
-    name="template",
-    help="Manage spec-kit template packs",
-    add_completion=False,
-)
-app.add_typer(template_app, name="template")
-
 
 def get_speckit_version() -> str:
     """Get current spec-kit version."""
@@ -1831,227 +1801,6 @@ def get_speckit_version() -> str:
     return "unknown"
 
 
-# ===== Template Pack Commands =====
-
-
-@template_app.command("list")
-def template_list():
-    """List installed template packs."""
-    from .templates import TemplatePackManager
-
-    project_root = Path.cwd()
-
-    specify_dir = project_root / ".specify"
-    if not specify_dir.exists():
-        console.print("[red]Error:[/red] Not a spec-kit project (no .specify/ directory)")
-        console.print("Run this command from a spec-kit project root")
-        raise typer.Exit(1)
-
-    manager = TemplatePackManager(project_root)
-    installed = manager.list_installed()
-
-    if not installed:
-        console.print("[yellow]No template packs installed.[/yellow]")
-        console.print("\nInstall a template pack with:")
-        console.print("  [cyan]specify template add <pack-name>[/cyan]")
-        return
-
-    console.print("\n[bold cyan]Installed Template Packs:[/bold cyan]\n")
-    for pack in installed:
-        status = "[green]enabled[/green]" if pack.get("enabled", True) else "[red]disabled[/red]"
-        console.print(f"  [bold]{pack['name']}[/bold] ({pack['id']}) v{pack['version']} — {status}")
-        console.print(f"    {pack['description']}")
-        if pack.get("tags"):
-            tags_str = ", ".join(pack["tags"])
-            console.print(f"    [dim]Tags: {tags_str}[/dim]")
-        console.print(f"    [dim]Templates: {pack['template_count']}[/dim]")
-        console.print()
-
-
-@template_app.command("add")
-def template_add(
-    pack_id: str = typer.Argument(None, help="Template pack ID to install from catalog"),
-    from_url: str = typer.Option(None, "--from", help="Install from a URL (ZIP file)"),
-    dev: str = typer.Option(None, "--dev", help="Install from local directory (development mode)"),
-):
-    """Install a template pack."""
-    from .templates import (
-        TemplatePackManager,
-        TemplateCatalog,
-        TemplateError,
-        TemplateValidationError,
-        TemplateCompatibilityError,
-    )
-
-    project_root = Path.cwd()
-
-    specify_dir = project_root / ".specify"
-    if not specify_dir.exists():
-        console.print("[red]Error:[/red] Not a spec-kit project (no .specify/ directory)")
-        console.print("Run this command from a spec-kit project root")
-        raise typer.Exit(1)
-
-    manager = TemplatePackManager(project_root)
-    speckit_version = get_speckit_version()
-
-    try:
-        if dev:
-            dev_path = Path(dev).resolve()
-            if not dev_path.exists():
-                console.print(f"[red]Error:[/red] Directory not found: {dev}")
-                raise typer.Exit(1)
-
-            console.print(f"Installing template pack from [cyan]{dev_path}[/cyan]...")
-            manifest = manager.install_from_directory(dev_path, speckit_version)
-            console.print(f"[green]✓[/green] Template pack '{manifest.name}' v{manifest.version} installed successfully")
-
-        elif from_url:
-            console.print(f"Installing template pack from [cyan]{from_url}[/cyan]...")
-            import urllib.request
-            import urllib.error
-            import tempfile
-
-            with tempfile.TemporaryDirectory() as tmpdir:
-                zip_path = Path(tmpdir) / "template-pack.zip"
-                try:
-                    with urllib.request.urlopen(from_url, timeout=60) as response:
-                        zip_path.write_bytes(response.read())
-                except urllib.error.URLError as e:
-                    console.print(f"[red]Error:[/red] Failed to download: {e}")
-                    raise typer.Exit(1)
-
-                manifest = manager.install_from_zip(zip_path, speckit_version)
-
-            console.print(f"[green]✓[/green] Template pack '{manifest.name}' v{manifest.version} installed successfully")
-
-        elif pack_id:
-            catalog = TemplateCatalog(project_root)
-            pack_info = catalog.get_pack_info(pack_id)
-
-            if not pack_info:
-                console.print(f"[red]Error:[/red] Template pack '{pack_id}' not found in catalog")
-                raise typer.Exit(1)
-
-            console.print(f"Installing template pack [cyan]{pack_info.get('name', pack_id)}[/cyan]...")
-
-            try:
-                zip_path = catalog.download_pack(pack_id)
-                manifest = manager.install_from_zip(zip_path, speckit_version)
-                console.print(f"[green]✓[/green] Template pack '{manifest.name}' v{manifest.version} installed successfully")
-            finally:
-                if 'zip_path' in locals() and zip_path.exists():
-                    zip_path.unlink(missing_ok=True)
-        else:
-            console.print("[red]Error:[/red] Specify a template pack ID, --from URL, or --dev path")
-            raise typer.Exit(1)
-
-    except TemplateCompatibilityError as e:
-        console.print(f"[red]Compatibility Error:[/red] {e}")
-        raise typer.Exit(1)
-    except TemplateValidationError as e:
-        console.print(f"[red]Validation Error:[/red] {e}")
-        raise typer.Exit(1)
-    except TemplateError as e:
-        console.print(f"[red]Error:[/red] {e}")
-        raise typer.Exit(1)
-
-
-@template_app.command("remove")
-def template_remove(
-    pack_id: str = typer.Argument(..., help="Template pack ID to remove"),
-):
-    """Remove an installed template pack."""
-    from .templates import TemplatePackManager
-
-    project_root = Path.cwd()
-
-    specify_dir = project_root / ".specify"
-    if not specify_dir.exists():
-        console.print("[red]Error:[/red] Not a spec-kit project (no .specify/ directory)")
-        console.print("Run this command from a spec-kit project root")
-        raise typer.Exit(1)
-
-    manager = TemplatePackManager(project_root)
-
-    if not manager.registry.is_installed(pack_id):
-        console.print(f"[red]Error:[/red] Template pack '{pack_id}' is not installed")
-        raise typer.Exit(1)
-
-    if manager.remove(pack_id):
-        console.print(f"[green]✓[/green] Template pack '{pack_id}' removed successfully")
-    else:
-        console.print(f"[red]Error:[/red] Failed to remove template pack '{pack_id}'")
-        raise typer.Exit(1)
-
-
-@template_app.command("search")
-def template_search(
-    query: str = typer.Argument(None, help="Search query"),
-    tag: str = typer.Option(None, "--tag", help="Filter by tag"),
-    author: str = typer.Option(None, "--author", help="Filter by author"),
-):
-    """Search for template packs in the catalog."""
-    from .templates import TemplateCatalog, TemplateError
-
-    project_root = Path.cwd()
-
-    specify_dir = project_root / ".specify"
-    if not specify_dir.exists():
-        console.print("[red]Error:[/red] Not a spec-kit project (no .specify/ directory)")
-        console.print("Run this command from a spec-kit project root")
-        raise typer.Exit(1)
-
-    catalog = TemplateCatalog(project_root)
-
-    try:
-        results = catalog.search(query=query, tag=tag, author=author)
-    except TemplateError as e:
-        console.print(f"[red]Error:[/red] {e}")
-        raise typer.Exit(1)
-
-    if not results:
-        console.print("[yellow]No template packs found matching your criteria.[/yellow]")
-        return
-
-    console.print(f"\n[bold cyan]Template Packs ({len(results)} found):[/bold cyan]\n")
-    for pack in results:
-        console.print(f"  [bold]{pack.get('name', pack['id'])}[/bold] ({pack['id']}) v{pack.get('version', '?')}")
-        console.print(f"    {pack.get('description', '')}")
-        if pack.get("tags"):
-            tags_str = ", ".join(pack["tags"])
-            console.print(f"    [dim]Tags: {tags_str}[/dim]")
-        console.print()
-
-
-@template_app.command("resolve")
-def template_resolve(
-    template_name: str = typer.Argument(..., help="Template name to resolve (e.g., spec-template)"),
-):
-    """Show which template will be resolved for a given name."""
-    from .templates import TemplateResolver
-
-    project_root = Path.cwd()
-
-    specify_dir = project_root / ".specify"
-    if not specify_dir.exists():
-        console.print("[red]Error:[/red] Not a spec-kit project (no .specify/ directory)")
-        console.print("Run this command from a spec-kit project root")
-        raise typer.Exit(1)
-
-    resolver = TemplateResolver(project_root)
-    result = resolver.resolve_with_source(template_name)
-
-    if result:
-        console.print(f"  [bold]{template_name}[/bold]: {result['path']}")
-        console.print(f"    [dim](from: {result['source']})[/dim]")
-    else:
-        console.print(f"  [yellow]{template_name}[/yellow]: not found")
-        console.print("    [dim]No template with this name exists in the resolution stack[/dim]")
-
-
-# ===== Extension Commands =====
-
-
 @extension_app.command("list")
 def extension_list(
     available: bool = typer.Option(False, "--available", help="Show available extensions from catalog"),

src/specify_cli/templates.py

@@ -1,938 +0,0 @@
-"""
-Template Pack Manager for Spec Kit
-
-Handles installation, removal, and management of Spec Kit template packs.
-Template packs are self-contained, versioned collections of templates
-(artifact, command, and script templates) that can be installed to
-customize the Spec-Driven Development workflow.
-"""
-
-import json
-import hashlib
-import os
-import tempfile
-import zipfile
-import shutil
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Optional, Dict, List, Any
-from datetime import datetime, timezone
-import re
-
-import yaml
-from packaging import version as pkg_version
-from packaging.specifiers import SpecifierSet, InvalidSpecifier
-
-
-class TemplateError(Exception):
-    """Base exception for template-related errors."""
-    pass
-
-
-class TemplateValidationError(TemplateError):
-    """Raised when template pack manifest validation fails."""
-    pass
-
-
-class TemplateCompatibilityError(TemplateError):
-    """Raised when template pack is incompatible with current environment."""
-    pass
-
-
-VALID_TEMPLATE_TYPES = {"artifact", "command", "script"}
-
-
-class TemplatePackManifest:
-    """Represents and validates a template pack manifest (template-pack.yml)."""
-
-    SCHEMA_VERSION = "1.0"
-    REQUIRED_FIELDS = ["schema_version", "template_pack", "requires", "provides"]
-
-    def __init__(self, manifest_path: Path):
-        """Load and validate template pack manifest.
-
-        Args:
-            manifest_path: Path to template-pack.yml file
-
-        Raises:
-            TemplateValidationError: If manifest is invalid
-        """
-        self.path = manifest_path
-        self.data = self._load_yaml(manifest_path)
-        self._validate()
-
-    def _load_yaml(self, path: Path) -> dict:
-        """Load YAML file safely."""
-        try:
-            with open(path, 'r') as f:
-                return yaml.safe_load(f) or {}
-        except yaml.YAMLError as e:
-            raise TemplateValidationError(f"Invalid YAML in {path}: {e}")
-        except FileNotFoundError:
-            raise TemplateValidationError(f"Manifest not found: {path}")
-
-    def _validate(self):
-        """Validate manifest structure and required fields."""
-        # Check required top-level fields
-        for field in self.REQUIRED_FIELDS:
-            if field not in self.data:
-                raise TemplateValidationError(f"Missing required field: {field}")
-
-        # Validate schema version
-        if self.data["schema_version"] != self.SCHEMA_VERSION:
-            raise TemplateValidationError(
-                f"Unsupported schema version: {self.data['schema_version']} "
-                f"(expected {self.SCHEMA_VERSION})"
-            )
-
-        # Validate template_pack metadata
-        pack = self.data["template_pack"]
-        for field in ["id", "name", "version", "description"]:
-            if field not in pack:
-                raise TemplateValidationError(f"Missing template_pack.{field}")
-
-        # Validate pack ID format
-        if not re.match(r'^[a-z0-9-]+$', pack["id"]):
-            raise TemplateValidationError(
-                f"Invalid template pack ID '{pack['id']}': "
-                "must be lowercase alphanumeric with hyphens only"
-            )
-
-        # Validate semantic version
-        try:
-            pkg_version.Version(pack["version"])
-        except pkg_version.InvalidVersion:
-            raise TemplateValidationError(f"Invalid version: {pack['version']}")
-
-        # Validate requires section
-        requires = self.data["requires"]
-        if "speckit_version" not in requires:
-            raise TemplateValidationError("Missing requires.speckit_version")
-
-        # Validate provides section
-        provides = self.data["provides"]
-        if "templates" not in provides or not provides["templates"]:
-            raise TemplateValidationError(
-                "Template pack must provide at least one template"
-            )
-
-        # Validate templates
-        for tmpl in provides["templates"]:
-            if "type" not in tmpl or "name" not in tmpl or "file" not in tmpl:
-                raise TemplateValidationError(
-                    "Template missing 'type', 'name', or 'file'"
-                )
-
-            if tmpl["type"] not in VALID_TEMPLATE_TYPES:
-                raise TemplateValidationError(
-                    f"Invalid template type '{tmpl['type']}': "
-                    f"must be one of {sorted(VALID_TEMPLATE_TYPES)}"
-                )
-
-            # Validate template name format
-            if not re.match(r'^[a-z0-9-]+$', tmpl["name"]):
-                raise TemplateValidationError(
-                    f"Invalid template name '{tmpl['name']}': "
-                    "must be lowercase alphanumeric with hyphens only"
-                )
-
-    @property
-    def id(self) -> str:
-        """Get template pack ID."""
-        return self.data["template_pack"]["id"]
-
-    @property
-    def name(self) -> str:
-        """Get template pack name."""
-        return self.data["template_pack"]["name"]
-
-    @property
-    def version(self) -> str:
-        """Get template pack version."""
-        return self.data["template_pack"]["version"]
-
-    @property
-    def description(self) -> str:
-        """Get template pack description."""
-        return self.data["template_pack"]["description"]
-
-    @property
-    def author(self) -> str:
-        """Get template pack author."""
-        return self.data["template_pack"].get("author", "")
-
-    @property
-    def requires_speckit_version(self) -> str:
-        """Get required spec-kit version range."""
-        return self.data["requires"]["speckit_version"]
-
-    @property
-    def templates(self) -> List[Dict[str, Any]]:
-        """Get list of provided templates."""
-        return self.data["provides"]["templates"]
-
-    @property
-    def tags(self) -> List[str]:
-        """Get template pack tags."""
-        return self.data.get("tags", [])
-
-    def get_hash(self) -> str:
-        """Calculate SHA256 hash of manifest file."""
-        with open(self.path, 'rb') as f:
-            return f"sha256:{hashlib.sha256(f.read()).hexdigest()}"
-
-
-class TemplatePackRegistry:
-    """Manages the registry of installed template packs."""
-
-    REGISTRY_FILE = ".registry"
-    SCHEMA_VERSION = "1.0"
-
-    def __init__(self, packs_dir: Path):
-        """Initialize registry.
-
-        Args:
-            packs_dir: Path to .specify/templates/packs/ directory
-        """
-        self.packs_dir = packs_dir
-        self.registry_path = packs_dir / self.REGISTRY_FILE
-        self.data = self._load()
-
-    def _load(self) -> dict:
-        """Load registry from disk."""
-        if not self.registry_path.exists():
-            return {
-                "schema_version": self.SCHEMA_VERSION,
-                "template_packs": {}
-            }
-
-        try:
-            with open(self.registry_path, 'r') as f:
-                return json.load(f)
-        except (json.JSONDecodeError, FileNotFoundError):
-            return {
-                "schema_version": self.SCHEMA_VERSION,
-                "template_packs": {}
-            }
-
-    def _save(self):
-        """Save registry to disk."""
-        self.packs_dir.mkdir(parents=True, exist_ok=True)
-        with open(self.registry_path, 'w') as f:
-            json.dump(self.data, f, indent=2)
-
-    def add(self, pack_id: str, metadata: dict):
-        """Add template pack to registry.
-
-        Args:
-            pack_id: Template pack ID
-            metadata: Pack metadata (version, source, etc.)
-        """
-        self.data["template_packs"][pack_id] = {
-            **metadata,
-            "installed_at": datetime.now(timezone.utc).isoformat()
-        }
-        self._save()
-
-    def remove(self, pack_id: str):
-        """Remove template pack from registry.
-
-        Args:
-            pack_id: Template pack ID
-        """
-        if pack_id in self.data["template_packs"]:
-            del self.data["template_packs"][pack_id]
-            self._save()
-
-    def get(self, pack_id: str) -> Optional[dict]:
-        """Get template pack metadata from registry.
-
-        Args:
-            pack_id: Template pack ID
-
-        Returns:
-            Pack metadata or None if not found
-        """
-        return self.data["template_packs"].get(pack_id)
-
-    def list(self) -> Dict[str, dict]:
-        """Get all installed template packs.
-
-        Returns:
-            Dictionary of pack_id -> metadata
-        """
-        return self.data["template_packs"]
-
-    def is_installed(self, pack_id: str) -> bool:
-        """Check if template pack is installed.
-
-        Args:
-            pack_id: Template pack ID
-
-        Returns:
-            True if pack is installed
-        """
-        return pack_id in self.data["template_packs"]
-
-
-class TemplatePackManager:
-    """Manages template pack lifecycle: installation, removal, updates."""
-
-    def __init__(self, project_root: Path):
-        """Initialize template pack manager.
-
-        Args:
-            project_root: Path to project root directory
-        """
-        self.project_root = project_root
-        self.templates_dir = project_root / ".specify" / "templates"
-        self.packs_dir = self.templates_dir / "packs"
-        self.registry = TemplatePackRegistry(self.packs_dir)
-
-    def check_compatibility(
-        self,
-        manifest: TemplatePackManifest,
-        speckit_version: str
-    ) -> bool:
-        """Check if template pack is compatible with current spec-kit version.
-
-        Args:
-            manifest: Template pack manifest
-            speckit_version: Current spec-kit version
-
-        Returns:
-            True if compatible
-
-        Raises:
-            TemplateCompatibilityError: If pack is incompatible
-        """
-        required = manifest.requires_speckit_version
-        current = pkg_version.Version(speckit_version)
-
-        try:
-            specifier = SpecifierSet(required)
-            if current not in specifier:
-                raise TemplateCompatibilityError(
-                    f"Template pack requires spec-kit {required}, "
-                    f"but {speckit_version} is installed.\n"
-                    f"Upgrade spec-kit with: uv tool install specify-cli --force"
-                )
-        except InvalidSpecifier:
-            raise TemplateCompatibilityError(
-                f"Invalid version specifier: {required}"
-            )
-
-        return True
-
-    def install_from_directory(
-        self,
-        source_dir: Path,
-        speckit_version: str,
-    ) -> TemplatePackManifest:
-        """Install template pack from a local directory.
-
-        Args:
-            source_dir: Path to template pack directory
-            speckit_version: Current spec-kit version
-
-        Returns:
-            Installed template pack manifest
-
-        Raises:
-            TemplateValidationError: If manifest is invalid
-            TemplateCompatibilityError: If pack is incompatible
-        """
-        manifest_path = source_dir / "template-pack.yml"
-        manifest = TemplatePackManifest(manifest_path)
-
-        self.check_compatibility(manifest, speckit_version)
-
-        if self.registry.is_installed(manifest.id):
-            raise TemplateError(
-                f"Template pack '{manifest.id}' is already installed. "
-                f"Use 'specify template remove {manifest.id}' first."
-            )
-
-        dest_dir = self.packs_dir / manifest.id
-        if dest_dir.exists():
-            shutil.rmtree(dest_dir)
-
-        shutil.copytree(source_dir, dest_dir)
-
-        self.registry.add(manifest.id, {
-            "version": manifest.version,
-            "source": "local",
-            "manifest_hash": manifest.get_hash(),
-            "enabled": True,
-        })
-
-        return manifest
-
-    def install_from_zip(
-        self,
-        zip_path: Path,
-        speckit_version: str
-    ) -> TemplatePackManifest:
-        """Install template pack from ZIP file.
-
-        Args:
-            zip_path: Path to template pack ZIP file
-            speckit_version: Current spec-kit version
-
-        Returns:
-            Installed template pack manifest
-
-        Raises:
-            TemplateValidationError: If manifest is invalid
-            TemplateCompatibilityError: If pack is incompatible
-        """
-        with tempfile.TemporaryDirectory() as tmpdir:
-            temp_path = Path(tmpdir)
-
-            with zipfile.ZipFile(zip_path, 'r') as zf:
-                temp_path_resolved = temp_path.resolve()
-                for member in zf.namelist():
-                    member_path = (temp_path / member).resolve()
-                    try:
-                        member_path.relative_to(temp_path_resolved)
-                    except ValueError:
-                        raise TemplateValidationError(
-                            f"Unsafe path in ZIP archive: {member} "
-                            "(potential path traversal)"
-                        )
-                zf.extractall(temp_path)
-
-            pack_dir = temp_path
-            manifest_path = pack_dir / "template-pack.yml"
-
-            if not manifest_path.exists():
-                subdirs = [d for d in temp_path.iterdir() if d.is_dir()]
-                if len(subdirs) == 1:
-                    pack_dir = subdirs[0]
-                    manifest_path = pack_dir / "template-pack.yml"
-
-            if not manifest_path.exists():
-                raise TemplateValidationError(
-                    "No template-pack.yml found in ZIP file"
-                )
-
-            return self.install_from_directory(pack_dir, speckit_version)
-
-    def remove(self, pack_id: str) -> bool:
-        """Remove an installed template pack.
-
-        Args:
-            pack_id: Template pack ID
-
-        Returns:
-            True if pack was removed
-        """
-        if not self.registry.is_installed(pack_id):
-            return False
-
-        pack_dir = self.packs_dir / pack_id
-        if pack_dir.exists():
-            shutil.rmtree(pack_dir)
-
-        self.registry.remove(pack_id)
-        return True
-
-    def list_installed(self) -> List[Dict[str, Any]]:
-        """List all installed template packs with metadata.
-
-        Returns:
-            List of template pack metadata dictionaries
-        """
-        result = []
-
-        for pack_id, metadata in self.registry.list().items():
-            pack_dir = self.packs_dir / pack_id
-            manifest_path = pack_dir / "template-pack.yml"
-
-            try:
-                manifest = TemplatePackManifest(manifest_path)
-                result.append({
-                    "id": pack_id,
-                    "name": manifest.name,
-                    "version": metadata["version"],
-                    "description": manifest.description,
-                    "enabled": metadata.get("enabled", True),
-                    "installed_at": metadata.get("installed_at"),
-                    "template_count": len(manifest.templates),
-                    "tags": manifest.tags,
-                })
-            except TemplateValidationError:
-                result.append({
-                    "id": pack_id,
-                    "name": pack_id,
-                    "version": metadata.get("version", "unknown"),
-                    "description": "⚠️ Corrupted template pack",
-                    "enabled": False,
-                    "installed_at": metadata.get("installed_at"),
-                    "template_count": 0,
-                    "tags": [],
-                })
-
-        return result
-
-    def get_pack(self, pack_id: str) -> Optional[TemplatePackManifest]:
-        """Get manifest for an installed template pack.
-
-        Args:
-            pack_id: Template pack ID
-
-        Returns:
-            Template pack manifest or None if not installed
-        """
-        if not self.registry.is_installed(pack_id):
-            return None
-
-        pack_dir = self.packs_dir / pack_id
-        manifest_path = pack_dir / "template-pack.yml"
-
-        try:
-            return TemplatePackManifest(manifest_path)
-        except TemplateValidationError:
-            return None
-
-
-class TemplateCatalog:
-    """Manages template pack catalog fetching, caching, and searching."""
-
-    DEFAULT_CATALOG_URL = "https://raw.githubusercontent.com/github/spec-kit/main/templates/catalog.json"
-    COMMUNITY_CATALOG_URL = "https://raw.githubusercontent.com/github/spec-kit/main/templates/catalog.community.json"
-    CACHE_DURATION = 3600  # 1 hour in seconds
-
-    def __init__(self, project_root: Path):
-        """Initialize template catalog manager.
-
-        Args:
-            project_root: Root directory of the spec-kit project
-        """
-        self.project_root = project_root
-        self.templates_dir = project_root / ".specify" / "templates"
-        self.cache_dir = self.templates_dir / "packs" / ".cache"
-        self.cache_file = self.cache_dir / "catalog.json"
-        self.cache_metadata_file = self.cache_dir / "catalog-metadata.json"
-
-    def _validate_catalog_url(self, url: str) -> None:
-        """Validate that a catalog URL uses HTTPS (localhost HTTP allowed).
-
-        Args:
-            url: URL to validate
-
-        Raises:
-            TemplateValidationError: If URL is invalid or uses non-HTTPS scheme
-        """
-        from urllib.parse import urlparse
-
-        parsed = urlparse(url)
-        is_localhost = parsed.hostname in ("localhost", "127.0.0.1", "::1")
-        if parsed.scheme != "https" and not (
-            parsed.scheme == "http" and is_localhost
-        ):
-            raise TemplateValidationError(
-                f"Catalog URL must use HTTPS (got {parsed.scheme}://). "
-                "HTTP is only allowed for localhost."
-            )
-        if not parsed.netloc:
-            raise TemplateValidationError(
-                "Catalog URL must be a valid URL with a host."
-            )
-
-    def get_catalog_url(self) -> str:
-        """Get the primary catalog URL.
-
-        Returns:
-            URL of the primary catalog
-        """
-        env_value = os.environ.get("SPECKIT_TEMPLATE_CATALOG_URL")
-        if env_value:
-            catalog_url = env_value.strip()
-            self._validate_catalog_url(catalog_url)
-            return catalog_url
-        return self.DEFAULT_CATALOG_URL
-
-    def is_cache_valid(self) -> bool:
-        """Check if cached catalog is still valid.
-
-        Returns:
-            True if cache exists and is within cache duration
-        """
-        if not self.cache_file.exists() or not self.cache_metadata_file.exists():
-            return False
-
-        try:
-            metadata = json.loads(self.cache_metadata_file.read_text())
-            cached_at = datetime.fromisoformat(metadata.get("cached_at", ""))
-            if cached_at.tzinfo is None:
-                cached_at = cached_at.replace(tzinfo=timezone.utc)
-            age_seconds = (
-                datetime.now(timezone.utc) - cached_at
-            ).total_seconds()
-            return age_seconds < self.CACHE_DURATION
-        except (json.JSONDecodeError, ValueError, KeyError, TypeError):
-            return False
-
-    def fetch_catalog(self, force_refresh: bool = False) -> Dict[str, Any]:
-        """Fetch template pack catalog from URL or cache.
-
-        Args:
-            force_refresh: If True, bypass cache and fetch from network
-
-        Returns:
-            Catalog data dictionary
-
-        Raises:
-            TemplateError: If catalog cannot be fetched
-        """
-        if not force_refresh and self.is_cache_valid():
-            try:
-                return json.loads(self.cache_file.read_text())
-            except json.JSONDecodeError:
-                pass
-
-        catalog_url = self.get_catalog_url()
-
-        try:
-            import urllib.request
-            import urllib.error
-
-            with urllib.request.urlopen(catalog_url, timeout=10) as response:
-                catalog_data = json.loads(response.read())
-
-            if (
-                "schema_version" not in catalog_data
-                or "template_packs" not in catalog_data
-            ):
-                raise TemplateError("Invalid template catalog format")
-
-            self.cache_dir.mkdir(parents=True, exist_ok=True)
-            self.cache_file.write_text(json.dumps(catalog_data, indent=2))
-
-            metadata = {
-                "cached_at": datetime.now(timezone.utc).isoformat(),
-                "catalog_url": catalog_url,
-            }
-            self.cache_metadata_file.write_text(
-                json.dumps(metadata, indent=2)
-            )
-
-            return catalog_data
-
-        except (ImportError, Exception) as e:
-            if isinstance(e, TemplateError):
-                raise
-            raise TemplateError(
-                f"Failed to fetch template catalog from {catalog_url}: {e}"
-            )
-
-    def search(
-        self,
-        query: Optional[str] = None,
-        tag: Optional[str] = None,
-        author: Optional[str] = None,
-    ) -> List[Dict[str, Any]]:
-        """Search catalog for template packs.
-
-        Args:
-            query: Search query (searches name, description, tags)
-            tag: Filter by specific tag
-            author: Filter by author name
-
-        Returns:
-            List of matching template pack metadata
-        """
-        try:
-            catalog_data = self.fetch_catalog()
-        except TemplateError:
-            return []
-
-        results = []
-        packs = catalog_data.get("template_packs", {})
-
-        for pack_id, pack_data in packs.items():
-            if author and pack_data.get("author", "").lower() != author.lower():
-                continue
-
-            if tag and tag.lower() not in [
-                t.lower() for t in pack_data.get("tags", [])
-            ]:
-                continue
-
-            if query:
-                query_lower = query.lower()
-                searchable_text = " ".join(
-                    [
-                        pack_data.get("name", ""),
-                        pack_data.get("description", ""),
-                        pack_id,
-                    ]
-                    + pack_data.get("tags", [])
-                ).lower()
-
-                if query_lower not in searchable_text:
-                    continue
-
-            results.append({**pack_data, "id": pack_id})
-
-        return results
-
-    def get_pack_info(
-        self, pack_id: str
-    ) -> Optional[Dict[str, Any]]:
-        """Get detailed information about a specific template pack.
-
-        Args:
-            pack_id: ID of the template pack
-
-        Returns:
-            Pack metadata or None if not found
-        """
-        try:
-            catalog_data = self.fetch_catalog()
-        except TemplateError:
-            return None
-
-        packs = catalog_data.get("template_packs", {})
-        if pack_id in packs:
-            return {**packs[pack_id], "id": pack_id}
-        return None
-
-    def download_pack(
-        self, pack_id: str, target_dir: Optional[Path] = None
-    ) -> Path:
-        """Download template pack ZIP from catalog.
-
-        Args:
-            pack_id: ID of the template pack to download
-            target_dir: Directory to save ZIP file (defaults to cache directory)
-
-        Returns:
-            Path to downloaded ZIP file
-
-        Raises:
-            TemplateError: If pack not found or download fails
-        """
-        import urllib.request
-        import urllib.error
-
-        pack_info = self.get_pack_info(pack_id)
-        if not pack_info:
-            raise TemplateError(
-                f"Template pack '{pack_id}' not found in catalog"
-            )
-
-        download_url = pack_info.get("download_url")
-        if not download_url:
-            raise TemplateError(
-                f"Template pack '{pack_id}' has no download URL"
-            )
-
-        from urllib.parse import urlparse
-
-        parsed = urlparse(download_url)
-        is_localhost = parsed.hostname in ("localhost", "127.0.0.1", "::1")
-        if parsed.scheme != "https" and not (
-            parsed.scheme == "http" and is_localhost
-        ):
-            raise TemplateError(
-                f"Template pack download URL must use HTTPS: {download_url}"
-            )
-
-        if target_dir is None:
-            target_dir = self.cache_dir / "downloads"
-        target_dir.mkdir(parents=True, exist_ok=True)
-
-        version = pack_info.get("version", "unknown")
-        zip_filename = f"{pack_id}-{version}.zip"
-        zip_path = target_dir / zip_filename
-
-        try:
-            with urllib.request.urlopen(download_url, timeout=60) as response:
-                zip_data = response.read()
-
-            zip_path.write_bytes(zip_data)
-            return zip_path
-
-        except urllib.error.URLError as e:
-            raise TemplateError(
-                f"Failed to download template pack from {download_url}: {e}"
-            )
-        except IOError as e:
-            raise TemplateError(f"Failed to save template pack ZIP: {e}")
-
-    def clear_cache(self):
-        """Clear the catalog cache."""
-        if self.cache_file.exists():
-            self.cache_file.unlink()
-        if self.cache_metadata_file.exists():
-            self.cache_metadata_file.unlink()
-
-
-class TemplateResolver:
-    """Resolves template names to file paths using a priority stack.
-
-    Resolution order:
-    1. .specify/templates/overrides/          - Project-local overrides
-    2. .specify/templates/packs/<pack-id>/    - Installed template packs
-    3. .specify/extensions/<ext-id>/templates/ - Extension-provided templates
-    4. .specify/templates/                    - Core templates (shipped with Spec Kit)
-    """
-
-    def __init__(self, project_root: Path):
-        """Initialize template resolver.
-
-        Args:
-            project_root: Path to project root directory
-        """
-        self.project_root = project_root
-        self.templates_dir = project_root / ".specify" / "templates"
-        self.packs_dir = self.templates_dir / "packs"
-        self.overrides_dir = self.templates_dir / "overrides"
-        self.extensions_dir = project_root / ".specify" / "extensions"
-
-    def resolve(
-        self,
-        template_name: str,
-        template_type: str = "artifact",
-    ) -> Optional[Path]:
-        """Resolve a template name to its file path.
-
-        Walks the priority stack and returns the first match.
-
-        Args:
-            template_name: Template name (e.g., "spec-template")
-            template_type: Template type ("artifact", "command", or "script")
-
-        Returns:
-            Path to the resolved template file, or None if not found
-        """
-        # Determine subdirectory based on template type
-        if template_type == "artifact":
-            subdirs = ["templates", ""]
-        elif template_type == "command":
-            subdirs = ["commands"]
-        elif template_type == "script":
-            subdirs = ["scripts"]
-        else:
-            subdirs = [""]
-
-        # Priority 1: Project-local overrides
-        for subdir in subdirs:
-            if template_type == "script":
-                override = self.overrides_dir / "scripts" / f"{template_name}.sh"
-            elif subdir:
-                override = self.overrides_dir / f"{template_name}.md"
-            else:
-                override = self.overrides_dir / f"{template_name}.md"
-            if override.exists():
-                return override
-
-        # Priority 2: Installed packs (by registry order)
-        if self.packs_dir.exists():
-            registry = TemplatePackRegistry(self.packs_dir)
-            for pack_id in registry.list():
-                pack_dir = self.packs_dir / pack_id
-                for subdir in subdirs:
-                    if subdir:
-                        candidate = (
-                            pack_dir / subdir / f"{template_name}.md"
-                        )
-                    else:
-                        candidate = pack_dir / f"{template_name}.md"
-                    if candidate.exists():
-                        return candidate
-
-        # Priority 3: Extension-provided templates
-        if self.extensions_dir.exists():
-            for ext_dir in sorted(self.extensions_dir.iterdir()):
-                if not ext_dir.is_dir() or ext_dir.name.startswith("."):
-                    continue
-                for subdir in subdirs:
-                    if subdir:
-                        candidate = (
-                            ext_dir / "templates" / f"{template_name}.md"
-                        )
-                    else:
-                        candidate = (
-                            ext_dir / "templates" / f"{template_name}.md"
-                        )
-                    if candidate.exists():
-                        return candidate
-
-        # Priority 4: Core templates
-        if template_type == "artifact":
-            core = self.templates_dir / f"{template_name}.md"
-            if core.exists():
-                return core
-        elif template_type == "command":
-            core = self.templates_dir / "commands" / f"{template_name}.md"
-            if core.exists():
-                return core
-
-        return None
-
-    def resolve_with_source(
-        self,
-        template_name: str,
-        template_type: str = "artifact",
-    ) -> Optional[Dict[str, str]]:
-        """Resolve a template name and return source attribution.
-
-        Args:
-            template_name: Template name (e.g., "spec-template")
-            template_type: Template type ("artifact", "command", or "script")
-
-        Returns:
-            Dictionary with 'path' and 'source' keys, or None if not found
-        """
-        # Priority 1: Project-local overrides
-        override = self.overrides_dir / f"{template_name}.md"
-        if override.exists():
-            return {"path": str(override), "source": "project override"}
-
-        # Priority 2: Installed packs
-        if self.packs_dir.exists():
-            registry = TemplatePackRegistry(self.packs_dir)
-            for pack_id in registry.list():
-                pack_dir = self.packs_dir / pack_id
-                # Check templates/ subdirectory first, then root
-                for subdir in ["templates", "commands", "scripts", ""]:
-                    if subdir:
-                        candidate = (
-                            pack_dir / subdir / f"{template_name}.md"
-                        )
-                    else:
-                        candidate = pack_dir / f"{template_name}.md"
-                    if candidate.exists():
-                        meta = registry.get(pack_id)
-                        version = meta.get("version", "?") if meta else "?"
-                        return {
-                            "path": str(candidate),
-                            "source": f"{pack_id} v{version}",
-                        }
-
-        # Priority 3: Extension-provided templates
-        if self.extensions_dir.exists():
-            for ext_dir in sorted(self.extensions_dir.iterdir()):
-                if not ext_dir.is_dir() or ext_dir.name.startswith("."):
-                    continue
-                candidate = ext_dir / "templates" / f"{template_name}.md"
-                if candidate.exists():
-                    return {
-                        "path": str(candidate),
-                        "source": f"extension:{ext_dir.name}",
-                    }
-
-        # Priority 4: Core templates
-        core = self.templates_dir / f"{template_name}.md"
-        if core.exists():
-            return {"path": str(core), "source": "core"}
-
-        # Also check commands subdirectory for core
-        core_cmd = self.templates_dir / "commands" / f"{template_name}.md"
-        if core_cmd.exists():
-            return {"path": str(core_cmd), "source": "core"}
-
-        return None

templates/catalog.community.json

@@ -1,6 +0,0 @@
-{
-  "schema_version": "1.0",
-  "updated_at": "2026-03-09T00:00:00Z",
-  "catalog_url": "https://raw.githubusercontent.com/github/spec-kit/main/templates/catalog.community.json",
-  "template_packs": {}
-}

templates/catalog.json

@@ -1,6 +0,0 @@
-{
-  "schema_version": "1.0",
-  "updated_at": "2026-03-09T00:00:00Z",
-  "catalog_url": "https://raw.githubusercontent.com/github/spec-kit/main/templates/catalog.json",
-  "template_packs": {}
-}

templates/template/README.md

@@ -1,49 +0,0 @@
-# My Template Pack
-
-A custom template pack for Spec Kit.
-
-## Overview
-
-This template pack provides customized artifact templates for your development workflow.
-
-## Templates Included
-
-| Template | Type | Description |
-|----------|------|-------------|
-| `spec-template` | artifact | Custom feature specification template |
-
-## Installation
-
-```bash
-# Install from local directory (during development)
-specify template add --dev /path/to/this/directory
-
-# Install from catalog (after publishing)
-specify template add my-template-pack
-```
-
-## Usage
-
-Once installed, templates are automatically resolved by the Spec Kit scripts.
-When you run `specify specify` or create a new feature, your custom templates
-will be used instead of the core defaults.
-
-## Template Types
-
-- **artifact** — Document scaffolds (spec.md, plan.md, tasks.md, etc.)
-- **command** — AI agent prompts (the files in `.claude/commands/`, etc.)
-- **script** — Custom scripts that replace core scripts
-
-## Development
-
-1. Edit templates in the `templates/` directory
-2. Test with: `specify template add --dev .`
-3. Verify with: `specify template resolve spec-template`
-
-## Publishing
-
-See the [Template Publishing Guide](../../docs/TEMPLATE-PUBLISHING-GUIDE.md) for details.
-
-## License
-
-MIT

templates/template/template-pack.yml

@@ -1,66 +0,0 @@
-schema_version: "1.0"
-
-template_pack:
-  # CUSTOMIZE: Change 'my-template-pack' to your template pack ID (lowercase, hyphen-separated)
-  id: "my-template-pack"
-
-  # CUSTOMIZE: Human-readable name for your template pack
-  name: "My Template Pack"
-
-  # CUSTOMIZE: Update version when releasing (semantic versioning: X.Y.Z)
-  version: "1.0.0"
-
-  # CUSTOMIZE: Brief description (under 200 characters)
-  description: "Brief description of what your template pack provides"
-
-  # CUSTOMIZE: Your name or organization name
-  author: "Your Name"
-
-  # CUSTOMIZE: GitHub repository URL (create before publishing)
-  repository: "https://github.com/your-org/spec-kit-templates-my-pack"
-
-  # REVIEW: License (MIT is recommended for open source)
-  license: "MIT"
-
-# Requirements for this template pack
-requires:
-  # CUSTOMIZE: Minimum spec-kit version required
-  speckit_version: ">=0.1.0"
-
-# Templates provided by this pack
-provides:
-  templates:
-    # CUSTOMIZE: Define your artifact templates
-    # Artifact templates are document scaffolds (spec.md, plan.md, etc.)
-    - type: "artifact"
-      name: "spec-template"
-      file: "templates/spec-template.md"
-      description: "Custom feature specification template"
-      replaces: "spec-template"  # Which core template this overrides (optional)
-
-    # ADD MORE TEMPLATES: Copy this block for each template
-    # - type: "artifact"
-    #   name: "plan-template"
-    #   file: "templates/plan-template.md"
-    #   description: "Custom plan template"
-    #   replaces: "plan-template"
-
-    # Command templates (AI agent prompts)
-    # - type: "command"
-    #   name: "specify"
-    #   file: "commands/specify.md"
-    #   description: "Custom specification command"
-    #   replaces: "specify"
-
-    # Script templates
-    # - type: "script"
-    #   name: "create-new-feature"
-    #   file: "scripts/bash/create-new-feature.sh"
-    #   description: "Custom feature creation script"
-    #   replaces: "create-new-feature"
-
-# CUSTOMIZE: Add relevant tags (2-5 recommended)
-# Used for discovery in catalog
-tags:
-  - "example"
-  - "template"

templates/template/templates/spec-template.md

@@ -1,21 +0,0 @@
-# Feature Specification
-
-> Replace this with your actual specification content.
-
-## Overview
-
-Brief description of the feature.
-
-## Requirements
-
-- Requirement 1
-- Requirement 2
-
-## Design
-
-Describe the design approach.
-
-## Acceptance Criteria
-
-- [ ] Criterion 1
-- [ ] Criterion 2

tests/test_templates.py

@@ -1,923 +0,0 @@
-"""
-Unit tests for the template pack system.
-
-Tests cover:
-- Template pack manifest validation
-- Template pack registry operations
-- Template pack manager installation/removal
-- Template catalog search
-- Template resolver priority stack
-- Extension-provided templates
-"""
-
-import pytest
-import json
-import tempfile
-import shutil
-import zipfile
-from pathlib import Path
-from datetime import datetime, timezone
-
-import yaml
-
-from specify_cli.templates import (
-    TemplatePackManifest,
-    TemplatePackRegistry,
-    TemplatePackManager,
-    TemplateCatalog,
-    TemplateResolver,
-    TemplateError,
-    TemplateValidationError,
-    TemplateCompatibilityError,
-    VALID_TEMPLATE_TYPES,
-)
-
-
-# ===== Fixtures =====
-
-
-@pytest.fixture
-def temp_dir():
-    """Create a temporary directory for tests."""
-    tmpdir = tempfile.mkdtemp()
-    yield Path(tmpdir)
-    shutil.rmtree(tmpdir)
-
-
-@pytest.fixture
-def valid_pack_data():
-    """Valid template pack manifest data."""
-    return {
-        "schema_version": "1.0",
-        "template_pack": {
-            "id": "test-pack",
-            "name": "Test Template Pack",
-            "version": "1.0.0",
-            "description": "A test template pack",
-            "author": "Test Author",
-            "repository": "https://github.com/test/test-pack",
-            "license": "MIT",
-        },
-        "requires": {
-            "speckit_version": ">=0.1.0",
-        },
-        "provides": {
-            "templates": [
-                {
-                    "type": "artifact",
-                    "name": "spec-template",
-                    "file": "templates/spec-template.md",
-                    "description": "Custom spec template",
-                    "replaces": "spec-template",
-                }
-            ]
-        },
-        "tags": ["testing", "example"],
-    }
-
-
-@pytest.fixture
-def pack_dir(temp_dir, valid_pack_data):
-    """Create a complete template pack directory structure."""
-    p_dir = temp_dir / "test-pack"
-    p_dir.mkdir()
-
-    # Write manifest
-    manifest_path = p_dir / "template-pack.yml"
-    with open(manifest_path, 'w') as f:
-        yaml.dump(valid_pack_data, f)
-
-    # Create templates directory
-    templates_dir = p_dir / "templates"
-    templates_dir.mkdir()
-
-    # Write template file
-    tmpl_file = templates_dir / "spec-template.md"
-    tmpl_file.write_text("# Custom Spec Template\n\nThis is a custom template.\n")
-
-    return p_dir
-
-
-@pytest.fixture
-def project_dir(temp_dir):
-    """Create a mock spec-kit project directory."""
-    proj_dir = temp_dir / "project"
-    proj_dir.mkdir()
-
-    # Create .specify directory
-    specify_dir = proj_dir / ".specify"
-    specify_dir.mkdir()
-
-    # Create templates directory with core templates
-    templates_dir = specify_dir / "templates"
-    templates_dir.mkdir()
-
-    # Create core spec-template
-    core_spec = templates_dir / "spec-template.md"
-    core_spec.write_text("# Core Spec Template\n")
-
-    # Create core plan-template
-    core_plan = templates_dir / "plan-template.md"
-    core_plan.write_text("# Core Plan Template\n")
-
-    # Create commands subdirectory
-    commands_dir = templates_dir / "commands"
-    commands_dir.mkdir()
-
-    return proj_dir
-
-
-# ===== TemplatePackManifest Tests =====
-
-
-class TestTemplatePackManifest:
-    """Test TemplatePackManifest validation and parsing."""
-
-    def test_valid_manifest(self, pack_dir):
-        """Test loading a valid manifest."""
-        manifest = TemplatePackManifest(pack_dir / "template-pack.yml")
-        assert manifest.id == "test-pack"
-        assert manifest.name == "Test Template Pack"
-        assert manifest.version == "1.0.0"
-        assert manifest.description == "A test template pack"
-        assert manifest.author == "Test Author"
-        assert manifest.requires_speckit_version == ">=0.1.0"
-        assert len(manifest.templates) == 1
-        assert manifest.tags == ["testing", "example"]
-
-    def test_missing_manifest(self, temp_dir):
-        """Test that missing manifest raises error."""
-        with pytest.raises(TemplateValidationError, match="Manifest not found"):
-            TemplatePackManifest(temp_dir / "nonexistent.yml")
-
-    def test_invalid_yaml(self, temp_dir):
-        """Test that invalid YAML raises error."""
-        bad_file = temp_dir / "bad.yml"
-        bad_file.write_text(": invalid: yaml: {{{")
-        with pytest.raises(TemplateValidationError, match="Invalid YAML"):
-            TemplatePackManifest(bad_file)
-
-    def test_missing_schema_version(self, temp_dir, valid_pack_data):
-        """Test missing schema_version field."""
-        del valid_pack_data["schema_version"]
-        manifest_path = temp_dir / "template-pack.yml"
-        with open(manifest_path, 'w') as f:
-            yaml.dump(valid_pack_data, f)
-        with pytest.raises(TemplateValidationError, match="Missing required field: schema_version"):
-            TemplatePackManifest(manifest_path)
-
-    def test_wrong_schema_version(self, temp_dir, valid_pack_data):
-        """Test unsupported schema version."""
-        valid_pack_data["schema_version"] = "2.0"
-        manifest_path = temp_dir / "template-pack.yml"
-        with open(manifest_path, 'w') as f:
-            yaml.dump(valid_pack_data, f)
-        with pytest.raises(TemplateValidationError, match="Unsupported schema version"):
-            TemplatePackManifest(manifest_path)
-
-    def test_missing_pack_id(self, temp_dir, valid_pack_data):
-        """Test missing template_pack.id field."""
-        del valid_pack_data["template_pack"]["id"]
-        manifest_path = temp_dir / "template-pack.yml"
-        with open(manifest_path, 'w') as f:
-            yaml.dump(valid_pack_data, f)
-        with pytest.raises(TemplateValidationError, match="Missing template_pack.id"):
-            TemplatePackManifest(manifest_path)
-
-    def test_invalid_pack_id_format(self, temp_dir, valid_pack_data):
-        """Test invalid pack ID format."""
-        valid_pack_data["template_pack"]["id"] = "Invalid_ID"
-        manifest_path = temp_dir / "template-pack.yml"
-        with open(manifest_path, 'w') as f:
-            yaml.dump(valid_pack_data, f)
-        with pytest.raises(TemplateValidationError, match="Invalid template pack ID"):
-            TemplatePackManifest(manifest_path)
-
-    def test_invalid_version(self, temp_dir, valid_pack_data):
-        """Test invalid semantic version."""
-        valid_pack_data["template_pack"]["version"] = "not-a-version"
-        manifest_path = temp_dir / "template-pack.yml"
-        with open(manifest_path, 'w') as f:
-            yaml.dump(valid_pack_data, f)
-        with pytest.raises(TemplateValidationError, match="Invalid version"):
-            TemplatePackManifest(manifest_path)
-
-    def test_missing_speckit_version(self, temp_dir, valid_pack_data):
-        """Test missing requires.speckit_version."""
-        del valid_pack_data["requires"]["speckit_version"]
-        manifest_path = temp_dir / "template-pack.yml"
-        with open(manifest_path, 'w') as f:
-            yaml.dump(valid_pack_data, f)
-        with pytest.raises(TemplateValidationError, match="Missing requires.speckit_version"):
-            TemplatePackManifest(manifest_path)
-
-    def test_no_templates_provided(self, temp_dir, valid_pack_data):
-        """Test pack with no templates."""
-        valid_pack_data["provides"]["templates"] = []
-        manifest_path = temp_dir / "template-pack.yml"
-        with open(manifest_path, 'w') as f:
-            yaml.dump(valid_pack_data, f)
-        with pytest.raises(TemplateValidationError, match="must provide at least one template"):
-            TemplatePackManifest(manifest_path)
-
-    def test_invalid_template_type(self, temp_dir, valid_pack_data):
-        """Test template with invalid type."""
-        valid_pack_data["provides"]["templates"][0]["type"] = "invalid"
-        manifest_path = temp_dir / "template-pack.yml"
-        with open(manifest_path, 'w') as f:
-            yaml.dump(valid_pack_data, f)
-        with pytest.raises(TemplateValidationError, match="Invalid template type"):
-            TemplatePackManifest(manifest_path)
-
-    def test_valid_template_types(self):
-        """Test that all expected template types are valid."""
-        assert "artifact" in VALID_TEMPLATE_TYPES
-        assert "command" in VALID_TEMPLATE_TYPES
-        assert "script" in VALID_TEMPLATE_TYPES
-
-    def test_template_missing_required_fields(self, temp_dir, valid_pack_data):
-        """Test template missing required fields."""
-        valid_pack_data["provides"]["templates"] = [{"type": "artifact"}]
-        manifest_path = temp_dir / "template-pack.yml"
-        with open(manifest_path, 'w') as f:
-            yaml.dump(valid_pack_data, f)
-        with pytest.raises(TemplateValidationError, match="missing 'type', 'name', or 'file'"):
-            TemplatePackManifest(manifest_path)
-
-    def test_invalid_template_name_format(self, temp_dir, valid_pack_data):
-        """Test template with invalid name format."""
-        valid_pack_data["provides"]["templates"][0]["name"] = "Invalid Name"
-        manifest_path = temp_dir / "template-pack.yml"
-        with open(manifest_path, 'w') as f:
-            yaml.dump(valid_pack_data, f)
-        with pytest.raises(TemplateValidationError, match="Invalid template name"):
-            TemplatePackManifest(manifest_path)
-
-    def test_get_hash(self, pack_dir):
-        """Test manifest hash calculation."""
-        manifest = TemplatePackManifest(pack_dir / "template-pack.yml")
-        hash_val = manifest.get_hash()
-        assert hash_val.startswith("sha256:")
-        assert len(hash_val) > 10
-
-    def test_multiple_templates(self, temp_dir, valid_pack_data):
-        """Test pack with multiple templates of different types."""
-        valid_pack_data["provides"]["templates"] = [
-            {"type": "artifact", "name": "spec-template", "file": "templates/spec-template.md"},
-            {"type": "artifact", "name": "plan-template", "file": "templates/plan-template.md"},
-            {"type": "command", "name": "specify", "file": "commands/specify.md"},
-            {"type": "script", "name": "create-new-feature", "file": "scripts/create-new-feature.sh"},
-        ]
-        manifest_path = temp_dir / "template-pack.yml"
-        with open(manifest_path, 'w') as f:
-            yaml.dump(valid_pack_data, f)
-        manifest = TemplatePackManifest(manifest_path)
-        assert len(manifest.templates) == 4
-
-
-# ===== TemplatePackRegistry Tests =====
-
-
-class TestTemplatePackRegistry:
-    """Test TemplatePackRegistry operations."""
-
-    def test_empty_registry(self, temp_dir):
-        """Test empty registry initialization."""
-        packs_dir = temp_dir / "packs"
-        packs_dir.mkdir()
-        registry = TemplatePackRegistry(packs_dir)
-        assert registry.list() == {}
-        assert not registry.is_installed("test-pack")
-
-    def test_add_and_get(self, temp_dir):
-        """Test adding and retrieving a pack."""
-        packs_dir = temp_dir / "packs"
-        packs_dir.mkdir()
-        registry = TemplatePackRegistry(packs_dir)
-
-        registry.add("test-pack", {"version": "1.0.0", "source": "local"})
-        assert registry.is_installed("test-pack")
-
-        metadata = registry.get("test-pack")
-        assert metadata is not None
-        assert metadata["version"] == "1.0.0"
-        assert "installed_at" in metadata
-
-    def test_remove(self, temp_dir):
-        """Test removing a pack."""
-        packs_dir = temp_dir / "packs"
-        packs_dir.mkdir()
-        registry = TemplatePackRegistry(packs_dir)
-
-        registry.add("test-pack", {"version": "1.0.0"})
-        assert registry.is_installed("test-pack")
-
-        registry.remove("test-pack")
-        assert not registry.is_installed("test-pack")
-
-    def test_remove_nonexistent(self, temp_dir):
-        """Test removing a pack that doesn't exist."""
-        packs_dir = temp_dir / "packs"
-        packs_dir.mkdir()
-        registry = TemplatePackRegistry(packs_dir)
-        registry.remove("nonexistent")  # Should not raise
-
-    def test_list(self, temp_dir):
-        """Test listing all packs."""
-        packs_dir = temp_dir / "packs"
-        packs_dir.mkdir()
-        registry = TemplatePackRegistry(packs_dir)
-
-        registry.add("pack-a", {"version": "1.0.0"})
-        registry.add("pack-b", {"version": "2.0.0"})
-
-        all_packs = registry.list()
-        assert len(all_packs) == 2
-        assert "pack-a" in all_packs
-        assert "pack-b" in all_packs
-
-    def test_persistence(self, temp_dir):
-        """Test that registry data persists across instances."""
-        packs_dir = temp_dir / "packs"
-        packs_dir.mkdir()
-
-        # Add with first instance
-        registry1 = TemplatePackRegistry(packs_dir)
-        registry1.add("test-pack", {"version": "1.0.0"})
-
-        # Load with second instance
-        registry2 = TemplatePackRegistry(packs_dir)
-        assert registry2.is_installed("test-pack")
-
-    def test_corrupted_registry(self, temp_dir):
-        """Test recovery from corrupted registry file."""
-        packs_dir = temp_dir / "packs"
-        packs_dir.mkdir()
-
-        registry_file = packs_dir / ".registry"
-        registry_file.write_text("not valid json{{{")
-
-        registry = TemplatePackRegistry(packs_dir)
-        assert registry.list() == {}
-
-    def test_get_nonexistent(self, temp_dir):
-        """Test getting a nonexistent pack."""
-        packs_dir = temp_dir / "packs"
-        packs_dir.mkdir()
-        registry = TemplatePackRegistry(packs_dir)
-        assert registry.get("nonexistent") is None
-
-
-# ===== TemplatePackManager Tests =====
-
-
-class TestTemplatePackManager:
-    """Test TemplatePackManager installation and removal."""
-
-    def test_install_from_directory(self, project_dir, pack_dir):
-        """Test installing a template pack from a directory."""
-        manager = TemplatePackManager(project_dir)
-        manifest = manager.install_from_directory(pack_dir, "0.1.5")
-
-        assert manifest.id == "test-pack"
-        assert manager.registry.is_installed("test-pack")
-
-        # Verify files are copied
-        installed_dir = project_dir / ".specify" / "templates" / "packs" / "test-pack"
-        assert installed_dir.exists()
-        assert (installed_dir / "template-pack.yml").exists()
-        assert (installed_dir / "templates" / "spec-template.md").exists()
-
-    def test_install_already_installed(self, project_dir, pack_dir):
-        """Test installing an already-installed pack raises error."""
-        manager = TemplatePackManager(project_dir)
-        manager.install_from_directory(pack_dir, "0.1.5")
-
-        with pytest.raises(TemplateError, match="already installed"):
-            manager.install_from_directory(pack_dir, "0.1.5")
-
-    def test_install_incompatible(self, project_dir, temp_dir, valid_pack_data):
-        """Test installing an incompatible pack raises error."""
-        valid_pack_data["requires"]["speckit_version"] = ">=99.0.0"
-        incompat_dir = temp_dir / "incompat-pack"
-        incompat_dir.mkdir()
-        manifest_path = incompat_dir / "template-pack.yml"
-        with open(manifest_path, 'w') as f:
-            yaml.dump(valid_pack_data, f)
-        (incompat_dir / "templates").mkdir()
-        (incompat_dir / "templates" / "spec-template.md").write_text("test")
-
-        manager = TemplatePackManager(project_dir)
-        with pytest.raises(TemplateCompatibilityError):
-            manager.install_from_directory(incompat_dir, "0.1.5")
-
-    def test_install_from_zip(self, project_dir, pack_dir, temp_dir):
-        """Test installing from a ZIP file."""
-        zip_path = temp_dir / "test-pack.zip"
-        with zipfile.ZipFile(zip_path, 'w') as zf:
-            for file_path in pack_dir.rglob('*'):
-                if file_path.is_file():
-                    arcname = file_path.relative_to(pack_dir)
-                    zf.write(file_path, arcname)
-
-        manager = TemplatePackManager(project_dir)
-        manifest = manager.install_from_zip(zip_path, "0.1.5")
-        assert manifest.id == "test-pack"
-        assert manager.registry.is_installed("test-pack")
-
-    def test_install_from_zip_nested(self, project_dir, pack_dir, temp_dir):
-        """Test installing from ZIP with nested directory."""
-        zip_path = temp_dir / "test-pack.zip"
-        with zipfile.ZipFile(zip_path, 'w') as zf:
-            for file_path in pack_dir.rglob('*'):
-                if file_path.is_file():
-                    arcname = Path("test-pack-v1.0.0") / file_path.relative_to(pack_dir)
-                    zf.write(file_path, arcname)
-
-        manager = TemplatePackManager(project_dir)
-        manifest = manager.install_from_zip(zip_path, "0.1.5")
-        assert manifest.id == "test-pack"
-
-    def test_install_from_zip_no_manifest(self, project_dir, temp_dir):
-        """Test installing from ZIP without manifest raises error."""
-        zip_path = temp_dir / "bad.zip"
-        with zipfile.ZipFile(zip_path, 'w') as zf:
-            zf.writestr("readme.txt", "no manifest here")
-
-        manager = TemplatePackManager(project_dir)
-        with pytest.raises(TemplateValidationError, match="No template-pack.yml found"):
-            manager.install_from_zip(zip_path, "0.1.5")
-
-    def test_remove(self, project_dir, pack_dir):
-        """Test removing a template pack."""
-        manager = TemplatePackManager(project_dir)
-        manager.install_from_directory(pack_dir, "0.1.5")
-        assert manager.registry.is_installed("test-pack")
-
-        result = manager.remove("test-pack")
-        assert result is True
-        assert not manager.registry.is_installed("test-pack")
-
-        installed_dir = project_dir / ".specify" / "templates" / "packs" / "test-pack"
-        assert not installed_dir.exists()
-
-    def test_remove_nonexistent(self, project_dir):
-        """Test removing a pack that doesn't exist."""
-        manager = TemplatePackManager(project_dir)
-        result = manager.remove("nonexistent")
-        assert result is False
-
-    def test_list_installed(self, project_dir, pack_dir):
-        """Test listing installed packs."""
-        manager = TemplatePackManager(project_dir)
-        manager.install_from_directory(pack_dir, "0.1.5")
-
-        installed = manager.list_installed()
-        assert len(installed) == 1
-        assert installed[0]["id"] == "test-pack"
-        assert installed[0]["name"] == "Test Template Pack"
-        assert installed[0]["version"] == "1.0.0"
-        assert installed[0]["template_count"] == 1
-
-    def test_list_installed_empty(self, project_dir):
-        """Test listing when no packs installed."""
-        manager = TemplatePackManager(project_dir)
-        assert manager.list_installed() == []
-
-    def test_get_pack(self, project_dir, pack_dir):
-        """Test getting a specific installed pack."""
-        manager = TemplatePackManager(project_dir)
-        manager.install_from_directory(pack_dir, "0.1.5")
-
-        pack = manager.get_pack("test-pack")
-        assert pack is not None
-        assert pack.id == "test-pack"
-
-    def test_get_pack_not_installed(self, project_dir):
-        """Test getting a non-installed pack returns None."""
-        manager = TemplatePackManager(project_dir)
-        assert manager.get_pack("nonexistent") is None
-
-    def test_check_compatibility_valid(self, pack_dir):
-        """Test compatibility check with valid version."""
-        manager = TemplatePackManager(Path(tempfile.mkdtemp()))
-        manifest = TemplatePackManifest(pack_dir / "template-pack.yml")
-        assert manager.check_compatibility(manifest, "0.1.5") is True
-
-    def test_check_compatibility_invalid(self, pack_dir):
-        """Test compatibility check with invalid specifier."""
-        manager = TemplatePackManager(Path(tempfile.mkdtemp()))
-        manifest = TemplatePackManifest(pack_dir / "template-pack.yml")
-        manifest.data["requires"]["speckit_version"] = "not-a-specifier"
-        with pytest.raises(TemplateCompatibilityError, match="Invalid version specifier"):
-            manager.check_compatibility(manifest, "0.1.5")
-
-
-# ===== TemplateResolver Tests =====
-
-
-class TestTemplateResolver:
-    """Test TemplateResolver priority stack."""
-
-    def test_resolve_core_template(self, project_dir):
-        """Test resolving a core template."""
-        resolver = TemplateResolver(project_dir)
-        result = resolver.resolve("spec-template")
-        assert result is not None
-        assert result.name == "spec-template.md"
-        assert "Core Spec Template" in result.read_text()
-
-    def test_resolve_nonexistent(self, project_dir):
-        """Test resolving a nonexistent template returns None."""
-        resolver = TemplateResolver(project_dir)
-        result = resolver.resolve("nonexistent-template")
-        assert result is None
-
-    def test_resolve_override_takes_priority(self, project_dir):
-        """Test that project overrides take priority over core."""
-        # Create override
-        overrides_dir = project_dir / ".specify" / "templates" / "overrides"
-        overrides_dir.mkdir(parents=True)
-        override = overrides_dir / "spec-template.md"
-        override.write_text("# Override Spec Template\n")
-
-        resolver = TemplateResolver(project_dir)
-        result = resolver.resolve("spec-template")
-        assert result is not None
-        assert "Override Spec Template" in result.read_text()
-
-    def test_resolve_pack_takes_priority_over_core(self, project_dir, pack_dir):
-        """Test that installed packs take priority over core templates."""
-        # Install the pack
-        manager = TemplatePackManager(project_dir)
-        manager.install_from_directory(pack_dir, "0.1.5")
-
-        resolver = TemplateResolver(project_dir)
-        result = resolver.resolve("spec-template")
-        assert result is not None
-        assert "Custom Spec Template" in result.read_text()
-
-    def test_resolve_override_takes_priority_over_pack(self, project_dir, pack_dir):
-        """Test that overrides take priority over installed packs."""
-        # Install the pack
-        manager = TemplatePackManager(project_dir)
-        manager.install_from_directory(pack_dir, "0.1.5")
-
-        # Create override
-        overrides_dir = project_dir / ".specify" / "templates" / "overrides"
-        overrides_dir.mkdir(parents=True)
-        override = overrides_dir / "spec-template.md"
-        override.write_text("# Override Spec Template\n")
-
-        resolver = TemplateResolver(project_dir)
-        result = resolver.resolve("spec-template")
-        assert result is not None
-        assert "Override Spec Template" in result.read_text()
-
-    def test_resolve_extension_provided_templates(self, project_dir):
-        """Test resolving templates provided by extensions."""
-        # Create extension with templates
-        ext_dir = project_dir / ".specify" / "extensions" / "my-ext"
-        ext_templates_dir = ext_dir / "templates"
-        ext_templates_dir.mkdir(parents=True)
-        ext_template = ext_templates_dir / "custom-template.md"
-        ext_template.write_text("# Extension Custom Template\n")
-
-        resolver = TemplateResolver(project_dir)
-        result = resolver.resolve("custom-template")
-        assert result is not None
-        assert "Extension Custom Template" in result.read_text()
-
-    def test_resolve_pack_over_extension(self, project_dir, pack_dir, temp_dir, valid_pack_data):
-        """Test that pack templates take priority over extension templates."""
-        # Create extension with templates
-        ext_dir = project_dir / ".specify" / "extensions" / "my-ext"
-        ext_templates_dir = ext_dir / "templates"
-        ext_templates_dir.mkdir(parents=True)
-        ext_template = ext_templates_dir / "spec-template.md"
-        ext_template.write_text("# Extension Spec Template\n")
-
-        # Install a pack with the same template
-        manager = TemplatePackManager(project_dir)
-        manager.install_from_directory(pack_dir, "0.1.5")
-
-        resolver = TemplateResolver(project_dir)
-        result = resolver.resolve("spec-template")
-        assert result is not None
-        # Pack should win over extension
-        assert "Custom Spec Template" in result.read_text()
-
-    def test_resolve_with_source_core(self, project_dir):
-        """Test resolve_with_source for core template."""
-        resolver = TemplateResolver(project_dir)
-        result = resolver.resolve_with_source("spec-template")
-        assert result is not None
-        assert result["source"] == "core"
-        assert "spec-template.md" in result["path"]
-
-    def test_resolve_with_source_override(self, project_dir):
-        """Test resolve_with_source for override template."""
-        overrides_dir = project_dir / ".specify" / "templates" / "overrides"
-        overrides_dir.mkdir(parents=True)
-        override = overrides_dir / "spec-template.md"
-        override.write_text("# Override\n")
-
-        resolver = TemplateResolver(project_dir)
-        result = resolver.resolve_with_source("spec-template")
-        assert result is not None
-        assert result["source"] == "project override"
-
-    def test_resolve_with_source_pack(self, project_dir, pack_dir):
-        """Test resolve_with_source for pack template."""
-        manager = TemplatePackManager(project_dir)
-        manager.install_from_directory(pack_dir, "0.1.5")
-
-        resolver = TemplateResolver(project_dir)
-        result = resolver.resolve_with_source("spec-template")
-        assert result is not None
-        assert "test-pack" in result["source"]
-        assert "v1.0.0" in result["source"]
-
-    def test_resolve_with_source_extension(self, project_dir):
-        """Test resolve_with_source for extension-provided template."""
-        ext_dir = project_dir / ".specify" / "extensions" / "my-ext"
-        ext_templates_dir = ext_dir / "templates"
-        ext_templates_dir.mkdir(parents=True)
-        ext_template = ext_templates_dir / "unique-template.md"
-        ext_template.write_text("# Unique\n")
-
-        resolver = TemplateResolver(project_dir)
-        result = resolver.resolve_with_source("unique-template")
-        assert result is not None
-        assert result["source"] == "extension:my-ext"
-
-    def test_resolve_with_source_not_found(self, project_dir):
-        """Test resolve_with_source for nonexistent template."""
-        resolver = TemplateResolver(project_dir)
-        result = resolver.resolve_with_source("nonexistent")
-        assert result is None
-
-    def test_resolve_skips_hidden_extension_dirs(self, project_dir):
-        """Test that hidden directories in extensions are skipped."""
-        ext_dir = project_dir / ".specify" / "extensions" / ".backup"
-        ext_templates_dir = ext_dir / "templates"
-        ext_templates_dir.mkdir(parents=True)
-        ext_template = ext_templates_dir / "hidden-template.md"
-        ext_template.write_text("# Hidden\n")
-
-        resolver = TemplateResolver(project_dir)
-        result = resolver.resolve("hidden-template")
-        assert result is None
-
-
-# ===== TemplateCatalog Tests =====
-
-
-class TestTemplateCatalog:
-    """Test template catalog functionality."""
-
-    def test_default_catalog_url(self, project_dir):
-        """Test default catalog URL."""
-        catalog = TemplateCatalog(project_dir)
-        assert "githubusercontent.com" in catalog.DEFAULT_CATALOG_URL
-        assert "templates/catalog.json" in catalog.DEFAULT_CATALOG_URL
-
-    def test_community_catalog_url(self, project_dir):
-        """Test community catalog URL."""
-        catalog = TemplateCatalog(project_dir)
-        assert "templates/catalog.community.json" in catalog.COMMUNITY_CATALOG_URL
-
-    def test_cache_validation_no_cache(self, project_dir):
-        """Test cache validation when no cache exists."""
-        catalog = TemplateCatalog(project_dir)
-        assert catalog.is_cache_valid() is False
-
-    def test_cache_validation_valid(self, project_dir):
-        """Test cache validation with valid cache."""
-        catalog = TemplateCatalog(project_dir)
-        catalog.cache_dir.mkdir(parents=True, exist_ok=True)
-
-        catalog.cache_file.write_text(json.dumps({
-            "schema_version": "1.0",
-            "template_packs": {},
-        }))
-        catalog.cache_metadata_file.write_text(json.dumps({
-            "cached_at": datetime.now(timezone.utc).isoformat(),
-        }))
-
-        assert catalog.is_cache_valid() is True
-
-    def test_cache_validation_expired(self, project_dir):
-        """Test cache validation with expired cache."""
-        catalog = TemplateCatalog(project_dir)
-        catalog.cache_dir.mkdir(parents=True, exist_ok=True)
-
-        catalog.cache_file.write_text(json.dumps({
-            "schema_version": "1.0",
-            "template_packs": {},
-        }))
-        catalog.cache_metadata_file.write_text(json.dumps({
-            "cached_at": "2020-01-01T00:00:00+00:00",
-        }))
-
-        assert catalog.is_cache_valid() is False
-
-    def test_cache_validation_corrupted(self, project_dir):
-        """Test cache validation with corrupted metadata."""
-        catalog = TemplateCatalog(project_dir)
-        catalog.cache_dir.mkdir(parents=True, exist_ok=True)
-
-        catalog.cache_file.write_text("not json")
-        catalog.cache_metadata_file.write_text("not json")
-
-        assert catalog.is_cache_valid() is False
-
-    def test_clear_cache(self, project_dir):
-        """Test clearing the cache."""
-        catalog = TemplateCatalog(project_dir)
-        catalog.cache_dir.mkdir(parents=True, exist_ok=True)
-        catalog.cache_file.write_text("{}")
-        catalog.cache_metadata_file.write_text("{}")
-
-        catalog.clear_cache()
-
-        assert not catalog.cache_file.exists()
-        assert not catalog.cache_metadata_file.exists()
-
-    def test_search_with_cached_data(self, project_dir):
-        """Test search with cached catalog data."""
-        catalog = TemplateCatalog(project_dir)
-        catalog.cache_dir.mkdir(parents=True, exist_ok=True)
-
-        catalog_data = {
-            "schema_version": "1.0",
-            "template_packs": {
-                "safe-agile": {
-                    "name": "SAFe Agile Templates",
-                    "description": "SAFe-aligned templates",
-                    "author": "agile-community",
-                    "version": "1.0.0",
-                    "tags": ["safe", "agile"],
-                },
-                "healthcare": {
-                    "name": "Healthcare Compliance",
-                    "description": "HIPAA-compliant templates",
-                    "author": "healthcare-org",
-                    "version": "1.0.0",
-                    "tags": ["healthcare", "hipaa"],
-                },
-            }
-        }
-
-        catalog.cache_file.write_text(json.dumps(catalog_data))
-        catalog.cache_metadata_file.write_text(json.dumps({
-            "cached_at": datetime.now(timezone.utc).isoformat(),
-        }))
-
-        # Search by query
-        results = catalog.search(query="agile")
-        assert len(results) == 1
-        assert results[0]["id"] == "safe-agile"
-
-        # Search by tag
-        results = catalog.search(tag="hipaa")
-        assert len(results) == 1
-        assert results[0]["id"] == "healthcare"
-
-        # Search by author
-        results = catalog.search(author="agile-community")
-        assert len(results) == 1
-
-        # Search all
-        results = catalog.search()
-        assert len(results) == 2
-
-    def test_get_pack_info(self, project_dir):
-        """Test getting info for a specific pack."""
-        catalog = TemplateCatalog(project_dir)
-        catalog.cache_dir.mkdir(parents=True, exist_ok=True)
-
-        catalog_data = {
-            "schema_version": "1.0",
-            "template_packs": {
-                "test-pack": {
-                    "name": "Test Pack",
-                    "version": "1.0.0",
-                },
-            }
-        }
-
-        catalog.cache_file.write_text(json.dumps(catalog_data))
-        catalog.cache_metadata_file.write_text(json.dumps({
-            "cached_at": datetime.now(timezone.utc).isoformat(),
-        }))
-
-        info = catalog.get_pack_info("test-pack")
-        assert info is not None
-        assert info["name"] == "Test Pack"
-        assert info["id"] == "test-pack"
-
-        assert catalog.get_pack_info("nonexistent") is None
-
-    def test_validate_catalog_url_https(self, project_dir):
-        """Test that HTTPS URLs are accepted."""
-        catalog = TemplateCatalog(project_dir)
-        catalog._validate_catalog_url("https://example.com/catalog.json")
-
-    def test_validate_catalog_url_http_rejected(self, project_dir):
-        """Test that HTTP URLs are rejected."""
-        catalog = TemplateCatalog(project_dir)
-        with pytest.raises(TemplateValidationError, match="must use HTTPS"):
-            catalog._validate_catalog_url("http://example.com/catalog.json")
-
-    def test_validate_catalog_url_localhost_http_allowed(self, project_dir):
-        """Test that HTTP is allowed for localhost."""
-        catalog = TemplateCatalog(project_dir)
-        catalog._validate_catalog_url("http://localhost:8080/catalog.json")
-        catalog._validate_catalog_url("http://127.0.0.1:8080/catalog.json")
-
-    def test_env_var_catalog_url(self, project_dir, monkeypatch):
-        """Test catalog URL from environment variable."""
-        monkeypatch.setenv("SPECKIT_TEMPLATE_CATALOG_URL", "https://custom.example.com/catalog.json")
-        catalog = TemplateCatalog(project_dir)
-        assert catalog.get_catalog_url() == "https://custom.example.com/catalog.json"
-
-
-# ===== Integration Tests =====
-
-
-class TestIntegration:
-    """Integration tests for complete template pack workflows."""
-
-    def test_full_install_resolve_remove_cycle(self, project_dir, pack_dir):
-        """Test complete lifecycle: install → resolve → remove."""
-        # Install
-        manager = TemplatePackManager(project_dir)
-        manifest = manager.install_from_directory(pack_dir, "0.1.5")
-        assert manifest.id == "test-pack"
-
-        # Resolve — pack template should win over core
-        resolver = TemplateResolver(project_dir)
-        result = resolver.resolve("spec-template")
-        assert result is not None
-        assert "Custom Spec Template" in result.read_text()
-
-        # Remove
-        manager.remove("test-pack")
-
-        # Resolve — should fall back to core
-        result = resolver.resolve("spec-template")
-        assert result is not None
-        assert "Core Spec Template" in result.read_text()
-
-    def test_override_beats_pack_beats_extension_beats_core(self, project_dir, pack_dir):
-        """Test the full priority stack: override > pack > extension > core."""
-        resolver = TemplateResolver(project_dir)
-
-        # Core should resolve
-        result = resolver.resolve_with_source("spec-template")
-        assert result["source"] == "core"
-
-        # Add extension template
-        ext_dir = project_dir / ".specify" / "extensions" / "my-ext"
-        ext_templates_dir = ext_dir / "templates"
-        ext_templates_dir.mkdir(parents=True)
-        (ext_templates_dir / "spec-template.md").write_text("# Extension\n")
-
-        result = resolver.resolve_with_source("spec-template")
-        assert result["source"] == "extension:my-ext"
-
-        # Install pack — should win over extension
-        manager = TemplatePackManager(project_dir)
-        manager.install_from_directory(pack_dir, "0.1.5")
-
-        result = resolver.resolve_with_source("spec-template")
-        assert "test-pack" in result["source"]
-
-        # Add override — should win over pack
-        overrides_dir = project_dir / ".specify" / "templates" / "overrides"
-        overrides_dir.mkdir(parents=True)
-        (overrides_dir / "spec-template.md").write_text("# Override\n")
-
-        result = resolver.resolve_with_source("spec-template")
-        assert result["source"] == "project override"
-
-    def test_install_from_zip_then_resolve(self, project_dir, pack_dir, temp_dir):
-        """Test installing from ZIP and then resolving."""
-        # Create ZIP
-        zip_path = temp_dir / "test-pack.zip"
-        with zipfile.ZipFile(zip_path, 'w') as zf:
-            for file_path in pack_dir.rglob('*'):
-                if file_path.is_file():
-                    arcname = file_path.relative_to(pack_dir)
-                    zf.write(file_path, arcname)
-
-        # Install
-        manager = TemplatePackManager(project_dir)
-        manager.install_from_zip(zip_path, "0.1.5")
-
-        # Resolve
-        resolver = TemplateResolver(project_dir)
-        result = resolver.resolve("spec-template")
-        assert result is not None
-        assert "Custom Spec Template" in result.read_text()