test(templates): add comprehensive unit tests for template pack system

Co-authored-by: mnriem <15701806+mnriem@users.noreply.github.com>

CHANGELOG.md

@@ -7,6 +7,58 @@ 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
+
+- fix: sync agent list comments with actual supported agents (#1785)
+- feat(extensions): support multiple active catalogs simultaneously (#1720)
+- Pavel/add tabnine cli support (#1503)
+- Add Understanding extension to community catalog (#1778)
+- Add ralph extension to community catalog (#1780)
+- Update README with project initialization instructions (#1772)
+- feat: add review extension to community catalog (#1775)
+- Add fleet extension to community catalog (#1771)
+- Integration of Mistral vibe support into speckit (#1725)
+- fix: Remove duplicate options in specify.md (#1765)
+- fix: use global branch numbering instead of per-short-name detection (#1757)
+- Add Community Walkthroughs section to README (#1766)
+- feat(extensions): add Jira Integration to community catalog (#1764)
+- Add Azure DevOps Integration extension to community catalog (#1734)
+- Fix docs: update Antigravity link and add initialization example (#1748)
+- fix: wire after_tasks and after_implement hook events into command templates (#1702)
+- make c ignores consistent with c++ (#1747)
+- chore: bump version to 0.1.13 (#1746)
+- feat: add kiro-cli and AGENT_CONFIG consistency coverage (#1690)
+- feat: add verify extension to community catalog (#1726)
+- Add Retrospective Extension to community catalog README table (#1741)
+- fix(scripts): add empty description validation and branch checkout error handling (#1559)
+- fix: correct Copilot extension command registration (#1724)
+- fix(implement): remove Makefile from C ignore patterns (#1558)
+- Add sync extension to community catalog (#1728)
+- fix(checklist): clarify file handling behavior for append vs create (#1556)
+- fix(clarify): correct conflicting question limit from 10 to 5 (#1557)
+- chore: bump version to 0.1.12 (#1737)
+- fix: use RELEASE_PAT so tag push triggers release workflow (#1736)
+- fix: release-trigger uses release branch + PR instead of direct push to main (#1733)
+- fix: Split release process to sync pyproject.toml version with git tags (#1732)
+
+
 ## [0.1.14] - 2026-03-09
 
 ### Added

README.md

@@ -421,7 +421,7 @@ specify init . --force --ai claude
 specify init --here --force --ai claude
 ```
 
-The CLI will check if you have Claude Code, Gemini CLI, Cursor CLI, Qwen CLI, opencode, Codex CLI, Qoder CLI, Tabnine CLI, or Kiro CLI installed. If you do not, or you prefer to get the templates without checking for the right tools, use `--ignore-agent-tools` with your command:
+The CLI will check if you have Claude Code, Gemini CLI, Cursor CLI, Qwen CLI, opencode, Codex CLI, Qoder CLI, Tabnine CLI, Kiro CLI, or Mistral Vibe installed. If you do not, or you prefer to get the templates without checking for the right tools, use `--ignore-agent-tools` with your command:
 
 ```bash
 specify init <project_name> --ai claude --ignore-agent-tools

pyproject.toml

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

scripts/bash/common.sh

@@ -154,3 +154,44 @@ 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,6 +166,7 @@ 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)
@@ -296,9 +297,9 @@ fi
 FEATURE_DIR="$SPECS_DIR/$BRANCH_NAME"
 mkdir -p "$FEATURE_DIR"
 
-TEMPLATE="$REPO_ROOT/.specify/templates/spec-template.md"
+TEMPLATE=$(resolve_template "spec-template" "$REPO_ROOT")
 SPEC_FILE="$FEATURE_DIR/spec.md"
-if [ -f "$TEMPLATE" ]; then cp "$TEMPLATE" "$SPEC_FILE"; else touch "$SPEC_FILE"; fi
+if [ -n "$TEMPLATE" ] && [ -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="$REPO_ROOT/.specify/templates/plan-template.md"
-if [[ -f "$TEMPLATE" ]]; then
+TEMPLATE=$(resolve_template "plan-template" "$REPO_ROOT")
+if [[ -n "$TEMPLATE" ]] && [[ -f "$TEMPLATE" ]]; then
     cp "$TEMPLATE" "$IMPL_PLAN"
     echo "Copied plan template to $IMPL_PLAN"
 else
-    echo "Warning: Plan template not found at $TEMPLATE"
+    echo "Warning: Plan template not found"
     # Create a basic plan file if template doesn't exist
     touch "$IMPL_PLAN"
 fi

scripts/bash/update-agent-context.sh

@@ -30,7 +30,7 @@
 #
 # 5. Multi-Agent Support
 #    - Handles agent-specific file paths and naming conventions
-#    - Supports: Claude, Gemini, Copilot, Cursor, Qwen, opencode, Codex, Windsurf, Kilo Code, Auggie CLI, Roo Code, CodeBuddy CLI, Qoder CLI, Amp, SHAI, Tabnine CLI, Kiro CLI, Mistral Vibe or Antigravity
+#    - Supports: Claude, Gemini, Copilot, Cursor, Qwen, opencode, Codex, Windsurf, Kilo Code, Auggie CLI, Roo Code, CodeBuddy CLI, Qoder CLI, Amp, SHAI, Tabnine CLI, Kiro CLI, Mistral Vibe, Antigravity or Generic
 #    - Can update single agents or all existing agent files
 #    - Creates default Claude file if no agent files exist
 #

scripts/powershell/common.ps1

@@ -135,3 +135,45 @@ 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,6 +141,9 @@ 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) {
@@ -276,9 +279,9 @@ if ($hasGit) {
 $featureDir = Join-Path $specsDir $branchName
 New-Item -ItemType Directory -Path $featureDir -Force | Out-Null
 
-$template = Join-Path $repoRoot '.specify/templates/spec-template.md'
+$template = Resolve-Template -TemplateName 'spec-template' -RepoRoot $repoRoot
 $specFile = Join-Path $featureDir 'spec.md'
-if (Test-Path $template) { 
+if ($template -and (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 = Join-Path $paths.REPO_ROOT '.specify/templates/plan-template.md'
-if (Test-Path $template) { 
+$template = Resolve-Template -TemplateName 'plan-template' -RepoRoot $paths.REPO_ROOT
+if ($template -and (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 at $template"
+    Write-Warning "Plan template not found"
     # Create a basic plan file if template doesn't exist
     New-Item -ItemType File -Path $paths.IMPL_PLAN -Force | Out-Null
 }

scripts/powershell/update-agent-context.ps1

@@ -9,7 +9,7 @@ Mirrors the behavior of scripts/bash/update-agent-context.sh:
  2. Plan Data Extraction
  3. Agent File Management (create from template or update existing)
  4. Content Generation (technology stack, recent changes, timestamp)
- 5. Multi-Agent Support (claude, gemini, copilot, cursor-agent, qwen, opencode, codex, windsurf, kilocode, auggie, roo, codebuddy, amp, shai, tabnine, kiro-cli, agy, bob, vibe, qodercli)
+ 5. Multi-Agent Support (claude, gemini, copilot, cursor-agent, qwen, opencode, codex, windsurf, kilocode, auggie, roo, codebuddy, amp, shai, tabnine, kiro-cli, agy, bob, vibe, qodercli, generic)
 
 .PARAMETER AgentType
 Optional agent key to update a single agent. If omitted, updates all existing agent files (creating a default Claude file if none exist).

src/specify_cli/__init__.py

@@ -1272,6 +1272,7 @@ 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.
@@ -1300,6 +1301,7 @@ 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()
@@ -1542,6 +1544,27 @@ 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))
@@ -1779,6 +1802,13 @@ 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."""
@@ -1801,6 +1831,227 @@ 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

@@ -0,0 +1,938 @@
+"""
+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

@@ -0,0 +1,6 @@
+{
+  "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

@@ -0,0 +1,6 @@
+{
+  "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

@@ -0,0 +1,49 @@
+# 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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,21 @@
+# 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

@@ -0,0 +1,923 @@
+"""
+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()