prjct-cli 0.25.2 → 0.28.0

package/CHANGELOG.md

@@ -1,5 +1,238 @@
 # Changelog
 
+## [0.28.0] - 2026-01-10
+
+### Feature: Claude Code Native Integration
+
+**Skills as First-Class Citizens**: prjct commands are now installed as Claude Code Skills for automatic discovery.
+
+- **SessionStart Hook**: Injects fresh project context at session start via `~/.claude/hooks/prjct-session-start.sh`
+- **Skills Auto-Install**: 4 skills installed to `~/.claude/skills/` during `npm install`:
+  - `prjct-task` - Start tasks with classification
+  - `prjct-sync` - Analyze codebase, generate agents
+  - `prjct-done` - Complete current subtask
+  - `prjct-ship` - Ship with PR + version bump
+- **Setup Integration**: `core/infrastructure/setup.ts` now installs hooks and skills automatically
+- **Simplified CLAUDE.md**: Reduced global template from 221 to ~50 lines - hooks handle fresh context
+
+**Upgrade Impact**: Run `npm install -g prjct-cli` to install hooks and skills.
+
+---
+
+## [0.27.0] - 2026-01-08
+
+### Fix: prjct Commit Signature (CRITICAL)
+
+**Problem:** Commits were only showing Claude's Co-Authored-By, missing the prjct signature.
+
+**Solution:** Made prjct signature NON-NEGOTIABLE in all commit-related templates:
+- `templates/commands/ship.md` - Updated commit format with HEREDOC
+- `templates/commands/git.md` - Updated commit message format
+- `CLAUDE.md` and `templates/global/CLAUDE.md` - Made footer CRITICAL
+
+**Correct commit format:**
+```
+feat: description
+
+🤖 Generated with [p/](https://www.prjct.app/)
+Designed for [Claude](https://www.anthropic.com/claude)
+
+```
+
+The `🤖 Generated with [p/]` line MUST appear in ALL prjct commits.
+
+---
+
+### Feature: Claude Code Skill Integration (AGENTIC)
+
+Agents are now linked to Claude Code skills from claude-plugins.dev. **Skills are discovered and installed AGENTICALLY** - Claude searches the marketplace dynamically to find the best matching skill for each agent.
+
+**New Capabilities:**
+
+1. **Agentic Skill Discovery** (`p. sync` Step 7.5)
+   - Searches `https://claude-plugins.dev/skills?q={searchTerm}` for each agent
+   - Analyzes results: prefers @anthropics, high downloads, recent updates
+   - Downloads skill content from GitHub source
+   - Installs to `~/.claude/skills/{name}.md`
+   - Creates custom skill if no marketplace match found
+   - Updates agent frontmatter with discovered skill name
+
+2. **Skill Invocation in Tasks** (`p. task`)
+   - Phase 2 (Exploration): Invokes skills based on task type
+   - Phase 4 (Design): Loads agent skills for domain expertise
+   - Example: UI tasks automatically use `/frontend-design`
+
+3. **Agent → Skill Mapping**
+
+   | Agent | Skill | Source |
+   |-------|-------|--------|
+   | `frontend.md` | `frontend-design` | @anthropics/claude-code-plugins |
+   | `uxui.md` | `frontend-design` | @anthropics/claude-code-plugins |
+   | `backend.md` | `javascript-typescript` | @wshobson/claude-code-workflows |
+   | `testing.md` | `developer-kit` | @claudebase/marketplace |
+   | `devops.md` | `developer-kit` | @claudebase/marketplace |
+   | `prjct-planner.md` | `feature-dev` | @anthropics/claude-code-plugins |
+   | `prjct-shipper.md` | `code-review` | @anthropics/claude-code-plugins |
+
+**New Files:**
+
+- `templates/config/skill-mappings.json` - Maps agents to skills
+- `templates/agentic/skill-integration.md` - Integration guide
+
+**Updated Files:**
+
+- `templates/commands/sync.md` - Added Step 7.5 for skill installation
+- `templates/commands/task.md` - Added skill invocation in Phase 2 & 4
+- `templates/agentic/subagent-generation.md` - Added skills to agent format
+- All subagent templates - Added `skills` field to frontmatter
+- `templates/global/CLAUDE.md` - Added skill integration section
+- `CLAUDE.md` - Added skill integration docs
+
+**Why This Matters:**
+
+- `frontend-design` provides anti-AI-slop patterns (no Inter + purple gradients)
+- `code-review` ensures quality before shipping
+- `javascript-typescript` provides Node.js/TypeScript best practices
+- `developer-kit` provides testing and DevOps automation
+
+**Usage:**
+
+```bash
+p. sync                        # Installs skills automatically
+p. task "create login form"    # Uses frontend-design skill
+p. ship "auth"                 # Uses code-review skill
+```
+
+---
+
+## [0.26.1] - 2026-01-08
+
+### Fix: Claude Context Efficiency (Critical)
+
+**Problem:** After v0.26.0, Claude was losing context, not analyzing properly, not applying skills, and making poor decisions across ALL commands.
+
+**Root Cause:**
+1. Templates were too long and procedural (~7000 lines total)
+2. `task.md` had 791 lines of pseudo-code scripts
+3. CLAUDE.md only referenced docs but Claude didn't read them proactively
+4. 11-phase workflow created too much cognitive overhead
+5. `context/CLAUDE.md` generated by sync only had stats, no behavioral rules
+
+**Solution:**
+
+1. **Simplified `task.md`**: 791 → 277 lines (65% reduction)
+   - Removed procedural bloat
+   - Focus on GUIDANCE not SCRIPTS
+   - Claude uses intelligence to adapt, not follow rigidly
+
+2. **Enhanced `templates/global/CLAUDE.md`**: 75 → 177 lines
+   - Added "HOW TO USE PRJCT" section
+   - Included architecture inline (not just references)
+   - Added "INTELLIGENT BEHAVIOR" section
+   - Key insight: "Templates are GUIDANCE, not scripts"
+
+3. **Rich `context/CLAUDE.md` on sync**: Complete rewrite
+   - Added "MANDATORY RULES (DO NOT IGNORE)" section
+   - Added "DO vs DON'T" table for clear behavior
+   - Added "HOW TO USE PRJCT" with command reference
+   - Added "EXPECTED BEHAVIOR" guidelines
+   - Includes current state, available agents
+   - **ALWAYS OVERWRITE on sync** to ensure latest rules
+
+4. **Reduced workflow complexity**: 11 → 5 phases for `p. task`
+   - Discovery → Exploration → Questions → Design → Implementation
+   - Simpler mental model, less overhead
+
+**Key Changes:**
+- `p. sync` now overwrites `context/CLAUDE.md` with rich behavioral context
+- Rules are NON-NEGOTIABLE and clearly marked
+- Claude gets explicit DO/DON'T guidance
+- All commands benefit from consistent context
+
+5. **TRULY Agentic Project Analysis (NEW)**
+   - Detects ecosystem: Ruby, Python, Go, Rust, Node.js, PHP, Java, .NET, Elixir, etc.
+   - Detects project type: Rails, Django, Next.js, Go API, etc.
+   - Analyzes ACTUAL files to determine commands
+   - No hardcoded rules - Claude REASONS about what it finds
+   - Saves to `analysis/repo-analysis.json`
+
+6. **Contextual CLAUDE.md (Ecosystem-Aware)**
+   - Shows correct commands for THIS ecosystem
+   - Rails: `bundle install`, `rails s`, `rspec`
+   - Python: `poetry install`, `pytest`
+   - Go: `go build`, `go test ./...`
+   - Node/bun: `bun install`, `bun test`
+   - Project-specific DO/DON'T table based on analysis
+
+**Example: Rails project generates:**
+```
+Ecosystem: Ruby | Type: Rails
+Commands:
+- Install: bundle install
+- Dev server: rails s
+- Tests: rspec
+- Migrations: rails db:migrate
+```
+
+**Example: Go project generates:**
+```
+Ecosystem: Go | Type: Go API
+Commands:
+- Build: go build
+- Tests: go test ./...
+- Run: go run .
+```
+
+**Files Changed:**
+- `templates/global/CLAUDE.md` - Rich context, intelligent guidance
+- `templates/commands/task.md` - Simplified, agentic approach
+- `templates/commands/sync.md` - Agentic analysis + contextual CLAUDE.md
+- `CLAUDE.md` - Updated project docs
+- `package.json` - Version bump
+
+## [0.26.0] - 2026-01-01
+
+### Complete Development Cycle with Workflow Integrity
+
+Major feature: 11-phase workflow system that ensures all development steps are completed. No more skipped version bumps, missing changelogs, or untracked ships.
+
+**New Commands:**
+- `p. test` - Run tests, advance from implement → test phase
+- `p. review` - MCP code review + GitHub approvals, advance test → review
+- `p. merge` - Merge PR to main, advance review → merge
+- `p. verify` - Validate all 11 checkpoints complete, close workflow
+
+**Workflow Phases:**
+```
+p. task → (implement) → p. test → p. review → p. merge → p. ship → p. verify
+```
+
+| Phase | Command | Action |
+|-------|---------|--------|
+| 1. analyze | p. task | PM agent breakdown |
+| 2. branch | p. task | Create feature branch |
+| 3. implement | (manual) | Write code |
+| 4. test | p. test | Run tests |
+| 5. review | p. review | MCP + GitHub approvals |
+| 6. merge | p. merge | Merge PR |
+| 7-10. ship | p. ship | Tag, release, deploy, register |
+| 11. verify | p. verify | Validate & close |
+
+**Phase Validation:**
+Each command validates the workflow phase before executing. Cannot skip steps.
+
+**Checkpoint Tracking:**
+- All phases tracked in `state.json` with timestamps
+- Events logged to `memory/events.jsonl`
+- Full audit trail for every workflow
+
+**Updated Commands:**
+- `task.md` - Initializes workflow with 11 checkpoints
+- `ship.md` - Validates merge phase, sets 4 checkpoints atomically
+- `done.md` - Clarified as subtask completion
+- `pause.md` - Preserves workflow state
+- `resume.md` - Shows workflow phase on resume
+
 ## [0.25.1] - 2026-01-01
 
 ### Bug Fix: npm install symlink resolution

