Enhanced Task Management System - Adaptation of PR #5 (#7)

* Add comprehensive task management system with hybrid todo integration - Automatic task detection based on complexity scoring (8+ points) - Seamless .tasks/ folder structure (pending/in-progress/completed) - Two-tier architecture: Tasks for persistence, TodoWrite for focus - Auto-conversion of task breakdowns to TodoWrite steps - Session recovery with context preservation - Git integration with automatic branching - Zero-interruption workflow for complex requirements 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com> * Enhance task management system with SuperClaude integration - Update all .tasks/ paths to ./claudedocs/tasks/ for consistency - Add plan mode integration for intelligent task suggestions - Implement UltraCompressed format (~70% token reduction) - Enhance git workflow with clean branch strategy and atomic commits - Add task-ultracompressed.yml configuration - Update install.sh to reflect new file counts - Integrate with exit_plan_mode for complex work detection This adapts PR #5's excellent task tracking functionality to fit SuperClaude's architecture while adding valuable enhancements. --------- Co-authored-by: Mohammad Aziz <mdaziz067@gmail.com> Co-authored-by: Claude <noreply@anthropic.com>
2025-12-29 16:16:08 +00:00 · 2025-06-24 11:29:02 +02:00
parent 0ff74016d7
commit 7413eb631c
11 changed files with 930 additions and 4 deletions
--- a/.claude/commands/shared/auto-task-trigger.yml
+++ b/.claude/commands/shared/auto-task-trigger.yml
@@ -0,0 +1,127 @@
+# auto-task-trigger.yml - Seamless Automatic Task Mode
+
+## Complexity Analysis Engine
+```yaml
+requirement_parser:
+  extract_keywords:
+    trigger_verbs: ["build", "create", "implement", "develop", "design", "add", "integrate"]
+    scope_nouns: ["system", "feature", "functionality", "component", "service", "application"]
+    complexity_flags: ["authentication", "database", "API", "full-stack", "architecture", "integration"]
+    
+  scoring_system:
+    base_score: 0
+    trigger_verb: +2 points
+    scope_noun: +2 points  
+    complexity_flag: +3 points
+    multi_step_indicator: +3 points
+    file_estimate: files * 1 point
+    
+  thresholds:
+    auto_create: ≥8 points
+    suggest_create: 5-7 points
+    proceed_normal: <5 points
+
+pattern_detection:
+  high_complexity_patterns:
+    - "build a * system"
+    - "create * authentication"
+    - "implement * database"
+    - "develop * application"
+    - "full-stack *"
+    - "end-to-end *"
+    
+  multi_session_indicators:
+    - "complete *"
+    - "entire *"
+    - "comprehensive *"
+    - mentions of multiple technologies
+    - frontend + backend mentions
+    - database + API mentions
+```
+
+## Seamless Auto-Creation
+```yaml
+execution_flow:
+  1_silent_analysis:
+    - parse requirement in background
+    - calculate complexity score
+    - no user interruption
+    
+  2_instant_decision:
+    score ≥8: auto_create_immediately
+    score 5-7: brief_notification_then_create
+    score <5: proceed_without_task
+    
+  3_background_setup:
+    - generate task ID
+    - create task file
+    - setup git branch
+    - move to in-progress
+    - begin implementation
+    
+user_notification:
+  high_complexity: "[Task created: {id}] {brief_description}"
+  medium_complexity: "[Multi-step work detected - creating task] {brief_description}"
+  format: single_line_notification
+  timing: after_creation_before_work
+  
+no_interruption_policy:
+  - never ask "should I create a task?"
+  - never wait for confirmation
+  - never pause workflow
+  - seamless background operation
+```
+
+## Context Preservation
+```yaml
+auto_save_triggers:
+  context_threshold: >70% full
+  session_timeout: >30min inactive
+  error_recovery: on failures
+  manual_break: user requests pause
+  
+seamless_recovery:
+  startup_scan: check ./claudedocs/tasks/in-progress/
+  auto_resume: highest priority active task
+  context_restore: previous session state
+  notification: "Resuming: {task_title}"
+  
+session_continuity:
+  preserve_state: file paths, variables, decisions
+  track_progress: completed steps, current focus
+  handle_blockers: previous issues & solutions
+  maintain_context: architectural decisions
+```
+
+## Integration Patterns
+```yaml
+command_integration:
+  /user:build → auto-detect complexity → create task if needed → proceed
+  /user:implement → always create task → breakdown → execute
+  /user:create → analyze scope → task if multi-step → proceed
+  
+plan_mode_integration:
+  exit_plan_mode:
+    - analyze plan complexity
+    - count steps, files, technologies
+    - if complexity ≥8: "Create task to track this plan? (y/n)"
+    - if yes: create task with plan content
+    - track plan execution through task
+  
+  planning_triggers:
+    - --plan flag detected
+    - risky operations (deploy, migrate)
+    - multi-phase work identified
+    - cross-cutting concerns
+  
+persona_activation:
+  architect: high complexity systems
+  frontend: UI/component requests  
+  backend: API/database work
+  security: authentication/authorization
+  
+workflow_chains:
+  detect → create → breakdown → branch → implement → test → complete
+  requirement → task → steps → code → validation → merge
+  plan → analyze → suggest task → create → track → complete
+```
--- a/.claude/commands/shared/session-recovery.yml
+++ b/.claude/commands/shared/session-recovery.yml
@@ -0,0 +1,144 @@
+# session-recovery.yml - Session Recovery & Context Preservation
+
+## Startup Detection
+```yaml
+scan_on_startup:
+  locations:
+    - ./claudedocs/tasks/in-progress/*.md
+    - ./claudedocs/tasks/pending/*.md (overdue)
+  
+  parse_tasks:
+    - extract metadata
+    - check git branch status
+    - identify next steps
+    - restore context variables
+    
+  recovery_prompt:
+    found_tasks: "Found {count} active tasks. Resume work?"
+    no_tasks: "No active tasks found. Ready for new work."
+    overdue: "Task {id} overdue. Continue or reschedule?"
+```
+
+## Context Preservation
+```yaml
+session_state:
+  file_paths: currently modified files
+  variables: important data & settings
+  decisions: architectural choices made
+  blockers: issues & solutions attempted
+  
+auto_save_triggers:
+  - major code changes
+  - before risky operations
+  - session timeout warnings
+  - manual /task:pause
+  
+context_format:
+  ```yaml
+  session_state:
+    current_files: [path1, path2]
+    key_variables:
+      api_endpoint: "https://api.example.com"
+      database_name: "myapp_prod"
+    decisions:
+      - "Used React over Vue for better team familiarity"
+      - "Chose PostgreSQL for ACID compliance"
+    blockers:
+      - issue: "CORS error on API calls"
+        attempted: ["added headers", "proxy setup"]
+        solution: "needed server-side CORS config"
+  ```
+```
+
+## Hybrid Recovery Process  
+```yaml
+step_1_identify:
+  - scan ./claudedocs/tasks/in-progress/
+  - parse task metadata
+  - check git branch status
+  - validate file existence
+  - restore previous TodoWrite state
+
+step_2_restore_both_systems:
+  task_context:
+    - load session context
+    - summarize previous work
+    - identify blocking issues
+  todo_context:
+    - regenerate TodoWrite from task breakdown
+    - identify last completed todo
+    - set current focus todo
+    - preserve todo progress
+
+step_3_seamless_resume:
+  no_prompts: true
+  auto_continue: true
+  template: |
+    Resuming {task_title} - working on: {current_todo}
+    Progress: {completed_todos}/{total_todos} todos, {task_progress}% complete
+    
+hybrid_state_restoration:
+  both_systems_sync:
+    - task provides persistence
+    - todos provide immediate focus
+    - progress tracked in both
+    - no duplication of effort
+```
+
+## Git Integration
+```yaml
+branch_tracking:
+  - verify branch exists
+  - check for uncommitted changes
+  - identify merge conflicts
+  - track remote status
+  
+checkpoint_restoration:
+  - list available checkpoints
+  - show diff since last checkpoint
+  - offer rollback options
+  - suggest merge strategies
+```
+
+## Session Break Handling
+```yaml
+graceful_pause:
+  auto_triggers:
+    - context >90% full
+    - long inactivity
+    - error thresholds
+    
+  pause_actions:
+    - save current context
+    - create git checkpoint
+    - update progress status
+    - log session summary
+    
+  resume_preparation:
+    - validate environment
+    - check dependencies
+    - restore file states
+    - prepare tools
+```
+
+## Multi-Task Management
+```yaml
+concurrent_tasks:
+  max_active: 3
+  priority_rules:
+    - high priority blocks others
+    - related tasks can be parallel
+    - different areas can overlap
+    
+task_switching:
+  - auto-save current context
+  - create checkpoint
+  - switch git branch
+  - restore new context
+  
+conflict_resolution:
+  - file modification conflicts
+  - git merge requirements
+  - dependency overlaps
+  - resource constraints
+```
--- a/.claude/commands/shared/task-management.yml
+++ b/.claude/commands/shared/task-management.yml
@@ -0,0 +1,205 @@
+# task-management.yml - Task Management & Session Recovery
+
+## Automatic Task Detection
+```yaml
+complexity_indicators:
+  high_complexity:
+    - mentions: ["system", "architecture", "integration", "authentication", "database"]
+    - scope: ["full-stack", "end-to-end", "complete", "entire"]
+    - actions: ["build", "create", "implement", "develop", "add feature"]
+    - files: >5 estimated files
+    - time: >2 hours estimated
+    - sessions: likely >1 session
+    
+  medium_complexity:
+    - mentions: ["component", "module", "service", "API"]
+    - scope: ["frontend", "backend", "single area"]
+    - files: 3-5 estimated files
+    - time: 1-2 hours estimated
+    
+  low_complexity:
+    - mentions: ["fix", "update", "modify", "adjust"]
+    - scope: ["single file", "small change"]
+    - files: 1-2 files
+    - time: <1 hour
+
+auto_task_thresholds:
+  always_create: high_complexity
+  suggest_create: medium_complexity + multi_step
+  never_create: low_complexity
+  
+detection_keywords:
+  trigger_words: ["build", "create", "implement", "develop", "add", "design", "system"]
+  scope_words: ["feature", "functionality", "component", "service", "integration"]
+  complexity_words: ["authentication", "database", "API", "architecture", "full-stack"]
+```
+
+## Hybrid Todo + Task System
+```yaml
+two_tier_approach:
+  task_level: high-level features (./claudedocs/tasks/ folders)
+  todo_level: immediate steps (TodoWrite/TodoRead)
+  
+integration_flow:
+  1. Complex requirement → auto-create Task
+  2. Task breakdown → TodoWrite for immediate steps
+  3. Work on todos → update task progress
+  4. Session break → preserve both systems
+  5. Resume → restore task + active todos
+  
+seamless_operation:
+  task_creates_todos: task breakdown → TodoWrite steps
+  todos_update_task: completed todos → task progress
+  context_preserves_both: session state includes task + todos
+  recovery_restores_both: startup → resume task + todos
+
+## Task Status Flow
+```yaml
+status_transitions:
+  pending → in-progress: /task:start {id} + TodoWrite breakdown
+  in-progress → completed: all todos complete + /task:complete {id}
+  in-progress → pending: /task:pause {id} + preserve todos
+  any → cancelled: /task:cancel {id} + clear todos
+  
+folder_mapping:
+  pending: ./claudedocs/tasks/pending/
+  in-progress: ./claudedocs/tasks/in-progress/ + active TodoWrite
+  completed: ./claudedocs/tasks/completed/ + archived todos
+```
+
+## Session Recovery
+```yaml
+startup_check:
+  - scan ./claudedocs/tasks/in-progress/
+  - identify active tasks
+  - restore context from task files
+  - suggest next steps
+  
+context_preservation:
+  key_decisions: important architectural choices
+  blockers: issues preventing progress
+  session_state: variables, file paths, current focus
+  
+recovery_prompts:
+  - "Resuming task: {title}"
+  - "Last context: {context}"
+  - "Next steps: {next_steps}"
+```
+
+## Task File Structure
+```yaml
+naming: {type}-{id}-{slug}.md
+types: [feature, bugfix, refactor, docs, test]
+id_format: YYYYMMDD-HHMMSS
+slug: kebab-case description
+
+metadata_required:
+  - id, title, status, priority
+  - created, updated timestamps
+  - git branch information
+  
+content_sections:
+  - requirement description
+  - step-by-step breakdown
+  - affected files list
+  - context preservation
+  - checkpoint history
+```
+
+## Git Integration
+```yaml
+branch_strategy:
+  naming: task/{id}-{slug}
+  creation: automatic on task start
+  protection: prevent force push
+  
+commit_discipline:
+  format: "[{task_id}] {phase}: {description}"
+  atomic: one logical change per commit
+  phases:
+    - "[{id}] Analysis: Requirements documented"
+    - "[{id}] Impl: {component} implemented"
+    - "[{id}] Test: {test_type} tests added"
+    - "[{id}] Complete: Task finished"
+  
+checkpoints:
+  automatic:
+    - phase transitions
+    - before risky operations
+    - session timeout (>30min)
+  manual:
+    - /task:pause command
+    - /user:git --checkpoint
+    
+cleanup_workflow:
+  on_complete:
+    - squash merge to main
+    - delete feature branch
+    - archive task to completed/
+  retention:
+    - keep completed tasks 30 days
+    - archive older tasks
+    - prune stale branches weekly
+    
+git_hooks:
+  pre_commit: validate task state
+  post_merge: update task status
+  branch_protection: task/* branches
+```
+
+## Automatic Task Creation Flow
+```yaml
+detection_process:
+  step_1_analyze:
+    - parse user requirement
+    - count complexity indicators
+    - estimate files affected
+    - assess time/session requirements
+    
+  step_2_decide:
+    high_complexity: auto_create_task
+    medium_complexity: brief_confirmation
+    low_complexity: proceed_normally
+    
+  step_3_execute:
+    auto_create:
+      - generate task ID
+      - create task file from requirement
+      - move to pending folder
+      - create git branch
+      - breakdown into TodoWrite steps
+      - start immediately with active todos
+    brief_confirm:
+      - "Creating task for multi-step work. Proceeding..."
+      - auto-create without waiting
+      - convert steps to TodoWrite
+    
+seamless_activation:
+  no_interruption: true
+  minimal_prompts: true
+  auto_start: true
+  background_setup: true
+  
+user_experience:
+  before: "I need to build user authentication"
+  after: "[Auto-creating task: user-auth-20250623-143052] Starting implementation..."
+  flow: requirement → auto-detect → create → start → implement
+```
+
+## Commands Integration
+```yaml
+task_commands:
+  create: /task:create {title} --type {type} --priority {priority}
+  list: /task:list --status {status}
+  start: /task:start {id}
+  pause: /task:pause {id}
+  complete: /task:complete {id}
+  resume: /task:resume {id}
+  cancel: /task:cancel {id}
+  
+auto_detection:
+  - scan for ./claudedocs/tasks/ on startup
+  - auto-create for complex requirements (no prompts)
+  - auto-pause tasks on context limits
+  - auto-resume on session start
+```
--- a/.claude/commands/shared/task-ultracompressed.yml
+++ b/.claude/commands/shared/task-ultracompressed.yml
@@ -0,0 +1,88 @@
+# Task UltraCompressed Format Configuration
+
+## Format Rules
+```yaml
+activation:
+  automatic: true for all task operations
+  exceptions: none - always use compressed format
+  
+compression_rules:
+  remove_words:
+    - the, a, an, is, are, was, were
+    - in, on, at, to, for, of, with
+    - that, which, this, these
+  
+  abbreviations:
+    status: S | priority: P | implementation: impl
+    configuration: cfg | documentation: docs
+    authentication: auth | database: db
+    architecture: arch | development: dev
+    production: prod | dependencies: deps
+    
+  symbols:
+    →: leads to / results in
+    &: and / with
+    w/: with / including
+    w/o: without
+    ✓: completed
+    □: pending
+    ⚠: blocked
+    
+structure:
+  title_line: "T: {title}"
+  metadata_line: "ID: {id} | S: {status} | P: {priority}"
+  branch_line: "Branch: {branch}"
+  phases: bullet list with symbols
+  context: key:value pairs
+  progress: percentage and todo count
+```
+
+## Task File Template
+```yaml
+header: |
+  # Legend: → leads to | & and | w/ with | S: status | P: priority | ✓ done | □ pending
+  
+  T: {title}
+  ID: {id} | S: {status} | P: {priority}
+  Branch: {branch}
+
+phases: |
+  ## Phases
+  {phase_list}
+
+context: |
+  ## Context
+  Dec: {decisions}
+  Block: {blockers}
+  Files: {files}
+  Next: {next_step}
+
+progress: |
+  ## Progress
+  Todos: {active}/{total}
+  Complete: {percentage}%
+```
+
+## Conversion Examples
+```yaml
+verbose_to_compressed:
+  before: "Create user authentication system with JWT tokens"
+  after: "T: User auth system w/ JWT"
+  
+  before: "Status: in-progress, Priority: high"
+  after: "S: in-progress | P: high"
+  
+  before: "Implementation phase is currently blocked by CORS configuration"
+  after: "Impl phase blocked: CORS cfg"
+  
+  before: "Decision made: Use PostgreSQL for database"
+  after: "Dec: PostgreSQL for db"
+```
+
+## Benefits
+```yaml
+token_savings: ~70% reduction
+readability: maintained through legend
+consistency: enforced format across all tasks
+scanning: easier to find key information
+```
--- a/.claude/commands/shared/templates/feature-template.md
+++ b/.claude/commands/shared/templates/feature-template.md
@@ -0,0 +1,59 @@
+# Task: {TASK_NAME}
+
+## Metadata
+```yaml
+id: {TASK_ID}
+title: {TASK_TITLE}
+status: pending
+priority: medium
+created: {TIMESTAMP}
+updated: {TIMESTAMP}
+assignee: Claude
+branch: feature/{TASK_ID}
+```
+
+## Requirement
+{REQUIREMENT_DESCRIPTION}
+
+## Breakdown
+### Analysis Phase
+- [ ] Understand requirements
+- [ ] Identify affected files
+- [ ] Plan architecture changes
+- [ ] Create git branch
+
+### Implementation Phase
+- [ ] {STEP_1}
+- [ ] {STEP_2}
+- [ ] {STEP_3}
+
+### Testing Phase
+- [ ] Write tests
+- [ ] Run test suite
+- [ ] Manual testing
+
+### Completion Phase
+- [ ] Code review
+- [ ] Documentation update
+- [ ] Merge to main
+
+## Files Affected
+```yaml
+new: []
+modified: []
+deleted: []
+```
+
+## Context Preservation
+```yaml
+key_decisions: []
+blockers: []
+notes: []
+session_state: {}
+```
+
+## Checkpoints
+```yaml
+commits: []
+branches: []
+```
--- a/.claude/commands/shared/templates/task-ultracompressed.md
+++ b/.claude/commands/shared/templates/task-ultracompressed.md
@@ -0,0 +1,26 @@
+# Legend: → leads to | & and | w/ with | S: status | P: priority | ✓ done | □ pending
+
+T: {TASK_TITLE}
+ID: {TASK_ID} | S: {STATUS} | P: {PRIORITY}
+Branch: {BRANCH}
+
+## Phases
+□ Analysis: Requirements & design
+□ Impl: Core functionality
+□ Test: Unit & integration
+□ Deploy: Staging & prod
+
+## Context
+Dec: {KEY_DECISIONS}
+Block: {BLOCKERS}
+Files: {AFFECTED_FILES}
+Next: {NEXT_STEP}
+
+## Progress
+Todos: {ACTIVE}/{TOTAL}
+Complete: {PERCENTAGE}%
+Session: {SESSION_TIME}
+
+## Git
+Commits: {COMMIT_COUNT}
+Last: {LAST_COMMIT}
--- a/.claude/commands/shared/todo-task-integration.yml
+++ b/.claude/commands/shared/todo-task-integration.yml
@@ -0,0 +1,153 @@
+# todo-task-integration.yml - Seamless Todo + Task System
+
+## Two-Tier Architecture
+```yaml
+hierarchy:
+  level_1_tasks: High-level features (./claudedocs/tasks/ folders)
+    purpose: Session persistence, git branching, requirement tracking
+    scope: Features spanning multiple sessions
+    examples: "build auth system", "implement dashboard", "create API"
+    
+  level_2_todos: Immediate actionable steps (TodoWrite/TodoRead)
+    purpose: Context switching, progress tracking, focus management
+    scope: Small chunks within current session
+    examples: "create user model", "add login endpoint", "write tests"
+
+integration_principle:
+  - Tasks provide persistence across sessions
+  - Todos provide focus within sessions
+  - Both work together seamlessly
+  - No duplication, clear boundaries
+```
+
+## Workflow Integration
+```yaml
+complex_requirement_flow:
+  1_auto_detect: complexity ≥8 → create task
+  2_breakdown: task phases → TodoWrite immediate steps
+  3_execute: work on todos → update task progress
+  4_session_break: preserve both systems
+  5_resume: restore task + todos state
+  
+simple_requirement_flow:
+  1_detect: complexity <5 → TodoWrite only
+  2_execute: work on todos directly
+  3_complete: mark todos done
+  
+medium_requirement_flow:
+  1_detect: complexity 5-7 → brief task creation
+  2_immediate: convert to TodoWrite steps
+  3_execute: work on todos with light task tracking
+```
+
+## Automatic Breakdown Logic
+```yaml
+task_to_todos_conversion:
+  when_task_starts:
+    - parse task breakdown sections
+    - extract actionable steps
+    - convert to TodoWrite format
+    - preserve task context
+    
+  step_extraction:
+    analysis_phase: → pending todos
+    implementation_phase: → pending todos  
+    testing_phase: → pending todos
+    completion_phase: → pending todos
+    
+  todo_format:
+    - id: auto-generated
+    - content: actionable step from task
+    - status: pending
+    - priority: inherit from task
+    - task_id: link back to parent task
+
+## Context Preservation
+```yaml
+session_state_tracking:
+  task_context:
+    - active task ID
+    - current phase
+    - architectural decisions
+    - git branch info
+    
+  todo_context:
+    - current todo list
+    - in_progress item
+    - completed items
+    - blocking issues
+    
+  combined_state:
+    - task progress percentage
+    - todos completion ratio
+    - session focus area
+    - next recommended action
+
+recovery_on_startup:
+  1_scan_tasks: check ./claudedocs/tasks/in-progress/
+  2_restore_todos: rebuild TodoWrite from task state
+  3_identify_focus: determine current todo
+  4_resume_message: "Resuming {task} - working on {current_todo}"
+```
+
+## Smart Synchronization
+```yaml
+todo_completion_updates_task:
+  on_todo_complete:
+    - calculate task progress
+    - update task file
+    - move to next logical step
+    - create checkpoint if needed
+    
+  progress_calculation:
+    total_steps: count all todos from task
+    completed_steps: count completed todos
+    percentage: completed / total * 100
+    
+task_completion_clears_todos:
+  on_task_complete:
+    - mark all todos complete
+    - clear TodoWrite state
+    - archive task to completed/
+    - create final git checkpoint
+
+## Error Recovery
+```yaml
+state_mismatch_handling:
+  task_exists_no_todos:
+    - regenerate todos from task breakdown
+    - resume from last known position
+    
+  todos_exist_no_task:
+    - continue with todos only
+    - warn about missing task context
+    
+  both_missing:
+    - start fresh workflow
+    - no recovery needed
+    
+context_corruption:
+  - fallback to task file data
+  - regenerate todos if possible
+  - manual recovery prompts
+```
+
+## User Experience Examples
+```yaml
+example_1_complex:
+  user: "Build user authentication system"
+  system: "[Task created: auth-20250623-143052]"
+  todos: ["Create user model", "Add registration endpoint", "Implement JWT"]
+  work: Focus on current todo with task context preserved
+  
+example_2_simple:
+  user: "Fix login button styling"
+  system: No task created
+  todos: ["Update button CSS", "Test responsive design"]
+  work: Direct todo completion
+  
+example_3_session_break:
+  before_break: Working on "Add registration endpoint" (todo 2/8)
+  after_resume: "Resuming auth system - continuing with registration endpoint"
+  state: Task context + todo position fully restored
+```
--- a/.claude/commands/task.md
+++ b/.claude/commands/task.md
@@ -0,0 +1,110 @@
+# /task: - Task Management & Session Recovery
+
+@task-management.yml
+
+## Purpose
+Manage complex features & requirements across sessions with automatic breakdown, context preservation & recovery.
+
+## Syntax
+```bash
+/task:create <title> [--type feature|bugfix|refactor|docs|test] [--priority high|medium|low]
+/task:list [--status pending|in-progress|completed] [--priority high|medium|low]
+/task:start <id>
+/task:pause <id>
+/task:complete <id>
+/task:resume <id>
+/task:cancel <id>
+/task:show <id>
+/task:update <id> --status <status> --priority <priority>
+```
+
+## Workflow
+```yaml
+Creation:
+  1. Analyze requirement complexity
+  2. Generate unique task ID (YYYYMMDD-HHMMSS)
+  3. Break down into phases & steps
+  4. Create task file from template
+  5. Create git branch
+  6. Move to pending folder
+
+Execution:
+  1. Move to in-progress folder
+  2. Create git checkpoint
+  3. Execute steps sequentially
+  4. Update progress & context
+  5. Handle session breaks gracefully
+
+Completion:
+  1. Verify all steps completed
+  2. Run final tests
+  3. Create completion checkpoint
+  4. Move to completed folder
+  5. Merge git branch
+```
+
+## Auto-Detection
+```yaml
+Triggers:
+  - "build feature X"
+  - "implement functionality Y"
+  - "add component Z"
+  - Requirements >3 files
+  - Complex multi-step work
+
+Response:
+  "This looks like a multi-step task. Should I create a task breakdown?"
+  Options: [Yes - create task] [No - proceed directly]
+```
+
+## Session Recovery
+```yaml
+Startup:
+  1. Scan .tasks/in-progress/
+  2. Identify active tasks
+  3. Restore context from task files
+  4. Suggest resumption steps
+
+Context:
+  - Key architectural decisions
+  - Current implementation state
+  - Known blockers & solutions
+  - File modification history
+```
+
+## Examples
+```bash
+# Create new feature task
+/task:create "User authentication system" --type feature --priority high
+
+# List all pending tasks
+/task:list --status pending
+
+# Start working on a task
+/task:start 20250623-143052
+
+# Pause current work (auto-saves context)
+/task:pause 20250623-143052
+
+# Resume after session break
+/task:resume 20250623-143052
+
+# Mark task complete
+/task:complete 20250623-143052
+```
+
+## Integration
+- **Git**: Automatic branching & checkpoints
+- **TodoWrite**: Sync with current todo system
+- **Personas**: Task-specific persona activation
+- **MCP**: Context preservation across tools
+- **Commands**: Chain with other /user: commands
+
+## File Structure
+```
+./claudedocs/tasks/
+├── pending/feature-20250623-143052-user-auth.md
+├── in-progress/bugfix-20250623-144022-login-error.md
+├── completed/refactor-20250623-142033-api-cleanup.md
+└── templates/feature-template.md
+```
--- a/.gitignore
+++ b/.gitignore
@@ -5,6 +5,9 @@ logs/
 # Claude operations documentation
 .claudedocs/

+# Task management (project-specific)
+./claudedocs/tasks/
+
 # System files
 .DS_Store
 Thumbs.db
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -18,7 +18,7 @@ Philosophy: Code>docs | Simple→complex | Security first
 Communication: Concise format | Symbols: →|&:» | Bullets>prose
 Workflow: TodoRead()→TodoWrite(3+)→Execute | Update immediate
 Stack: React|TS|Vite + Node|Express|PostgreSQL + Git|ESLint|Jest
-Commands: /user:<command> [flags] | Ex: /user:build --init
+Commands: /user:<command> [flags] | /task:<action> | Ex: /user:build --init
 ```

 ## Thinking Modes
@@ -72,6 +72,17 @@ Efficiency: Min tokens | Cache results | Batch ops
 Files: *.tsx→frontend | *.sql→data | Docker→devops | *.test→qa
 Keywords: bug|error→debugger | optimize→performance | secure→security
 Context: TypeError→trace | Module error→deps | Permission→security
+Tasks: Auto-detect complexity→seamless task creation | ./claudedocs/tasks/in-progress→auto-resume
+```
+
+## Task Management
+
+```yaml
+Mode: Automatic | No user prompts | Seamless activation
+Detection: ≥8 complexity points→auto-create | 5-7→brief notify | <5→normal
+Triggers: "build|create|implement" + "system|feature" + complexity flags
+Flow: requirement→analyze→create→breakdown→implement | Background operation
+Recovery: Auto-resume active tasks | Context preservation | Git integration
 ```

 ## Performance
--- a/install.sh
+++ b/install.sh
@@ -133,11 +133,11 @@ command_files=$(ls -1 "$INSTALL_DIR/commands/"*.md 2>/dev/null | wc -l)
 shared_files=$(ls -1 "$INSTALL_DIR/commands/shared/"*.yml 2>/dev/null | wc -l)

 echo -e "Main config files: ${GREEN}$main_files${NC} (expected: 4)"
-echo -e "Command files: ${GREEN}$command_files${NC} (expected: 18)"
-echo -e "Shared resources: ${GREEN}$shared_files${NC} (expected: 26)"
+echo -e "Command files: ${GREEN}$command_files${NC} (expected: 19)"
+echo -e "Shared resources: ${GREEN}$shared_files${NC} (expected: 31)"

 # Check if installation was successful
-if [ "$main_files" -ge 4 ] && [ "$command_files" -ge 18 ] && [ "$shared_files" -ge 26 ]; then
+if [ "$main_files" -ge 4 ] && [ "$command_files" -ge 19 ] && [ "$shared_files" -ge 31 ]; then
    echo ""
    echo -e "${GREEN}✓ SuperClaude installed successfully!${NC}"
    echo ""