
taskmaster
AI-powered task management system for ambitious development workflows with intelligent orchestration, complexity analysis, and automated coordination
Install
/plugin install taskmaster@taskmasterRun it inside Claude Code after adding the marketplace with /plugin marketplace add khulnasoft-bot/claude-task.
Contents
Discovered from sourceCommands 47
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
task-master add-dependency --id=<task-id> --depends-on=<dependency-id>
Validation
Before adding:
- Verify both tasks exist
- Check for circular dependencies
- Ensure dependency makes logical sense
- 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:
- Show updated dependency graph
- Identify any newly blocked tasks
- Suggest task order changes
- Update project timeline
Example Flows
/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
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
task-master add-subtask --parent=<id> --title="<title>" --description="<desc>"
2. Convert Existing Task
task-master add-subtask --parent=<id> --task-id=<existing-id>
Smart Features
-
Automatic Subtask Generation
- If title contains "and" or commas, create multiple
- Suggest common subtask patterns
- Inherit parent's context
-
Intelligent Defaults
- Priority based on parent
- Appropriate time estimates
- Logical dependencies between subtasks
-
Validation
- Check parent task complexity
- Warn if too many subtasks
- Ensure subtask makes sense
Creation Process
- Parse parent task context
- Generate subtask with ID like "5.1"
- Set appropriate defaults
- Link to parent task
- Update parent's time estimate
Example Flows
/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
/taskmaster: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
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
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.
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
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
-
Pattern Recognition
- Similar task comparisons
- Historical complexity accuracy
- Team velocity consideration
- Technology stack factors
-
Contextual Factors
- Team expertise
- Available resources
- Timeline constraints
- Business criticality
-
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:
- Complexity score with reasoning
- Specific expansion suggestions
- Risk mitigation approaches
- 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:
/taskmaster:expand 5 # Expand specific task
/taskmaster:expand-all # Expand all recommended
/taskmaster:complexity-report # View detailed report
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.
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
- Research existing patterns
- Design component architecture
- Implement with tests
- Integrate with system
- Update documentation
Bug Fix Tasks
- Reproduce issue
- Identify root cause
- Implement minimal fix
- Add regression tests
- Verify side effects
Refactoring Tasks
- Analyze current structure
- Plan incremental changes
- Maintain test coverage
- Refactor step-by-step
- 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.
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
- Parse pipeline specification
- Validate command sequence
- Execute with state passing
- Handle conditions and loops
- Aggregate results
- Show summary
This enables complex workflows like:
parse-prd → expand-all → filter:complex>70 → assign:senior → sprint-plan:weighted
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
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:
- Expand task #5 - Critical path + high complexity
- Expand task #12 - High risk + dependencies
- 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:
-
Quick Actions
- Press 'e' to expand a task
- Press 'd' for task details
- Press 'r' to refresh analysis
-
Filtering
- View by complexity level
- Filter by risk factors
- Show only actionable items
-
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
/taskmaster:complexity-report
→ Opens latest analysis
/taskmaster:complexity-report --file=archived/2024-01-01.md
→ View historical analysis
After viewing:
/taskmaster:expand 5
→ Expand high-complexity task
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
task-master add-subtask --parent=<parent-id> --task-id=<task-to-convert>
Pre-Conversion Checks
-
Validation
- Both tasks exist and are valid
- No circular parent relationships
- Task isn't already a subtask
- Logical hierarchy makes sense
-
Impact Analysis
- Dependencies that will be affected
- Tasks that depend on converting task
- Priority alignment needed
- Status compatibility
Conversion Process
- Change task ID from "8" to "5.1" (next available)
- Update all dependency references
- Inherit parent's context where appropriate
- Adjust priorities if needed
- Update time estimates
Smart Features
- Preserve task history
- Maintain dependencies
- Update all references
- Create conversion log
Example
/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
→ 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
Expand all pending tasks that need subtasks.
Bulk Task Expansion
Intelligently expands all tasks that would benefit from breakdown.
Execution
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
-
Analysis Phase
- Identify expansion candidates
- Group related tasks
- Plan expansion strategy
-
Batch Processing
- Expand tasks in logical order
- Maintain consistency
- Preserve relationships
- Optimize for parallelism
-
Quality Control
- Ensure subtask quality
- Avoid over-decomposition
- Maintain task coherence
- Update dependencies
Options
- Add
forceto expand all regardless of complexity - Add
researchfor enhanced AI analysis
Results
After bulk expansion:
- Summary of tasks expanded
- New subtask count
- Updated complexity metrics
- Suggested task order
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
task-master expand --id=$ARGUMENTS
Expansion Process
-
Task Analysis
- Review task complexity
- Identify components
- Detect technical challenges
- Estimate time requirements
-
Subtask Generation
- Create 3-7 subtasks typically
- Each subtask 1-4 hours
- Logical implementation order
- Clear acceptance criteria
-
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:
- Show subtask hierarchy
- Update time estimates
- Suggest implementation order
- Highlight critical path
Automatically fix dependency issues found during validation.
Automatic Dependency Repair
Intelligently fixes common dependency problems while preserving project logic.
Execution
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
-
Analysis Phase
- Run validation check
- Categorize issues by type
- Determine fix strategy
-
Execution Phase
- Apply automatic fixes
- Log all changes made
- Preserve task relationships
-
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 '/taskmaster:validate-dependencies' to verify fixes
Safety
- Preview mode available
- Rollback capability
- Change logging
- No data loss
Generate individual task files from tasks.json.
Task File Generation
Creates separate markdown files for each task, perfect for AI agents or documentation.
Execution
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
-
Consistent Formatting
- Standardized structure
- Clear sections
- AI-readable format
- Markdown compatible
-
Contextual Information
- Full task details
- Related task references
- Progress indicators
- Implementation notes
-
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
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
- Install:
/taskmaster:quick-install-taskmaster - Initialize:
/taskmaster:init-project-quick - Learn:
/taskmaster:learn - Work:
/taskmaster:smart-workflow
For detailed command info, run the specific command with --help or check command documentation.
Quick initialization with auto-confirmation.
Arguments: $ARGUMENTS
Initialize a Task Master project without prompts, accepting all defaults.
Quick Setup
task-master init -y
What It Does
- Creates
.taskmaster/directory structure - Initializes empty
tasks.json - Sets up default configuration
- Uses directory name as project name
- 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:
-
Configure AI models if needed:
/taskmaster:models/setup -
Parse PRD if available:
/taskmaster:parse-prd <file> -
Or create first task:
/taskmaster:add-task create initial setup
Perfect for rapid project setup!
Initialize a new Task Master project.
Arguments: $ARGUMENTS
Parse arguments to determine initialization preferences.
Initialization Process
-
Parse Arguments
- PRD file path (if provided)
- Project name
- Auto-confirm flag (-y)
-
Project Setup
task-master init -
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:
- Show project structure created
- Verify AI models configured
- Suggest next steps:
- Parse PRD if available
- Configure AI providers
- Set up git hooks
- Create first tasks
Integration
If PRD file provided:
/taskmaster:init my-prd.md
→ Automatically runs parse-prd after init
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
-
Check Current Installation
# Check if task-master command exists which task-master || echo "Task Master not found" # Check npm global packages npm list -g task-master-ai -
System Requirements Check
# Verify Node.js is installed node --version # Verify npm is installed npm --version # Check Node version (need 16+) -
Install Task Master Globally If not installed, run:
npm install -g task-master-ai -
Verify Installation
# Check version task-master --version # Verify command is available which task-master -
Initial Setup
# Initialize in current directory task-master init -
Configure AI Provider Ensure you have at least one AI provider API key set:
# 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" -
Quick Test
# 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:
# 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:
# Use different registry
npm install -g task-master-ai --registry https://registry.npmjs.org/
Node Version Issues:
# 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:
- Run
/project:utils:check-healthto verify setup - Configure AI providers with
/project:task-master:models - Start using Task Master commands!
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:
- init → Create project
- status → Understand state
- next → Find work
- complete → Finish task
Intermediate Path:
- expand → Break down complex tasks
- sprint-plan → Organize work
- complexity-report → Understand difficulty
- validate-deps → Ensure consistency
Advanced Path:
- pipeline → Chain operations
- smart-flow → Context-aware automation
- 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
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 startedin-progress- Currently being worked ondone- Completedreview- Awaiting reviewdeferred- Postponedcancelled- Cancelled
Execution
Based on $ARGUMENTS, run:
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
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:
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.
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:
-
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
-
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
-
Execute Appropriate Query Based on parsed intent, run the most specific task-master command
-
Enhanced Display
- Group by relevant criteria
- Show most important information first
- Use visual indicators for quick scanning
- Include relevant metrics
-
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
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:
- Show full context and history
- Set up development environment
- Run relevant tests
- Open related files
- Show similar completed tasks
- 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.
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
task-master parse-prd --input=$ARGUMENTS --research
Research Benefits
-
Current Best Practices
- Latest framework patterns
- Security considerations
- Performance optimizations
- Accessibility requirements
-
Technical Deep Dive
- Implementation approaches
- Library recommendations
- Architecture patterns
- Testing strategies
-
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
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
task-master parse-prd --input=$ARGUMENTS
Parsing Process
-
Document Analysis
- Extract key requirements
- Identify technical components
- Detect dependencies
- Estimate complexity
-
Task Generation
- Create 10-15 tasks by default
- Include implementation tasks
- Add testing tasks
- Include documentation tasks
- Set logical dependencies
-
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 modecomprehensive→ Generate more tasks
Post-Generation
After parsing:
- Display task summary
- Show dependency graph
- Suggest task expansion for complex items
- Recommend sprint planning
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:
- Immediate actions (unblock critical path)
- Today's focus (optimal task sequence)
- Process improvements (recurring patterns)
- Resource needs (skills, time, dependencies)
6. Historical Context
Compare to previous periods:
- Velocity changes
- Pattern recognition
- Improvement areas
- Success patterns to repeat
Quick install Task Master globally if not already installed.
Execute this streamlined installation:
# 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:
- Restart your terminal
- 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.
Clear all subtasks from all tasks globally.
Global Subtask Clearing
Remove all subtasks across the entire project. Use with extreme caution.
Execution
task-master clear-subtasks --all
Pre-Clear Analysis
-
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 -
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
- Full project analysis
- Create backup file
- Show detailed impact
- Require confirmation
- Execute removal
- 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
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
task-master remove-dependency --id=<task-id> --depends-on=<dependency-id>
Pre-Removal Checks
- Verify dependency exists
- Check impact on task flow
- Warn if it breaks logical sequence
- 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:
- Show updated task status
- List newly unblocked tasks
- Update project timeline
- Suggest next actions
Safety Features
- Confirm if removing critical dependency
- Show tasks that become immediately actionable
- Warn about potential issues
- Keep removal history
Example
/taskmaster: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
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
task-master remove-subtask --id=<parentId.subtaskId>
2. Convert to Standalone
task-master remove-subtask --id=<parentId.subtaskId> --convert
Pre-Removal Checks
-
Validate Subtask
- Verify subtask exists
- Check completion status
- Review dependencies
-
Impact Analysis
- Other subtasks that depend on it
- Parent task implications
- Data that will be lost
Removal Process
For Deletion:
- Confirm if subtask has work done
- Update parent task estimates
- Remove subtask and its data
- Clean up dependencies
For Conversion:
- Assign new standalone task ID
- Preserve all task data
- Update dependency references
- Maintain task history
Smart Features
- Warn if subtask is in-progress
- Show impact on parent task
- Preserve important data
- Update related estimates
Example Flows
/taskmaster: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)
/taskmaster: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
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
task-master clear-subtasks --id=<task-id>
Pre-Clear Analysis
-
Subtask Summary
- Number of subtasks
- Completion status of each
- Work already done
- Dependencies affected
-
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
- List all subtasks for confirmation
- Check for in-progress work
- Remove all subtasks
- Update parent task
- 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
/taskmaster: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
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
task-master remove-task --id=<id> [-y]
Pre-Removal Analysis
-
Task Details
- Current status
- Work completed
- Time invested
- Associated data
-
Relationship Check
- Tasks that depend on this
- Dependencies this task has
- Subtasks that will be removed
- Blocking implications
-
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
- Show comprehensive impact
- Require confirmation (unless -y)
- Update dependent task references
- Remove task and subtasks
- Clean up orphaned dependencies
- 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
/taskmaster: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)
/taskmaster:remove-task 5 -y
→ Removed: Task #5 and 4 subtasks
→ Updated: 3 task dependencies
→ Warning: Tasks #7, #8, #9 now have missing dependency
→ Run /taskmaster:fix-dependencies to resolve
Safety Features
- Confirmation required
- Impact preview
- Removal logging
- Suggest alternatives
- No cascade delete of dependents
Run interactive setup to configure AI models.
Interactive Model Configuration
Guides you through setting up AI providers for Task Master.
Execution
task-master models --setup
Setup Process
-
Environment Check
- Detect existing API keys
- Show current configuration
- Identify missing providers
-
Provider Selection
- Choose main provider (required)
- Select research provider (recommended)
- Configure fallback (optional)
-
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:
- Environment variables (recommended)
.envfile in project- Global
.taskmaster/config
Post-Setup
After configuration:
- Test each provider
- Show usage examples
- Suggest next steps
- Verify parse-prd works
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
Execute an intelligent workflow based on current project state and recent commands.
This command analyzes:
- Recent commands you've run
- Current project state
- Time of day / day of week
- 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 standupcomplete→ Task finished → Find next tasklist pending→ Planning → Suggest sprint planningexpand→ Breaking down work → Show complexity analysisinit→ 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:
- Analyze current state
- Execute primary workflow
- Suggest follow-up actions
- 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
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
task-master sync-readme [--with-subtasks] [--status=<status>]
README Generation
1. Project Header
# 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
-
Intelligent Grouping
- By feature area
- By sprint/milestone
- By assigned developer
- By priority
-
Progress Tracking
- Overall completion
- Sprint velocity
- Burndown indication
- Time tracking
-
Formatting Options
- GitHub-flavored markdown
- Task checkboxes
- Collapsible sections
- Table format available
Example Output
## 🚀 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:
- Show diff preview
- Backup existing README
- Write new content
- Commit reminder
- Update timestamp
Integration
Works well with:
- Git workflows
- CI/CD pipelines
- Project documentation
- Team updates
- Client reports
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
/taskmaster:init
init-project- Initialize new project (handles PRD files intelligently)init-project-quick- Quick setup with auto-confirmation (-y flag)
/taskmaster:models
view-models- View current AI model configurationsetup-models- Interactive model configurationset-main- Set primary generation modelset-research- Set research modelset-fallback- Set fallback model
Task Generation
/taskmaster:parse-prd
parse-prd- Generate tasks from PRD documentparse-prd-with-research- Enhanced parsing with research mode
/taskmaster:generate
generate-tasks- Create individual task files from tasks.json
Task Management
/taskmaster:list
list-tasks- Smart listing with natural language filterslist-tasks-with-subtasks- Include subtasks in hierarchical viewlist-tasks-by-status- Filter by specific status
/taskmaster:set-status
to-pending- Reset task to pendingto-in-progress- Start working on taskto-done- Mark task completeto-review- Submit for reviewto-deferred- Defer taskto-cancelled- Cancel task
/taskmaster:sync-readme
sync-readme- Export tasks to README.md with formatting
/taskmaster:update
update-task- Update tasks with natural languageupdate-tasks-from-id- Update multiple tasks from a starting pointupdate-single-task- Update specific task
/taskmaster:add-task
add-task- Add new task with AI assistance
/taskmaster:remove-task
remove-task- Remove task with confirmation
Subtask Management
/taskmaster:add-subtask
add-subtask- Add new subtask to parentconvert-task-to-subtask- Convert existing task to subtask
/taskmaster:remove-subtask
remove-subtask- Remove subtask (with optional conversion)
/taskmaster:clear-subtasks
clear-subtasks- Clear subtasks from specific taskclear-all-subtasks- Clear all subtasks globally
Task Analysis & Breakdown
/taskmaster:analyze-complexity
analyze-complexity- Analyze and generate expansion recommendations
/taskmaster:complexity-report
complexity-report- Display complexity analysis report
/taskmaster:expand
expand-task- Break down specific taskexpand-all-tasks- Expand all eligible taskswith-research- Enhanced expansion
Task Navigation
/taskmaster:next
next-task- Intelligent next task recommendation
/taskmaster:show
show-task- Display detailed task information
/taskmaster:status
project-status- Comprehensive project dashboard
Dependency Management
/taskmaster:add-dependency
add-dependency- Add task dependency
/taskmaster:remove-dependency
remove-dependency- Remove task dependency
/taskmaster:validate-dependencies
validate-dependencies- Check for dependency issues
/taskmaster:fix-dependencies
fix-dependencies- Automatically fix dependency problems
Workflows & Automation
/taskmaster:workflows
smart-workflow- Context-aware intelligent workflow executioncommand-pipeline- Chain multiple commands togetherauto-implement-tasks- Advanced auto-implementation with code generation
Utilities
/taskmaster:utils
analyze-project- Deep project analysis and insights
/taskmaster:setup
install-taskmaster- Comprehensive installation guidequick-install-taskmaster- One-line global installation
Usage Patterns
Natural Language
Most commands accept natural language arguments:
/taskmaster:add-task create user authentication system
/taskmaster:update mark all API tasks as high priority
/taskmaster:list show blocked tasks
ID-Based Commands
Commands requiring IDs intelligently parse from $ARGUMENTS:
/taskmaster:show 45
/taskmaster:expand 23
/taskmaster:set-status/to-done 67
Smart Defaults
Commands provide intelligent defaults and suggestions based on context.
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
- Confirm no critical dependencies
- Check for partial implementation
- Verify cancellation rationale
- Document lessons learned
Execution
task-master set-status --id=$ARGUMENTS --status=cancelled
Cancellation Impact
When cancelling:
-
Dependency Updates
- Notify dependent tasks
- Update project scope
- Recalculate timelines
-
Clean-up Actions
- Remove related branches
- Archive any work done
- Update documentation
- Close related issues
-
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
Agents 3
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
-
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
- Retrieve task details using MCP tool
-
Implementation Verification
- Use
Readtool to examine all created/modified files - Use
Bashtool to run compilation and build commands - Use
Greptool to search for required patterns and implementations - Verify file structure matches specifications
- Check that all required methods/functions are implemented
- Use
-
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
-
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
-
Dependency Validation
- Verify all task dependencies were actually completed
- Check integration points with dependent tasks
- Ensure no breaking changes to existing functionality
Verification Workflow
-
Retrieve Task Information
Use mcp__task-master-ai__get_task to get full task details Note the implementation requirements and test strategy -
Check File Existence
# Verify all required files exist ls -la [expected directories] # Read key files to verify content -
Verify Implementation
- Read each created/modified file
- Check against requirements checklist
- Verify all subtasks are complete
-
Run Tests
# TypeScript compilation cd [project directory] && npx tsc --noEmit # Run specified tests npm test [specific test files] # Build verification npm run build -
Generate Verification Report
Output Format
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 commandsGrep: Search for patterns in codemcp__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:
- Task-executor implements and marks as 'review'
- You verify and report PASS/FAIL
- Claude either marks as 'done' (PASS) or 'pending' (FAIL)
- If FAIL, task-executor re-implements based on your report
Your verification ensures high quality and prevents accumulation of technical debt.
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.
Core Responsibilities:
-
Task Analysis: When given a task, first retrieve its full details using
task-master show <id>to understand requirements, dependencies, and acceptance criteria. -
Implementation Planning: Before coding, briefly outline your implementation approach:
- Identify files that need to be created or modified
- Note any dependencies or prerequisites
- Consider the testing strategy defined in the task
-
Focused Execution:
- Implement one subtask at a time for clarity and traceability
- Follow the project's coding standards from CLAUDE.md if available
- Prefer editing existing files over creating new ones
- Only create files that are essential for the task completion
-
Progress Documentation:
- Use
task-master update-subtask --id=<id> --prompt="implementation notes"to log your approach and any important decisions - Update task status to 'in-progress' when starting:
task-master set-status --id=<id> --status=in-progress - Mark as 'done' only after verification:
task-master set-status --id=<id> --status=done
- Use
-
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
-
Dependency Management:
- Check task dependencies before starting implementation
- If blocked by incomplete dependencies, clearly communicate this
- Use
task-master validate-dependencieswhen needed
Implementation Workflow:
- Retrieve task details and understand requirements
- Check dependencies and prerequisites
- Plan implementation approach
- Update task status to in-progress
- Implement the solution incrementally
- Log progress and decisions in subtask updates
- Test and verify the implementation
- Mark task as done when complete
- Suggest next task if appropriate
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.
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
-
Task Queue Analysis: You continuously monitor and analyze the task queue using Task Master MCP tools to understand the current state of work, dependencies, and priorities.
-
Dependency Graph Management: You build and maintain a mental model of task dependencies, identifying which tasks can be executed in parallel and which must wait for prerequisites.
-
Executor Deployment: You strategically deploy task-executor agents for individual tasks or task groups, ensuring each executor has the necessary context and clear success criteria.
-
Progress Coordination: You track the progress of deployed executors, handle task completion notifications, and reassess the execution strategy as tasks complete.
Operational Workflow
Initial Assessment Phase
- Use
get_tasksortask-master listto retrieve all available tasks - Analyze task statuses, priorities, and dependencies
- Identify tasks with status 'pending' that have no blocking dependencies
- Group related tasks that could benefit from specialized executors
- Create an execution plan that maximizes parallelization
Executor Deployment Phase
- 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
- Maintain a registry of active executors and their assigned tasks
- Establish communication protocols for progress updates
Coordination Phase
- Monitor executor progress through task status updates
- When a task completes:
- Verify completion with
get_taskortask-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
- Verify completion with
- 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:
- Acknowledge completion or issues
- Update task status in Task Master
- Reassess execution strategy
- 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
- Executor Failure: Reassign task to new executor with additional context about the failure
- Dependency Conflicts: Halt affected executors, resolve conflict, then resume
- Task Ambiguity: Request clarification from user before proceeding
- 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 monitoringget_task- Detailed task analysisset_task_status- Progress trackingnext_task- Fallback for serial executionanalyze_project_complexity- Strategic planningcomplexity_report- Resource allocation
You are the strategic mind coordinating the entire task execution effort. Your success is measured by the efficient completion of all tasks while maintaining quality and respecting dependencies. Think systematically, act decisively, and continuously optimize the execution strategy based on real-time progress.
Sponsors
Details
- Marketplace
- khulnasoft-bot/claude-task
- Source
- packages/claude-code-plugin
- Author
- Hamster
- Category
- Productivity
- Keywords
- task-management, ai, workflow, orchestration, automation, mcp