package/CLAUDE.md

@@ -4,155 +4,125 @@ This file provides guidance to Claude Code when working with prjct-cli.
 
 ## Project Overview
 
-**prjct-cli** is a developer momentum tool. Track progress through slash commands without meetings or traditional PM overhead.
+**prjct-cli** is a developer momentum tool. Track progress through natural language commands (`p. <command>`) without meetings or traditional PM overhead.
+
+## HOW PRJCT WORKS
+
+When user types `p. <command>`, load the template from `templates/commands/{command}.md` and execute it **intelligently** - templates are GUIDANCE, not rigid scripts.
+
+```
+p. sync     → Analyze project, generate domain agents
+p. task X   → Start task with classification + breakdown
+p. done     → Complete current subtask
+p. ship X   → Ship feature with PR + version bump
+```
+
+---
 
 ## CRITICAL RULES
 
-### 1. Path Resolution
+### 1. Path Resolution (MOST IMPORTANT)
 **ALL writes go to global storage**: `~/.prjct-cli/projects/{projectId}/`
-- NEVER write to `.prjct/` (config only)
-- NEVER write to `./` (current directory)
+- **NEVER** write to `.prjct/` (config only, read-only)
+- **NEVER** write to `./` (current directory)
 
-### 2. Timestamps
-```bash
-# Prefer bun, fallback to node
-bun -e "console.log(new Date().toISOString())" 2>/dev/null || node -e "console.log(new Date().toISOString())"
+### 2. Before Any Command
+```
+1. Read .prjct/prjct.config.json → get projectId
+2. Set globalPath = ~/.prjct-cli/projects/{projectId}
+3. Execute using globalPath for all writes
+4. Log to {globalPath}/memory/events.jsonl
 ```
-- Result: `"2025-12-20T10:30:00.000Z"`
-- NEVER hardcode dates or times
 
-### 3. UUIDs
+### 3. Timestamps & UUIDs
 ```bash
