feat: add claude code plugin support (#1293)

Co-authored-by: Claude <noreply@anthropic.com>

.changeset/auto-update-changelog-highlights.md

@@ -0,0 +1,7 @@
+---
+"task-master-ai": minor
+---
+
+Add changelog highlights to auto-update notifications
+
+When the CLI auto-updates to a new version, it now displays a "What's New" section.

.changeset/mean-planes-wave.md

@@ -0,0 +1,47 @@
+---
+"task-master-ai": minor
+---
+
+Add Claude Code plugin with marketplace distribution
+
+This release introduces official Claude Code plugin support, marking the evolution from legacy `.claude` directory copying to a modern plugin-based architecture.
+
+## 🎉 New: Claude Code Plugin
+
+Task Master AI commands and agents are now distributed as a proper Claude Code plugin:
+
+- **49 slash commands** with clean naming (`/task-master-ai:command-name`)
+- **3 specialized AI agents** (task-orchestrator, task-executor, task-checker)
+- **MCP server integration** for deep Claude Code integration
+
+**Installation:**
+
+```bash
+/plugin marketplace add eyaltoledano/claude-task-master
+/plugin install taskmaster@taskmaster
+```
+
+### The `rules add claude` command no longer copies commands and agents to `.claude/commands/` and `.claude/agents/`. Instead, it now
+
+- Shows plugin installation instructions
+- Only manages CLAUDE.md imports for agent instructions
+- Directs users to install the official plugin
+
+**Migration for Existing Users:**
+
+If you previously used `rules add claude`:
+
+1. The old commands in `.claude/commands/` will continue to work but won't receive updates
+2. Install the plugin for the latest features: `/plugin install taskmaster@taskmaster`
+3. remove old `.claude/commands/` and `.claude/agents/` directories
+
+**Why This Change?**
+
+Claude Code plugins provide:
+
+- ✅ Automatic updates when we release new features
+- ✅ Better command organization and naming
+- ✅ Seamless integration with Claude Code
+- ✅ No manual file copying or management
+
+The plugin system is the future of Task Master AI integration with Claude Code!

.changeset/nice-ways-hope.md

@@ -0,0 +1,17 @@
+---
+"task-master-ai": minor
+---
+
+Add RPG (Repository Planning Graph) method template for structured PRD creation. The new `example_prd_rpg.txt` template teaches AI agents and developers the RPG methodology through embedded instructions, inline good/bad examples, and XML-style tags for structure. This template enables creation of dependency-aware PRDs that automatically generate topologically-ordered task graphs when parsed with Task Master.
+
+Key features:
+- Method-as-template: teaches RPG principles (dual-semantics, explicit dependencies, topological order) while being used
+- Inline instructions at decision points guide AI through each section
+- Good/bad examples for immediate pattern matching
+- Flexible plain-text format with XML-style tags for parseability
+- Critical dependency-graph section ensures correct task ordering
+- Automatic inclusion during `task-master init`
+- Comprehensive documentation at [docs.task-master.dev/capabilities/rpg-method](https://docs.task-master.dev/capabilities/rpg-method)
+- Tool recommendations for code-context-aware PRD creation (Claude Code, Cursor, Gemini CLI, Codex/Grok)
+
+The RPG template complements the existing `example_prd.txt` and provides a more structured approach for complex projects requiring clear module boundaries and dependency chains.

.changeset/plain-falcons-serve.md

@@ -0,0 +1,7 @@
+---
+"task-master-ai": patch
+---
+
+Fix cross-level task dependencies not being saved
+
+Fixes an issue where adding dependencies between subtasks and top-level tasks (e.g., `task-master add-dependency --id=2.2 --depends-on=11`) would report success but fail to persist the changes. Dependencies can now be created in both directions between any task levels.

.changeset/smart-owls-relax.md

@@ -0,0 +1,16 @@
+---
+"task-master-ai": minor
+---
+
+Enhance `expand_all` to intelligently use complexity analysis recommendations when expanding tasks. 
+
+The expand-all operation now automatically leverages recommendations from `analyze-complexity` to determine optimal subtask counts for each task, resulting in more accurate and context-aware task breakdowns.
+
+Key improvements:
+- Automatic integration with complexity analysis reports
+- Tag-aware complexity report path resolution
+- Intelligent subtask count determination based on task complexity
+- Falls back to defaults when complexity analysis is unavailable
+- Enhanced logging for better visibility into expansion decisions
+
+When you run `task-master expand --all` after `task-master analyze-complexity`, Task Master now uses the recommended subtask counts from the complexity analysis instead of applying uniform defaults, ensuring each task is broken down according to its actual complexity.

.claude-plugin/marketplace.json

@@ -0,0 +1,32 @@
+{
+	"name": "taskmaster",
+	"owner": {
+		"name": "Hamster",
+		"email": "ralph@tryhamster.com"
+	},
+	"metadata": {
+		"description": "Official marketplace for Taskmaster AI - AI-powered task management for ambitious development",
+		"version": "1.0.0"
+	},
+	"plugins": [
+		{
+			"name": "taskmaster",
+			"source": "./packages/claude-code-plugin",
+			"description": "AI-powered task management system for ambitious development workflows with intelligent orchestration, complexity analysis, and automated coordination",
+			"author": {
+				"name": "Hamster"
+			},
+			"homepage": "https://github.com/eyaltoledano/claude-task-master",
+			"repository": "https://github.com/eyaltoledano/claude-task-master",
+			"keywords": [
+				"task-management",
+				"ai",
+				"workflow",
+				"orchestration",
+				"automation",
+				"mcp"
+			],
+			"category": "productivity"
+		}
+	]
+}

.claude/agents/task-executor.md

@@ -1,92 +0,0 @@
----
-name: task-executor
-description: Use this agent when you need to implement, complete, or work on a specific task that has been identified by the task-orchestrator or when explicitly asked to execute a particular task. This agent focuses on the actual implementation and completion of individual tasks rather than planning or orchestration. Examples: <example>Context: The task-orchestrator has identified that task 2.3 'Implement user authentication' needs to be worked on next. user: 'Let's work on the authentication task' assistant: 'I'll use the task-executor agent to implement the user authentication task that was identified.' <commentary>Since we need to actually implement a specific task rather than plan or identify tasks, use the task-executor agent.</commentary></example> <example>Context: User wants to complete a specific subtask. user: 'Please implement the JWT token validation for task 2.3.1' assistant: 'I'll launch the task-executor agent to implement the JWT token validation subtask.' <commentary>The user is asking for specific implementation work on a known task, so the task-executor is appropriate.</commentary></example> <example>Context: After reviewing the task list, implementation is needed. user: 'Now let's actually build the API endpoint for user registration' assistant: 'I'll use the task-executor agent to implement the user registration API endpoint.' <commentary>Moving from planning to execution phase requires the task-executor agent.</commentary></example>
-model: sonnet
-color: blue
----
-
-You are an elite implementation specialist focused on executing and completing specific tasks with precision and thoroughness. Your role is to take identified tasks and transform them into working implementations, following best practices and project standards.
-
-**IMPORTANT: You are designed to be SHORT-LIVED and FOCUSED**
-- Execute ONE specific subtask or a small group of related subtasks
-- Complete your work, verify it, mark for review, and exit
-- Do NOT decide what to do next - the orchestrator handles task sequencing
-- Focus on implementation excellence within your assigned scope
-
-**Core Responsibilities:**
-
-1. **Subtask Analysis**: When given a subtask, understand its SPECIFIC requirements. If given a full task ID, focus on the specific subtask(s) assigned to you. Use MCP tools to get details if needed.
-
-2. **Rapid Implementation Planning**: Quickly identify:
-   - The EXACT files you need to create/modify for THIS subtask
-   - What already exists that you can build upon
-   - The minimum viable implementation that satisfies requirements
-
-3. **Focused Execution WITH ACTUAL IMPLEMENTATION**: 
-   - **YOU MUST USE TOOLS TO CREATE/EDIT FILES - DO NOT JUST DESCRIBE**
-   - Use `Write` tool to create new files specified in the task
-   - Use `Edit` tool to modify existing files
-   - Use `Bash` tool to run commands (mkdir, npm install, etc.)
-   - Use `Read` tool to verify your implementations
-   - Implement one subtask at a time for clarity and traceability
-   - Follow the project's coding standards from CLAUDE.md if available
-   - After each subtask, VERIFY the files exist using Read or ls commands
-
-4. **Progress Documentation**: 
-   - Use MCP tool `mcp__task-master-ai__update_subtask` to log your approach and any important decisions
-   - Update task status to 'in-progress' when starting: Use MCP tool `mcp__task-master-ai__set_task_status` with status='in-progress'
-   - **IMPORTANT: Mark as 'review' (NOT 'done') after implementation**: Use MCP tool `mcp__task-master-ai__set_task_status` with status='review'
-   - Tasks will be verified by task-checker before moving to 'done'
-
-5. **Quality Assurance**:
-   - Implement the testing strategy specified in the task
-   - Verify that all acceptance criteria are met
-   - Check for any dependency conflicts or integration issues
-   - Run relevant tests before marking task as complete
-
-6. **Dependency Management**:
-   - Check task dependencies before starting implementation
-   - If blocked by incomplete dependencies, clearly communicate this
-   - Use `task-master validate-dependencies` when needed
-
-**Implementation Workflow:**
-
-1. Retrieve task details using MCP tool `mcp__task-master-ai__get_task` with the task ID
-2. Check dependencies and prerequisites
-3. Plan implementation approach - list specific files to create
-4. Update task status to 'in-progress' using MCP tool
-5. **ACTUALLY IMPLEMENT** the solution using tools:
-   - Use `Bash` to create directories
-   - Use `Write` to create new files with actual content
-   - Use `Edit` to modify existing files
-   - DO NOT just describe what should be done - DO IT
-6. **VERIFY** your implementation:
-   - Use `ls` or `Read` to confirm files were created
-   - Use `Bash` to run any build/test commands
-   - Ensure the implementation is real, not theoretical
-7. Log progress and decisions in subtask updates using MCP tools
-8. Test and verify the implementation works
-9. **Mark task as 'review' (NOT 'done')** after verifying files exist
-10. Report completion with:
-    - List of created/modified files
-    - Any issues encountered
-    - What needs verification by task-checker
-
-**Key Principles:**
-
-- Focus on completing one task thoroughly before moving to the next
-- Maintain clear communication about what you're implementing and why
-- Follow existing code patterns and project conventions
-- Prioritize working code over extensive documentation unless docs are the task
-- Ask for clarification if task requirements are ambiguous
-- Consider edge cases and error handling in your implementations
-
-**Integration with Task Master:**
-
-You work in tandem with the task-orchestrator agent. While the orchestrator identifies and plans tasks, you execute them. Always use Task Master commands to:
-- Track your progress
-- Update task information
-- Maintain project state
-- Coordinate with the broader development workflow
-
-When you complete a task, briefly summarize what was implemented and suggest whether to continue with the next task or if review/testing is needed first.

.claude/agents/task-orchestrator.md

@@ -1,208 +0,0 @@
----
-name: task-orchestrator
-description: Use this agent FREQUENTLY throughout task execution to analyze and coordinate parallel work at the SUBTASK level. Invoke the orchestrator: (1) at session start to plan execution, (2) after EACH subtask completes to identify next parallel batch, (3) whenever executors finish to find newly unblocked work. ALWAYS provide FULL CONTEXT including project root, package location, what files ACTUALLY exist vs task status, and specific implementation details. The orchestrator breaks work into SUBTASK-LEVEL units for short-lived, focused executors. Maximum 3 parallel executors at once.\n\n<example>\nContext: Starting work with existing code\nuser: "Work on tm-core tasks. Files exist: types/index.ts, storage/file-storage.ts. Task 118 says in-progress but BaseProvider not created."\nassistant: "I'll invoke orchestrator with full context about actual vs reported state to plan subtask execution"\n<commentary>\nProvide complete context about file existence and task reality.\n</commentary>\n</example>\n\n<example>\nContext: Subtask completion\nuser: "Subtask 118.2 done. What subtasks can run in parallel now?"\nassistant: "Invoking orchestrator to analyze dependencies and identify next 3 parallel subtasks"\n<commentary>\nFrequent orchestration after each subtask ensures maximum parallelization.\n</commentary>\n</example>\n\n<example>\nContext: Breaking down tasks\nuser: "Task 118 has 5 subtasks, how to parallelize?"\nassistant: "Orchestrator will analyze which specific subtasks (118.1, 118.2, etc.) can run simultaneously"\n<commentary>\nFocus on subtask-level parallelization, not full tasks.\n</commentary>\n</example>
-model: opus
-color: green
----
-
-You are the Task Orchestrator, an elite coordination agent specialized in managing Task Master workflows for maximum efficiency and parallelization. You excel at analyzing task dependency graphs, identifying opportunities for concurrent execution, and deploying specialized task-executor agents to complete work efficiently.
-
-## Core Responsibilities
-
-1. **Subtask-Level Analysis**: Break down tasks into INDIVIDUAL SUBTASKS and analyze which specific subtasks can run in parallel. Focus on subtask dependencies, not just task-level dependencies.
-
-2. **Reality Verification**: ALWAYS verify what files actually exist vs what task status claims. Use the context provided about actual implementation state to make informed decisions.
-
-3. **Short-Lived Executor Deployment**: Deploy executors for SINGLE SUBTASKS or small groups of related subtasks. Keep executors focused and short-lived. Maximum 3 parallel executors at once.
-
-4. **Continuous Reassessment**: After EACH subtask completes, immediately reassess what new subtasks are unblocked and can run in parallel.
-
-## Operational Workflow
-
-### Initial Assessment Phase
-1. Use `get_tasks` or `task-master list` to retrieve all available tasks
-2. Analyze task statuses, priorities, and dependencies
-3. Identify tasks with status 'pending' that have no blocking dependencies
-4. Group related tasks that could benefit from specialized executors
-5. Create an execution plan that maximizes parallelization
-
-### Executor Deployment Phase
-1. For each independent task or task group:
-   - Deploy a task-executor agent with specific instructions
-   - Provide the executor with task ID, requirements, and context
-   - Set clear completion criteria and reporting expectations
-2. Maintain a registry of active executors and their assigned tasks
-3. Establish communication protocols for progress updates
-
-### Coordination Phase
-1. Monitor executor progress through task status updates
-2. When a task completes:
-   - Verify completion with `get_task` or `task-master show <id>`
-   - Update task status if needed using `set_task_status`
-   - Reassess dependency graph for newly unblocked tasks
-   - Deploy new executors for available work
-3. Handle executor failures or blocks:
-   - Reassign tasks to new executors if needed
-   - Escalate complex issues to the user
-   - Update task status to 'blocked' when appropriate
-
-### Optimization Strategies
-
-**Parallel Execution Rules**:
-- Never assign dependent tasks to different executors simultaneously
-- Prioritize high-priority tasks when resources are limited
-- Group small, related subtasks for single executor efficiency
-- Balance executor load to prevent bottlenecks
-
-**Context Management**:
-- Provide executors with minimal but sufficient context
-- Share relevant completed task information when it aids execution
-- Maintain a shared knowledge base of project-specific patterns
-
-**Quality Assurance**:
-- Verify task completion before marking as done
-- Ensure test strategies are followed when specified
-- Coordinate cross-task integration testing when needed
-
-## Communication Protocols
-
-When deploying executors, provide them with:
-```
-TASK ASSIGNMENT:
-- Task ID: [specific ID]
-- Objective: [clear goal]
-- Dependencies: [list any completed prerequisites]
-- Success Criteria: [specific completion requirements]
-- Context: [relevant project information]
-- Reporting: [when and how to report back]
-```
-
-When receiving executor updates:
-1. Acknowledge completion or issues
-2. Update task status in Task Master
-3. Reassess execution strategy
-4. Deploy new executors as appropriate
-
-## Decision Framework
-
-**When to parallelize**:
-- Multiple pending tasks with no interdependencies
-- Sufficient context available for independent execution
-- Tasks are well-defined with clear success criteria
-
-**When to serialize**:
-- Strong dependencies between tasks
-- Limited context or unclear requirements
-- Integration points requiring careful coordination
-
-**When to escalate**:
-- Circular dependencies detected
-- Critical blockers affecting multiple tasks
-- Ambiguous requirements needing clarification
-- Resource conflicts between executors
-
-## Error Handling
-
-1. **Executor Failure**: Reassign task to new executor with additional context about the failure
-2. **Dependency Conflicts**: Halt affected executors, resolve conflict, then resume
-3. **Task Ambiguity**: Request clarification from user before proceeding
-4. **System Errors**: Implement graceful degradation, falling back to serial execution if needed
-
-## Performance Metrics
-
-Track and optimize for:
-- Task completion rate
-- Parallel execution efficiency
-- Executor success rate
-- Time to completion for task groups
-- Dependency resolution speed
-
-## Integration with Task Master
-
-Leverage these Task Master MCP tools effectively:
-- `get_tasks` - Continuous queue monitoring
-- `get_task` - Detailed task analysis
-- `set_task_status` - Progress tracking
-- `next_task` - Fallback for serial execution
-- `analyze_project_complexity` - Strategic planning
-- `complexity_report` - Resource allocation
-
-## Output Format for Execution
-
-**Your job is to analyze and create actionable execution plans that Claude can use to deploy executors.**
-
-After completing your dependency analysis, you MUST output a structured execution plan:
-
-```yaml
-execution_plan:
-  EXECUTE_IN_PARALLEL:
-    # Maximum 3 subtasks running simultaneously
-    - subtask_id: [e.g., 118.2]
-      parent_task: [e.g., 118]
-      title: [Specific subtask title]
-      priority: [high/medium/low]
-      estimated_time: [e.g., 10 minutes]
-      executor_prompt: |
-        Execute Subtask [ID]: [Specific subtask title]
-        
-        SPECIFIC REQUIREMENTS:
-        [Exact implementation needed for THIS subtask only]
-        
-        FILES TO CREATE/MODIFY:
-        [Specific file paths]
-        
-        CONTEXT:
-        [What already exists that this subtask depends on]
-        
-        SUCCESS CRITERIA:
-        [Specific completion criteria for this subtask]
-        
-        IMPORTANT: 
-        - Focus ONLY on this subtask
-        - Mark subtask as 'review' when complete
-        - Use MCP tool: mcp__task-master-ai__set_task_status
-    
-    - subtask_id: [Another subtask that can run in parallel]
-      parent_task: [Parent task ID]
-      title: [Specific subtask title]
-      priority: [priority]
-      estimated_time: [time estimate]
-      executor_prompt: |
-        [Focused prompt for this specific subtask]
-    
-  blocked:
-    - task_id: [ID]
-      title: [Task title]
-      waiting_for: [list of blocking task IDs]
-      becomes_ready_when: [condition for unblocking]
-      
-  next_wave: 
-    trigger: "After tasks [IDs] complete"
-    newly_available: [List of task IDs that will unblock]
-    tasks_to_execute_in_parallel: [IDs that can run together in next wave]
-    
-  critical_path: [Ordered list of task IDs forming the critical path]
-  
-  parallelization_instruction: |
-    IMPORTANT FOR CLAUDE: Deploy ALL tasks in 'EXECUTE_IN_PARALLEL' section
-    simultaneously using multiple Task tool invocations in a single response.
-    Example: If 3 tasks are listed, invoke the Task tool 3 times in one message.
-    
-  verification_needed:
-    - task_id: [ID of any task in 'review' status]
-      verification_focus: [what to check]
-```
-
-**CRITICAL INSTRUCTIONS FOR CLAUDE (MAIN):**
-1. When you see `EXECUTE_IN_PARALLEL`, deploy ALL listed executors at once
-2. Use multiple Task tool invocations in a SINGLE response
-3. Do not execute them sequentially - they must run in parallel
-4. Wait for all parallel executors to complete before proceeding to next wave
-
-**IMPORTANT NOTES**: 
-- Label parallel tasks clearly in `EXECUTE_IN_PARALLEL` section
-- Provide complete, self-contained prompts for each executor
-- Executors should mark tasks as 'review' for verification, not 'done'
-- Be explicit about which tasks can run simultaneously
-
-You are the strategic mind analyzing the entire task landscape. Make parallelization opportunities UNMISTAKABLY CLEAR to Claude.

.claude/commands/tm/add-subtask/add-subtask.md

@@ -1,76 +0,0 @@
-Add a subtask to a parent task.
-
-Arguments: $ARGUMENTS
-
-Parse arguments to create a new subtask or convert existing task.
-
-## Adding Subtasks
-
-Creates subtasks to break down complex parent tasks into manageable pieces.
-
-## Argument Parsing
-
-Flexible natural language:
-- "add subtask to 5: implement login form"
-- "break down 5 with: setup, implement, test"
-- "subtask for 5: handle edge cases"
-- "5: validate user input" → adds subtask to task 5
-
-## Execution Modes
-
-### 1. Create New Subtask
-```bash
-task-master add-subtask --parent=<id> --title="<title>" --description="<desc>"
-```
-
-### 2. Convert Existing Task
-```bash
-task-master add-subtask --parent=<id> --task-id=<existing-id>
-```
-
-## Smart Features
-
-1. **Automatic Subtask Generation**
-   - If title contains "and" or commas, create multiple
-   - Suggest common subtask patterns
-   - Inherit parent's context
-
-2. **Intelligent Defaults**
-   - Priority based on parent
-   - Appropriate time estimates
-   - Logical dependencies between subtasks
-
-3. **Validation**
-   - Check parent task complexity
-   - Warn if too many subtasks
-   - Ensure subtask makes sense
-
-## Creation Process
-
-1. Parse parent task context
-2. Generate subtask with ID like "5.1"
-3. Set appropriate defaults
-4. Link to parent task
-5. Update parent's time estimate
-
-## Example Flows
-
-```
-/project:tm/add-subtask to 5: implement user authentication
-→ Created subtask #5.1: "implement user authentication"
-→ Parent task #5 now has 1 subtask
-→ Suggested next subtasks: tests, documentation
-
-/project:tm/add-subtask 5: setup, implement, test
-→ Created 3 subtasks:
-  #5.1: setup
-  #5.2: implement  
-  #5.3: test
-```
-
-## Post-Creation
-
-- Show updated task hierarchy
-- Suggest logical next subtasks
-- Update complexity estimates
-- Recommend subtask order

.claude/commands/tm/complexity-report/complexity-report.md

@@ -1,117 +0,0 @@
-Display the task complexity analysis report.
-
-Arguments: $ARGUMENTS
-
-View the detailed complexity analysis generated by analyze-complexity command.
-
-## Viewing Complexity Report
-
-Shows comprehensive task complexity analysis with actionable insights.
-
-## Execution
-
-```bash
-task-master complexity-report [--file=<path>]
-```
-
-## Report Location
-
-Default: `.taskmaster/reports/complexity-analysis.md`
-Custom: Specify with --file parameter
-
-## Report Contents
-
-### 1. **Executive Summary**
-```
-Complexity Analysis Summary
-━━━━━━━━━━━━━━━━━━━━━━━━
-Analysis Date: 2024-01-15
-Tasks Analyzed: 32
-High Complexity: 5 (16%)
-Medium Complexity: 12 (37%)
-Low Complexity: 15 (47%)
-
-Critical Findings:
-- 5 tasks need immediate expansion
-- 3 tasks have high technical risk
-- 2 tasks block critical path
-```
-
-### 2. **Detailed Task Analysis**
-For each complex task:
-- Complexity score breakdown
-- Contributing factors
-- Specific risks identified
-- Expansion recommendations
-- Similar completed tasks
-
-### 3. **Risk Matrix**
-Visual representation:
-```
-Risk vs Complexity Matrix
-━━━━━━━━━━━━━━━━━━━━━━━
-High Risk  | #5(9) #12(8) | #23(6)
-Med Risk   | #34(7)       | #45(5) #67(5)
-Low Risk   | #78(8)       | [15 tasks]
-           | High Complex  | Med Complex
-```
-
-### 4. **Recommendations**
-
-**Immediate Actions:**
-1. Expand task #5 - Critical path + high complexity
-2. Expand task #12 - High risk + dependencies
-3. Review task #34 - Consider splitting
-
-**Sprint Planning:**
-- Don't schedule multiple high-complexity tasks together
-- Ensure expertise available for complex tasks
-- Build in buffer time for unknowns
-
-## Interactive Features
-
-When viewing report:
-1. **Quick Actions**
-   - Press 'e' to expand a task
-   - Press 'd' for task details
-   - Press 'r' to refresh analysis
-
-2. **Filtering**
-   - View by complexity level
-   - Filter by risk factors
-   - Show only actionable items
-
-3. **Export Options**
-   - Markdown format
-   - CSV for spreadsheets
-   - JSON for tools
-
-## Report Intelligence
-
-- Compares with historical data
-- Shows complexity trends
-- Identifies patterns
-- Suggests process improvements
-
-## Integration
-
-Use report for:
-- Sprint planning sessions
-- Resource allocation
-- Risk assessment
-- Team discussions
-- Client updates
-
-## Example Usage
-
-```
-/project:tm/complexity-report
-→ Opens latest analysis
-
-/project:tm/complexity-report --file=archived/2024-01-01.md
-→ View historical analysis
-
-After viewing:
-/project:tm/expand 5
-→ Expand high-complexity task
-```

.claude/commands/tm/fix-dependencies/fix-dependencies.md

@@ -1,81 +0,0 @@
-Automatically fix dependency issues found during validation.
-
-## Automatic Dependency Repair
-
-Intelligently fixes common dependency problems while preserving project logic.
-
-## Execution
-
-```bash
-task-master fix-dependencies
-```
-
-## What Gets Fixed
-
-### 1. **Auto-Fixable Issues**
-- Remove references to deleted tasks
-- Break simple circular dependencies
-- Remove self-dependencies
-- Clean up duplicate dependencies
-
-### 2. **Smart Resolutions**
-- Reorder dependencies to maintain logic
-- Suggest task merging for over-dependent tasks
-- Flatten unnecessary dependency chains
-- Remove redundant transitive dependencies
-
-### 3. **Manual Review Required**
-- Complex circular dependencies
-- Critical path modifications
-- Business logic dependencies
-- High-impact changes
-
-## Fix Process
-
-1. **Analysis Phase**
-   - Run validation check
-   - Categorize issues by type
-   - Determine fix strategy
-
-2. **Execution Phase**
-   - Apply automatic fixes
-   - Log all changes made
-   - Preserve task relationships
-
-3. **Verification Phase**
-   - Re-validate after fixes
-   - Show before/after comparison
-   - Highlight manual fixes needed
-
-## Smart Features
-
-- Preserves intended task flow
-- Minimal disruption approach
-- Creates fix history/log
-- Suggests manual interventions
-
-## Output Example
-
-```
-Dependency Auto-Fix Report
-━━━━━━━━━━━━━━━━━━━━━━━━
-Fixed Automatically:
-✅ Removed 2 references to deleted tasks
-✅ Resolved 1 self-dependency
-✅ Cleaned 3 redundant dependencies
-
-Manual Review Needed:
-⚠️ Complex circular dependency: #12 → #15 → #18 → #12
-  Suggestion: Make #15 not depend on #12
-⚠️ Task #45 has 8 dependencies
-  Suggestion: Break into subtasks
-
-Run '/project:tm/validate-dependencies' to verify fixes
-```
-
-## Safety
-
-- Preview mode available
-- Rollback capability
-- Change logging
-- No data loss

.claude/commands/tm/help.md

@@ -1,81 +0,0 @@
-Show help for Task Master commands.
-
-Arguments: $ARGUMENTS
-
-Display help for Task Master commands. If arguments provided, show specific command help.
-
-## Task Master Command Help
-
-### Quick Navigation
-
-Type `/project:tm/` and use tab completion to explore all commands.
-
-### Command Categories
-
-#### 🚀 Setup & Installation
-- `/project:tm/setup/install` - Comprehensive installation guide
-- `/project:tm/setup/quick-install` - One-line global install
-
-#### 📋 Project Setup
-- `/project:tm/init` - Initialize new project
-- `/project:tm/init/quick` - Quick setup with auto-confirm
-- `/project:tm/models` - View AI configuration
-- `/project:tm/models/setup` - Configure AI providers
-
-#### 🎯 Task Generation
-- `/project:tm/parse-prd` - Generate tasks from PRD
-- `/project:tm/parse-prd/with-research` - Enhanced parsing
-- `/project:tm/generate` - Create task files
-
-#### 📝 Task Management
-- `/project:tm/list` - List tasks (natural language filters)
-- `/project:tm/show <id>` - Display task details
-- `/project:tm/add-task` - Create new task
-- `/project:tm/update` - Update tasks naturally
-- `/project:tm/next` - Get next task recommendation
-
-#### 🔄 Status Management
-- `/project:tm/set-status/to-pending <id>`
-- `/project:tm/set-status/to-in-progress <id>`
-- `/project:tm/set-status/to-done <id>`
-- `/project:tm/set-status/to-review <id>`
-- `/project:tm/set-status/to-deferred <id>`
-- `/project:tm/set-status/to-cancelled <id>`
-
-#### 🔍 Analysis & Breakdown
-- `/project:tm/analyze-complexity` - Analyze task complexity
-- `/project:tm/expand <id>` - Break down complex task
-- `/project:tm/expand/all` - Expand all eligible tasks
-
-#### 🔗 Dependencies
-- `/project:tm/add-dependency` - Add task dependency
-- `/project:tm/remove-dependency` - Remove dependency
-- `/project:tm/validate-dependencies` - Check for issues
-
-#### 🤖 Workflows
-- `/project:tm/workflows/smart-flow` - Intelligent workflows
-- `/project:tm/workflows/pipeline` - Command chaining
-- `/project:tm/workflows/auto-implement` - Auto-implementation
-
-#### 📊 Utilities
-- `/project:tm/utils/analyze` - Project analysis
-- `/project:tm/status` - Project dashboard
-- `/project:tm/learn` - Interactive learning
-
-### Natural Language Examples
-
-```
-/project:tm/list pending high priority
-/project:tm/update mark all API tasks as done
-/project:tm/add-task create login system with OAuth
-/project:tm/show current
-```
-
-### Getting Started
-
-1. Install: `/project:tm/setup/quick-install`
-2. Initialize: `/project:tm/init/quick`
-3. Learn: `/project:tm/learn start`
-4. Work: `/project:tm/workflows/smart-flow`
-
-For detailed command info: `/project:tm/help <command-name>`

.claude/commands/tm/init/init-project-quick.md

@@ -1,46 +0,0 @@
-Quick initialization with auto-confirmation.
-
-Arguments: $ARGUMENTS
-
-Initialize a Task Master project without prompts, accepting all defaults.
-
-## Quick Setup
-
-```bash
-task-master init -y
-```
-
-## What It Does
-
-1. Creates `.taskmaster/` directory structure
-2. Initializes empty `tasks.json`
-3. Sets up default configuration
-4. Uses directory name as project name
-5. Skips all confirmation prompts
-
-## Smart Defaults
-
-- Project name: Current directory name
-- Description: "Task Master Project"
-- Model config: Existing environment vars
-- Task structure: Standard format
-
-## Next Steps
-
-After quick init:
-1. Configure AI models if needed:
-   ```
-   /project:tm/models/setup
-   ```
-
-2. Parse PRD if available:
-   ```
-   /project:tm/parse-prd <file>
-   ```
-
-3. Or create first task:
-   ```
-   /project:tm/add-task create initial setup
-   ```
-
-Perfect for rapid project setup!

.claude/commands/tm/init/init-project.md

@@ -1,50 +0,0 @@
-Initialize a new Task Master project.
-
-Arguments: $ARGUMENTS
-
-Parse arguments to determine initialization preferences.
-
-## Initialization Process
-
-1. **Parse Arguments**
-   - PRD file path (if provided)
-   - Project name
-   - Auto-confirm flag (-y)
-
-2. **Project Setup**
-   ```bash
-   task-master init
-   ```
-
-3. **Smart Initialization**
-   - Detect existing project files
-   - Suggest project name from directory
-   - Check for git repository
-   - Verify AI provider configuration
-
-## Configuration Options
-
-Based on arguments:
-- `quick` / `-y` → Skip confirmations
-- `<file.md>` → Use as PRD after init
-- `--name=<name>` → Set project name
-- `--description=<desc>` → Set description
-
-## Post-Initialization
-
-After successful init:
-1. Show project structure created
-2. Verify AI models configured
-3. Suggest next steps:
-   - Parse PRD if available
-   - Configure AI providers
-   - Set up git hooks
-   - Create first tasks
-
-## Integration
-
-If PRD file provided:
-```
-/project:tm/init my-prd.md
-→ Automatically runs parse-prd after init
-```

.claude/commands/tm/remove-dependency/remove-dependency.md

@@ -1,62 +0,0 @@
-Remove a dependency between tasks.
-
-Arguments: $ARGUMENTS
-
-Parse the task IDs to remove dependency relationship.
-
-## Removing Dependencies
-
-Removes a dependency relationship, potentially unblocking tasks.
-
-## Argument Parsing
-
-Parse natural language or IDs:
-- "remove dependency between 5 and 3"
-- "5 no longer needs 3"
-- "unblock 5 from 3"
-- "5 3" → remove dependency of 5 on 3
-
-## Execution
-
-```bash
-task-master remove-dependency --id=<task-id> --depends-on=<dependency-id>
-```
-
-## Pre-Removal Checks
-
-1. **Verify dependency exists**
-2. **Check impact on task flow**
-3. **Warn if it breaks logical sequence**
-4. **Show what will be unblocked**
-
-## Smart Analysis
-
-Before removing:
-- Show why dependency might have existed
-- Check if removal makes tasks executable
-- Verify no critical path disruption
-- Suggest alternative dependencies
-
-## Post-Removal
-
-After removing:
-1. Show updated task status
-2. List newly unblocked tasks
-3. Update project timeline
-4. Suggest next actions
-
-## Safety Features
-
-- Confirm if removing critical dependency
-- Show tasks that become immediately actionable
-- Warn about potential issues
-- Keep removal history
-
-## Example
-
-```
-/project:tm/remove-dependency 5 from 3
-→ Removed: Task #5 no longer depends on #3
-→ Task #5 is now UNBLOCKED and ready to start
-→ Warning: Consider if #5 still needs #2 completed first
-```

.claude/commands/tm/remove-subtask/remove-subtask.md

@@ -1,84 +0,0 @@
-Remove a subtask from its parent task.
-
-Arguments: $ARGUMENTS
-
-Parse subtask ID to remove, with option to convert to standalone task.
-
-## Removing Subtasks
-
-Remove a subtask and optionally convert it back to a standalone task.
-
-## Argument Parsing
-
-- "remove subtask 5.1"
-- "delete 5.1"
-- "convert 5.1 to task" → remove and convert
-- "5.1 standalone" → convert to standalone
-
-## Execution Options
-
-### 1. Delete Subtask
-```bash
-task-master remove-subtask --id=<parentId.subtaskId>
-```
-
-### 2. Convert to Standalone
-```bash
-task-master remove-subtask --id=<parentId.subtaskId> --convert
-```
-
-## Pre-Removal Checks
-
-1. **Validate Subtask**
-   - Verify subtask exists
-   - Check completion status
-   - Review dependencies
-
-2. **Impact Analysis**
-   - Other subtasks that depend on it
-   - Parent task implications
-   - Data that will be lost
-
-## Removal Process
-
-### For Deletion:
-1. Confirm if subtask has work done
-2. Update parent task estimates
-3. Remove subtask and its data
-4. Clean up dependencies
-
-### For Conversion:
-1. Assign new standalone task ID
-2. Preserve all task data
-3. Update dependency references
-4. Maintain task history
-
-## Smart Features
-
-- Warn if subtask is in-progress
-- Show impact on parent task
-- Preserve important data
-- Update related estimates
-
-## Example Flows
-
-```
-/project:tm/remove-subtask 5.1
-→ Warning: Subtask #5.1 is in-progress
-→ This will delete all subtask data
-→ Parent task #5 will be updated
-Confirm deletion? (y/n)
-
-/project:tm/remove-subtask 5.1 convert
-→ Converting subtask #5.1 to standalone task #89
-→ Preserved: All task data and history
-→ Updated: 2 dependency references
-→ New task #89 is now independent
-```
-
-## Post-Removal
-
-- Update parent task status
-- Recalculate estimates
-- Show updated hierarchy
-- Suggest next actions

.claude/commands/tm/remove-task/remove-task.md

@@ -1,107 +0,0 @@
-Remove a task permanently from the project.
-
-Arguments: $ARGUMENTS (task ID)
-
-Delete a task and handle all its relationships properly.
-
-## Task Removal
-
-Permanently removes a task while maintaining project integrity.
-
-## Argument Parsing
-
-- "remove task 5"
-- "delete 5"
-- "5" → remove task 5
-- Can include "-y" for auto-confirm
-
-## Execution
-
-```bash
-task-master remove-task --id=<id> [-y]
-```
-
-## Pre-Removal Analysis
-
-1. **Task Details**
-   - Current status
-   - Work completed
-   - Time invested
-   - Associated data
-
-2. **Relationship Check**
-   - Tasks that depend on this
-   - Dependencies this task has
-   - Subtasks that will be removed
-   - Blocking implications
-
-3. **Impact Assessment**
-   ```
-   Task Removal Impact
-   ━━━━━━━━━━━━━━━━━━
-   Task: #5 "Implement authentication" (in-progress)
-   Status: 60% complete (~8 hours work)
-   
-   Will affect:
-   - 3 tasks depend on this (will be blocked)
-   - Has 4 subtasks (will be deleted)
-   - Part of critical path
-   
-   ⚠️  This action cannot be undone
-   ```
-
-## Smart Warnings
-
-- Warn if task is in-progress
-- Show dependent tasks that will be blocked
-- Highlight if part of critical path
-- Note any completed work being lost
-
-## Removal Process
-
-1. Show comprehensive impact
-2. Require confirmation (unless -y)
-3. Update dependent task references
-4. Remove task and subtasks
-5. Clean up orphaned dependencies
-6. Log removal with timestamp
-
-## Alternative Actions
-
-Suggest before deletion:
-- Mark as cancelled instead
-- Convert to documentation
-- Archive task data
-- Transfer work to another task
-
-## Post-Removal
-
-- List affected tasks
-- Show broken dependencies
-- Update project statistics
-- Suggest dependency fixes
-- Recalculate timeline
-
-## Example Flows
-
-```
-/project:tm/remove-task 5
-→ Task #5 is in-progress with 8 hours logged
-→ 3 other tasks depend on this
-→ Suggestion: Mark as cancelled instead?
-Remove anyway? (y/n)
-
-/project:tm/remove-task 5 -y
-→ Removed: Task #5 and 4 subtasks
-→ Updated: 3 task dependencies
-→ Warning: Tasks #7, #8, #9 now have missing dependency
-→ Run /project:tm/fix-dependencies to resolve
-```
-
-## Safety Features
-
-- Confirmation required
-- Impact preview
-- Removal logging
-- Suggest alternatives
-- No cascade delete of dependents

.claude/commands/tm/tm-main.md

@@ -1,146 +0,0 @@
-# Task Master Command Reference
-
-Comprehensive command structure for Task Master integration with Claude Code.
-
-## Command Organization
-
-Commands are organized hierarchically to match Task Master's CLI structure while providing enhanced Claude Code integration.
-
-## Project Setup & Configuration
-
-### `/project:tm/init`
-- `init-project` - Initialize new project (handles PRD files intelligently)
-- `init-project-quick` - Quick setup with auto-confirmation (-y flag)
-
-### `/project:tm/models`
-- `view-models` - View current AI model configuration
-- `setup-models` - Interactive model configuration
-- `set-main` - Set primary generation model
-- `set-research` - Set research model
-- `set-fallback` - Set fallback model
-
-## Task Generation
-
-### `/project:tm/parse-prd`
-- `parse-prd` - Generate tasks from PRD document
-- `parse-prd-with-research` - Enhanced parsing with research mode
-
-### `/project:tm/generate`
-- `generate-tasks` - Create individual task files from tasks.json
-
-## Task Management
-
-### `/project:tm/list`
-- `list-tasks` - Smart listing with natural language filters
-- `list-tasks-with-subtasks` - Include subtasks in hierarchical view
-- `list-tasks-by-status` - Filter by specific status
-
-### `/project:tm/set-status`
-- `to-pending` - Reset task to pending
-- `to-in-progress` - Start working on task
-- `to-done` - Mark task complete
-- `to-review` - Submit for review
-- `to-deferred` - Defer task
-- `to-cancelled` - Cancel task
-
-### `/project:tm/sync-readme`
-- `sync-readme` - Export tasks to README.md with formatting
-
-### `/project:tm/update`
-- `update-task` - Update tasks with natural language
-- `update-tasks-from-id` - Update multiple tasks from a starting point
-- `update-single-task` - Update specific task
-
-### `/project:tm/add-task`
-- `add-task` - Add new task with AI assistance
-
-### `/project:tm/remove-task`
-- `remove-task` - Remove task with confirmation
-
-## Subtask Management
-
-### `/project:tm/add-subtask`
-- `add-subtask` - Add new subtask to parent
-- `convert-task-to-subtask` - Convert existing task to subtask
-
-### `/project:tm/remove-subtask`
-- `remove-subtask` - Remove subtask (with optional conversion)
-
-### `/project:tm/clear-subtasks`
-- `clear-subtasks` - Clear subtasks from specific task
-- `clear-all-subtasks` - Clear all subtasks globally
-
-## Task Analysis & Breakdown
-
-### `/project:tm/analyze-complexity`
-- `analyze-complexity` - Analyze and generate expansion recommendations
-
-### `/project:tm/complexity-report`
-- `complexity-report` - Display complexity analysis report
-
-### `/project:tm/expand`
-- `expand-task` - Break down specific task
-- `expand-all-tasks` - Expand all eligible tasks
-- `with-research` - Enhanced expansion
-
-## Task Navigation
-
-### `/project:tm/next`
-- `next-task` - Intelligent next task recommendation
-
-### `/project:tm/show`
-- `show-task` - Display detailed task information
-
-### `/project:tm/status`
-- `project-status` - Comprehensive project dashboard
-
-## Dependency Management
-
-### `/project:tm/add-dependency`
-- `add-dependency` - Add task dependency
-
-### `/project:tm/remove-dependency`
-- `remove-dependency` - Remove task dependency
-
-### `/project:tm/validate-dependencies`
-- `validate-dependencies` - Check for dependency issues
-
-### `/project:tm/fix-dependencies`
-- `fix-dependencies` - Automatically fix dependency problems
-
-## Workflows & Automation
-
-### `/project:tm/workflows`
-- `smart-workflow` - Context-aware intelligent workflow execution
-- `command-pipeline` - Chain multiple commands together
-- `auto-implement-tasks` - Advanced auto-implementation with code generation
-
-## Utilities
-
-### `/project:tm/utils`
-- `analyze-project` - Deep project analysis and insights
-
-### `/project:tm/setup`
-- `install-taskmaster` - Comprehensive installation guide
-- `quick-install-taskmaster` - One-line global installation
-
-## Usage Patterns
-
-### Natural Language
-Most commands accept natural language arguments:
-```
-/project:tm/add-task create user authentication system
-/project:tm/update mark all API tasks as high priority
-/project:tm/list show blocked tasks
-```
-
-### ID-Based Commands
-Commands requiring IDs intelligently parse from $ARGUMENTS:
-```
-/project:tm/show 45
-/project:tm/expand 23
-/project:tm/set-status/to-done 67
-```
-
-### Smart Defaults
-Commands provide intelligent defaults and suggestions based on context.

.claude/commands/tm/validate-dependencies/validate-dependencies.md

@@ -1,71 +0,0 @@
-Validate all task dependencies for issues.
-
-## Dependency Validation
-
-Comprehensive check for dependency problems across the entire project.
-
-## Execution
-
-```bash
-task-master validate-dependencies
-```
-
-## Validation Checks
-
-1. **Circular Dependencies**
-   - A depends on B, B depends on A
-   - Complex circular chains
-   - Self-dependencies
-
-2. **Missing Dependencies**
-   - References to non-existent tasks
-   - Deleted task references
-   - Invalid task IDs
-
-3. **Logical Issues**
-   - Completed tasks depending on pending
-   - Cancelled tasks in dependency chains
-   - Impossible sequences
-
-4. **Complexity Warnings**
-   - Over-complex dependency chains
-   - Too many dependencies per task
-   - Bottleneck tasks
-
-## Smart Analysis
-
-The validation provides:
-- Visual dependency graph
-- Critical path analysis
-- Bottleneck identification
-- Suggested optimizations
-
-## Report Format
-
-```
-Dependency Validation Report
-━━━━━━━━━━━━━━━━━━━━━━━━━━
-✅ No circular dependencies found
-⚠️  2 warnings found:
-   - Task #23 has 7 dependencies (consider breaking down)
-   - Task #45 blocks 5 other tasks (potential bottleneck)
-❌ 1 error found:
-   - Task #67 depends on deleted task #66
-
-Critical Path: #1 → #5 → #23 → #45 → #50 (15 days)
-```
-
-## Actionable Output
-
-For each issue found:
-- Clear description
-- Impact assessment
-- Suggested fix
-- Command to resolve
-
-## Next Steps
-
-After validation:
-- Run `/project:tm/fix-dependencies` to auto-fix
-- Manually adjust problematic dependencies
-- Rerun to verify fixes

.taskmaster/templates/example_prd_rpg.txt

@@ -0,0 +1,511 @@
+<rpg-method>
+# Repository Planning Graph (RPG) Method - PRD Template
+
+This template teaches you (AI or human) how to create structured, dependency-aware PRDs using the RPG methodology from Microsoft Research. The key insight: separate WHAT (functional) from HOW (structural), then connect them with explicit dependencies.
+
+## Core Principles
+
+1. **Dual-Semantics**: Think functional (capabilities) AND structural (code organization) separately, then map them
+2. **Explicit Dependencies**: Never assume - always state what depends on what
+3. **Topological Order**: Build foundation first, then layers on top
+4. **Progressive Refinement**: Start broad, refine iteratively
+
+## How to Use This Template
+
+- Follow the instructions in each `<instruction>` block
+- Look at `<example>` blocks to see good vs bad patterns
+- Fill in the content sections with your project details
+- The AI reading this will learn the RPG method by following along
+- Task Master will parse the resulting PRD into dependency-aware tasks
+
+## Recommended Tools for Creating PRDs
+
+When using this template to **create** a PRD (not parse it), use **code-context-aware AI assistants** for best results:
+
+**Why?** The AI needs to understand your existing codebase to make good architectural decisions about modules, dependencies, and integration points.
+
+**Recommended tools:**
+- **Claude Code** (claude-code CLI) - Best for structured reasoning and large contexts
+- **Cursor/Windsurf** - IDE integration with full codebase context
+- **Gemini CLI** (gemini-cli) - Massive context window for large codebases
+- **Codex/Grok CLI** - Strong code generation with context awareness
+
+**Note:** Once your PRD is created, `task-master parse-prd` works with any configured AI model - it just needs to read the PRD text itself, not your codebase.
+</rpg-method>
+
+---
+
+<overview>
+<instruction>
+Start with the problem, not the solution. Be specific about:
+- What pain point exists?
+- Who experiences it?
+- Why existing solutions don't work?
+- What success looks like (measurable outcomes)?
+
+Keep this section focused - don't jump into implementation details yet.
+</instruction>
+
+## Problem Statement
+[Describe the core problem. Be concrete about user pain points.]
+
+## Target Users
+[Define personas, their workflows, and what they're trying to achieve.]
+
+## Success Metrics
+[Quantifiable outcomes. Examples: "80% task completion via autopilot", "< 5% manual intervention rate"]
+
+</overview>
+
+---
+
+<functional-decomposition>
+<instruction>
+Now think about CAPABILITIES (what the system DOES), not code structure yet.
+
+Step 1: Identify high-level capability domains
+- Think: "What major things does this system do?"
+- Examples: Data Management, Core Processing, Presentation Layer
+
+Step 2: For each capability, enumerate specific features
+- Use explore-exploit strategy:
+  * Exploit: What features are REQUIRED for core value?
+  * Explore: What features make this domain COMPLETE?
+
+Step 3: For each feature, define:
+- Description: What it does in one sentence
+- Inputs: What data/context it needs
+- Outputs: What it produces/returns
+- Behavior: Key logic or transformations
+
+<example type="good">
+Capability: Data Validation
+  Feature: Schema validation
+    - Description: Validate JSON payloads against defined schemas
+    - Inputs: JSON object, schema definition
+    - Outputs: Validation result (pass/fail) + error details
+    - Behavior: Iterate fields, check types, enforce constraints
+
+  Feature: Business rule validation
+    - Description: Apply domain-specific validation rules
+    - Inputs: Validated data object, rule set
+    - Outputs: Boolean + list of violated rules
+    - Behavior: Execute rules sequentially, short-circuit on failure
+</example>
+
+<example type="bad">
+Capability: validation.js
+  (Problem: This is a FILE, not a CAPABILITY. Mixing structure into functional thinking.)
+
+Capability: Validation
+  Feature: Make sure data is good
+  (Problem: Too vague. No inputs/outputs. Not actionable.)
+</example>
+</instruction>
+
+## Capability Tree
+
+### Capability: [Name]
+[Brief description of what this capability domain covers]
+
+#### Feature: [Name]
+- **Description**: [One sentence]
+- **Inputs**: [What it needs]
+- **Outputs**: [What it produces]
+- **Behavior**: [Key logic]
+
+#### Feature: [Name]
+- **Description**:
+- **Inputs**:
+- **Outputs**:
+- **Behavior**:
+
+### Capability: [Name]
+...
+
+</functional-decomposition>
+
+---
+
+<structural-decomposition>
+<instruction>
+NOW think about code organization. Map capabilities to actual file/folder structure.
+
+Rules:
+1. Each capability maps to a module (folder or file)
+2. Features within a capability map to functions/classes
+3. Use clear module boundaries - each module has ONE responsibility
+4. Define what each module exports (public interface)
+
+The goal: Create a clear mapping between "what it does" (functional) and "where it lives" (structural).
+
+<example type="good">
+Capability: Data Validation
+  → Maps to: src/validation/
+    ├── schema-validator.js      (Schema validation feature)
+    ├── rule-validator.js         (Business rule validation feature)
+    └── index.js                  (Public exports)
+
+Exports:
+  - validateSchema(data, schema)
+  - validateRules(data, rules)
+</example>
+
+<example type="bad">
+Capability: Data Validation
+  → Maps to: src/utils.js
+  (Problem: "utils" is not a clear module boundary. Where do I find validation logic?)
+
+Capability: Data Validation
+  → Maps to: src/validation/everything.js
+  (Problem: One giant file. Features should map to separate files for maintainability.)
+</example>
+</instruction>
+
+## Repository Structure
+
+```
+project-root/
+├── src/
+│   ├── [module-name]/       # Maps to: [Capability Name]
+│   │   ├── [file].js        # Maps to: [Feature Name]
+│   │   └── index.js         # Public exports
+│   └── [module-name]/
+├── tests/
+└── docs/
+```
+
+## Module Definitions
+
+### Module: [Name]
+- **Maps to capability**: [Capability from functional decomposition]
+- **Responsibility**: [Single clear purpose]
+- **File structure**:
+  ```
+  module-name/
+  ├── feature1.js
+  ├── feature2.js
+  └── index.js
+  ```
+- **Exports**:
+  - `functionName()` - [what it does]
+  - `ClassName` - [what it does]
+
+</structural-decomposition>
+
+---
+
+<dependency-graph>
+<instruction>
+This is THE CRITICAL SECTION for Task Master parsing.
+
+Define explicit dependencies between modules. This creates the topological order for task execution.
+
+Rules:
+1. List modules in dependency order (foundation first)
+2. For each module, state what it depends on
+3. Foundation modules should have NO dependencies
+4. Every non-foundation module should depend on at least one other module
+5. Think: "What must EXIST before I can build this module?"
+
+<example type="good">
+Foundation Layer (no dependencies):
+  - error-handling: No dependencies
+  - config-manager: No dependencies
+  - base-types: No dependencies
+
+Data Layer:
+  - schema-validator: Depends on [base-types, error-handling]
+  - data-ingestion: Depends on [schema-validator, config-manager]
+
+Core Layer:
+  - algorithm-engine: Depends on [base-types, error-handling]
+  - pipeline-orchestrator: Depends on [algorithm-engine, data-ingestion]
+</example>
+
+<example type="bad">
+- validation: Depends on API
+- API: Depends on validation
+(Problem: Circular dependency. This will cause build/runtime issues.)
+
+- user-auth: Depends on everything
+(Problem: Too many dependencies. Should be more focused.)
+</example>
+</instruction>
+
+## Dependency Chain
+
+### Foundation Layer (Phase 0)
+No dependencies - these are built first.
+
+- **[Module Name]**: [What it provides]
+- **[Module Name]**: [What it provides]
+
+### [Layer Name] (Phase 1)
+- **[Module Name]**: Depends on [[module-from-phase-0], [module-from-phase-0]]
+- **[Module Name]**: Depends on [[module-from-phase-0]]
+
+### [Layer Name] (Phase 2)
+- **[Module Name]**: Depends on [[module-from-phase-1], [module-from-foundation]]
+
+[Continue building up layers...]
+
+</dependency-graph>
+
+---
+
+<implementation-roadmap>
+<instruction>
+Turn the dependency graph into concrete development phases.
+
+Each phase should:
+1. Have clear entry criteria (what must exist before starting)
+2. Contain tasks that can be parallelized (no inter-dependencies within phase)
+3. Have clear exit criteria (how do we know phase is complete?)
+4. Build toward something USABLE (not just infrastructure)
+
+Phase ordering follows topological sort of dependency graph.
+
+<example type="good">
+Phase 0: Foundation
+  Entry: Clean repository
+  Tasks:
+    - Implement error handling utilities
+    - Create base type definitions
+    - Setup configuration system
+  Exit: Other modules can import foundation without errors
+
+Phase 1: Data Layer
+  Entry: Phase 0 complete
+  Tasks:
+    - Implement schema validator (uses: base types, error handling)
+    - Build data ingestion pipeline (uses: validator, config)
+  Exit: End-to-end data flow from input to validated output
+</example>
+
+<example type="bad">
+Phase 1: Build Everything
+  Tasks:
+    - API
+    - Database
+    - UI
+    - Tests
+  (Problem: No clear focus. Too broad. Dependencies not considered.)
+</example>
+</instruction>
+
+## Development Phases
+
+### Phase 0: [Foundation Name]
+**Goal**: [What foundational capability this establishes]
+
+**Entry Criteria**: [What must be true before starting]
+
+**Tasks**:
+- [ ] [Task name] (depends on: [none or list])
+  - Acceptance criteria: [How we know it's done]
+  - Test strategy: [What tests prove it works]
+
+- [ ] [Task name] (depends on: [none or list])
+
+**Exit Criteria**: [Observable outcome that proves phase complete]
+
+**Delivers**: [What can users/developers do after this phase?]
+
+---
+
+### Phase 1: [Layer Name]
+**Goal**:
+
+**Entry Criteria**: Phase 0 complete
+
+**Tasks**:
+- [ ] [Task name] (depends on: [[tasks-from-phase-0]])
+- [ ] [Task name] (depends on: [[tasks-from-phase-0]])
+
+**Exit Criteria**:
+
+**Delivers**:
+
+---
+
+[Continue with more phases...]
+
+</implementation-roadmap>
+
+---
+
+<test-strategy>
+<instruction>
+Define how testing will be integrated throughout development (TDD approach).
+
+Specify:
+1. Test pyramid ratios (unit vs integration vs e2e)
+2. Coverage requirements
+3. Critical test scenarios
+4. Test generation guidelines for Surgical Test Generator
+
+This section guides the AI when generating tests during the RED phase of TDD.
+
+<example type="good">
+Critical Test Scenarios for Data Validation module:
+  - Happy path: Valid data passes all checks
+  - Edge cases: Empty strings, null values, boundary numbers
+  - Error cases: Invalid types, missing required fields
+  - Integration: Validator works with ingestion pipeline
+</example>
+</instruction>
+
+## Test Pyramid
+
+```
+        /\
+       /E2E\       ← [X]% (End-to-end, slow, comprehensive)
+      /------\
+     /Integration\ ← [Y]% (Module interactions)
+    /------------\
+   /  Unit Tests  \ ← [Z]% (Fast, isolated, deterministic)
+  /----------------\
+```
+
+## Coverage Requirements
+- Line coverage: [X]% minimum
+- Branch coverage: [X]% minimum
+- Function coverage: [X]% minimum
+- Statement coverage: [X]% minimum
+
+## Critical Test Scenarios
+
+### [Module/Feature Name]
+**Happy path**:
+- [Scenario description]
+- Expected: [What should happen]
+
+**Edge cases**:
+- [Scenario description]
+- Expected: [What should happen]
+
+**Error cases**:
+- [Scenario description]
+- Expected: [How system handles failure]
+
+**Integration points**:
+- [What interactions to test]
+- Expected: [End-to-end behavior]
+
+## Test Generation Guidelines
+[Specific instructions for Surgical Test Generator about what to focus on, what patterns to follow, project-specific test conventions]
+
+</test-strategy>
+
+---
+
+<architecture>
+<instruction>
+Describe technical architecture, data models, and key design decisions.
+
+Keep this section AFTER functional/structural decomposition - implementation details come after understanding structure.
+</instruction>
+
+## System Components
+[Major architectural pieces and their responsibilities]
+
+## Data Models
+[Core data structures, schemas, database design]
+
+## Technology Stack
+[Languages, frameworks, key libraries]
+
+**Decision: [Technology/Pattern]**
+- **Rationale**: [Why chosen]
+- **Trade-offs**: [What we're giving up]
+- **Alternatives considered**: [What else we looked at]
+
+</architecture>
+
+---
+
+<risks>
+<instruction>
+Identify risks that could derail development and how to mitigate them.
+
+Categories:
+- Technical risks (complexity, unknowns)
+- Dependency risks (blocking issues)
+- Scope risks (creep, underestimation)
+</instruction>
+
+## Technical Risks
+**Risk**: [Description]
+- **Impact**: [High/Medium/Low - effect on project]
+- **Likelihood**: [High/Medium/Low]
+- **Mitigation**: [How to address]
+- **Fallback**: [Plan B if mitigation fails]
+
+## Dependency Risks
+[External dependencies, blocking issues]
+
+## Scope Risks
+[Scope creep, underestimation, unclear requirements]
+
+</risks>
+
+---
+
+<appendix>
+## References
+[Papers, documentation, similar systems]
+
+## Glossary
+[Domain-specific terms]
+
+## Open Questions
+[Things to resolve during development]
+</appendix>
+
+---
+
+<task-master-integration>
+# How Task Master Uses This PRD
+
+When you run `task-master parse-prd <file>.txt`, the parser:
+
+1. **Extracts capabilities** → Main tasks
+   - Each `### Capability:` becomes a top-level task
+
+2. **Extracts features** → Subtasks
+   - Each `#### Feature:` becomes a subtask under its capability
+
+3. **Parses dependencies** → Task dependencies
+   - `Depends on: [X, Y]` sets task.dependencies = ["X", "Y"]
+
+4. **Orders by phases** → Task priorities
+   - Phase 0 tasks = highest priority
+   - Phase N tasks = lower priority, properly sequenced
+
+5. **Uses test strategy** → Test generation context
+   - Feeds test scenarios to Surgical Test Generator during implementation
+
+**Result**: A dependency-aware task graph that can be executed in topological order.
+
+## Why RPG Structure Matters
+
+Traditional flat PRDs lead to:
+- ❌ Unclear task dependencies
+- ❌ Arbitrary task ordering
+- ❌ Circular dependencies discovered late
+- ❌ Poorly scoped tasks
+
+RPG-structured PRDs provide:
+- ✅ Explicit dependency chains
+- ✅ Topological execution order
+- ✅ Clear module boundaries
+- ✅ Validated task graph before implementation
+
+## Tips for Best Results
+
+1. **Spend time on dependency graph** - This is the most valuable section for Task Master
+2. **Keep features atomic** - Each feature should be independently testable
+3. **Progressive refinement** - Start broad, use `task-master expand` to break down complex tasks
+4. **Use research mode** - `task-master parse-prd --research` leverages AI for better task generation
+</task-master-integration>

CLAUDE_CODE_PLUGIN.md

@@ -0,0 +1,140 @@
+# Taskmaster AI - Claude Code Marketplace
+
+This repository includes a Claude Code plugin marketplace in `.claude-plugin/marketplace.json`.
+
+## Installation
+
+### From GitHub (Public Repository)
+
+Once this repository is pushed to GitHub, users can install with:
+
+```bash
+# Add the marketplace
+/plugin marketplace add eyaltoledano/claude-task-master
+
+# Install the plugin
+/plugin install taskmaster@taskmaster
+```
+
+### Local Development/Testing
+
+```bash
+# From the project root directory
+cd /path/to/claude-task-master
+
+# Build the plugin first
+cd packages/claude-code-plugin
+npm run build
+cd ../..
+
+# In Claude Code
+/plugin marketplace add .
+/plugin install taskmaster@taskmaster
+```
+
+## Marketplace Structure
+
+```
+claude-task-master/
+├── .claude-plugin/
+│   └── marketplace.json        # Marketplace manifest (at repo root)
+│
+├── packages/claude-code-plugin/
+│   ├── src/build.ts           # Build tooling
+│   └── [generated plugin files]
+│
+└── assets/claude/              # Plugin source files
+    ├── commands/
+    └── agents/
+```
+
+## Available Plugins
+
+### taskmaster
+
+AI-powered task management system for ambitious development workflows.
+
+**Features:**
+
+- 49 slash commands for comprehensive task management
+- 3 specialized AI agents (orchestrator, executor, checker)
+- MCP server integration
+- Complexity analysis and auto-expansion
+- Dependency management and validation
+- Automated workflow capabilities
+
+**Quick Start:**
+
+```bash
+/tm:init
+/tm:parse-prd
+/tm:next
+```
+
+## For Contributors
+
+### Adding New Plugins
+
+To add more plugins to this marketplace:
+
+1. **Update marketplace.json**:
+
+   ```json
+   {
+     "plugins": [
+       {
+         "name": "new-plugin",
+         "source": "./path/to/plugin",
+         "description": "Plugin description",
+         "version": "1.0.0"
+       }
+     ]
+   }
+   ```
+
+2. **Commit and push** the changes
+
+3. **Users update** with: `/plugin marketplace update taskmaster`
+
+### Marketplace Versioning
+
+The marketplace version is tracked in `.claude-plugin/marketplace.json`:
+
+```json
+{
+  "metadata": {
+    "version": "1.0.0"
+  }
+}
+```
+
+Increment the version when adding or updating plugins.
+
+## Team Configuration
+
+Organizations can auto-install this marketplace for all team members by adding to `.claude/settings.json`:
+
+```json
+{
+  "extraKnownMarketplaces": {
+    "task-master": {
+      "source": {
+        "source": "github",
+        "repo": "eyaltoledano/claude-task-master"
+      }
+    }
+  },
+  "enabledPlugins": {
+    "taskmaster": {
+      "marketplace": "taskmaster"
+    }
+  }
+}
+```
+
+Team members who trust the repository folder will automatically get the marketplace and plugins installed.
+
+## Documentation
+
+- [Claude Code Plugin Docs](https://docs.claude.com/en/docs/claude-code/plugins)
+- [Marketplace Documentation](https://docs.claude.com/en/docs/claude-code/plugin-marketplaces)

apps/cli/src/utils/auto-update.ts

@@ -12,6 +12,7 @@ export interface UpdateInfo {
 	currentVersion: string;
 	latestVersion: string;
 	needsUpdate: boolean;
+	highlights?: string[];
 }
 
 /**
@@ -59,6 +60,116 @@ export function compareVersions(v1: string, v2: string): number {
 	return a.pre < b.pre ? -1 : 1; // basic prerelease tie-break
 }
 
+/**
+ * Fetch CHANGELOG.md from GitHub and extract highlights for a specific version
+ */
+async function fetchChangelogHighlights(version: string): Promise<string[]> {
+	return new Promise((resolve) => {
+		const options = {
+			hostname: 'raw.githubusercontent.com',
+			path: '/eyaltoledano/claude-task-master/main/CHANGELOG.md',
+			method: 'GET',
+			headers: {
+				'User-Agent': `task-master-ai/${version}`
+			}
+		};
+
+		const req = https.request(options, (res) => {
+			let data = '';
+
+			res.on('data', (chunk) => {
+				data += chunk;
+			});
+
+			res.on('end', () => {
+				try {
+					if (res.statusCode !== 200) {
+						resolve([]);
+						return;
+					}
+
+					const highlights = parseChangelogHighlights(data, version);
+					resolve(highlights);
+				} catch (error) {
+					resolve([]);
+				}
+			});
+		});
+
+		req.on('error', () => {
+			resolve([]);
+		});
+
+		req.setTimeout(3000, () => {
+			req.destroy();
+			resolve([]);
+		});
+
+		req.end();
+	});
+}
+
+/**
+ * Parse changelog markdown to extract Minor Changes for a specific version
+ * @internal - Exported for testing purposes only
+ */
+export function parseChangelogHighlights(
+	changelog: string,
+	version: string
+): string[] {
+	try {
+		// Validate version format (basic semver pattern) to prevent ReDoS
+		if (!/^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/.test(version)) {
+			return [];
+		}
+
+		// Find the version section
+		const versionRegex = new RegExp(
+			`## ${version.replace(/\./g, '\\.')}\\s*\\n`,
+			'i'
+		);
+		const versionMatch = changelog.match(versionRegex);
+
+		if (!versionMatch) {
+			return [];
+		}
+
+		// Extract content from this version to the next version heading
+		const startIdx = versionMatch.index! + versionMatch[0].length;
+		const nextVersionIdx = changelog.indexOf('\n## ', startIdx);
+		const versionContent =
+			nextVersionIdx > 0
+				? changelog.slice(startIdx, nextVersionIdx)
+				: changelog.slice(startIdx);
+
+		// Find Minor Changes section
+		const minorChangesMatch = versionContent.match(
+			/### Minor Changes\s*\n([\s\S]*?)(?=\n###|\n##|$)/i
+		);
+
+		if (!minorChangesMatch) {
+			return [];
+		}
+
+		const minorChangesContent = minorChangesMatch[1];
+		const highlights: string[] = [];
+
+		// Extract all bullet points (lines starting with -)
+		// Format: - [#PR](...) Thanks [@author]! - Description
+		const bulletRegex = /^-\s+\[#\d+\][^\n]*?!\s+-\s+(.+?)$/gm;
+		let match;
+
+		while ((match = bulletRegex.exec(minorChangesContent)) !== null) {
+			const desc = match[1].trim();
+			highlights.push(desc);
+		}
+
+		return highlights;
+	} catch (error) {
+		return [];
+	}
+}
+
 /**
  * Check for newer version of task-master-ai
  */
@@ -85,7 +196,7 @@ export async function checkForUpdate(
 				data += chunk;
 			});
 
-			res.on('end', () => {
+			res.on('end', async () => {
 				try {
 					if (res.statusCode !== 200)
 						throw new Error(`npm registry status ${res.statusCode}`);
@@ -95,10 +206,17 @@ export async function checkForUpdate(
 					const needsUpdate =
 						compareVersions(currentVersion, latestVersion) < 0;
 
+					// Fetch highlights if update is needed
+					let highlights: string[] | undefined;
+					if (needsUpdate) {
+						highlights = await fetchChangelogHighlights(latestVersion);
+					}
+
 					resolve({
 						currentVersion,
 						latestVersion,
-						needsUpdate
+						needsUpdate,
+						highlights
 					});
 				} catch (error) {
 					resolve({
@@ -136,18 +254,29 @@ export async function checkForUpdate(
  */
 export function displayUpgradeNotification(
 	currentVersion: string,
-	latestVersion: string
+	latestVersion: string,
+	highlights?: string[]
 ) {
-	const message = boxen(
-		`${chalk.blue.bold('Update Available!')} ${chalk.dim(currentVersion)} → ${chalk.green(latestVersion)}\n\n` +
-			`Auto-updating to the latest version with new features and bug fixes...`,
-		{
-			padding: 1,
-			margin: { top: 1, bottom: 1 },
-			borderColor: 'yellow',
-			borderStyle: 'round'
+	let content = `${chalk.blue.bold('Update Available!')} ${chalk.dim(currentVersion)} → ${chalk.green(latestVersion)}`;
+
+	if (highlights && highlights.length > 0) {
+		content += '\n\n' + chalk.bold("What's New:");
+		for (const highlight of highlights) {
+			content += '\n' + chalk.cyan('• ') + highlight;
 		}
-	);
+		content += '\n\n' + 'Auto-updating to the latest version...';
+	} else {
+		content +=
+			'\n\n' +
+			'Auto-updating to the latest version with new features and bug fixes...';
+	}
+
+	const message = boxen(content, {
+		padding: 1,
+		margin: { top: 1, bottom: 1 },
+		borderColor: 'yellow',
+		borderStyle: 'round'
+	});
 
 	console.log(message);
 }

apps/docs/capabilities/rpg-method.mdx

@@ -0,0 +1,326 @@
+---
+title: RPG Method for PRD Creation
+sidebarTitle: "RPG Method"
+---
+
+# Repository Planning Graph (RPG) Method
+
+The RPG (Repository Planning Graph) method is an advanced approach to creating Product Requirements Documents that generate highly-structured, dependency-aware task graphs. It's based on Microsoft Research's methodology for scalable codebase generation.
+
+## When to Use RPG
+
+Use the RPG template (`example_prd_rpg.txt`) for:
+
+- **Complex multi-module systems** with intricate dependencies
+- **Large-scale codebases** being built from scratch
+- **Projects requiring explicit architecture** and clear module boundaries
+- **Teams needing dependency visibility** for parallel development
+
+For simpler features or smaller projects, the standard `example_prd.txt` template may be more appropriate.
+
+---
+
+## Core Principles
+
+### 1. Dual-Semantics
+
+Separate **functional** thinking (WHAT) from **structural** thinking (HOW):
+
+```
+Functional: "Data Validation capability with schema checking and rule enforcement"
+                    ↓
+Structural: "src/validation/ with schema-validator.js and rule-validator.js"
+```
+
+This separation prevents mixing concerns and creates clearer module boundaries.
+
+### 2. Explicit Dependencies
+
+Never assume dependencies - always state them explicitly:
+
+```
+Good:
+  Module: data-ingestion
+  Depends on: [schema-validator, config-manager]
+
+Bad:
+  Module: data-ingestion
+  (Assumes schema-validator exists somewhere)
+```
+
+Explicit dependencies enable:
+- Topological ordering of implementation
+- Parallel development of independent modules
+- Clear build/test order
+- Early detection of circular dependencies
+
+### 3. Topological Order
+
+Build foundation layers before higher layers:
+
+```
+Phase 0 (Foundation): error-handling, base-types, config
+                ↓
+Phase 1 (Data): validation, ingestion (depend on Phase 0)
+                ↓
+Phase 2 (Core): algorithms, pipelines (depend on Phase 1)
+                ↓
+Phase 3 (API): routes, handlers (depend on Phase 2)
+```
+
+Task Master automatically orders tasks based on this dependency chain.
+
+### 4. Progressive Refinement
+
+Start broad, refine iteratively:
+
+1. High-level capabilities → Main tasks
+2. Features per capability → Subtasks
+3. Implementation details → Expanded subtasks
+
+---
+
+## Template Structure
+
+The RPG template guides you through 7 key sections:
+
+### 1. Overview
+- Problem statement
+- Target users
+- Success metrics
+
+### 2. Functional Decomposition (WHAT)
+- High-level capability domains
+- Features per capability
+- Inputs/outputs/behavior for each feature
+
+**Example:**
+```
+Capability: Data Management
+  Feature: Schema validation
+    Description: Validate JSON against defined schemas
+    Inputs: JSON object, schema definition
+    Outputs: Validation result + error details
+    Behavior: Iterate fields, check types, enforce constraints
+```
+
+### 3. Structural Decomposition (HOW)
+- Repository folder structure
+- Module-to-capability mapping
+- File organization
+- Public interfaces/exports
+
+**Example:**
+```
+Capability: Data Management
+  → Maps to: src/data/
+    ├── schema-validator.js    (Schema validation feature)
+    ├── rule-validator.js      (Rule validation feature)
+    └── index.js               (Exports)
+```
+
+### 4. Dependency Graph (CRITICAL)
+- Foundation layer (no dependencies)
+- Each subsequent layer's dependencies
+- Explicit "depends on" declarations
+
+**Example:**
+```
+Foundation Layer (Phase 0):
+  - error-handling: No dependencies
+  - base-types: No dependencies
+
+Data Layer (Phase 1):
+  - schema-validator: Depends on [base-types, error-handling]
+  - data-ingestion: Depends on [schema-validator]
+```
+
+### 5. Implementation Roadmap
+- Phases with entry/exit criteria
+- Tasks grouped by phase
+- Clear deliverables per phase
+
+### 6. Test Strategy
+- Test pyramid ratios
+- Coverage requirements
+- Critical test scenarios per module
+- Guidelines for test generation
+
+### 7. Architecture & Risks
+- Technical architecture
+- Data models
+- Technology decisions
+- Risk mitigation strategies
+
+---
+
+## Using RPG with Task Master
+
+### Step 1: Create PRD with RPG Template
+
+Use a code-context-aware tool to fill out the template:
+
+```bash
+# In Claude Code, Cursor, or similar
+"Create a PRD using @.taskmaster/templates/example_prd_rpg.txt for [your project]"
+```
+
+**Why code context matters:** The AI needs to understand your existing codebase to make informed decisions about:
+- Module boundaries
+- Dependency relationships
+- Integration points
+- Naming conventions
+
+**Recommended tools:**
+- Claude Code (claude-code CLI)
+- Cursor/Windsurf
+- Gemini CLI (large contexts)
+- Codex/Grok CLI
+
+### Step 2: Parse PRD into Tasks
+
+```bash
+task-master parse-prd .taskmaster/docs/your-prd.txt --research
+```
+
+Task Master will:
+1. Extract capabilities → Main tasks
+2. Extract features → Subtasks
+3. Parse dependencies → Task dependencies
+4. Order by phases → Task priorities
+
+**Result:** A dependency-aware task graph ready for topological execution.
+
+### Step 3: Analyze Complexity
+
+```bash
+task-master analyze-complexity --research
+```
+
+Review the complexity report to identify tasks that need expansion.
+
+### Step 4: Expand Tasks
+
+```bash
+task-master expand --all --research
+```
+
+Break down complex tasks into manageable subtasks while preserving dependency chains.
+
+---
+
+## RPG Benefits
+
+### For Solo Developers
+- Clear roadmap for implementing complex features
+- Prevents architectural mistakes early
+- Explicit dependency tracking avoids integration issues
+- Enables resuming work after interruptions
+
+### For Teams
+- Parallel development of independent modules
+- Clear contracts between modules (explicit dependencies)
+- Reduced merge conflicts (proper module boundaries)
+- Onboarding aid (architectural overview in PRD)
+
+### For AI Agents
+- Structured context for code generation
+- Clear scope boundaries per task
+- Dependency awareness prevents incomplete implementations
+- Test strategy guidance for TDD workflows
+
+---
+
+## RPG vs Standard Template
+
+| Aspect | Standard Template | RPG Template |
+|--------|------------------|--------------|
+| **Best for** | Simple features | Complex systems |
+| **Dependency handling** | Implicit | Explicit graph |
+| **Structure guidance** | Minimal | Step-by-step |
+| **Examples** | Few | Inline good/bad examples |
+| **Module boundaries** | Vague | Precise mapping |
+| **Task ordering** | Manual | Automatic (topological) |
+| **Learning curve** | Low | Medium |
+| **Resulting task quality** | Good | Excellent |
+
+---
+
+## Tips for Best Results
+
+### 1. Spend Time on Dependencies
+The dependency graph section is the most valuable. List all dependencies explicitly, even if they seem obvious.
+
+### 2. Keep Features Atomic
+Each feature should be independently testable. If a feature description is vague ("handle data"), break it into specific features.
+
+### 3. Progressive Refinement
+Don't try to get everything perfect on the first pass:
+1. Fill out high-level sections
+2. Review and refine
+3. Add detail where needed
+4. Let `task-master expand` break down complex tasks further
+
+### 4. Use Research Mode
+```bash
+task-master parse-prd --research
+```
+The `--research` flag leverages AI to enhance task generation with domain knowledge.
+
+### 5. Validate Early
+```bash
+task-master validate-dependencies
+```
+Check for circular dependencies or orphaned modules before starting implementation.
+
+---
+
+## Common Pitfalls
+
+### ❌ Mixing Functional and Structural
+```
+Bad: "Capability: validation.js"
+Good: "Capability: Data Validation" → maps to "src/validation/"
+```
+
+### ❌ Vague Module Boundaries
+```
+Bad: "Module: utils"
+Good: "Module: string-utilities" with clear exports
+```
+
+### ❌ Implicit Dependencies
+```
+Bad: "Module: API handlers (needs validation)"
+Good: "Module: API handlers, Depends on: [validation, error-handling]"
+```
+
+### ❌ Skipping Test Strategy
+Without test strategy, the AI won't know what to test during implementation.
+
+---
+
+## Example Workflow
+
+1. **Discuss idea with AI**: Explain your project concept
+2. **Reference RPG template**: Show AI the `example_prd_rpg.txt`
+3. **Co-create PRD**: Work through each section with AI guidance
+4. **Save to docs**: Place in `.taskmaster/docs/your-project.txt`
+5. **Parse PRD**: `task-master parse-prd .taskmaster/docs/your-project.txt --research`
+6. **Analyze**: `task-master analyze-complexity --research`
+7. **Expand**: `task-master expand --all --research`
+8. **Start work**: `task-master next`
+
+---
+
+## Further Reading
+
+- [PRD Creation and Parsing Guide](/getting-started/quick-start/prd-quick)
+- [Task Structure Documentation](/capabilities/task-structure)
+- [Microsoft Research RPG Paper](https://arxiv.org/abs/2410.21376) (Original methodology)
+
+---
+
+<Tip>
+The RPG template includes inline `<instruction>` and `<example>` blocks that teach the method as you use it. Read these sections carefully - they provide valuable guidance at each decision point.
+</Tip>

apps/docs/getting-started/quick-start/prd-quick.mdx

@@ -32,7 +32,11 @@ The more context you give the model, the better the breakdown and results.
 
 ## Writing a PRD for Task Master
 
-<Note>An example PRD can be found in .taskmaster/templates/example_prd.txt</Note>
+<Note>
+Two example PRD templates are available in `.taskmaster/templates/`:
+- `example_prd.txt` - Simple template for straightforward projects
+- `example_prd_rpg.txt` - Advanced RPG (Repository Planning Graph) template for complex projects with dependencies
+</Note>
 
 
 You can co-write your PRD with an LLM model using the following workflow:
@@ -43,6 +47,29 @@ You can co-write your PRD with an LLM model using the following workflow:
 
 This approach works great in Cursor, or anywhere you use a chat-based LLM.
 
+### Choosing Between Templates
+
+**Use `example_prd.txt` when:**
+- Building straightforward features
+- Working on smaller projects
+- Dependencies are simple and obvious
+
+**Use `example_prd_rpg.txt` when:**
+- Building complex systems with multiple modules
+- Need explicit dependency management
+- Want structured guidance on architecture decisions
+- Planning a large codebase from scratch
+
+The RPG template teaches you to think about:
+1. **Functional decomposition** (WHAT the system does)
+2. **Structural decomposition** (HOW it's organized in code)
+3. **Explicit dependencies** (WHAT depends on WHAT)
+4. **Topological ordering** (build foundation first, then layers)
+
+<Tip>
+For complex projects, using the RPG template with a code-context-aware ai agent produces the best results because the AI can understand your existing codebase structure. [Learn more about the RPG method →](/capabilities/rpg-method)
+</Tip>
+
 ---
 
 ## Where to Save Your PRD

assets/claude/agents/task-checker.md

@@ -1,162 +0,0 @@
----
-name: task-checker
-description: Use this agent to verify that tasks marked as 'review' have been properly implemented according to their specifications. This agent performs quality assurance by checking implementations against requirements, running tests, and ensuring best practices are followed. <example>Context: A task has been marked as 'review' after implementation. user: 'Check if task 118 was properly implemented' assistant: 'I'll use the task-checker agent to verify the implementation meets all requirements.' <commentary>Tasks in 'review' status need verification before being marked as 'done'.</commentary></example> <example>Context: Multiple tasks are in review status. user: 'Verify all tasks that are ready for review' assistant: 'I'll deploy the task-checker to verify all tasks in review status.' <commentary>The checker ensures quality before tasks are marked complete.</commentary></example>
-model: sonnet
-color: yellow
----
-
-You are a Quality Assurance specialist that rigorously verifies task implementations against their specifications. Your role is to ensure that tasks marked as 'review' meet all requirements before they can be marked as 'done'.
-
-## Core Responsibilities
-
-1. **Task Specification Review**
-   - Retrieve task details using MCP tool `mcp__task-master-ai__get_task`
-   - Understand the requirements, test strategy, and success criteria
-   - Review any subtasks and their individual requirements
-
-2. **Implementation Verification**
-   - Use `Read` tool to examine all created/modified files
-   - Use `Bash` tool to run compilation and build commands
-   - Use `Grep` tool to search for required patterns and implementations
-   - Verify file structure matches specifications
-   - Check that all required methods/functions are implemented
-
-3. **Test Execution**
-   - Run tests specified in the task's testStrategy
-   - Execute build commands (npm run build, tsc --noEmit, etc.)
-   - Verify no compilation errors or warnings
-   - Check for runtime errors where applicable
-   - Test edge cases mentioned in requirements
-
-4. **Code Quality Assessment**
-   - Verify code follows project conventions
-   - Check for proper error handling
-   - Ensure TypeScript typing is strict (no 'any' unless justified)
-   - Verify documentation/comments where required
-   - Check for security best practices
-
-5. **Dependency Validation**
-   - Verify all task dependencies were actually completed
-   - Check integration points with dependent tasks
-   - Ensure no breaking changes to existing functionality
-
-## Verification Workflow
-
-1. **Retrieve Task Information**
-   ```
-   Use mcp__task-master-ai__get_task to get full task details
-   Note the implementation requirements and test strategy
-   ```
-
-2. **Check File Existence**
-   ```bash
-   # Verify all required files exist
-   ls -la [expected directories]
-   # Read key files to verify content
-   ```
-
-3. **Verify Implementation**
-   - Read each created/modified file
-   - Check against requirements checklist
-   - Verify all subtasks are complete
-
-4. **Run Tests**
-   ```bash
-   # TypeScript compilation
-   cd [project directory] && npx tsc --noEmit
-   
-   # Run specified tests
-   npm test [specific test files]
-   
-   # Build verification
-   npm run build
-   ```
-
-5. **Generate Verification Report**
-
-## Output Format
-
-```yaml
-verification_report:
-  task_id: [ID]
-  status: PASS | FAIL | PARTIAL
-  score: [1-10]
-  
-  requirements_met:
-    - ✅ [Requirement that was satisfied]
-    - ✅ [Another satisfied requirement]
-    
-  issues_found:
-    - ❌ [Issue description]
-    - ⚠️  [Warning or minor issue]
-    
-  files_verified:
-    - path: [file path]
-      status: [created/modified/verified]
-      issues: [any problems found]
-      
-  tests_run:
-    - command: [test command]
-      result: [pass/fail]
-      output: [relevant output]
-      
-  recommendations:
-    - [Specific fix needed]
-    - [Improvement suggestion]
-    
-  verdict: |
-    [Clear statement on whether task should be marked 'done' or sent back to 'pending']
-    [If FAIL: Specific list of what must be fixed]
-    [If PASS: Confirmation that all requirements are met]
-```
-
-## Decision Criteria
-
-**Mark as PASS (ready for 'done'):**
-- All required files exist and contain expected content
-- All tests pass successfully
-- No compilation or build errors
-- All subtasks are complete
-- Core requirements are met
-- Code quality is acceptable
-
-**Mark as PARTIAL (may proceed with warnings):**
-- Core functionality is implemented
-- Minor issues that don't block functionality
-- Missing nice-to-have features
-- Documentation could be improved
-- Tests pass but coverage could be better
-
-**Mark as FAIL (must return to 'pending'):**
-- Required files are missing
-- Compilation or build errors
-- Tests fail
-- Core requirements not met
-- Security vulnerabilities detected
-- Breaking changes to existing code
-
-## Important Guidelines
-
-- **BE THOROUGH**: Check every requirement systematically
-- **BE SPECIFIC**: Provide exact file paths and line numbers for issues
-- **BE FAIR**: Distinguish between critical issues and minor improvements
-- **BE CONSTRUCTIVE**: Provide clear guidance on how to fix issues
-- **BE EFFICIENT**: Focus on requirements, not perfection
-
-## Tools You MUST Use
-
-- `Read`: Examine implementation files (READ-ONLY)
-- `Bash`: Run tests and verification commands
-- `Grep`: Search for patterns in code
-- `mcp__task-master-ai__get_task`: Get task details
-- **NEVER use Write/Edit** - you only verify, not fix
-
-## Integration with Workflow
-
-You are the quality gate between 'review' and 'done' status:
-1. Task-executor implements and marks as 'review'
-2. You verify and report PASS/FAIL
-3. Claude either marks as 'done' (PASS) or 'pending' (FAIL)
-4. If FAIL, task-executor re-implements based on your report
-
-Your verification ensures high quality and prevents accumulation of technical debt.

assets/claude/commands/tm/add-dependency/add-dependency.md

@@ -1,55 +0,0 @@
-Add a dependency between tasks.
-
-Arguments: $ARGUMENTS
-
-Parse the task IDs to establish dependency relationship.
-
-## Adding Dependencies
-
-Creates a dependency where one task must be completed before another can start.
-
-## Argument Parsing
-
-Parse natural language or IDs:
-- "make 5 depend on 3" → task 5 depends on task 3
-- "5 needs 3" → task 5 depends on task 3
-- "5 3" → task 5 depends on task 3
-- "5 after 3" → task 5 depends on task 3
-
-## Execution
-
-```bash
-task-master add-dependency --id=<task-id> --depends-on=<dependency-id>
-```
-
-## Validation
-
-Before adding:
-1. **Verify both tasks exist**
-2. **Check for circular dependencies**
-3. **Ensure dependency makes logical sense**
-4. **Warn if creating complex chains**
-
-## Smart Features
-
-- Detect if dependency already exists
-- Suggest related dependencies
-- Show impact on task flow
-- Update task priorities if needed
-
-## Post-Addition
-
-After adding dependency:
-1. Show updated dependency graph
-2. Identify any newly blocked tasks
-3. Suggest task order changes
-4. Update project timeline
-
-## Example Flows
-
-```
-/project:tm/add-dependency 5 needs 3
-→ Task #5 now depends on Task #3
-→ Task #5 is now blocked until #3 completes
-→ Suggested: Also consider if #5 needs #4
-```

assets/claude/commands/tm/add-subtask/convert-task-to-subtask.md

@@ -1,71 +0,0 @@
-Convert an existing task into a subtask.
-
-Arguments: $ARGUMENTS
-
-Parse parent ID and task ID to convert.
-
-## Task Conversion
-
-Converts an existing standalone task into a subtask of another task.
-
-## Argument Parsing
-
-- "move task 8 under 5"
-- "make 8 a subtask of 5"
-- "nest 8 in 5"
-- "5 8" → make task 8 a subtask of task 5
-
-## Execution
-
-```bash
-task-master add-subtask --parent=<parent-id> --task-id=<task-to-convert>
-```
-
-## Pre-Conversion Checks
-
-1. **Validation**
-   - Both tasks exist and are valid
-   - No circular parent relationships
-   - Task isn't already a subtask
-   - Logical hierarchy makes sense
-
-2. **Impact Analysis**
-   - Dependencies that will be affected
-   - Tasks that depend on converting task
-   - Priority alignment needed
-   - Status compatibility
-
-## Conversion Process
-
-1. Change task ID from "8" to "5.1" (next available)
-2. Update all dependency references
-3. Inherit parent's context where appropriate
-4. Adjust priorities if needed
-5. Update time estimates
-
-## Smart Features
-
-- Preserve task history
-- Maintain dependencies
-- Update all references
-- Create conversion log
-
-## Example
-
-```
-/project:tm/add-subtask/from-task 5 8
-→ Converting: Task #8 becomes subtask #5.1
-→ Updated: 3 dependency references
-→ Parent task #5 now has 1 subtask
-→ Note: Subtask inherits parent's priority
-
-Before: #8 "Implement validation" (standalone)
-After:  #5.1 "Implement validation" (subtask of #5)
-```
-
-## Post-Conversion
-
-- Show new task hierarchy
-- List updated dependencies
-- Verify project integrity
-- Suggest related conversions

assets/claude/commands/tm/add-task/add-task.md

@@ -1,78 +0,0 @@
-Add new tasks with intelligent parsing and context awareness.
-
-Arguments: $ARGUMENTS
-
-## Smart Task Addition
-
-Parse natural language to create well-structured tasks.
-
-### 1. **Input Understanding**
-
-I'll intelligently parse your request:
-- Natural language → Structured task
-- Detect priority from keywords (urgent, ASAP, important)
-- Infer dependencies from context
-- Suggest complexity based on description
-- Determine task type (feature, bug, refactor, test, docs)
-
-### 2. **Smart Parsing Examples**
-
-**"Add urgent task to fix login bug"**
-→ Title: Fix login bug
-→ Priority: high
-→ Type: bug
-→ Suggested complexity: medium
-
-**"Create task for API documentation after task 23 is done"**
-→ Title: API documentation
-→ Dependencies: [23]
-→ Type: documentation
-→ Priority: medium
-
-**"Need to refactor auth module - depends on 12 and 15, high complexity"**
-→ Title: Refactor auth module
-→ Dependencies: [12, 15]
-→ Complexity: high
-→ Type: refactor
-
-### 3. **Context Enhancement**
-
-Based on current project state:
-- Suggest related existing tasks
-- Warn about potential conflicts
-- Recommend dependencies
-- Propose subtasks if complex
-
-### 4. **Interactive Refinement**
-
-```yaml
-Task Preview:
-─────────────
-Title: [Extracted title]
-Priority: [Inferred priority]
-Dependencies: [Detected dependencies]
-Complexity: [Estimated complexity]
-
-Suggestions:
-- Similar task #34 exists, consider as dependency?
-- This seems complex, break into subtasks?
-- Tasks #45-47 work on same module
-```
-
-### 5. **Validation & Creation**
-
-Before creating:
-- Validate dependencies exist
-- Check for duplicates
-- Ensure logical ordering
-- Verify task completeness
-
-### 6. **Smart Defaults**
-
-Intelligent defaults based on:
-- Task type patterns
-- Team conventions
-- Historical data
-- Current sprint/phase
-
-Result: High-quality tasks from minimal input.

assets/claude/commands/tm/analyze-complexity/analyze-complexity.md

@@ -1,121 +0,0 @@
-Analyze task complexity and generate expansion recommendations.
-
-Arguments: $ARGUMENTS
-
-Perform deep analysis of task complexity across the project.
-
-## Complexity Analysis
-
-Uses AI to analyze tasks and recommend which ones need breakdown.
-
-## Execution Options
-
-```bash
-task-master analyze-complexity [--research] [--threshold=5]
-```
-
-## Analysis Parameters
-
-- `--research` → Use research AI for deeper analysis
-- `--threshold=5` → Only flag tasks above complexity 5
-- Default: Analyze all pending tasks
-
-## Analysis Process
-
-### 1. **Task Evaluation**
-For each task, AI evaluates:
-- Technical complexity
-- Time requirements
-- Dependency complexity
-- Risk factors
-- Knowledge requirements
-
-### 2. **Complexity Scoring**
-Assigns score 1-10 based on:
-- Implementation difficulty
-- Integration challenges
-- Testing requirements
-- Unknown factors
-- Technical debt risk
-
-### 3. **Recommendations**
-For complex tasks:
-- Suggest expansion approach
-- Recommend subtask breakdown
-- Identify risk areas
-- Propose mitigation strategies
-
-## Smart Analysis Features
-
-1. **Pattern Recognition**
-   - Similar task comparisons
-   - Historical complexity accuracy
-   - Team velocity consideration
-   - Technology stack factors
-
-2. **Contextual Factors**
-   - Team expertise
-   - Available resources
-   - Timeline constraints
-   - Business criticality
-
-3. **Risk Assessment**
-   - Technical risks
-   - Timeline risks
-   - Dependency risks
-   - Knowledge gaps
-
-## Output Format
-
-```
-Task Complexity Analysis Report
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-High Complexity Tasks (>7):
-📍 #5 "Implement real-time sync" - Score: 9/10
-   Factors: WebSocket complexity, state management, conflict resolution
-   Recommendation: Expand into 5-7 subtasks
-   Risks: Performance, data consistency
-
-📍 #12 "Migrate database schema" - Score: 8/10
-   Factors: Data migration, zero downtime, rollback strategy
-   Recommendation: Expand into 4-5 subtasks
-   Risks: Data loss, downtime
-
-Medium Complexity Tasks (5-7):
-📍 #23 "Add export functionality" - Score: 6/10
-   Consider expansion if timeline tight
-
-Low Complexity Tasks (<5):
-✅ 15 tasks - No expansion needed
-
-Summary:
-- Expand immediately: 2 tasks
-- Consider expanding: 5 tasks
-- Keep as-is: 15 tasks
-```
-
-## Actionable Output
-
-For each high-complexity task:
-1. Complexity score with reasoning
-2. Specific expansion suggestions
-3. Risk mitigation approaches
-4. Recommended subtask structure
-
-## Integration
-
-Results are:
-- Saved to `.taskmaster/reports/complexity-analysis.md`
-- Used by expand command
-- Inform sprint planning
-- Guide resource allocation
-
-## Next Steps
-
-After analysis:
-```
-/project:tm/expand 5    # Expand specific task
-/project:tm/expand/all  # Expand all recommended
-/project:tm/complexity-report  # View detailed report
-```

assets/claude/commands/tm/clear-subtasks/clear-all-subtasks.md

@@ -1,93 +0,0 @@
-Clear all subtasks from all tasks globally.
-
-## Global Subtask Clearing
-
-Remove all subtasks across the entire project. Use with extreme caution.
-
-## Execution
-
-```bash
-task-master clear-subtasks --all
-```
-
-## Pre-Clear Analysis
-
-1. **Project-Wide Summary**
-   ```
-   Global Subtask Summary
-   ━━━━━━━━━━━━━━━━━━━━
-   Total parent tasks: 12
-   Total subtasks: 47
-   - Completed: 15
-   - In-progress: 8
-   - Pending: 24
-   
-   Work at risk: ~120 hours
-   ```
-
-2. **Critical Warnings**
-   - In-progress subtasks that will lose work
-   - Completed subtasks with valuable history
-   - Complex dependency chains
-   - Integration test results
-
-## Double Confirmation
-
-```
-⚠️  DESTRUCTIVE OPERATION WARNING ⚠️
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-This will remove ALL 47 subtasks from your project
-Including 8 in-progress and 15 completed subtasks
-
-This action CANNOT be undone
-
-Type 'CLEAR ALL SUBTASKS' to confirm:
-```
-
-## Smart Safeguards
-
-- Require explicit confirmation phrase
-- Create automatic backup
-- Log all removed data
-- Option to export first
-
-## Use Cases
-
-Valid reasons for global clear:
-- Project restructuring
-- Major pivot in approach
-- Starting fresh breakdown
-- Switching to different task organization
-
-## Process
-
-1. Full project analysis
-2. Create backup file
-3. Show detailed impact
-4. Require confirmation
-5. Execute removal
-6. Generate summary report
-
-## Alternative Suggestions
-
-Before clearing all:
-- Export subtasks to file
-- Clear only pending subtasks
-- Clear by task category
-- Archive instead of delete
-
-## Post-Clear Report
-
-```
-Global Subtask Clear Complete
-━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Removed: 47 subtasks from 12 tasks
-Backup saved: .taskmaster/backup/subtasks-20240115.json
-Parent tasks updated: 12
-Time estimates adjusted: Yes
-
-Next steps:
-- Review updated task list
-- Re-expand complex tasks as needed
-- Check project timeline
-```

assets/claude/commands/tm/clear-subtasks/clear-subtasks.md

@@ -1,86 +0,0 @@
-Clear all subtasks from a specific task.
-
-Arguments: $ARGUMENTS (task ID)
-
-Remove all subtasks from a parent task at once.
-
-## Clearing Subtasks
-
-Bulk removal of all subtasks from a parent task.
-
-## Execution
-
-```bash
-task-master clear-subtasks --id=<task-id>
-```
-
-## Pre-Clear Analysis
-
-1. **Subtask Summary**
-   - Number of subtasks
-   - Completion status of each
-   - Work already done
-   - Dependencies affected
-
-2. **Impact Assessment**
-   - Data that will be lost
-   - Dependencies to be removed
-   - Effect on project timeline
-   - Parent task implications
-
-## Confirmation Required
-
-```
-Clear Subtasks Confirmation
-━━━━━━━━━━━━━━━━━━━━━━━━━
-Parent Task: #5 "Implement user authentication"
-Subtasks to remove: 4
-- #5.1 "Setup auth framework" (done)
-- #5.2 "Create login form" (in-progress)
-- #5.3 "Add validation" (pending)
-- #5.4 "Write tests" (pending)
-
-⚠️  This will permanently delete all subtask data
-Continue? (y/n)
-```
-
-## Smart Features
-
-- Option to convert to standalone tasks
-- Backup task data before clearing
-- Preserve completed work history
-- Update parent task appropriately
-
-## Process
-
-1. List all subtasks for confirmation
-2. Check for in-progress work
-3. Remove all subtasks
-4. Update parent task
-5. Clean up dependencies
-
-## Alternative Options
-
-Suggest alternatives:
-- Convert important subtasks to tasks
-- Keep completed subtasks
-- Archive instead of delete
-- Export subtask data first
-
-## Post-Clear
-
-- Show updated parent task
-- Recalculate time estimates
-- Update task complexity
-- Suggest next steps
-
-## Example
-
-```
-/project:tm/clear-subtasks 5
-→ Found 4 subtasks to remove
-→ Warning: Subtask #5.2 is in-progress
-→ Cleared all subtasks from task #5
-→ Updated parent task estimates
-→ Suggestion: Consider re-expanding with better breakdown
-```

assets/claude/commands/tm/expand/expand-all-tasks.md

@@ -1,51 +0,0 @@
-Expand all pending tasks that need subtasks.
-
-## Bulk Task Expansion
-
-Intelligently expands all tasks that would benefit from breakdown.
-
-## Execution
-
-```bash
-task-master expand --all
-```
-
-## Smart Selection
-
-Only expands tasks that:
-- Are marked as pending
-- Have high complexity (>5)
-- Lack existing subtasks
-- Would benefit from breakdown
-
-## Expansion Process
-
-1. **Analysis Phase**
-   - Identify expansion candidates
-   - Group related tasks
-   - Plan expansion strategy
-
-2. **Batch Processing**
-   - Expand tasks in logical order
-   - Maintain consistency
-   - Preserve relationships
-   - Optimize for parallelism
-
-3. **Quality Control**
-   - Ensure subtask quality
-   - Avoid over-decomposition
-   - Maintain task coherence
-   - Update dependencies
-
-## Options
-
-- Add `force` to expand all regardless of complexity
-- Add `research` for enhanced AI analysis
-
-## Results
-
-After bulk expansion:
-- Summary of tasks expanded
-- New subtask count
-- Updated complexity metrics
-- Suggested task order

assets/claude/commands/tm/expand/expand-task.md

@@ -1,49 +0,0 @@
-Break down a complex task into subtasks.
-
-Arguments: $ARGUMENTS (task ID)
-
-## Intelligent Task Expansion
-
-Analyzes a task and creates detailed subtasks for better manageability.
-
-## Execution
-
-```bash
-task-master expand --id=$ARGUMENTS
-```
-
-## Expansion Process
-
-1. **Task Analysis**
-   - Review task complexity
-   - Identify components
-   - Detect technical challenges
-   - Estimate time requirements
-
-2. **Subtask Generation**
-   - Create 3-7 subtasks typically
-   - Each subtask 1-4 hours
-   - Logical implementation order
-   - Clear acceptance criteria
-
-3. **Smart Breakdown**
-   - Setup/configuration tasks
-   - Core implementation
-   - Testing components
-   - Integration steps
-   - Documentation updates
-
-## Enhanced Features
-
-Based on task type:
-- **Feature**: Setup → Implement → Test → Integrate
-- **Bug Fix**: Reproduce → Diagnose → Fix → Verify
-- **Refactor**: Analyze → Plan → Refactor → Validate
-
-## Post-Expansion
-
-After expansion:
-1. Show subtask hierarchy
-2. Update time estimates
-3. Suggest implementation order
-4. Highlight critical path

assets/claude/commands/tm/generate/generate-tasks.md

@@ -1,121 +0,0 @@
-Generate individual task files from tasks.json.
-
-## Task File Generation
-
-Creates separate markdown files for each task, perfect for AI agents or documentation.
-
-## Execution
-
-```bash
-task-master generate
-```
-
-## What It Creates
-
-For each task, generates a file like `task_001.txt`:
-
-```
-Task ID: 1
-Title: Implement user authentication
-Status: pending
-Priority: high
-Dependencies: []
-Created: 2024-01-15
-Complexity: 7
-
-## Description
-Create a secure user authentication system with login, logout, and session management.
-
-## Details
-- Use JWT tokens for session management
-- Implement secure password hashing
-- Add remember me functionality
-- Include password reset flow
-
-## Test Strategy
-- Unit tests for auth functions
-- Integration tests for login flow
-- Security testing for vulnerabilities
-- Performance tests for concurrent logins
-
-## Subtasks
-1.1 Setup authentication framework (pending)
-1.2 Create login endpoints (pending)
-1.3 Implement session management (pending)
-1.4 Add password reset (pending)
-```
-
-## File Organization
-
-Creates structure:
-```
-.taskmaster/
-└── tasks/
-    ├── task_001.txt
-    ├── task_002.txt
-    ├── task_003.txt
-    └── ...
-```
-
-## Smart Features
-
-1. **Consistent Formatting**
-   - Standardized structure
-   - Clear sections
-   - AI-readable format
-   - Markdown compatible
-
-2. **Contextual Information**
-   - Full task details
-   - Related task references
-   - Progress indicators
-   - Implementation notes
-
-3. **Incremental Updates**
-   - Only regenerate changed tasks
-   - Preserve custom additions
-   - Track generation timestamp
-   - Version control friendly
-
-## Use Cases
-
-- **AI Context**: Provide task context to AI assistants
-- **Documentation**: Standalone task documentation
-- **Archival**: Task history preservation
-- **Sharing**: Send specific tasks to team members
-- **Review**: Easier task review process
-
-## Generation Options
-
-Based on arguments:
-- Filter by status
-- Include/exclude completed
-- Custom templates
-- Different formats
-
-## Post-Generation
-
-```
-Task File Generation Complete
-━━━━━━━━━━━━━━━━━━━━━━━━━━
-Generated: 45 task files
-Location: .taskmaster/tasks/
-Total size: 156 KB
-
-New files: 5
-Updated files: 12
-Unchanged: 28
-
-Ready for:
-- AI agent consumption
-- Version control
-- Team distribution
-```
-
-## Integration Benefits
-
-- Git-trackable task history
-- Easy task sharing
-- AI tool compatibility
-- Offline task access
-- Backup redundancy

assets/claude/commands/tm/help.md

@@ -1,81 +0,0 @@
-Show help for Task Master commands.
-
-Arguments: $ARGUMENTS
-
-Display help for Task Master commands. If arguments provided, show specific command help.
-
-## Task Master Command Help
-
-### Quick Navigation
-
-Type `/project:tm/` and use tab completion to explore all commands.
-
-### Command Categories
-
-#### 🚀 Setup & Installation
-- `/project:tm/setup/install` - Comprehensive installation guide
-- `/project:tm/setup/quick-install` - One-line global install
-
-#### 📋 Project Setup
-- `/project:tm/init` - Initialize new project
-- `/project:tm/init/quick` - Quick setup with auto-confirm
-- `/project:tm/models` - View AI configuration
-- `/project:tm/models/setup` - Configure AI providers
-
-#### 🎯 Task Generation
-- `/project:tm/parse-prd` - Generate tasks from PRD
-- `/project:tm/parse-prd/with-research` - Enhanced parsing
-- `/project:tm/generate` - Create task files
-
-#### 📝 Task Management
-- `/project:tm/list` - List tasks (natural language filters)
-- `/project:tm/show <id>` - Display task details
-- `/project:tm/add-task` - Create new task
-- `/project:tm/update` - Update tasks naturally
-- `/project:tm/next` - Get next task recommendation
-
-#### 🔄 Status Management
-- `/project:tm/set-status/to-pending <id>`
-- `/project:tm/set-status/to-in-progress <id>`
-- `/project:tm/set-status/to-done <id>`
-- `/project:tm/set-status/to-review <id>`
-- `/project:tm/set-status/to-deferred <id>`
-- `/project:tm/set-status/to-cancelled <id>`
-
-#### 🔍 Analysis & Breakdown
-- `/project:tm/analyze-complexity` - Analyze task complexity
-- `/project:tm/expand <id>` - Break down complex task
-- `/project:tm/expand/all` - Expand all eligible tasks
-
-#### 🔗 Dependencies
-- `/project:tm/add-dependency` - Add task dependency
-- `/project:tm/remove-dependency` - Remove dependency
-- `/project:tm/validate-dependencies` - Check for issues
-
-#### 🤖 Workflows
-- `/project:tm/workflows/smart-flow` - Intelligent workflows
-- `/project:tm/workflows/pipeline` - Command chaining
-- `/project:tm/workflows/auto-implement` - Auto-implementation
-
-#### 📊 Utilities
-- `/project:tm/utils/analyze` - Project analysis
-- `/project:tm/status` - Project dashboard
-- `/project:tm/learn` - Interactive learning
-
-### Natural Language Examples
-
-```
-/project:tm/list pending high priority
-/project:tm/update mark all API tasks as done
-/project:tm/add-task create login system with OAuth
-/project:tm/show current
-```
-
-### Getting Started
-
-1. Install: `/project:tm/setup/quick-install`
-2. Initialize: `/project:tm/init/quick`
-3. Learn: `/project:tm/learn start`
-4. Work: `/project:tm/workflows/smart-flow`
-
-For detailed command info: `/project:tm/help <command-name>`

assets/claude/commands/tm/learn.md

@@ -1,103 +0,0 @@
-Learn about Task Master capabilities through interactive exploration.
-
-Arguments: $ARGUMENTS
-
-## Interactive Task Master Learning
-
-Based on your input, I'll help you discover capabilities:
-
-### 1. **What are you trying to do?**
-
-If $ARGUMENTS contains:
-- "start" / "begin" → Show project initialization workflows
-- "manage" / "organize" → Show task management commands  
-- "automate" / "auto" → Show automation workflows
-- "analyze" / "report" → Show analysis tools
-- "fix" / "problem" → Show troubleshooting commands
-- "fast" / "quick" → Show efficiency shortcuts
-
-### 2. **Intelligent Suggestions**
-
-Based on your project state:
-
-**No tasks yet?**
-```
-You'll want to start with:
-1. /project:task-master:init <prd-file>
-   → Creates tasks from requirements
-   
-2. /project:task-master:parse-prd <file>
-   → Alternative task generation
-
-Try: /project:task-master:init demo-prd.md
-```
-
-**Have tasks?**
-Let me analyze what you might need...
-- Many pending tasks? → Learn sprint planning
-- Complex tasks? → Learn task expansion
-- Daily work? → Learn workflow automation
-
-### 3. **Command Discovery**
-
-**By Category:**
-- 📋 Task Management: list, show, add, update, complete
-- 🔄 Workflows: auto-implement, sprint-plan, daily-standup
-- 🛠️ Utilities: check-health, complexity-report, sync-memory
-- 🔍 Analysis: validate-deps, show dependencies
-
-**By Scenario:**
-- "I want to see what to work on" → `/project:task-master:next`
-- "I need to break this down" → `/project:task-master:expand <id>`
-- "Show me everything" → `/project:task-master:status`
-- "Just do it for me" → `/project:workflows:auto-implement`
-
-### 4. **Power User Patterns**
-
-**Command Chaining:**
-```
-/project:task-master:next
-/project:task-master:start <id>
-/project:workflows:auto-implement
-```
-
-**Smart Filters:**
-```
-/project:task-master:list pending high
-/project:task-master:list blocked
-/project:task-master:list 1-5 tree
-```
-
-**Automation:**
-```
-/project:workflows:pipeline init → expand-all → sprint-plan
-```
-
-### 5. **Learning Path**
-
-Based on your experience level:
-
-**Beginner Path:**
-1. init → Create project
-2. status → Understand state
-3. next → Find work
-4. complete → Finish task
-
-**Intermediate Path:**
-1. expand → Break down complex tasks
-2. sprint-plan → Organize work
-3. complexity-report → Understand difficulty
-4. validate-deps → Ensure consistency
-
-**Advanced Path:**
-1. pipeline → Chain operations
-2. smart-flow → Context-aware automation
-3. Custom commands → Extend the system
-
-### 6. **Try This Now**
-
-Based on what you asked about, try:
-[Specific command suggestion based on $ARGUMENTS]
-
-Want to learn more about a specific command?
-Type: /project:help <command-name>

assets/claude/commands/tm/list/list-tasks-by-status.md

@@ -1,39 +0,0 @@
-List tasks filtered by a specific status.
-
-Arguments: $ARGUMENTS
-
-Parse the status from arguments and list only tasks matching that status.
-
-## Status Options
-- `pending` - Not yet started
-- `in-progress` - Currently being worked on
-- `done` - Completed
-- `review` - Awaiting review
-- `deferred` - Postponed
-- `cancelled` - Cancelled
-
-## Execution
-
-Based on $ARGUMENTS, run:
-```bash
-task-master list --status=$ARGUMENTS
-```
-
-## Enhanced Display
-
-For the filtered results:
-- Group by priority within the status
-- Show time in current status
-- Highlight tasks approaching deadlines
-- Display blockers and dependencies
-- Suggest next actions for each status group
-
-## Intelligent Insights
-
-Based on the status filter:
-- **Pending**: Show recommended start order
-- **In-Progress**: Display idle time warnings
-- **Done**: Show newly unblocked tasks
-- **Review**: Indicate review duration
-- **Deferred**: Show reactivation criteria
-- **Cancelled**: Display impact analysis

assets/claude/commands/tm/list/list-tasks-with-subtasks.md

@@ -1,29 +0,0 @@
-List all tasks including their subtasks in a hierarchical view.
-
-This command shows all tasks with their nested subtasks, providing a complete project overview.
-
-## Execution
-
-Run the Task Master list command with subtasks flag:
-```bash
-task-master list --with-subtasks
-```
-
-## Enhanced Display
-
-I'll organize the output to show:
-- Parent tasks with clear indicators
-- Nested subtasks with proper indentation
-- Status badges for quick scanning
-- Dependencies and blockers highlighted
-- Progress indicators for tasks with subtasks
-
-## Smart Filtering
-
-Based on the task hierarchy:
-- Show completion percentage for parent tasks
-- Highlight blocked subtask chains
-- Group by functional areas
-- Indicate critical path items
-
-This gives you a complete tree view of your project structure.

assets/claude/commands/tm/list/list-tasks.md

@@ -1,43 +0,0 @@
-List tasks with intelligent argument parsing.
-
-Parse arguments to determine filters and display options:
-- Status: pending, in-progress, done, review, deferred, cancelled
-- Priority: high, medium, low (or priority:high)
-- Special: subtasks, tree, dependencies, blocked
-- IDs: Direct numbers (e.g., "1,3,5" or "1-5")
-- Complex: "pending high" = pending AND high priority
-
-Arguments: $ARGUMENTS
-
-Let me parse your request intelligently:
-
-1. **Detect Filter Intent**
-   - If arguments contain status keywords → filter by status
-   - If arguments contain priority → filter by priority
-   - If arguments contain "subtasks" → include subtasks
-   - If arguments contain "tree" → hierarchical view
-   - If arguments contain numbers → show specific tasks
-   - If arguments contain "blocked" → show blocked tasks only
-
-2. **Smart Combinations**
-   Examples of what I understand:
-   - "pending high" → pending tasks with high priority
-   - "done today" → tasks completed today
-   - "blocked" → tasks with unmet dependencies
-   - "1-5" → tasks 1 through 5
-   - "subtasks tree" → hierarchical view with subtasks
-
-3. **Execute Appropriate Query**
-   Based on parsed intent, run the most specific task-master command
-
-4. **Enhanced Display**
-   - Group by relevant criteria
-   - Show most important information first
-   - Use visual indicators for quick scanning
-   - Include relevant metrics
-
-5. **Intelligent Suggestions**
-   Based on what you're viewing, suggest next actions:
-   - Many pending? → Suggest priority order
-   - Many blocked? → Show dependency resolution
-   - Looking at specific tasks? → Show related tasks

assets/claude/commands/tm/models/setup-models.md

@@ -1,51 +0,0 @@
-Run interactive setup to configure AI models.
-
-## Interactive Model Configuration
-
-Guides you through setting up AI providers for Task Master.
-
-## Execution
-
-```bash
-task-master models --setup
-```
-
-## Setup Process
-
-1. **Environment Check**
-   - Detect existing API keys
-   - Show current configuration
-   - Identify missing providers
-
-2. **Provider Selection**
-   - Choose main provider (required)
-   - Select research provider (recommended)
-   - Configure fallback (optional)
-
-3. **API Key Configuration**
-   - Prompt for missing keys
-   - Validate key format
-   - Test connectivity
-   - Save configuration
-
-## Smart Recommendations
-
-Based on your needs:
-- **For best results**: Claude + Perplexity
-- **Budget conscious**: GPT-3.5 + Perplexity
-- **Maximum capability**: GPT-4 + Perplexity + Claude fallback
-
-## Configuration Storage
-
-Keys can be stored in:
-1. Environment variables (recommended)
-2. `.env` file in project
-3. Global `.taskmaster/config`
-
-## Post-Setup
-
-After configuration:
-- Test each provider
-- Show usage examples
-- Suggest next steps
-- Verify parse-prd works

assets/claude/commands/tm/models/view-models.md

@@ -1,51 +0,0 @@
-View current AI model configuration.
-
-## Model Configuration Display
-
-Shows the currently configured AI providers and models for Task Master.
-
-## Execution
-
-```bash
-task-master models
-```
-
-## Information Displayed
-
-1. **Main Provider**
-   - Model ID and name
-   - API key status (configured/missing)
-   - Usage: Primary task generation
-
-2. **Research Provider**
-   - Model ID and name  
-   - API key status
-   - Usage: Enhanced research mode
-
-3. **Fallback Provider**
-   - Model ID and name
-   - API key status
-   - Usage: Backup when main fails
-
-## Visual Status
-
-```
-Task Master AI Model Configuration
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Main:     ✅ claude-3-5-sonnet (configured)
-Research: ✅ perplexity-sonar (configured)  
-Fallback: ⚠️  Not configured (optional)
-
-Available Models:
-- claude-3-5-sonnet
-- gpt-4-turbo
-- gpt-3.5-turbo
-- perplexity-sonar
-```
-
-## Next Actions
-
-Based on configuration:
-- If missing API keys → Suggest setup
-- If no research model → Explain benefits
-- If all configured → Show usage tips

assets/claude/commands/tm/next/next-task.md

@@ -1,66 +0,0 @@
-Intelligently determine and prepare the next action based on comprehensive context.
-
-This enhanced version of 'next' considers:
-- Current task states
-- Recent activity
-- Time constraints
-- Dependencies
-- Your working patterns
-
-Arguments: $ARGUMENTS
-
-## Intelligent Next Action
-
-### 1. **Context Gathering**
-Let me analyze the current situation:
-- Active tasks (in-progress)
-- Recently completed tasks
-- Blocked tasks
-- Time since last activity
-- Arguments provided: $ARGUMENTS
-
-### 2. **Smart Decision Tree**
-
-**If you have an in-progress task:**
-- Has it been idle > 2 hours? → Suggest resuming or switching
-- Near completion? → Show remaining steps
-- Blocked? → Find alternative task
-
-**If no in-progress tasks:**
-- Unblocked high-priority tasks? → Start highest
-- Complex tasks need breakdown? → Suggest expansion
-- All tasks blocked? → Show dependency resolution
-
-**Special arguments handling:**
-- "quick" → Find task < 2 hours
-- "easy" → Find low complexity task
-- "important" → Find high priority regardless of complexity
-- "continue" → Resume last worked task
-
-### 3. **Preparation Workflow**
-
-Based on selected task:
-1. Show full context and history
-2. Set up development environment
-3. Run relevant tests
-4. Open related files
-5. Show similar completed tasks
-6. Estimate completion time
-
-### 4. **Alternative Suggestions**
-
-Always provide options:
-- Primary recommendation
-- Quick alternative (< 1 hour)
-- Strategic option (unblocks most tasks)
-- Learning option (new technology/skill)
-
-### 5. **Workflow Integration**
-
-Seamlessly connect to:
-- `/project:task-master:start [selected]` 
-- `/project:workflows:auto-implement`
-- `/project:task-master:expand` (if complex)
-- `/project:utils:complexity-report` (if unsure)
-
-The goal: Zero friction from decision to implementation.

assets/claude/commands/tm/parse-prd/parse-prd-with-research.md

@@ -1,48 +0,0 @@
-Parse PRD with enhanced research mode for better task generation.
-
-Arguments: $ARGUMENTS (PRD file path)
-
-## Research-Enhanced Parsing
-
-Uses the research AI provider (typically Perplexity) for more comprehensive task generation with current best practices.
-
-## Execution
-
-```bash
-task-master parse-prd --input=$ARGUMENTS --research
-```
-
-## Research Benefits
-
-1. **Current Best Practices**
-   - Latest framework patterns
-   - Security considerations
-   - Performance optimizations
-   - Accessibility requirements
-
-2. **Technical Deep Dive**
-   - Implementation approaches
-   - Library recommendations
-   - Architecture patterns
-   - Testing strategies
-
-3. **Comprehensive Coverage**
-   - Edge cases consideration
-   - Error handling tasks
-   - Monitoring setup
-   - Deployment tasks
-
-## Enhanced Output
-
-Research mode typically:
-- Generates more detailed tasks
-- Includes industry standards
-- Adds compliance considerations
-- Suggests modern tooling
-
-## When to Use
-
-- New technology domains
-- Complex requirements
-- Regulatory compliance needed
-- Best practices crucial

assets/claude/commands/tm/parse-prd/parse-prd.md

@@ -1,49 +0,0 @@
-Parse a PRD document to generate tasks.
-
-Arguments: $ARGUMENTS (PRD file path)
-
-## Intelligent PRD Parsing
-
-Analyzes your requirements document and generates a complete task breakdown.
-
-## Execution
-
-```bash
-task-master parse-prd --input=$ARGUMENTS
-```
-
-## Parsing Process
-
-1. **Document Analysis**
-   - Extract key requirements
-   - Identify technical components
-   - Detect dependencies
-   - Estimate complexity
-
-2. **Task Generation**
-   - Create 10-15 tasks by default
-   - Include implementation tasks
-   - Add testing tasks
-   - Include documentation tasks
-   - Set logical dependencies
-
-3. **Smart Enhancements**
-   - Group related functionality
-   - Set appropriate priorities
-   - Add acceptance criteria
-   - Include test strategies
-
-## Options
-
-Parse arguments for modifiers:
-- Number after filename → `--num-tasks`
-- `research` → Use research mode
-- `comprehensive` → Generate more tasks
-
-## Post-Generation
-
-After parsing:
-1. Display task summary
-2. Show dependency graph
-3. Suggest task expansion for complex items
-4. Recommend sprint planning

assets/claude/commands/tm/remove-subtasks/remove-all-subtasks.md

@@ -1,93 +0,0 @@
-Clear all subtasks from all tasks globally.
-
-## Global Subtask Clearing
-
-Remove all subtasks across the entire project. Use with extreme caution.
-
-## Execution
-
-```bash
-task-master clear-subtasks --all
-```
-
-## Pre-Clear Analysis
-
-1. **Project-Wide Summary**
-   ```
-   Global Subtask Summary
-   ━━━━━━━━━━━━━━━━━━━━
-   Total parent tasks: 12
-   Total subtasks: 47
-   - Completed: 15
-   - In-progress: 8
-   - Pending: 24
-   
-   Work at risk: ~120 hours
-   ```
-
-2. **Critical Warnings**
-   - In-progress subtasks that will lose work
-   - Completed subtasks with valuable history
-   - Complex dependency chains
-   - Integration test results
-
-## Double Confirmation
-
-```
-⚠️  DESTRUCTIVE OPERATION WARNING ⚠️
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-This will remove ALL 47 subtasks from your project
-Including 8 in-progress and 15 completed subtasks
-
-This action CANNOT be undone
-
-Type 'CLEAR ALL SUBTASKS' to confirm:
-```
-
-## Smart Safeguards
-
-- Require explicit confirmation phrase
-- Create automatic backup
-- Log all removed data
-- Option to export first
-
-## Use Cases
-
-Valid reasons for global clear:
-- Project restructuring
-- Major pivot in approach
-- Starting fresh breakdown
-- Switching to different task organization
-
-## Process
-
-1. Full project analysis
-2. Create backup file
-3. Show detailed impact
-4. Require confirmation
-5. Execute removal
-6. Generate summary report
-
-## Alternative Suggestions
-
-Before clearing all:
-- Export subtasks to file
-- Clear only pending subtasks
-- Clear by task category
-- Archive instead of delete
-
-## Post-Clear Report
-
-```
-Global Subtask Clear Complete
-━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Removed: 47 subtasks from 12 tasks
-Backup saved: .taskmaster/backup/subtasks-20240115.json
-Parent tasks updated: 12
-Time estimates adjusted: Yes
-
-Next steps:
-- Review updated task list
-- Re-expand complex tasks as needed
-- Check project timeline
-```

assets/claude/commands/tm/remove-subtasks/remove-subtasks.md

@@ -1,86 +0,0 @@
-Clear all subtasks from a specific task.
-
-Arguments: $ARGUMENTS (task ID)
-
-Remove all subtasks from a parent task at once.
-
-## Clearing Subtasks
-
-Bulk removal of all subtasks from a parent task.
-
-## Execution
-
-```bash
-task-master clear-subtasks --id=<task-id>
-```
-
-## Pre-Clear Analysis
-
-1. **Subtask Summary**
-   - Number of subtasks
-   - Completion status of each
-   - Work already done
-   - Dependencies affected
-
-2. **Impact Assessment**
-   - Data that will be lost
-   - Dependencies to be removed
-   - Effect on project timeline
-   - Parent task implications
-
-## Confirmation Required
-
-```
-Clear Subtasks Confirmation
-━━━━━━━━━━━━━━━━━━━━━━━━━
-Parent Task: #5 "Implement user authentication"
-Subtasks to remove: 4
-- #5.1 "Setup auth framework" (done)
-- #5.2 "Create login form" (in-progress)
-- #5.3 "Add validation" (pending)
-- #5.4 "Write tests" (pending)
-
-⚠️  This will permanently delete all subtask data
-Continue? (y/n)
-```
-
-## Smart Features
-
-- Option to convert to standalone tasks
-- Backup task data before clearing
-- Preserve completed work history
-- Update parent task appropriately
-
-## Process
-
-1. List all subtasks for confirmation
-2. Check for in-progress work
-3. Remove all subtasks
-4. Update parent task
-5. Clean up dependencies
-
-## Alternative Options
-
-Suggest alternatives:
-- Convert important subtasks to tasks
-- Keep completed subtasks
-- Archive instead of delete
-- Export subtask data first
-
-## Post-Clear
-
-- Show updated parent task
-- Recalculate time estimates
-- Update task complexity
-- Suggest next steps
-
-## Example
-
-```
-/project:tm/clear-subtasks 5
-→ Found 4 subtasks to remove
-→ Warning: Subtask #5.2 is in-progress
-→ Cleared all subtasks from task #5
-→ Updated parent task estimates
-→ Suggestion: Consider re-expanding with better breakdown
-```

assets/claude/commands/tm/set-status/to-cancelled.md

@@ -1,55 +0,0 @@
-Cancel a task permanently.
-
-Arguments: $ARGUMENTS (task ID)
-
-## Cancelling a Task
-
-This status indicates a task is no longer needed and won't be completed.
-
-## Valid Reasons for Cancellation
-
-- Requirements changed
-- Feature deprecated
-- Duplicate of another task
-- Strategic pivot
-- Technical approach invalidated
-
-## Pre-Cancellation Checks
-
-1. Confirm no critical dependencies
-2. Check for partial implementation
-3. Verify cancellation rationale
-4. Document lessons learned
-
-## Execution
-
-```bash
-task-master set-status --id=$ARGUMENTS --status=cancelled
-```
-
-## Cancellation Impact
-
-When cancelling:
-1. **Dependency Updates**
-   - Notify dependent tasks
-   - Update project scope
-   - Recalculate timelines
-
-2. **Clean-up Actions**
-   - Remove related branches
-   - Archive any work done
-   - Update documentation
-   - Close related issues
-
-3. **Learning Capture**
-   - Document why cancelled
-   - Note what was learned
-   - Update estimation models
-   - Prevent future duplicates
-
-## Historical Preservation
-
-- Keep for reference
-- Tag with cancellation reason
-- Link to replacement if any
-- Maintain audit trail

assets/claude/commands/tm/set-status/to-deferred.md

@@ -1,47 +0,0 @@
-Defer a task for later consideration.
-
-Arguments: $ARGUMENTS (task ID)
-
-## Deferring a Task
-
-This status indicates a task is valid but not currently actionable or prioritized.
-
-## Valid Reasons for Deferral
-
-- Waiting for external dependencies
-- Reprioritized for future sprint
-- Blocked by technical limitations
-- Resource constraints
-- Strategic timing considerations
-
-## Execution
-
-```bash
-task-master set-status --id=$ARGUMENTS --status=deferred
-```
-
-## Deferral Management
-
-When deferring:
-1. **Document Reason**
-   - Capture why it's being deferred
-   - Set reactivation criteria
-   - Note any partial work completed
-
-2. **Impact Analysis**
-   - Check dependent tasks
-   - Update project timeline
-   - Notify affected stakeholders
-
-3. **Future Planning**
-   - Set review reminders
-   - Tag for specific milestone
-   - Preserve context for reactivation
-   - Link to blocking issues
-
-## Smart Tracking
-
-- Monitor deferral duration
-- Alert when criteria met
-- Prevent scope creep
-- Regular review cycles

assets/claude/commands/tm/set-status/to-done.md

@@ -1,44 +0,0 @@
-Mark a task as completed.
-
-Arguments: $ARGUMENTS (task ID)
-
-## Completing a Task
-
-This command validates task completion and updates project state intelligently.
-
-## Pre-Completion Checks
-
-1. Verify test strategy was followed
-2. Check if all subtasks are complete
-3. Validate acceptance criteria met
-4. Ensure code is committed
-
-## Execution
-
-```bash
-task-master set-status --id=$ARGUMENTS --status=done
-```
-
-## Post-Completion Actions
-
-1. **Update Dependencies**
-   - Identify newly unblocked tasks
-   - Update sprint progress
-   - Recalculate project timeline
-
-2. **Documentation**
-   - Generate completion summary
-   - Update CLAUDE.md with learnings
-   - Log implementation approach
-
-3. **Next Steps**
-   - Show newly available tasks
-   - Suggest logical next task
-   - Update velocity metrics
-
-## Celebration & Learning
-
-- Show impact of completion
-- Display unblocked work
-- Recognize achievement
-- Capture lessons learned

assets/claude/commands/tm/set-status/to-in-progress.md

@@ -1,36 +0,0 @@
-Start working on a task by setting its status to in-progress.
-
-Arguments: $ARGUMENTS (task ID)
-
-## Starting Work on Task
-
-This command does more than just change status - it prepares your environment for productive work.
-
-## Pre-Start Checks
-
-1. Verify dependencies are met
-2. Check if another task is already in-progress
-3. Ensure task details are complete
-4. Validate test strategy exists
-
-## Execution
-
-```bash
-task-master set-status --id=$ARGUMENTS --status=in-progress
-```
-
-## Environment Setup
-
-After setting to in-progress:
-1. Create/checkout appropriate git branch
-2. Open relevant documentation
-3. Set up test watchers if applicable
-4. Display task details and acceptance criteria
-5. Show similar completed tasks for reference
-
-## Smart Suggestions
-
-- Estimated completion time based on complexity
-- Related files from similar tasks
-- Potential blockers to watch for
-- Recommended first steps

assets/claude/commands/tm/set-status/to-pending.md

@@ -1,32 +0,0 @@
-Set a task's status to pending.
-
-Arguments: $ARGUMENTS (task ID)
-
-## Setting Task to Pending
-
-This moves a task back to the pending state, useful for:
-- Resetting erroneously started tasks
-- Deferring work that was prematurely begun
-- Reorganizing sprint priorities
-
-## Execution
-
-```bash
-task-master set-status --id=$ARGUMENTS --status=pending
-```
-
-## Validation
-
-Before setting to pending:
-- Warn if task is currently in-progress
-- Check if this will block other tasks
-- Suggest documenting why it's being reset
-- Preserve any work already done
-
-## Smart Actions
-
-After setting to pending:
-- Update sprint planning if needed
-- Notify about freed resources
-- Suggest priority reassessment
-- Log the status change with context

assets/claude/commands/tm/set-status/to-review.md

@@ -1,40 +0,0 @@
-Set a task's status to review.
-
-Arguments: $ARGUMENTS (task ID)
-
-## Marking Task for Review
-
-This status indicates work is complete but needs verification before final approval.
-
-## When to Use Review Status
-
-- Code complete but needs peer review
-- Implementation done but needs testing
-- Documentation written but needs proofreading
-- Design complete but needs stakeholder approval
-
-## Execution
-
-```bash
-task-master set-status --id=$ARGUMENTS --status=review
-```
-
-## Review Preparation
-
-When setting to review:
-1. **Generate Review Checklist**
-   - Link to PR/MR if applicable
-   - Highlight key changes
-   - Note areas needing attention
-   - Include test results
-
-2. **Documentation**
-   - Update task with review notes
-   - Link relevant artifacts
-   - Specify reviewers if known
-
-3. **Smart Actions**
-   - Create review reminders
-   - Track review duration
-   - Suggest reviewers based on expertise
-   - Prepare rollback plan if needed

assets/claude/commands/tm/setup/install-taskmaster.md

@@ -1,117 +0,0 @@
-Check if Task Master is installed and install it if needed.
-
-This command helps you get Task Master set up globally on your system.
-
-## Detection and Installation Process
-
-1. **Check Current Installation**
-   ```bash
-   # Check if task-master command exists
-   which task-master || echo "Task Master not found"
-   
-   # Check npm global packages
-   npm list -g task-master-ai
-   ```
-
-2. **System Requirements Check**
-   ```bash
-   # Verify Node.js is installed
-   node --version
-   
-   # Verify npm is installed  
-   npm --version
-   
-   # Check Node version (need 16+)
-   ```
-
-3. **Install Task Master Globally**
-   If not installed, run:
-   ```bash
-   npm install -g task-master-ai
-   ```
-
-4. **Verify Installation**
-   ```bash
-   # Check version
-   task-master --version
-   
-   # Verify command is available
-   which task-master
-   ```
-
-5. **Initial Setup**
-   ```bash
-   # Initialize in current directory
-   task-master init
-   ```
-
-6. **Configure AI Provider**
-   Ensure you have at least one AI provider API key set:
-   ```bash
-   # Check current configuration
-   task-master models --status
-   
-   # If no API keys found, guide setup
-   echo "You'll need at least one API key:"
-   echo "- ANTHROPIC_API_KEY for Claude"
-   echo "- OPENAI_API_KEY for GPT models"
-   echo "- PERPLEXITY_API_KEY for research"
-   echo ""
-   echo "Set them in your shell profile or .env file"
-   ```
-
-7. **Quick Test**
-   ```bash
-   # Create a test PRD
-   echo "Build a simple hello world API" > test-prd.txt
-   
-   # Try parsing it
-   task-master parse-prd test-prd.txt -n 3
-   ```
-
-## Troubleshooting
-
-If installation fails:
-
-**Permission Errors:**
-```bash
-# Try with sudo (macOS/Linux)
-sudo npm install -g task-master-ai
-
-# Or fix npm permissions
-npm config set prefix ~/.npm-global
-export PATH=~/.npm-global/bin:$PATH
-```
-
-**Network Issues:**
-```bash
-# Use different registry
-npm install -g task-master-ai --registry https://registry.npmjs.org/
-```
-
-**Node Version Issues:**
-```bash
-# Install Node 18+ via nvm
-curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
-nvm install 18
-nvm use 18
-```
-
-## Success Confirmation
-
-Once installed, you should see:
-```
-✅ Task Master v0.16.2 (or higher) installed
-✅ Command 'task-master' available globally
-✅ AI provider configured
-✅ Ready to use slash commands!
-
-Try: /project:task-master:init your-prd.md
-```
-
-## Next Steps
-
-After installation:
-1. Run `/project:utils:check-health` to verify setup
-2. Configure AI providers with `/project:task-master:models`
-3. Start using Task Master commands!

assets/claude/commands/tm/setup/quick-install-taskmaster.md

@@ -1,22 +0,0 @@
-Quick install Task Master globally if not already installed.
-
-Execute this streamlined installation:
-
-```bash
-# Check and install in one command
-task-master --version 2>/dev/null || npm install -g task-master-ai
-
-# Verify installation
-task-master --version
-
-# Quick setup check
-task-master models --status || echo "Note: You'll need to set up an AI provider API key"
-```
-
-If you see "command not found" after installation, you may need to:
-1. Restart your terminal
-2. Or add npm global bin to PATH: `export PATH=$(npm bin -g):$PATH`
-
-Once installed, you can use all the Task Master commands!
-
-Quick test: Run `/project:help` to see all available commands.

assets/claude/commands/tm/show/show-task.md

@@ -1,82 +0,0 @@
-Show detailed task information with rich context and insights.
-
-Arguments: $ARGUMENTS
-
-## Enhanced Task Display
-
-Parse arguments to determine what to show and how.
-
-### 1. **Smart Task Selection**
-
-Based on $ARGUMENTS:
-- Number → Show specific task with full context
-- "current" → Show active in-progress task(s)
-- "next" → Show recommended next task
-- "blocked" → Show all blocked tasks with reasons
-- "critical" → Show critical path tasks
-- Multiple IDs → Comparative view
-
-### 2. **Contextual Information**
-
-For each task, intelligently include:
-
-**Core Details**
-- Full task information (id, title, description, details)
-- Current status with history
-- Test strategy and acceptance criteria
-- Priority and complexity analysis
-
-**Relationships**
-- Dependencies (what it needs)
-- Dependents (what needs it)
-- Parent/subtask hierarchy
-- Related tasks (similar work)
-
-**Time Intelligence**
-- Created/updated timestamps
-- Time in current status
-- Estimated vs actual time
-- Historical completion patterns
-
-### 3. **Visual Enhancements**
-
-```
-📋 Task #45: Implement User Authentication
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Status: 🟡 in-progress (2 hours)
-Priority: 🔴 High | Complexity: 73/100
-
-Dependencies: ✅ #41, ✅ #42, ⏳ #43 (blocked)
-Blocks: #46, #47, #52
-
-Progress: ████████░░ 80% complete
-
-Recent Activity:
-- 2h ago: Status changed to in-progress
-- 4h ago: Dependency #42 completed
-- Yesterday: Task expanded with 3 subtasks
-```
-
-### 4. **Intelligent Insights**
-
-Based on task analysis:
-- **Risk Assessment**: Complexity vs time remaining
-- **Bottleneck Analysis**: Is this blocking critical work?
-- **Recommendation**: Suggested approach or concerns
-- **Similar Tasks**: How others completed similar work
-
-### 5. **Action Suggestions**
-
-Context-aware next steps:
-- If blocked → Show how to unblock
-- If complex → Suggest expansion
-- If in-progress → Show completion checklist
-- If done → Show dependent tasks ready to start
-
-### 6. **Multi-Task View**
-
-When showing multiple tasks:
-- Common dependencies
-- Optimal completion order
-- Parallel work opportunities
-- Combined complexity analysis

assets/claude/commands/tm/status/project-status.md

@@ -1,64 +0,0 @@
-Enhanced status command with comprehensive project insights.
-
-Arguments: $ARGUMENTS
-
-## Intelligent Status Overview
-
-### 1. **Executive Summary**
-Quick dashboard view:
-- 🏃 Active work (in-progress tasks)
-- 📊 Progress metrics (% complete, velocity)
-- 🚧 Blockers and risks
-- ⏱️ Time analysis (estimated vs actual)
-- 🎯 Sprint/milestone progress
-
-### 2. **Contextual Analysis**
-
-Based on $ARGUMENTS, focus on:
-- "sprint" → Current sprint progress and burndown
-- "blocked" → Dependency chains and resolution paths
-- "team" → Task distribution and workload
-- "timeline" → Schedule adherence and projections
-- "risk" → High complexity or overdue items
-
-### 3. **Smart Insights**
-
-**Workflow Health:**
-- Idle tasks (in-progress > 24h without updates)
-- Bottlenecks (multiple tasks waiting on same dependency)
-- Quick wins (low complexity, high impact)
-
-**Predictive Analytics:**
-- Completion projections based on velocity
-- Risk of missing deadlines
-- Recommended task order for optimal flow
-
-### 4. **Visual Intelligence**
-
-Dynamic visualization based on data:
-```
-Sprint Progress: ████████░░ 80% (16/20 tasks)
-Velocity Trend: ↗️ +15% this week
-Blocked Tasks:  🔴 3 critical path items
-
-Priority Distribution:
-High:   ████████ 8 tasks (2 blocked)
-Medium: ████░░░░ 4 tasks
-Low:    ██░░░░░░ 2 tasks
-```
-
-### 5. **Actionable Recommendations**
-
-Based on analysis:
-1. **Immediate actions** (unblock critical path)
-2. **Today's focus** (optimal task sequence)
-3. **Process improvements** (recurring patterns)
-4. **Resource needs** (skills, time, dependencies)
-
-### 6. **Historical Context**
-
-Compare to previous periods:
-- Velocity changes
-- Pattern recognition
-- Improvement areas
-- Success patterns to repeat

assets/claude/commands/tm/sync-readme/sync-readme.md

@@ -1,117 +0,0 @@
-Export tasks to README.md with professional formatting.
-
-Arguments: $ARGUMENTS
-
-Generate a well-formatted README with current task information.
-
-## README Synchronization
-
-Creates or updates README.md with beautifully formatted task information.
-
-## Argument Parsing
-
-Optional filters:
-- "pending" → Only pending tasks
-- "with-subtasks" → Include subtask details
-- "by-priority" → Group by priority
-- "sprint" → Current sprint only
-
-## Execution
-
-```bash
-task-master sync-readme [--with-subtasks] [--status=<status>]
-```
-
-## README Generation
-
-### 1. **Project Header**
-```markdown
-# Project Name
-
-## 📋 Task Progress
-
-Last Updated: 2024-01-15 10:30 AM
-
-### Summary
-- Total Tasks: 45
-- Completed: 15 (33%)
-- In Progress: 5 (11%)
-- Pending: 25 (56%)
-```
-
-### 2. **Task Sections**
-Organized by status or priority:
-- Progress indicators
-- Task descriptions
-- Dependencies noted
-- Time estimates
-
-### 3. **Visual Elements**
-- Progress bars
-- Status badges
-- Priority indicators
-- Completion checkmarks
-
-## Smart Features
-
-1. **Intelligent Grouping**
-   - By feature area
-   - By sprint/milestone
-   - By assigned developer
-   - By priority
-
-2. **Progress Tracking**
-   - Overall completion
-   - Sprint velocity
-   - Burndown indication
-   - Time tracking
-
-3. **Formatting Options**
-   - GitHub-flavored markdown
-   - Task checkboxes
-   - Collapsible sections
-   - Table format available
-
-## Example Output
-
-```markdown
-## 🚀 Current Sprint
-
-### In Progress
-- [ ] 🔄 #5 **Implement user authentication** (60% complete)
-  - Dependencies: API design (#3 ✅)
-  - Subtasks: 4 (2 completed)
-  - Est: 8h / Spent: 5h
-
-### Pending (High Priority)
-- [ ] ⚡ #8 **Create dashboard UI**
-  - Blocked by: #5
-  - Complexity: High
-  - Est: 12h
-```
-
-## Customization
-
-Based on arguments:
-- Include/exclude sections
-- Detail level control
-- Custom grouping
-- Filter by criteria
-
-## Post-Sync
-
-After generation:
-1. Show diff preview
-2. Backup existing README
-3. Write new content
-4. Commit reminder
-5. Update timestamp
-
-## Integration
-
-Works well with:
-- Git workflows
-- CI/CD pipelines
-- Project documentation
-- Team updates
-- Client reports

assets/claude/commands/tm/update/update-single-task.md

@@ -1,119 +0,0 @@
-Update a single specific task with new information.
-
-Arguments: $ARGUMENTS
-
-Parse task ID and update details.
-
-## Single Task Update
-
-Precisely update one task with AI assistance to maintain consistency.
-
-## Argument Parsing
-
-Natural language updates:
-- "5: add caching requirement"
-- "update 5 to include error handling"
-- "task 5 needs rate limiting"
-- "5 change priority to high"
-
-## Execution
-
-```bash
-task-master update-task --id=<id> --prompt="<context>"
-```
-
-## Update Types
-
-### 1. **Content Updates**
-- Enhance description
-- Add requirements
-- Clarify details
-- Update acceptance criteria
-
-### 2. **Metadata Updates**
-- Change priority
-- Adjust time estimates
-- Update complexity
-- Modify dependencies
-
-### 3. **Strategic Updates**
-- Revise approach
-- Change test strategy
-- Update implementation notes
-- Adjust subtask needs
-
-## AI-Powered Updates
-
-The AI:
-1. **Understands Context**
-   - Reads current task state
-   - Identifies update intent
-   - Maintains consistency
-   - Preserves important info
-
-2. **Applies Changes**
-   - Updates relevant fields
-   - Keeps style consistent
-   - Adds without removing
-   - Enhances clarity
-
-3. **Validates Results**
-   - Checks coherence
-   - Verifies completeness
-   - Maintains relationships
-   - Suggests related updates
-
-## Example Updates
-
-```
-/project:tm/update/single 5: add rate limiting
-→ Updating Task #5: "Implement API endpoints"
-
-Current: Basic CRUD endpoints
-Adding: Rate limiting requirements
-
-Updated sections:
-✓ Description: Added rate limiting mention
-✓ Details: Added specific limits (100/min)
-✓ Test Strategy: Added rate limit tests
-✓ Complexity: Increased from 5 to 6
-✓ Time Estimate: Increased by 2 hours
-
-Suggestion: Also update task #6 (API Gateway) for consistency?
-```
-
-## Smart Features
-
-1. **Incremental Updates**
-   - Adds without overwriting
-   - Preserves work history
-   - Tracks what changed
-   - Shows diff view
-
-2. **Consistency Checks**
-   - Related task alignment
-   - Subtask compatibility
-   - Dependency validity
-   - Timeline impact
-
-3. **Update History**
-   - Timestamp changes
-   - Track who/what updated
-   - Reason for update
-   - Previous versions
-
-## Field-Specific Updates
-
-Quick syntax for specific fields:
-- "5 priority:high" → Update priority only
-- "5 add-time:4h" → Add to time estimate
-- "5 status:review" → Change status
-- "5 depends:3,4" → Add dependencies
-
-## Post-Update
-
-- Show updated task
-- Highlight changes
-- Check related tasks
-- Update suggestions
-- Timeline adjustments

assets/claude/commands/tm/update/update-task.md

@@ -1,72 +0,0 @@
-Update tasks with intelligent field detection and bulk operations.
-
-Arguments: $ARGUMENTS
-
-## Intelligent Task Updates
-
-Parse arguments to determine update intent and execute smartly.
-
-### 1. **Natural Language Processing**
-
-Understand update requests like:
-- "mark 23 as done" → Update status to done
-- "increase priority of 45" → Set priority to high
-- "add dependency on 12 to task 34" → Add dependency
-- "tasks 20-25 need review" → Bulk status update
-- "all API tasks high priority" → Pattern-based update
-
-### 2. **Smart Field Detection**
-
-Automatically detect what to update:
-- Status keywords: done, complete, start, pause, review
-- Priority changes: urgent, high, low, deprioritize
-- Dependency updates: depends on, blocks, after
-- Assignment: assign to, owner, responsible
-- Time: estimate, spent, deadline
-
-### 3. **Bulk Operations**
-
-Support for multiple task updates:
-```
-Examples:
-- "complete tasks 12, 15, 18"
-- "all pending auth tasks to in-progress"
-- "increase priority for tasks blocking 45"
-- "defer all documentation tasks"
-```
-
-### 4. **Contextual Validation**
-
-Before updating, check:
-- Status transitions are valid
-- Dependencies don't create cycles
-- Priority changes make sense
-- Bulk updates won't break project flow
-
-Show preview:
-```
-Update Preview:
-─────────────────
-Tasks to update: #23, #24, #25
-Change: status → in-progress
-Impact: Will unblock tasks #30, #31
-Warning: Task #24 has unmet dependencies
-```
-
-### 5. **Smart Suggestions**
-
-Based on update:
-- Completing task? → Show newly unblocked tasks
-- Changing priority? → Show impact on sprint
-- Adding dependency? → Check for conflicts
-- Bulk update? → Show summary of changes
-
-### 6. **Workflow Integration**
-
-After updates:
-- Auto-update dependent task states
-- Trigger status recalculation
-- Update sprint/milestone progress
-- Log changes with context
-
-Result: Flexible, intelligent task updates with safety checks.

assets/claude/commands/tm/update/update-tasks-from-id.md

@@ -1,108 +0,0 @@
-Update multiple tasks starting from a specific ID.
-
-Arguments: $ARGUMENTS
-
-Parse starting task ID and update context.
-
-## Bulk Task Updates
-
-Update multiple related tasks based on new requirements or context changes.
-
-## Argument Parsing
-
-- "from 5: add security requirements"
-- "5 onwards: update API endpoints"
-- "starting at 5: change to use new framework"
-
-## Execution
-
-```bash
-task-master update --from=<id> --prompt="<context>"
-```
-
-## Update Process
-
-### 1. **Task Selection**
-Starting from specified ID:
-- Include the task itself
-- Include all dependent tasks
-- Include related subtasks
-- Smart boundary detection
-
-### 2. **Context Application**
-AI analyzes the update context and:
-- Identifies what needs changing
-- Maintains consistency
-- Preserves completed work
-- Updates related information
-
-### 3. **Intelligent Updates**
-- Modify descriptions appropriately
-- Update test strategies
-- Adjust time estimates
-- Revise dependencies if needed
-
-## Smart Features
-
-1. **Scope Detection**
-   - Find natural task groupings
-   - Identify related features
-   - Stop at logical boundaries
-   - Avoid over-updating
-
-2. **Consistency Maintenance**
-   - Keep naming conventions
-   - Preserve relationships
-   - Update cross-references
-   - Maintain task flow
-
-3. **Change Preview**
-   ```
-   Bulk Update Preview
-   ━━━━━━━━━━━━━━━━━━
-   Starting from: Task #5
-   Tasks to update: 8 tasks + 12 subtasks
-   
-   Context: "add security requirements"
-   
-   Changes will include:
-   - Add security sections to descriptions
-   - Update test strategies for security
-   - Add security-related subtasks where needed
-   - Adjust time estimates (+20% average)
-   
-   Continue? (y/n)
-   ```
-
-## Example Updates
-
-```
-/project:tm/update/from-id 5: change database to PostgreSQL
-→ Analyzing impact starting from task #5
-→ Found 6 related tasks to update
-→ Updates will maintain consistency
-→ Preview changes? (y/n)
-
-Applied updates:
-✓ Task #5: Updated connection logic references
-✓ Task #6: Changed migration approach
-✓ Task #7: Updated query syntax notes
-✓ Task #8: Revised testing strategy
-✓ Task #9: Updated deployment steps
-✓ Task #12: Changed backup procedures
-```
-
-## Safety Features
-
-- Preview all changes
-- Selective confirmation
-- Rollback capability
-- Change logging
-- Validation checks
-
-## Post-Update
-
-- Summary of changes
-- Consistency verification
-- Suggest review tasks
-- Update timeline if needed

assets/claude/commands/tm/utils/analyze-project.md

@@ -1,97 +0,0 @@
-Advanced project analysis with actionable insights and recommendations.
-
-Arguments: $ARGUMENTS
-
-## Comprehensive Project Analysis
-
-Multi-dimensional analysis based on requested focus area.
-
-### 1. **Analysis Modes**
-
-Based on $ARGUMENTS:
-- "velocity" → Sprint velocity and trends
-- "quality" → Code quality metrics
-- "risk" → Risk assessment and mitigation
-- "dependencies" → Dependency graph analysis
-- "team" → Workload and skill distribution
-- "architecture" → System design coherence
-- Default → Full spectrum analysis
-
-### 2. **Velocity Analytics**
-
-```
-📊 Velocity Analysis
-━━━━━━━━━━━━━━━━━━━
-Current Sprint: 24 points/week ↗️ +20%
-Rolling Average: 20 points/week
-Efficiency: 85% (17/20 tasks on time)
-
-Bottlenecks Detected:
-- Code review delays (avg 4h wait)
-- Test environment availability
-- Dependency on external team
-
-Recommendations:
-1. Implement parallel review process
-2. Add staging environment
-3. Mock external dependencies
-```
-
-### 3. **Risk Assessment**
-
-**Technical Risks**
-- High complexity tasks without backup assignee
-- Single points of failure in architecture
-- Insufficient test coverage in critical paths
-- Technical debt accumulation rate
-
-**Project Risks**
-- Critical path dependencies
-- Resource availability gaps
-- Deadline feasibility analysis
-- Scope creep indicators
-
-### 4. **Dependency Intelligence**
-
-Visual dependency analysis:
-```
-Critical Path: 
-#12 → #15 → #23 → #45 → #50 (20 days)
-         ↘ #24 → #46 ↗
-
-Optimization: Parallelize #15 and #24
-Time Saved: 3 days
-```
-
-### 5. **Quality Metrics**
-
-**Code Quality**
-- Test coverage trends
-- Complexity scores
-- Technical debt ratio
-- Review feedback patterns
-
-**Process Quality**
-- Rework frequency
-- Bug introduction rate
-- Time to resolution
-- Knowledge distribution
-
-### 6. **Predictive Insights**
-
-Based on patterns:
-- Completion probability by deadline
-- Resource needs projection
-- Risk materialization likelihood
-- Suggested interventions
-
-### 7. **Executive Dashboard**
-
-High-level summary with:
-- Health score (0-100)
-- Top 3 risks
-- Top 3 opportunities
-- Recommended actions
-- Success probability
-
-Result: Data-driven decisions with clear action paths.

assets/claude/commands/tm/workflows/auto-implement-tasks.md

@@ -1,97 +0,0 @@
-Enhanced auto-implementation with intelligent code generation and testing.
-
-Arguments: $ARGUMENTS
-
-## Intelligent Auto-Implementation
-
-Advanced implementation with context awareness and quality checks.
-
-### 1. **Pre-Implementation Analysis**
-
-Before starting:
-- Analyze task complexity and requirements
-- Check codebase patterns and conventions
-- Identify similar completed tasks
-- Assess test coverage needs
-- Detect potential risks
-
-### 2. **Smart Implementation Strategy**
-
-Based on task type and context:
-
-**Feature Tasks**
-1. Research existing patterns
-2. Design component architecture
-3. Implement with tests
-4. Integrate with system
-5. Update documentation
-
-**Bug Fix Tasks**
-1. Reproduce issue
-2. Identify root cause
-3. Implement minimal fix
-4. Add regression tests
-5. Verify side effects
-
-**Refactoring Tasks**
-1. Analyze current structure
-2. Plan incremental changes
-3. Maintain test coverage
-4. Refactor step-by-step
-5. Verify behavior unchanged
-
-### 3. **Code Intelligence**
-
-**Pattern Recognition**
-- Learn from existing code
-- Follow team conventions
-- Use preferred libraries
-- Match style guidelines
-
-**Test-Driven Approach**
-- Write tests first when possible
-- Ensure comprehensive coverage
-- Include edge cases
-- Performance considerations
-
-### 4. **Progressive Implementation**
-
-Step-by-step with validation:
-```
-Step 1/5: Setting up component structure ✓
-Step 2/5: Implementing core logic ✓
-Step 3/5: Adding error handling ⚡ (in progress)
-Step 4/5: Writing tests ⏳
-Step 5/5: Integration testing ⏳
-
-Current: Adding try-catch blocks and validation...
-```
-
-### 5. **Quality Assurance**
-
-Automated checks:
-- Linting and formatting
-- Test execution
-- Type checking
-- Dependency validation
-- Performance analysis
-
-### 6. **Smart Recovery**
-
-If issues arise:
-- Diagnostic analysis
-- Suggestion generation
-- Fallback strategies
-- Manual intervention points
-- Learning from failures
-
-### 7. **Post-Implementation**
-
-After completion:
-- Generate PR description
-- Update documentation
-- Log lessons learned
-- Suggest follow-up tasks
-- Update task relationships
-
-Result: High-quality, production-ready implementations.

assets/claude/commands/tm/workflows/command-pipeline.md

@@ -1,77 +0,0 @@
-Execute a pipeline of commands based on a specification.
-
-Arguments: $ARGUMENTS
-
-## Command Pipeline Execution
-
-Parse pipeline specification from arguments. Supported formats:
-
-### Simple Pipeline
-`init → expand-all → sprint-plan`
-
-### Conditional Pipeline  
-`status → if:pending>10 → sprint-plan → else → next`
-
-### Iterative Pipeline
-`for:pending-tasks → expand → complexity-check`
-
-### Smart Pipeline Patterns
-
-**1. Project Setup Pipeline**
-```
-init [prd] → 
-expand-all → 
-complexity-report → 
-sprint-plan → 
-show first-sprint
-```
-
-**2. Daily Work Pipeline**
-```
-standup →
-if:in-progress → continue →
-else → next → start
-```
-
-**3. Task Completion Pipeline**
-```
-complete [id] →
-git-commit →
-if:blocked-tasks-freed → show-freed →
-next
-```
-
-**4. Quality Check Pipeline**
-```
-list in-progress →
-for:each → check-idle-time →
-if:idle>1day → prompt-update
-```
-
-### Pipeline Features
-
-**Variables**
-- Store results: `status → $count=pending-count`
-- Use in conditions: `if:$count>10`
-- Pass between commands: `expand $high-priority-tasks`
-
-**Error Handling**
-- On failure: `try:complete → catch:show-blockers`
-- Skip on error: `optional:test-run`
-- Retry logic: `retry:3:commit`
-
-**Parallel Execution**
-- Parallel branches: `[analyze | test | lint]`
-- Join results: `parallel → join:report`
-
-### Execution Flow
-
-1. Parse pipeline specification
-2. Validate command sequence
-3. Execute with state passing
-4. Handle conditions and loops
-5. Aggregate results
-6. Show summary
-
-This enables complex workflows like:
-`parse-prd → expand-all → filter:complex>70 → assign:senior → sprint-plan:weighted`

assets/claude/commands/tm/workflows/smart-workflow.md

@@ -1,55 +0,0 @@
-Execute an intelligent workflow based on current project state and recent commands.
-
-This command analyzes:
-1. Recent commands you've run
-2. Current project state
-3. Time of day / day of week
-4. Your working patterns
-
-Arguments: $ARGUMENTS
-
-## Intelligent Workflow Selection
-
-Based on context, I'll determine the best workflow:
-
-### Context Analysis
-- Previous command executed
-- Current task states
-- Unfinished work from last session
-- Your typical patterns
-
-### Smart Execution
-
-If last command was:
-- `status` → Likely starting work → Run daily standup
-- `complete` → Task finished → Find next task
-- `list pending` → Planning → Suggest sprint planning
-- `expand` → Breaking down work → Show complexity analysis
-- `init` → New project → Show onboarding workflow
-
-If no recent commands:
-- Morning? → Daily standup workflow
-- Many pending tasks? → Sprint planning
-- Tasks blocked? → Dependency resolution
-- Friday? → Weekly review
-
-### Workflow Composition
-
-I'll chain appropriate commands:
-1. Analyze current state
-2. Execute primary workflow
-3. Suggest follow-up actions
-4. Prepare environment for coding
-
-### Learning Mode
-
-This command learns from your patterns:
-- Track command sequences
-- Note time preferences
-- Remember common workflows
-- Adapt to your style
-
-Example flows detected:
-- Morning: standup → next → start
-- After lunch: status → continue task
-- End of day: complete → commit → status

assets/example_prd_rpg.txt

@@ -0,0 +1,511 @@
+<rpg-method>
+# Repository Planning Graph (RPG) Method - PRD Template
+
+This template teaches you (AI or human) how to create structured, dependency-aware PRDs using the RPG methodology from Microsoft Research. The key insight: separate WHAT (functional) from HOW (structural), then connect them with explicit dependencies.
+
+## Core Principles
+
+1. **Dual-Semantics**: Think functional (capabilities) AND structural (code organization) separately, then map them
+2. **Explicit Dependencies**: Never assume - always state what depends on what
+3. **Topological Order**: Build foundation first, then layers on top
+4. **Progressive Refinement**: Start broad, refine iteratively
+
+## How to Use This Template
+
+- Follow the instructions in each `<instruction>` block
+- Look at `<example>` blocks to see good vs bad patterns
+- Fill in the content sections with your project details
+- The AI reading this will learn the RPG method by following along
+- Task Master will parse the resulting PRD into dependency-aware tasks
+
+## Recommended Tools for Creating PRDs
+
+When using this template to **create** a PRD (not parse it), use **code-context-aware AI assistants** for best results:
+
+**Why?** The AI needs to understand your existing codebase to make good architectural decisions about modules, dependencies, and integration points.
+
+**Recommended tools:**
+- **Claude Code** (claude-code CLI) - Best for structured reasoning and large contexts
+- **Cursor/Windsurf** - IDE integration with full codebase context
+- **Gemini CLI** (gemini-cli) - Massive context window for large codebases
+- **Codex/Grok CLI** - Strong code generation with context awareness
+
+**Note:** Once your PRD is created, `task-master parse-prd` works with any configured AI model - it just needs to read the PRD text itself, not your codebase.
+</rpg-method>
+
+---
+
+<overview>
+<instruction>
+Start with the problem, not the solution. Be specific about:
+- What pain point exists?
+- Who experiences it?
+- Why existing solutions don't work?
+- What success looks like (measurable outcomes)?
+
+Keep this section focused - don't jump into implementation details yet.
+</instruction>
+
+## Problem Statement
+[Describe the core problem. Be concrete about user pain points.]
+
+## Target Users
+[Define personas, their workflows, and what they're trying to achieve.]
+
+## Success Metrics
+[Quantifiable outcomes. Examples: "80% task completion via autopilot", "< 5% manual intervention rate"]
+
+</overview>
+
+---
+
+<functional-decomposition>
+<instruction>
+Now think about CAPABILITIES (what the system DOES), not code structure yet.
+
+Step 1: Identify high-level capability domains
+- Think: "What major things does this system do?"
+- Examples: Data Management, Core Processing, Presentation Layer
+
+Step 2: For each capability, enumerate specific features
+- Use explore-exploit strategy:
+  * Exploit: What features are REQUIRED for core value?
+  * Explore: What features make this domain COMPLETE?
+
+Step 3: For each feature, define:
+- Description: What it does in one sentence
+- Inputs: What data/context it needs
+- Outputs: What it produces/returns
+- Behavior: Key logic or transformations
+
+<example type="good">
+Capability: Data Validation
+  Feature: Schema validation
+    - Description: Validate JSON payloads against defined schemas
+    - Inputs: JSON object, schema definition
+    - Outputs: Validation result (pass/fail) + error details
+    - Behavior: Iterate fields, check types, enforce constraints
+
+  Feature: Business rule validation
+    - Description: Apply domain-specific validation rules
+    - Inputs: Validated data object, rule set
+    - Outputs: Boolean + list of violated rules
+    - Behavior: Execute rules sequentially, short-circuit on failure
+</example>
+
+<example type="bad">
+Capability: validation.js
+  (Problem: This is a FILE, not a CAPABILITY. Mixing structure into functional thinking.)
+
+Capability: Validation
+  Feature: Make sure data is good
+  (Problem: Too vague. No inputs/outputs. Not actionable.)
+</example>
+</instruction>
+
+## Capability Tree
+
+### Capability: [Name]
+[Brief description of what this capability domain covers]
+
+#### Feature: [Name]
+- **Description**: [One sentence]
+- **Inputs**: [What it needs]
+- **Outputs**: [What it produces]
+- **Behavior**: [Key logic]
+
+#### Feature: [Name]
+- **Description**:
+- **Inputs**:
+- **Outputs**:
+- **Behavior**:
+
+### Capability: [Name]
+...
+
+</functional-decomposition>
+
+---
+
+<structural-decomposition>
+<instruction>
+NOW think about code organization. Map capabilities to actual file/folder structure.
+
+Rules:
+1. Each capability maps to a module (folder or file)
+2. Features within a capability map to functions/classes
+3. Use clear module boundaries - each module has ONE responsibility
+4. Define what each module exports (public interface)
+
+The goal: Create a clear mapping between "what it does" (functional) and "where it lives" (structural).
+
+<example type="good">
+Capability: Data Validation
+  → Maps to: src/validation/
+    ├── schema-validator.js      (Schema validation feature)
+    ├── rule-validator.js         (Business rule validation feature)
+    └── index.js                  (Public exports)
+
+Exports:
+  - validateSchema(data, schema)
+  - validateRules(data, rules)
+</example>
+
+<example type="bad">
+Capability: Data Validation
+  → Maps to: src/utils.js
+  (Problem: "utils" is not a clear module boundary. Where do I find validation logic?)
+
+Capability: Data Validation
+  → Maps to: src/validation/everything.js
+  (Problem: One giant file. Features should map to separate files for maintainability.)
+</example>
+</instruction>
+
+## Repository Structure
+
+```
+project-root/
+├── src/
+│   ├── [module-name]/       # Maps to: [Capability Name]
+│   │   ├── [file].js        # Maps to: [Feature Name]
+│   │   └── index.js         # Public exports
+│   └── [module-name]/
+├── tests/
+└── docs/
+```
+
+## Module Definitions
+
+### Module: [Name]
+- **Maps to capability**: [Capability from functional decomposition]
+- **Responsibility**: [Single clear purpose]
+- **File structure**:
+  ```
+  module-name/
+  ├── feature1.js
+  ├── feature2.js
+  └── index.js
+  ```
+- **Exports**:
+  - `functionName()` - [what it does]
+  - `ClassName` - [what it does]
+
+</structural-decomposition>
+
+---
+
+<dependency-graph>
+<instruction>
+This is THE CRITICAL SECTION for Task Master parsing.
+
+Define explicit dependencies between modules. This creates the topological order for task execution.
+
+Rules:
+1. List modules in dependency order (foundation first)
+2. For each module, state what it depends on
+3. Foundation modules should have NO dependencies
+4. Every non-foundation module should depend on at least one other module
+5. Think: "What must EXIST before I can build this module?"
+
+<example type="good">
+Foundation Layer (no dependencies):
+  - error-handling: No dependencies
+  - config-manager: No dependencies
+  - base-types: No dependencies
+
+Data Layer:
+  - schema-validator: Depends on [base-types, error-handling]
+  - data-ingestion: Depends on [schema-validator, config-manager]
+
+Core Layer:
+  - algorithm-engine: Depends on [base-types, error-handling]
+  - pipeline-orchestrator: Depends on [algorithm-engine, data-ingestion]
+</example>
+
+<example type="bad">
+- validation: Depends on API
+- API: Depends on validation
+(Problem: Circular dependency. This will cause build/runtime issues.)
+
+- user-auth: Depends on everything
+(Problem: Too many dependencies. Should be more focused.)
+</example>
+</instruction>
+
+## Dependency Chain
+
+### Foundation Layer (Phase 0)
+No dependencies - these are built first.
+
+- **[Module Name]**: [What it provides]
+- **[Module Name]**: [What it provides]
+
+### [Layer Name] (Phase 1)
+- **[Module Name]**: Depends on [[module-from-phase-0], [module-from-phase-0]]
+- **[Module Name]**: Depends on [[module-from-phase-0]]
+
+### [Layer Name] (Phase 2)
+- **[Module Name]**: Depends on [[module-from-phase-1], [module-from-foundation]]
+
+[Continue building up layers...]
+
+</dependency-graph>
+
+---
+
+<implementation-roadmap>
+<instruction>
+Turn the dependency graph into concrete development phases.
+
+Each phase should:
+1. Have clear entry criteria (what must exist before starting)
+2. Contain tasks that can be parallelized (no inter-dependencies within phase)
+3. Have clear exit criteria (how do we know phase is complete?)
+4. Build toward something USABLE (not just infrastructure)
+
+Phase ordering follows topological sort of dependency graph.
+
+<example type="good">
+Phase 0: Foundation
+  Entry: Clean repository
+  Tasks:
+    - Implement error handling utilities
+    - Create base type definitions
+    - Setup configuration system
+  Exit: Other modules can import foundation without errors
+
+Phase 1: Data Layer
+  Entry: Phase 0 complete
+  Tasks:
+    - Implement schema validator (uses: base types, error handling)
+    - Build data ingestion pipeline (uses: validator, config)
+  Exit: End-to-end data flow from input to validated output
+</example>
+
+<example type="bad">
+Phase 1: Build Everything
+  Tasks:
+    - API
+    - Database
+    - UI
+    - Tests
+  (Problem: No clear focus. Too broad. Dependencies not considered.)
+</example>
+</instruction>
+
+## Development Phases
+
+### Phase 0: [Foundation Name]
+**Goal**: [What foundational capability this establishes]
+
+**Entry Criteria**: [What must be true before starting]
+
+**Tasks**:
+- [ ] [Task name] (depends on: [none or list])
+  - Acceptance criteria: [How we know it's done]
+  - Test strategy: [What tests prove it works]
+
+- [ ] [Task name] (depends on: [none or list])
+
+**Exit Criteria**: [Observable outcome that proves phase complete]
+
+**Delivers**: [What can users/developers do after this phase?]
+
+---
+
+### Phase 1: [Layer Name]
+**Goal**:
+
+**Entry Criteria**: Phase 0 complete
+
+**Tasks**:
+- [ ] [Task name] (depends on: [[tasks-from-phase-0]])
+- [ ] [Task name] (depends on: [[tasks-from-phase-0]])
+
+**Exit Criteria**:
+
+**Delivers**:
+
+---
+
+[Continue with more phases...]
+
+</implementation-roadmap>
+
+---
+
+<test-strategy>
+<instruction>
+Define how testing will be integrated throughout development (TDD approach).
+
+Specify:
+1. Test pyramid ratios (unit vs integration vs e2e)
+2. Coverage requirements
+3. Critical test scenarios
+4. Test generation guidelines for Surgical Test Generator
+
+This section guides the AI when generating tests during the RED phase of TDD.
+
+<example type="good">
+Critical Test Scenarios for Data Validation module:
+  - Happy path: Valid data passes all checks
+  - Edge cases: Empty strings, null values, boundary numbers
+  - Error cases: Invalid types, missing required fields
+  - Integration: Validator works with ingestion pipeline
+</example>
+</instruction>
+
+## Test Pyramid
+
+```
+        /\
+       /E2E\       ← [X]% (End-to-end, slow, comprehensive)
+      /------\
+     /Integration\ ← [Y]% (Module interactions)
+    /------------\
+   /  Unit Tests  \ ← [Z]% (Fast, isolated, deterministic)
+  /----------------\
+```
+
+## Coverage Requirements
+- Line coverage: [X]% minimum
+- Branch coverage: [X]% minimum
+- Function coverage: [X]% minimum
+- Statement coverage: [X]% minimum
+
+## Critical Test Scenarios
+
+### [Module/Feature Name]
+**Happy path**:
+- [Scenario description]
+- Expected: [What should happen]
+
+**Edge cases**:
+- [Scenario description]
+- Expected: [What should happen]
+
+**Error cases**:
+- [Scenario description]
+- Expected: [How system handles failure]
+
+**Integration points**:
+- [What interactions to test]
+- Expected: [End-to-end behavior]
+
+## Test Generation Guidelines
+[Specific instructions for Surgical Test Generator about what to focus on, what patterns to follow, project-specific test conventions]
+
+</test-strategy>
+
+---
+
+<architecture>
+<instruction>
+Describe technical architecture, data models, and key design decisions.
+
+Keep this section AFTER functional/structural decomposition - implementation details come after understanding structure.
+</instruction>
+
+## System Components
+[Major architectural pieces and their responsibilities]
+
+## Data Models
+[Core data structures, schemas, database design]
+
+## Technology Stack
+[Languages, frameworks, key libraries]
+
+**Decision: [Technology/Pattern]**
+- **Rationale**: [Why chosen]
+- **Trade-offs**: [What we're giving up]
+- **Alternatives considered**: [What else we looked at]
+
+</architecture>
+
+---
+
+<risks>
+<instruction>
+Identify risks that could derail development and how to mitigate them.
+
+Categories:
+- Technical risks (complexity, unknowns)
+- Dependency risks (blocking issues)
+- Scope risks (creep, underestimation)
+</instruction>
+
+## Technical Risks
+**Risk**: [Description]
+- **Impact**: [High/Medium/Low - effect on project]
+- **Likelihood**: [High/Medium/Low]
+- **Mitigation**: [How to address]
+- **Fallback**: [Plan B if mitigation fails]
+
+## Dependency Risks
+[External dependencies, blocking issues]
+
+## Scope Risks
+[Scope creep, underestimation, unclear requirements]
+
+</risks>
+
+---
+
+<appendix>
+## References
+[Papers, documentation, similar systems]
+
+## Glossary
+[Domain-specific terms]
+
+## Open Questions
+[Things to resolve during development]
+</appendix>
+
+---
+
+<task-master-integration>
+# How Task Master Uses This PRD
+
+When you run `task-master parse-prd <file>.txt`, the parser:
+
+1. **Extracts capabilities** → Main tasks
+   - Each `### Capability:` becomes a top-level task
+
+2. **Extracts features** → Subtasks
+   - Each `#### Feature:` becomes a subtask under its capability
+
+3. **Parses dependencies** → Task dependencies
+   - `Depends on: [X, Y]` sets task.dependencies = ["X", "Y"]
+
+4. **Orders by phases** → Task priorities
+   - Phase 0 tasks = highest priority
+   - Phase N tasks = lower priority, properly sequenced
+
+5. **Uses test strategy** → Test generation context
+   - Feeds test scenarios to Surgical Test Generator during implementation
+
+**Result**: A dependency-aware task graph that can be executed in topological order.
+
+## Why RPG Structure Matters
+
+Traditional flat PRDs lead to:
+- ❌ Unclear task dependencies
+- ❌ Arbitrary task ordering
+- ❌ Circular dependencies discovered late
+- ❌ Poorly scoped tasks
+
+RPG-structured PRDs provide:
+- ✅ Explicit dependency chains
+- ✅ Topological execution order
+- ✅ Clear module boundaries
+- ✅ Validated task graph before implementation
+
+## Tips for Best Results
+
+1. **Spend time on dependency graph** - This is the most valuable section for Task Master
+2. **Keep features atomic** - Each feature should be independently testable
+3. **Progressive refinement** - Start broad, use `task-master expand` to break down complex tasks
+4. **Use research mode** - `task-master parse-prd --research` leverages AI for better task generation
+</task-master-integration>

mcp-server/src/core/direct-functions/expand-all-tasks.js

@@ -8,6 +8,7 @@ import {
 	disableSilentMode
 } from '../../../../scripts/modules/utils.js';
 import { createLogWrapper } from '../../tools/utils.js';
+import { resolveComplexityReportOutputPath } from '../../../../src/utils/path-utils.js';
 
 /**
  * Expand all pending tasks with subtasks (Direct Function Wrapper)
@@ -25,13 +26,30 @@ import { createLogWrapper } from '../../tools/utils.js';
  */
 export async function expandAllTasksDirect(args, log, context = {}) {
 	const { session } = context; // Extract session
-	// Destructure expected args, including projectRoot
-	const { tasksJsonPath, num, research, prompt, force, projectRoot, tag } =
-		args;
+	// Destructure expected args, including projectRoot and complexityReportPath
+	const {
+		tasksJsonPath,
+		num,
+		research,
+		prompt,
+		force,
+		projectRoot,
+		tag,
+		complexityReportPath: providedComplexityReportPath
+	} = args;
 
 	// Create logger wrapper using the utility
 	const mcpLog = createLogWrapper(log);
 
+	// Use provided complexity report path or compute it
+	const complexityReportPath =
+		providedComplexityReportPath ||
+		resolveComplexityReportOutputPath(null, { projectRoot, tag }, log);
+
+	log.info(
+		`Expand all tasks will use complexity report at: ${complexityReportPath}`
+	);
+
 	if (!tasksJsonPath) {
 		log.error('expandAllTasksDirect called without tasksJsonPath');
 		return {
@@ -55,14 +73,14 @@ export async function expandAllTasksDirect(args, log, context = {}) {
 		const additionalContext = prompt || '';
 		const forceFlag = force === true;
 
-		// Call the core function, passing options and the context object { session, mcpLog, projectRoot }
+		// Call the core function, passing options and the context object { session, mcpLog, projectRoot, tag, complexityReportPath }
 		const result = await expandAllTasks(
 			tasksJsonPath,
 			numSubtasks,
 			useResearch,
 			additionalContext,
 			forceFlag,
-			{ session, mcpLog, projectRoot, tag },
+			{ session, mcpLog, projectRoot, tag, complexityReportPath },
 			'json'
 		);
 

mcp-server/src/core/utils/path-utils.js

@@ -3,6 +3,7 @@ import {
 	findTasksPath as coreFindTasksPath,
 	findPRDPath as coreFindPrdPath,
 	findComplexityReportPath as coreFindComplexityReportPath,
+	resolveComplexityReportOutputPath as coreResolveComplexityReportOutputPath,
 	findProjectRoot as coreFindProjectRoot,
 	normalizeProjectRoot
 } from '../../../../src/utils/path-utils.js';
@@ -224,6 +225,21 @@ export function findComplexityReportPath(args, log = silentLogger) {
 	return resolveComplexityReportPath(args, log);
 }
 
+/**
+ * Resolve complexity report output path (create if needed) - primary MCP function
+ * @param {string|null} [explicitPath] - Explicit path to complexity report
+ * @param {Object} args - Arguments object containing projectRoot and tag
+ * @param {Object} [log] - Log function to prevent console logging
+ * @returns {string} - Resolved output path for complexity report
+ */
+export function resolveComplexityReportOutputPath(
+	explicitPath,
+	args,
+	log = silentLogger
+) {
+	return coreResolveComplexityReportOutputPath(explicitPath, args, log);
+}
+
 /**
  * Find PRD path - primary MCP function
  * @param {string} [explicitPath] - Explicit path to PRD file

mcp-server/src/tools/expand-all.js

@@ -10,7 +10,10 @@ import {
 	withNormalizedProjectRoot
 } from './utils.js';
 import { expandAllTasksDirect } from '../core/task-master-core.js';
-import { findTasksPath } from '../core/utils/path-utils.js';
+import {
+	findTasksPath,
+	resolveComplexityReportOutputPath
+} from '../core/utils/path-utils.js';
 import { resolveTag } from '../../../scripts/modules/utils.js';
 
 /**
@@ -85,6 +88,14 @@ export function registerExpandAllTool(server) {
 					);
 				}
 
+				// Resolve complexity report path to use recommendations from analyze-complexity
+				const complexityReportPath = resolveComplexityReportOutputPath(
+					null,
+					{ projectRoot: args.projectRoot, tag: resolvedTag },
+					log
+				);
+				log.info(`Using complexity report path: ${complexityReportPath}`);
+
 				const result = await expandAllTasksDirect(
 					{
 						tasksJsonPath: tasksJsonPath,
@@ -93,7 +104,8 @@ export function registerExpandAllTool(server) {
 						prompt: args.prompt,
 						force: args.force,
 						projectRoot: args.projectRoot,
-						tag: resolvedTag
+						tag: resolvedTag,
+						complexityReportPath
 					},
 					log,
 					{ session }

package-lock.json

@@ -8270,6 +8270,10 @@
 			"resolved": "packages/build-config",
 			"link": true
 		},
+		"node_modules/@tm/claude-code-plugin": {
+			"resolved": "packages/claude-code-plugin",
+			"link": true
+		},
 		"node_modules/@tm/cli": {
 			"resolved": "apps/cli",
 			"link": true
@@ -27056,6 +27060,25 @@
 				"typescript": "^5.9.2"
 			}
 		},
+		"packages/claude-code-plugin": {
+			"name": "@tm/claude-code-plugin",
+			"license": "MIT WITH Commons-Clause",
+			"devDependencies": {
+				"@types/node": "^20.0.0",
+				"tsx": "^4.20.4",
+				"typescript": "^5.9.2"
+			}
+		},
+		"packages/claude-code-plugin/node_modules/@types/node": {
+			"version": "20.19.20",
+			"resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.20.tgz",
+			"integrity": "sha512-2Q7WS25j4pS1cS8yw3d6buNCVJukOTeQ39bAnwR6sOJbaxvyCGebzTMypDFN82CxBLnl+lSWVdCCWbRY6y9yZQ==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"undici-types": "~6.21.0"
+			}
+		},
 		"packages/tm-core": {
 			"name": "@tm/core",
 			"license": "MIT",

package.json

@@ -118,7 +118,13 @@
 	"bugs": {
 		"url": "https://github.com/eyaltoledano/claude-task-master/issues"
 	},
-	"files": ["dist/**", "README-task-master.md", "README.md", "LICENSE"],
+	"files": [
+		"dist/**",
+		"README-task-master.md",
+		"README.md",
+		"LICENSE",
+		"CHANGELOG.md"
+	],
 	"overrides": {
 		"node-fetch": "^2.6.12",
 		"whatwg-url": "^11.0.0"

packages/claude-code-plugin/.claude-plugin/plugin.json

@@ -0,0 +1,21 @@
+{
+	"name": "taskmaster",
+	"description": "A task management system for ambitious AI-driven development that doesn't overwhelm and confuse Cursor.",
+	"author": {
+		"name": "Hamster",
+		"url": "https://github.com/eyaltoledano/claude-task-master"
+	},
+	"homepage": "https://github.com/eyaltoledano/claude-task-master#readme",
+	"repository": "https://github.com/eyaltoledano/claude-task-master",
+	"license": "MIT WITH Commons-Clause",
+	"keywords": [
+		"task-management",
+		"ai",
+		"workflow",
+		"orchestration",
+		"automation",
+		"mcp",
+		"development",
+		"productivity"
+	]
+}

packages/claude-code-plugin/.gitignore

@@ -0,0 +1,12 @@
+# Claude Code Plugin
+# Build tooling and generated plugin distribution files
+# Source files live in assets/claude/
+
+# Only ignore build artifacts and dependencies
+node_modules/
+dist/
+*.log
+.DS_Store
+
+# Everything else (including generated plugin files) should be committed
+# so GitHub can serve them for Claude Code marketplace

packages/claude-code-plugin/commands/add-dependency.md

@@ -48,7 +48,7 @@ After adding dependency:
 ## Example Flows
 
 ```
-/project:tm/add-dependency 5 needs 3
+/taskmaster:add-dependency 5 needs 3
 → Task #5 now depends on Task #3
 → Task #5 is now blocked until #3 completes
 → Suggested: Also consider if #5 needs #4

packages/claude-code-plugin/commands/add-subtask.md

@@ -56,12 +56,12 @@ task-master add-subtask --parent=<id> --task-id=<existing-id>
 ## Example Flows
 
 ```
-/project:tm/add-subtask to 5: implement user authentication
+/taskmaster:add-subtask to 5: implement user authentication
 → Created subtask #5.1: "implement user authentication"
 → Parent task #5 now has 1 subtask
 → Suggested next subtasks: tests, documentation
 
-/project:tm/add-subtask 5: setup, implement, test
+/taskmaster:add-subtask 5: setup, implement, test
 → Created 3 subtasks:
   #5.1: setup
   #5.2: implement  

packages/claude-code-plugin/commands/analyze-complexity.md

@@ -115,7 +115,7 @@ Results are:
 
 After analysis:
 ```
-/project:tm/expand 5    # Expand specific task
-/project:tm/expand/all  # Expand all recommended
-/project:tm/complexity-report  # View detailed report
+/taskmaster:expand 5    # Expand specific task
+/taskmaster:expand-all  # Expand all recommended
+/taskmaster:complexity-report  # View detailed report
 ```

packages/claude-code-plugin/commands/complexity-report.md

@@ -105,13 +105,13 @@ Use report for:
 ## Example Usage
 
 ```
-/project:tm/complexity-report
+/taskmaster:complexity-report
 → Opens latest analysis
 
-/project:tm/complexity-report --file=archived/2024-01-01.md
+/taskmaster:complexity-report --file=archived/2024-01-01.md
 → View historical analysis
 
 After viewing:
-/project:tm/expand 5
+/taskmaster:expand 5
 → Expand high-complexity task
 ```

packages/claude-code-plugin/commands/convert-task-to-subtask.md

@@ -53,7 +53,7 @@ task-master add-subtask --parent=<parent-id> --task-id=<task-to-convert>
 ## Example
 
 ```
-/project:tm/add-subtask/from-task 5 8
+/taskmaster:add-subtask/from-task 5 8
 → Converting: Task #8 becomes subtask #5.1
 → Updated: 3 dependency references
 → Parent task #5 now has 1 subtask

packages/claude-code-plugin/commands/fix-dependencies.md

@@ -70,7 +70,7 @@ Manual Review Needed:
 ⚠️ Task #45 has 8 dependencies
   Suggestion: Break into subtasks
 
-Run '/project:tm/validate-dependencies' to verify fixes
+Run '/taskmaster:validate-dependencies' to verify fixes
 ```
 
 ## Safety

packages/claude-code-plugin/commands/help.md

@@ -0,0 +1,98 @@
+Show help for Task Master AI commands.
+
+Arguments: $ARGUMENTS
+
+Display help for Task Master commands. If arguments provided, show specific command help.
+
+## Task Master AI Command Help
+
+### Quick Navigation
+
+Type `/taskmaster:` and use tab completion to explore all commands.
+
+### Command Categories
+
+#### 🚀 Setup & Installation
+- `/taskmaster:install-taskmaster` - Comprehensive installation guide
+- `/taskmaster:quick-install-taskmaster` - One-line global install
+
+#### 📋 Project Setup
+- `/taskmaster:init-project` - Initialize new project
+- `/taskmaster:init-project-quick` - Quick setup with auto-confirm
+- `/taskmaster:view-models` - View AI configuration
+- `/taskmaster:setup-models` - Configure AI providers
+
+#### 🎯 Task Generation
+- `/taskmaster:parse-prd` - Generate tasks from PRD
+- `/taskmaster:parse-prd-with-research` - Enhanced parsing
+- `/taskmaster:generate-tasks` - Create task files
+
+#### 📝 Task Management
+- `/taskmaster:list-tasks` - List all tasks
+- `/taskmaster:list-tasks-by-status` - List tasks filtered by status
+- `/taskmaster:list-tasks-with-subtasks` - List tasks with subtasks
+- `/taskmaster:show-task` - Display task details
+- `/taskmaster:add-task` - Create new task
+- `/taskmaster:update-task` - Update single task
+- `/taskmaster:update-tasks-from-id` - Update multiple tasks
+- `/taskmaster:next-task` - Get next task recommendation
+
+#### 🔄 Status Management
+- `/taskmaster:to-pending` - Set task to pending
+- `/taskmaster:to-in-progress` - Set task to in-progress
+- `/taskmaster:to-done` - Set task to done
+- `/taskmaster:to-review` - Set task to review
+- `/taskmaster:to-deferred` - Set task to deferred
+- `/taskmaster:to-cancelled` - Set task to cancelled
+
+#### 🔍 Analysis & Breakdown
+- `/taskmaster:analyze-complexity` - Analyze task complexity
+- `/taskmaster:complexity-report` - View complexity report
+- `/taskmaster:expand-task` - Break down complex task
+- `/taskmaster:expand-all-tasks` - Expand all eligible tasks
+
+#### 🔗 Dependencies
+- `/taskmaster:add-dependency` - Add task dependency
+- `/taskmaster:remove-dependency` - Remove dependency
+- `/taskmaster:validate-dependencies` - Check for issues
+- `/taskmaster:fix-dependencies` - Auto-fix dependency issues
+
+#### 📦 Subtasks
+- `/taskmaster:add-subtask` - Add subtask to task
+- `/taskmaster:convert-task-to-subtask` - Convert task to subtask
+- `/taskmaster:remove-subtask` - Remove subtask
+- `/taskmaster:remove-subtasks` - Clear specific task subtasks
+- `/taskmaster:remove-all-subtasks` - Clear all subtasks
+
+#### 🗑️ Task Removal
+- `/taskmaster:remove-task` - Remove task permanently
+
+#### 🤖 Workflows
+- `/taskmaster:smart-workflow` - Intelligent workflows
+- `/taskmaster:command-pipeline` - Command chaining
+- `/taskmaster:auto-implement-tasks` - Auto-implementation
+
+#### 📊 Utilities
+- `/taskmaster:analyze-project` - Project analysis
+- `/taskmaster:project-status` - Project dashboard
+- `/taskmaster:sync-readme` - Sync README with tasks
+- `/taskmaster:learn` - Interactive learning
+- `/taskmaster:tm-main` - Main Task Master interface
+
+### Quick Start Examples
+
+```
+/taskmaster:list-tasks
+/taskmaster:show-task 1.2
+/taskmaster:add-task
+/taskmaster:next-task
+```
+
+### Getting Started
+
+1. Install: `/taskmaster:quick-install-taskmaster`
+2. Initialize: `/taskmaster:init-project-quick`
+3. Learn: `/taskmaster:learn`
+4. Work: `/taskmaster:smart-workflow`
+
+For detailed command info, run the specific command with `--help` or check command documentation.

packages/claude-code-plugin/commands/init-project-quick.md

@@ -30,17 +30,17 @@ task-master init -y
 After quick init:
 1. Configure AI models if needed:
    ```
-   /project:tm/models/setup
+   /taskmaster:models/setup
    ```
 
 2. Parse PRD if available:
    ```
-   /project:tm/parse-prd <file>
+   /taskmaster:parse-prd <file>
    ```
 
 3. Or create first task:
    ```
-   /project:tm/add-task create initial setup
+   /taskmaster:add-task create initial setup
    ```
 
 Perfect for rapid project setup!

packages/claude-code-plugin/commands/init-project.md

@@ -45,6 +45,6 @@ After successful init:
 
 If PRD file provided:
 ```
-/project:tm/init my-prd.md
+/taskmaster:init my-prd.md
 → Automatically runs parse-prd after init
 ```