SuperClaude/.claude/commands/task.md

/task - Manage complex features and requirements

Legend

Symbol	Meaning		Abbrev	Meaning
→	leads to		cfg	configuration
&	and/with		impl	implementation
w/	with		perf	performance
@	at/located		ops	operations
>	greater than		val	validation
∀	for all/every		req	requirements
∃	exists/there is		deps	dependencies
∴	therefore		env	environment
∵	because		db	database
≡	equivalent		api	interface
≈	approximately		docs	documentation
📁	directory/path		std	standard
🔢	number/count		def	default
📝	text/string		ctx	context
⚙	setting/config		err	error
🎛	control/flags		exec	execution
🔧	configuration		qual	quality
📋	group/category		rec	recovery
🚨	critical/urgent		sev	severity
⚠	warning/caution		resp	response
🔄	retry/recovery		esc	escalation
✅	success/fixed		tok	token
❌	failure/error		opt	optimization
ℹ	information		UX	user experience
⚡	fast/quick		UI	user interface
🐌	slow/delayed		C	critical
✨	complete/done		H	high
📖	read operation		M	medium
✏	edit operation		L	low
🗑	delete operation

Purpose

Manage complex features and requirements across sessions with automatic breakdown, context preservation, and recovery capabilities.

Syntax

/task [operation] [parameters]

Universal Flags

--plan: "Show execution plan before running" --uc: "UltraCompressed mode (~70% token reduction)" --ultracompressed: "Alias for --uc" --think: "Multi-file analysis w/ context (4K tokens)" --think-hard: "Deep architectural analysis (10K tokens)" --ultrathink: "Critical system redesign (32K tokens)" --c7: "Enable Context7→library documentation lookup" --seq: "Enable Sequential→complex analysis & thinking" --magic: "Enable Magic→UI component generation" --pup: "Enable Puppeteer→browser automation & testing" --all-mcp: "Enable all MCP servers" --no-mcp: "Disable all MCP servers (native tools only)" --no-c7: "Disable Context7 specifically" --no-seq: "Disable Sequential thinking specifically" --no-magic: "Disable Magic UI builder specifically" --no-pup: "Disable Puppeteer specifically"

Command-Specific Operations

Task Operations:

• create <title>: Create new task with automatic breakdown
• list: Show tasks filtered by status or priority
• start <id>: Begin working on specific task
• pause <id>: Pause current work and save context
• resume <id>: Resume previously paused task
• complete <id>: Mark task as completed with verification
• cancel <id>: Cancel task and clean up resources
• show <id>: Display detailed task information
• update <id>: Modify task status, priority, or details

Task Types:

• --type feature: New feature development
• --type bugfix: Bug resolution and fixes
• --type refactor: Code refactoring and improvement
• --type docs: Documentation creation or updates
• --type test: Testing implementation or enhancement

Priority Levels:

• --priority high: Critical or urgent tasks
• --priority medium: Standard priority tasks (default)
• --priority low: Nice-to-have or future enhancements

Status Filters:

• --status pending: Tasks waiting to be started
• --status in-progress: Currently active tasks
• --status completed: Finished tasks
• --status cancelled: Cancelled or abandoned tasks

Examples

• /task create "User authentication system" --type feature --priority high
• /task list --status pending --priority high
• /task start 20250623-143052
• /task pause 20250623-143052
• /task resume 20250623-143052
• /task complete 20250623-143052
• /task show 20250623-143052
• /task update 20250623-143052 --priority low

Task Workflow

Task Creation:

1. Requirement Analysis: Analyze complexity and scope
2. ID Generation: Create unique task ID (YYYYMMDD-HHMMSS)
3. Breakdown: Decompose into phases and actionable steps
4. File Creation: Generate task file from appropriate template
5. Git Integration: Create dedicated branch for task
6. Organization: Move to pending folder for tracking

Task Execution:

1. Activation: Move task to in-progress folder
2. Checkpoint: Create git checkpoint for safety
3. Sequential Execution: Work through steps systematically
4. Progress Tracking: Update progress and context continuously
5. Session Management: Handle interruptions and breaks gracefully

Task Completion:

1. Verification: Ensure all steps completed successfully
2. Testing: Run comprehensive tests and validation
3. Checkpoint: Create completion checkpoint
4. Organization: Move to completed folder
5. Integration: Merge git branch and clean up

Auto-Detection

Complexity Triggers:

• "build feature X" or "implement functionality Y"
• "add component Z" or "create system W"
• Requirements affecting more than 3 files
• Multi-step work requiring coordination
• Complex integration or architectural changes

System Response:

• Analyze request complexity automatically
• Suggest task creation for complex work
• Provide options: [Create task breakdown] [Proceed directly]
• Explain benefits of task management approach
• Respect user preference for simple tasks

Session Recovery

Startup Process:

1. Scan: Check .claudedocs/tasks/in-progress/ directory
2. Identify: Find active tasks and their current state
3. Restore: Load context from task files and git history
4. Suggest: Recommend next steps for resumption

Context Preservation:

• Key architectural decisions and rationale
• Current implementation state and progress
• Known blockers and proposed solutions
• File modification history and dependencies
• Integration points and testing requirements

Task File Structure

Directory Organization:

.claudedocs/tasks/
├── pending/          # Tasks waiting to be started
├── in-progress/      # Currently active tasks
├── completed/        # Finished tasks
├── cancelled/        # Cancelled or abandoned tasks
└── templates/        # Task templates by type

File Naming Convention:

{type}-{id}-{slug}.md

Examples:
feature-20250623-143052-user-auth.md
bugfix-20250623-144022-login-error.md
refactor-20250623-142033-api-cleanup.md

Task File Content:

• Task metadata (ID, type, priority, status)
• Detailed description and requirements
• Phase breakdown with progress tracking
• Context and architectural decisions
• Blockers and resolution strategies
• Testing and validation requirements

Integration Capabilities

Git Integration:

• Automatic branch creation and management
• Checkpoint creation for safety and rollback
• Merge strategy and conflict resolution
• Commit message generation and conventions

TodoWrite Synchronization:

• Sync with existing todo system
• Convert todos to tasks when appropriate
• Maintain consistency across systems
• Provide unified task management experience

Persona Activation:

• Task-specific persona selection
• Specialized expertise for different task types
• Context-aware skill application
• Collaborative persona workflows

MCP Integration:

• Context preservation across MCP tools
• State management for complex operations
• Tool coordination for task execution
• Resource optimization and sharing

Command Chaining:

• Chain with other SuperClaude commands
• Workflow automation and optimization
• Cross-command context sharing
• Integrated development experience

Advanced Features

Task Dependencies:

• Define prerequisite relationships
• Automatic dependency resolution
• Blocked task identification
• Parallel execution planning

Progress Tracking:

• Phase-based progress measurement
• Milestone tracking and reporting
• Time estimation and actual tracking
• Velocity and performance metrics

Collaboration Support:

• Multi-contributor task support
• Handoff procedures and documentation
• Knowledge transfer mechanisms
• Team coordination features

Deliverables

• Task Files: Comprehensive task documentation with progress tracking
• Git Branches: Dedicated branches with checkpoint history
• Progress Reports: Regular status updates and metrics
• Context Documentation: Preserved decision-making rationale
• Integration Plans: Merge and deployment strategies

Research Requirements

External_Library_Research:

• Identify library/framework mentioned
• Context7 lookup for official documentation
• Verify API patterns and examples
• Check version compatibility
• Document findings in implementation Pattern_Research:
• Search existing codebase for similar patterns
• Magic component search if UI-related
• WebSearch for official documentation
• Validate approach with Sequential thinking
• Document pattern choice rationale API_Integration_Research:
• Official documentation lookup
• Authentication requirements
• Rate limiting and error handling
• SDK availability and examples
• Integration testing approach

Report Notifications

📄 Analysis report saved to: {path} 📊 Metrics updated: {path} 📋 Summary saved to: {path} 💾 Checkpoint created: {path} 📚 Documentation created: {path} 📁 Created directory: {path} ✅ {operation} completed successfully ❌ {operation} failed: {reason} ⚠ {operation} completed w/ warnings

Best Practices

Task Creation:

• Define clear, specific objectives
• Break down complex work into manageable phases
• Set realistic timelines and expectations
• Include comprehensive context and requirements
• Plan for testing and validation

Execution Management:

• Update progress regularly and consistently
• Document decisions and changes promptly
• Handle blockers and dependencies proactively
• Maintain clean git history and commits
• Communicate status changes effectively

Quality Assurance:

• Verify completion criteria before marking done
• Run comprehensive tests and validation
• Review code quality and standards compliance
• Update documentation and knowledge base
• Plan for maintenance and future enhancements

Troubleshooting

• Complex Tasks: Use automatic breakdown with phase management
• Session Interruptions: Leverage auto-save and context preservation
• Integration Issues: Apply git checkpoints and rollback capabilities
• Progress Tracking: Use detailed phase and milestone tracking

Success Messages

✅ {operation} completed successfully 📝 Created: {file_path} ✏ Updated: {file_path} ✨ Task completed: {task_title}