+# Timestamp (NEVER hardcode)
+bun -e "console.log(new Date().toISOString())" 2>/dev/null || node -e "console.log(new Date().toISOString())"
+
+# UUID
 bun -e "console.log(crypto.randomUUID())" 2>/dev/null || node -e "console.log(require('crypto').randomUUID())"
 ```
 
-### 4. Git Commit Footer
+### 4. Git Commit Footer (CRITICAL - ALWAYS INCLUDE)
+
+**Every commit MUST include the prjct signature:**
+
 ```
 🤖 Generated with [p/](https://www.prjct.app/)
 Designed for [Claude](https://www.anthropic.com/claude)
+
 ```
 
-## Architecture: Write-Through Pattern
+**NON-NEGOTIABLE: The `🤖 Generated with [p/]` line identifies prjct-powered commits.**
+
+---
+
+## ARCHITECTURE: Write-Through Pattern
 
 ```
 User Action → Storage (JSON) → Context (MD) → Sync Events
 ```
 
-### Layer System (10 layers)
-
 | Layer | Path | Purpose |
 |-------|------|---------|
-| **Storage** | `storage/*.json` | Source of truth (state, queue, shipped) |
-| **Context** | `context/*.md` | Claude-readable generated files |
-| **Core** | `core/` | Current task data |
-| **Progress** | `progress/` | Historical progress tracking |
-| **Planning** | `planning/` | Ideas, roadmap, specs, tasks |
-| **Analysis** | `analysis/` | Repo analysis, tech stack |
-| **Memory** | `memory/` | Events, patterns, semantic memories |
-| **Agents** | `agents/` | Domain specialists (auto-generated) |
-| **Sessions** | `sessions/YYYY/MM/DD/` | Daily session logs |
-| **Sync** | `sync/` | Backend sync events |
+| **Storage** | `storage/*.json` | Source of truth |
+| **Context** | `context/*.md` | Claude-readable summaries |
+| **Memory** | `memory/events.jsonl` | Audit trail (append-only) |
+| **Agents** | `agents/*.md` | Domain specialists |
 
 ### File Structure
 ```
 ~/.prjct-cli/projects/{projectId}/
-├── project.json           # Project config (authors, version)
 ├── storage/
-│   ├── state.json         # Current task (source of truth)
-│   ├── queue.json         # Priority queue
-│   └── shipped.json       # Shipped features
+│   ├── state.json      # Current task (SOURCE OF TRUTH)
+│   ├── queue.json      # Task queue
+│   └── shipped.json    # Shipped features
 ├── context/
-│   ├── now.md             # Generated from state.json
-│   ├── next.md            # Generated from queue.json
-│   └── shipped.md         # Generated from shipped.json
-├── core/                  # Current task context
-├── progress/              # Historical metrics
-├── planning/
-│   ├── ideas.json         # Captured ideas
-│   ├── roadmap.json       # Feature roadmap
-│   └── tasks/             # Task breakdowns
-├── analysis/
-│   └── repo-analysis.json # Tech stack, patterns
+│   ├── now.md          # Current task (generated)
+│   └── next.md         # Queue (generated)
 ├── memory/
-│   ├── events.jsonl       # Audit trail
-│   └── context.jsonl      # Semantic memories
-├── agents/                # Auto-generated domain specialists
-├── sessions/              # Daily session logs (YYYY/MM/DD/)
+│   └── events.jsonl    # Audit trail
+├── agents/             # Domain specialists
 └── sync/
-    ├── pending.json       # Events pending sync
-    └── last-sync.json     # Last sync timestamp
+    └── pending.json    # Backend events
 ```
 
-## Core Workflow
+---
 
-```
-/p:sync → /p:task "description" → [work] → /p:done → /p:ship
-```
+## COMMANDS
 
-## Commands
-
-### Core Commands
-| Command | Purpose |
-|---------|---------|
-| `/p:init` | Initialize project with deep analysis |
-| `/p:idea` | Transform ideas into architectures |
-| `/p:task` | Start task with agentic classification + 7-phase workflow |
-| `/p:spec` | Create detailed specifications |
-| `/p:pause` | Pause active task |
-| `/p:resume` | Resume paused task |
-| `/p:next` | Show priority queue |
-| `/p:done` | Complete current task |
-| `/p:ship` | Ship with quality checks |
-| `/p:bug` | Report bug with auto-priority |
-| `/p:dash` | Unified dashboard |
-| `/p:sync` | Analyze repo, generate agents |
-| `/p:suggest` | Context-aware recommendations |
-
-### Deprecated Commands
-| Command | Migration |
-|---------|-----------|
-| `/p:now` | Use `/p:task` instead |
-| `/p:feature` | Use `/p:task` instead |
-| `/p:work` | Use `/p:task` instead |
-
-### Optional Commands
-| Command | Purpose |
+| Trigger | Purpose |
 |---------|---------|
-| `/p:design` | System architecture design |
-| `/p:cleanup` | Clean temp files |
-| `/p:analyze` | Deep repo analysis |
-| `/p:undo` / `/p:redo` | Snapshot management |
-| `/p:git` | Smart git operations |
-| `/p:test` | Run tests with auto-fix |
+| `p. init` | Initialize project with deep analysis |
+| `p. sync` | Analyze repo, generate agents |
+| `p. task <desc>` | Start task with agentic classification |
+| `p. done` | Complete current subtask |
+| `p. ship [name]` | Ship with PR + version bump |
+| `p. pause` | Pause active task |
+| `p. resume` | Resume paused task |
+| `p. bug <desc>` | Report bug with auto-priority |
 
-## Natural Language Trigger
-
-Messages starting with `p.` trigger commands:
+### Workflow
 ```
-p. task add auth → /p:task "add auth"
-p. task fix login → /p:task "fix login"
-p. done          → /p:done
-p. ship login    → /p:ship "login"
+p. sync → p. task "description" → [work] → p. done → p. ship
 ```
 
-## Template-Driven Execution
+---
 
-Templates define command behavior:
-```
-templates/commands/{command}.md
-```
+## INTELLIGENT BEHAVIOR
 
-Claude reads template → executes flow → generates response.
+Templates provide guidance. Use your intelligence to:
 
-## Key Rules
+1. **Read before write** - Always read existing files first
+2. **Explore before coding** - Use Task(Explore) to understand codebase
+3. **Ask when uncertain** - Use AskUserQuestion to clarify
+4. **Load agents** - Read from `{globalPath}/agents/` for domain expertise
+5. **Adapt templates** - They're guidance, not rigid scripts
+6. **Log everything** - Append to memory/events.jsonl
 
-1. **Read files before editing** - Never assume structure
-2. **Use node commands for timestamps** - Never hardcode dates
-3. **Follow template instructions** - Templates are source of truth
-4. **Log to memory** - Append to `memory/events.jsonl`
-5. **Suggest next actions** - Maintain user momentum
+---
 
-## Output Format
+## OUTPUT FORMAT
 
 Concise responses (< 4 lines):
 ```
@@ -162,10 +132,47 @@ Concise responses (< 4 lines):
 Next: [suggested action]
 ```
 
-## Documentation
+---
+
+## KEY RULES
+
+1. **Read files before editing** - Never assume structure
+2. **Use node/bun for timestamps** - Never hardcode dates
+3. **Follow template guidance** - But adapt intelligently
+4. **Log to memory** - Append to `memory/events.jsonl`
+5. **Suggest next actions** - Maintain user momentum
+6. **Use linked skills** - Agents have skills in frontmatter
+
+---
+
+## CLAUDE CODE INTEGRATION (v0.28)
+
+prjct-cli uses Claude Code's native features for robust integration:
+
+### SessionStart Hook
+
+A hook runs at the start of every Claude Code session to inject fresh context:
+- Located at: `~/.claude/hooks/prjct-session-start.sh`
+- Automatically reads project state and injects into session
+- Bypasses CLAUDE.md caching issues
+
+### Skills (Auto-Discovery)
+
+Skills are auto-discovered by Claude Code when relevant:
+
+| Skill | Trigger |
+|-------|---------|
+| `prjct-task` | "p. task", starting work, features/bugs |
+| `prjct-sync` | "p. sync", analyze codebase |
+| `prjct-done` | "p. done", completing work |
+| `prjct-ship` | "p. ship", releasing features |
+
+Skills location: `~/.claude/skills/prjct-*/SKILL.md`
+
+### Setup
 
-For detailed information:
-- Architecture: `~/.prjct-cli/docs/architecture.md`
-- Commands: `~/.prjct-cli/docs/commands.md`
-- Validation: `~/.prjct-cli/docs/validation.md`
-- Agents: `~/.prjct-cli/docs/agents.md`
+All integration is installed automatically via `npm install -g prjct-cli`:
+1. SessionStart hook → `~/.claude/hooks/`
+2. Skills → `~/.claude/skills/`
+3. Commands → `~/.claude/commands/p/`
+4. Settings → `~/.claude/settings.json`

package/core/infrastructure/command-installer.ts

@@ -163,6 +163,9 @@ export class CommandInstaller {
 
   constructor() {
     this.homeDir = os.homedir()
+    // Commands are stored in p/ subdirectory, accessed via p. trigger
+    // Note: Claude Code bug #2422 prevents native slash command discovery
+    // We use the p.md router in commands/ root instead
     this.claudeCommandsPath = path.join(this.homeDir, '.claude', 'commands', 'p')
     this.claudeConfigPath = path.join(this.homeDir, '.claude')
     this.templatesDir = path.join(__dirname, '..', '..', 'templates', 'commands')
@@ -227,6 +230,9 @@ export class CommandInstaller {
     }
 
     try {
+      // Install the p.md router to enable "p. task" trigger
+      await this.installRouter()
+
       // Ensure commands directory exists
       await fs.mkdir(this.claudeCommandsPath, { recursive: true })
 
@@ -378,6 +384,24 @@ export class CommandInstaller {
     }
   }
 
+  /**
+   * Install the p.md router to ~/.claude/commands/
+   * This enables the "p. task" natural language trigger
+   * Claude Code bug #2422 prevents subdirectory slash command discovery
+   */
+  async installRouter(): Promise<boolean> {
+    try {
+      const routerSource = path.join(this.templatesDir, 'p.md')
+      const routerDest = path.join(this.homeDir, '.claude', 'commands', 'p.md')
+
+      const content = await fs.readFile(routerSource, 'utf-8')
+      await fs.writeFile(routerDest, content, 'utf-8')
+      return true
+    } catch {
+      return false
+    }
+  }
+
   /**
    * Sync commands - intelligent update that detects and removes orphans
    */
@@ -395,6 +419,9 @@ export class CommandInstaller {
     }
 
     try {
+      // Install the p.md router to enable "p. task" trigger
+      await this.installRouter()
+
       // Ensure commands directory exists
       await fs.mkdir(this.claudeCommandsPath, { recursive: true })
 

package/core/infrastructure/setup.ts

@@ -112,6 +112,12 @@ export async function run(): Promise<SetupResults> {
 
     // Step 4c: Install status line with version check
     await installStatusLine()
+
+    // Step 4d: Install SessionStart hook for fresh context injection
+    await installSessionHook()
+
+    // Step 4e: Install Skills for auto-discovery
+    await installSkills()
   }
 
   // Step 5: Save version in editors-config
@@ -272,6 +278,99 @@ echo "⚡ prjct"
   }
 }
 
+/**
+ * Install SessionStart hook for fresh context injection
+ * This hook runs at the start of every Claude Code session
+ */
+async function installSessionHook(): Promise<void> {
+  try {
+    const claudeDir = path.join(os.homedir(), '.claude')
+    const hooksDir = path.join(claudeDir, 'hooks')
+    const hookPath = path.join(hooksDir, 'prjct-session-start.sh')
+    const settingsPath = path.join(claudeDir, 'settings.json')
+
+    // Ensure hooks directory exists
+    if (!fs.existsSync(hooksDir)) {
+      fs.mkdirSync(hooksDir, { recursive: true })
+    }
+
+    // Copy hook from templates
+    const templateHookPath = path.join(__dirname, '../../templates/hooks/prjct-session-start.sh')
+    if (fs.existsSync(templateHookPath)) {
+      const hookContent = fs.readFileSync(templateHookPath, 'utf8')
+      fs.writeFileSync(hookPath, hookContent, { mode: 0o755 })
+    }
+
+    // Update settings.json to include SessionStart hook
+    let settings: Record<string, unknown> = {}
+    if (fs.existsSync(settingsPath)) {
+      try {
+        settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'))
+      } catch {
+        // Invalid JSON, start fresh
+      }
+    }
+
+    // Add or update hooks configuration
+    const hooks = (settings.hooks as Record<string, unknown[]>) || {}
+    hooks.SessionStart = [
+      {
+        matcher: 'startup',
+        hooks: [
+          {
+            type: 'command',
+            command: hookPath
+          }
+        ]
+      }
+    ]
+    settings.hooks = hooks
+
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2))
+    console.log(`   ${GREEN}✓${NC} SessionStart hook installed`)
+  } catch {
+    // Silently fail - hook is optional but recommended
+  }
+}
+
+/**
+ * Install Skills for Claude Code auto-discovery
+ * Skills are loaded automatically when relevant to user's request
+ */
+async function installSkills(): Promise<void> {
+  try {
+    const claudeDir = path.join(os.homedir(), '.claude')
+    const skillsDir = path.join(claudeDir, 'skills')
+    const templateSkillsDir = path.join(__dirname, '../../templates/skills')
+
+    const skillNames = ['prjct-task', 'prjct-sync', 'prjct-done', 'prjct-ship']
+    let installed = 0
+
+    for (const skillName of skillNames) {
+      const destDir = path.join(skillsDir, skillName)
+      const templatePath = path.join(templateSkillsDir, skillName, 'SKILL.md')
+
+      if (fs.existsSync(templatePath)) {
+        // Ensure skill directory exists
+        if (!fs.existsSync(destDir)) {
+          fs.mkdirSync(destDir, { recursive: true })
+        }
+
+        // Copy SKILL.md
+        const skillContent = fs.readFileSync(templatePath, 'utf8')
+        fs.writeFileSync(path.join(destDir, 'SKILL.md'), skillContent)
+        installed++
+      }
+    }
+
+    if (installed > 0) {
+      console.log(`   ${GREEN}✓${NC} ${installed} Skills installed`)
+    }
+  } catch {
+    // Silently fail - skills are optional but recommended
+  }
+}
+
 /**
  * Show setup results
  */