Initial commit

.claude/commands/sc/analyze.md

@@ -0,0 +1,33 @@
+---
+allowed-tools: [Read, Grep, Glob, Bash, TodoWrite]
+description: "Analyze code quality, security, performance, and architecture"
+---
+
+# /sc:analyze - Code Analysis
+
+## Purpose
+Execute comprehensive code analysis across quality, security, performance, and architecture domains.
+
+## Usage
+```
+/sc:analyze [target] [--focus quality|security|performance|architecture] [--depth quick|deep]
+```
+
+## Arguments
+- `target` - Files, directories, or project to analyze
+- `--focus` - Analysis focus area (quality, security, performance, architecture)
+- `--depth` - Analysis depth (quick, deep)
+- `--format` - Output format (text, json, report)
+
+## Execution
+1. Discover and categorize files for analysis
+2. Apply appropriate analysis tools and techniques
+3. Generate findings with severity ratings
+4. Create actionable recommendations with priorities
+5. Present comprehensive analysis report
+
+## Claude Code Integration
+- Uses Glob for systematic file discovery
+- Leverages Grep for pattern-based analysis
+- Applies Read for deep code inspection
+- Maintains structured analysis reporting

.claude/commands/sc/build.md

@@ -0,0 +1,34 @@
+---
+allowed-tools: [Read, Bash, Glob, TodoWrite, Edit]
+description: "Build, compile, and package projects with error handling and optimization"
+---
+
+# /sc:build - Project Building
+
+## Purpose
+Build, compile, and package projects with comprehensive error handling and optimization.
+
+## Usage
+```
+/sc:build [target] [--type dev|prod|test] [--clean] [--optimize]
+```
+
+## Arguments
+- `target` - Project or specific component to build
+- `--type` - Build type (dev, prod, test)
+- `--clean` - Clean build artifacts before building
+- `--optimize` - Enable build optimizations
+- `--verbose` - Enable detailed build output
+
+## Execution
+1. Analyze project structure and build configuration
+2. Validate dependencies and environment setup
+3. Execute build process with error monitoring
+4. Handle build errors and provide diagnostic information
+5. Optimize build output and report results
+
+## Claude Code Integration
+- Uses Bash for build command execution
+- Leverages Read for build configuration analysis
+- Applies TodoWrite for build progress tracking
+- Maintains comprehensive error handling and reporting

.claude/commands/sc/cleanup.md

@@ -0,0 +1,34 @@
+---
+allowed-tools: [Read, Grep, Glob, Bash, Edit, MultiEdit]
+description: "Clean up code, remove dead code, and optimize project structure"
+---
+
+# /sc:cleanup - Code and Project Cleanup
+
+## Purpose
+Systematically clean up code, remove dead code, optimize imports, and improve project structure.
+
+## Usage
+```
+/sc:cleanup [target] [--type code|imports|files|all] [--safe|--aggressive]
+```
+
+## Arguments
+- `target` - Files, directories, or entire project to clean
+- `--type` - Cleanup type (code, imports, files, all)
+- `--safe` - Conservative cleanup (default)
+- `--aggressive` - More thorough cleanup with higher risk
+- `--dry-run` - Preview changes without applying them
+
+## Execution
+1. Analyze target for cleanup opportunities
+2. Identify dead code, unused imports, and redundant files
+3. Create cleanup plan with risk assessment
+4. Execute cleanup operations with appropriate safety measures
+5. Validate changes and report cleanup results
+
+## Claude Code Integration
+- Uses Glob for systematic file discovery
+- Leverages Grep for dead code detection
+- Applies MultiEdit for batch cleanup operations
+- Maintains backup and rollback capabilities

.claude/commands/sc/design.md

@@ -0,0 +1,33 @@
+---
+allowed-tools: [Read, Grep, Glob, Write, Edit, TodoWrite]
+description: "Design system architecture, APIs, and component interfaces"
+---
+
+# /sc:design - System and Component Design
+
+## Purpose
+Design system architecture, APIs, component interfaces, and technical specifications.
+
+## Usage
+```
+/sc:design [target] [--type architecture|api|component|database] [--format diagram|spec|code]
+```
+
+## Arguments
+- `target` - System, component, or feature to design
+- `--type` - Design type (architecture, api, component, database)
+- `--format` - Output format (diagram, spec, code)
+- `--iterative` - Enable iterative design refinement
+
+## Execution
+1. Analyze requirements and design constraints
+2. Create initial design concepts and alternatives
+3. Develop detailed design specifications
+4. Validate design against requirements and best practices
+5. Generate design documentation and implementation guides
+
+## Claude Code Integration
+- Uses Read for requirement analysis
+- Leverages Write for design documentation
+- Applies TodoWrite for design task tracking
+- Maintains consistency with architectural patterns

.claude/commands/sc/document.md

@@ -0,0 +1,33 @@
+---
+allowed-tools: [Read, Grep, Glob, Write, Edit]
+description: "Create focused documentation for specific components or features"
+---
+
+# /sc:document - Focused Documentation
+
+## Purpose
+Generate precise, focused documentation for specific components, functions, or features.
+
+## Usage
+```
+/sc:document [target] [--type inline|external|api|guide] [--style brief|detailed]
+```
+
+## Arguments
+- `target` - Specific file, function, or component to document
+- `--type` - Documentation type (inline, external, api, guide)
+- `--style` - Documentation style (brief, detailed)
+- `--template` - Use specific documentation template
+
+## Execution
+1. Analyze target component and extract key information
+2. Identify documentation requirements and audience
+3. Generate appropriate documentation based on type and style
+4. Apply consistent formatting and structure
+5. Integrate with existing documentation ecosystem
+
+## Claude Code Integration
+- Uses Read for deep component analysis
+- Leverages Edit for inline documentation updates
+- Applies Write for external documentation creation
+- Maintains documentation standards and conventions

.claude/commands/sc/estimate.md

@@ -0,0 +1,33 @@
+---
+allowed-tools: [Read, Grep, Glob, Bash]
+description: "Provide development estimates for tasks, features, or projects"
+---
+
+# /sc:estimate - Development Estimation
+
+## Purpose
+Generate accurate development estimates for tasks, features, or projects based on complexity analysis.
+
+## Usage
+```
+/sc:estimate [target] [--type time|effort|complexity|cost] [--unit hours|days|weeks]
+```
+
+## Arguments
+- `target` - Task, feature, or project to estimate
+- `--type` - Estimation type (time, effort, complexity, cost)
+- `--unit` - Time unit for estimates (hours, days, weeks)
+- `--breakdown` - Provide detailed breakdown of estimates
+
+## Execution
+1. Analyze scope and requirements of target
+2. Identify complexity factors and dependencies
+3. Apply estimation methodologies and historical data
+4. Generate estimates with confidence intervals
+5. Present detailed breakdown with risk factors
+
+## Claude Code Integration
+- Uses Read for requirement analysis
+- Leverages Glob for codebase complexity assessment
+- Applies Grep for pattern-based estimation
+- Maintains structured estimation documentation

.claude/commands/sc/explain.md

@@ -0,0 +1,33 @@
+---
+allowed-tools: [Read, Grep, Glob, Bash]
+description: "Provide clear explanations of code, concepts, or system behavior"
+---
+
+# /sc:explain - Code and Concept Explanation
+
+## Purpose
+Deliver clear, comprehensive explanations of code functionality, concepts, or system behavior.
+
+## Usage
+```
+/sc:explain [target] [--level basic|intermediate|advanced] [--format text|diagram|examples]
+```
+
+## Arguments
+- `target` - Code file, function, concept, or system to explain
+- `--level` - Explanation complexity (basic, intermediate, advanced)
+- `--format` - Output format (text, diagram, examples)
+- `--context` - Additional context for explanation
+
+## Execution
+1. Analyze target code or concept thoroughly
+2. Identify key components and relationships
+3. Structure explanation based on complexity level
+4. Provide relevant examples and use cases
+5. Present clear, accessible explanation with proper formatting
+
+## Claude Code Integration
+- Uses Read for comprehensive code analysis
+- Leverages Grep for pattern identification
+- Applies Bash for runtime behavior analysis
+- Maintains clear, educational communication style

.claude/commands/sc/git.md

@@ -0,0 +1,34 @@
+---
+allowed-tools: [Bash, Read, Glob, TodoWrite, Edit]
+description: "Git operations with intelligent commit messages and branch management"
+---
+
+# /sc:git - Git Operations
+
+## Purpose
+Execute Git operations with intelligent commit messages, branch management, and workflow optimization.
+
+## Usage
+```
+/sc:git [operation] [args] [--smart-commit] [--branch-strategy]
+```
+
+## Arguments
+- `operation` - Git operation (add, commit, push, pull, merge, branch, status)
+- `args` - Operation-specific arguments
+- `--smart-commit` - Generate intelligent commit messages
+- `--branch-strategy` - Apply branch naming conventions
+- `--interactive` - Interactive mode for complex operations
+
+## Execution
+1. Analyze current Git state and repository context
+2. Execute requested Git operations with validation
+3. Apply intelligent commit message generation
+4. Handle merge conflicts and branch management
+5. Provide clear feedback and next steps
+
+## Claude Code Integration
+- Uses Bash for Git command execution
+- Leverages Read for repository analysis
+- Applies TodoWrite for operation tracking
+- Maintains Git best practices and conventions

.claude/commands/sc/implement.md

@@ -0,0 +1,54 @@
+---
+allowed-tools: [Read, Write, Edit, MultiEdit, Bash, Glob, TodoWrite, Task]
+description: "Feature and code implementation with intelligent persona activation and MCP integration"
+---
+
+# /sc:implement - Feature Implementation
+
+## Purpose
+Implement features, components, and code functionality with intelligent expert activation and comprehensive development support.
+
+## Usage
+```
+/sc:implement [feature-description] [--type component|api|service|feature] [--framework react|vue|express|etc] [--safe]
+```
+
+## Arguments
+- `feature-description` - Description of what to implement
+- `--type` - Implementation type (component, api, service, feature, module)
+- `--framework` - Target framework or technology stack
+- `--safe` - Use conservative implementation approach
+- `--iterative` - Enable iterative development with validation steps
+- `--with-tests` - Include test implementation
+- `--documentation` - Generate documentation alongside implementation
+
+## Execution
+1. Analyze implementation requirements and detect technology context
+2. Auto-activate relevant personas (frontend, backend, security, etc.)
+3. Coordinate with MCP servers (Magic for UI, Context7 for patterns, Sequential for complex logic)
+4. Generate implementation code with best practices
+5. Apply security and quality validation
+6. Provide testing recommendations and next steps
+
+## Claude Code Integration
+- Uses Write/Edit/MultiEdit for code generation and modification
+- Leverages Read and Glob for codebase analysis and context understanding
+- Applies TodoWrite for implementation progress tracking
+- Integrates Task tool for complex multi-step implementations
+- Coordinates with MCP servers for specialized functionality
+- Auto-activates appropriate personas based on implementation type
+
+## Auto-Activation Patterns
+- **Frontend**: UI components, React/Vue/Angular development
+- **Backend**: APIs, services, database integration
+- **Security**: Authentication, authorization, data protection
+- **Architecture**: System design, module structure
+- **Performance**: Optimization, scalability considerations
+
+## Examples
+```
+/sc:implement user authentication system --type feature --with-tests
+/sc:implement dashboard component --type component --framework react
+/sc:implement REST API for user management --type api --safe
+/sc:implement payment processing service --type service --iterative
+```

.claude/commands/sc/improve.md

@@ -0,0 +1,33 @@
+---
+allowed-tools: [Read, Grep, Glob, Edit, MultiEdit, TodoWrite]
+description: "Apply systematic improvements to code quality, performance, and maintainability"
+---
+
+# /sc:improve - Code Improvement
+
+## Purpose
+Apply systematic improvements to code quality, performance, maintainability, and best practices.
+
+## Usage
+```
+/sc:improve [target] [--type quality|performance|maintainability|style] [--safe]
+```
+
+## Arguments
+- `target` - Files, directories, or project to improve
+- `--type` - Improvement type (quality, performance, maintainability, style)
+- `--safe` - Apply only safe, low-risk improvements
+- `--preview` - Show improvements without applying them
+
+## Execution
+1. Analyze code for improvement opportunities
+2. Identify specific improvement patterns and techniques
+3. Create improvement plan with risk assessment
+4. Apply improvements with appropriate validation
+5. Verify improvements and report changes
+
+## Claude Code Integration
+- Uses Read for comprehensive code analysis
+- Leverages MultiEdit for batch improvements
+- Applies TodoWrite for improvement tracking
+- Maintains safety and validation mechanisms

.claude/commands/sc/index.md

@@ -0,0 +1,33 @@
+---
+allowed-tools: [Read, Grep, Glob, Bash, Write]
+description: "Generate comprehensive project documentation and knowledge base"
+---
+
+# /sc:index - Project Documentation
+
+## Purpose
+Create and maintain comprehensive project documentation, indexes, and knowledge bases.
+
+## Usage
+```
+/sc:index [target] [--type docs|api|structure|readme] [--format md|json|yaml]
+```
+
+## Arguments
+- `target` - Project directory or specific component to document
+- `--type` - Documentation type (docs, api, structure, readme)
+- `--format` - Output format (md, json, yaml)
+- `--update` - Update existing documentation
+
+## Execution
+1. Analyze project structure and identify key components
+2. Extract documentation from code comments and README files
+3. Generate comprehensive documentation based on type
+4. Create navigation structure and cross-references
+5. Output formatted documentation with proper organization
+
+## Claude Code Integration
+- Uses Glob for systematic file discovery
+- Leverages Grep for extracting documentation patterns
+- Applies Write for creating structured documentation
+- Maintains consistency with project conventions

.claude/commands/sc/load.md

@@ -0,0 +1,33 @@
+---
+allowed-tools: [Read, Grep, Glob, Bash, Write]
+description: "Load and analyze project context, configurations, and dependencies"
+---
+
+# /sc:load - Project Context Loading
+
+## Purpose
+Load and analyze project context, configurations, dependencies, and environment setup.
+
+## Usage
+```
+/sc:load [target] [--type project|config|deps|env] [--cache]
+```
+
+## Arguments
+- `target` - Project directory or specific configuration to load
+- `--type` - Loading type (project, config, deps, env)
+- `--cache` - Cache loaded context for faster subsequent access
+- `--refresh` - Force refresh of cached context
+
+## Execution
+1. Discover and analyze project structure and configuration files
+2. Load dependencies, environment variables, and settings
+3. Parse and validate configuration consistency
+4. Create comprehensive project context map
+5. Cache context for efficient future access
+
+## Claude Code Integration
+- Uses Glob for comprehensive project discovery
+- Leverages Read for configuration analysis
+- Applies Bash for environment validation
+- Maintains efficient context caching mechanisms

.claude/commands/sc/spawn.md

@@ -0,0 +1,33 @@
+---
+allowed-tools: [Read, Grep, Glob, Bash, TodoWrite, Edit, MultiEdit, Write]
+description: "Break complex tasks into coordinated subtasks with efficient execution"
+---
+
+# /sc:spawn - Task Orchestration
+
+## Purpose
+Decompose complex requests into manageable subtasks and coordinate their execution.
+
+## Usage
+```
+/sc:spawn [task] [--sequential|--parallel] [--validate]
+```
+
+## Arguments
+- `task` - Complex task or project to orchestrate
+- `--sequential` - Execute tasks in dependency order (default)
+- `--parallel` - Execute independent tasks concurrently
+- `--validate` - Enable quality checkpoints between tasks
+
+## Execution
+1. Parse request and create hierarchical task breakdown
+2. Map dependencies between subtasks
+3. Choose optimal execution strategy (sequential/parallel)
+4. Execute subtasks with progress monitoring
+5. Integrate results and validate completion
+
+## Claude Code Integration
+- Uses TodoWrite for task breakdown and tracking
+- Leverages file operations for coordinated changes
+- Applies efficient batching for related operations
+- Maintains clear dependency management

.claude/commands/sc/task.md

@@ -0,0 +1,157 @@
+---
+allowed-tools: [Read, Glob, Grep, TodoWrite, Task, mcp__sequential-thinking__sequentialthinking]
+description: "Execute complex tasks with intelligent workflow management and cross-session persistence"
+wave-enabled: true
+complexity-threshold: 0.7
+performance-profile: complex
+personas: [architect, analyzer, project-manager]
+mcp-servers: [sequential, context7]
+---
+
+# /sc:task - Enhanced Task Management
+
+## Purpose
+Execute complex tasks with intelligent workflow management, cross-session persistence, hierarchical task organization, and advanced orchestration capabilities.
+
+## Usage
+```
+/sc:task [action] [target] [--strategy systematic|agile|enterprise] [--persist] [--hierarchy] [--delegate]
+```
+
+## Actions
+- `create` - Create new project-level task hierarchy
+- `execute` - Execute task with intelligent orchestration
+- `status` - View task status across sessions
+- `analytics` - Task performance and analytics dashboard
+- `optimize` - Optimize task execution strategies
+- `delegate` - Delegate tasks across multiple agents
+- `validate` - Validate task completion with evidence
+
+## Arguments
+- `target` - Task description, project scope, or existing task ID
+- `--strategy` - Execution strategy (systematic, agile, enterprise)
+- `--persist` - Enable cross-session task persistence
+- `--hierarchy` - Create hierarchical task breakdown
+- `--delegate` - Enable multi-agent task delegation
+- `--wave-mode` - Enable wave-based execution
+- `--validate` - Enforce quality gates and validation
+- `--mcp-routing` - Enable intelligent MCP server routing
+
+## Execution Modes
+
+### Systematic Strategy
+1. **Discovery Phase**: Comprehensive project analysis and scope definition
+2. **Planning Phase**: Hierarchical task breakdown with dependency mapping
+3. **Execution Phase**: Sequential execution with validation gates
+4. **Validation Phase**: Evidence collection and quality assurance
+5. **Optimization Phase**: Performance analysis and improvement recommendations
+
+### Agile Strategy
+1. **Sprint Planning**: Priority-based task organization
+2. **Iterative Execution**: Short cycles with continuous feedback
+3. **Adaptive Planning**: Dynamic task adjustment based on outcomes
+4. **Continuous Integration**: Real-time validation and testing
+5. **Retrospective Analysis**: Learning and process improvement
+
+### Enterprise Strategy
+1. **Stakeholder Analysis**: Multi-domain impact assessment
+2. **Resource Allocation**: Optimal resource distribution across tasks
+3. **Risk Management**: Comprehensive risk assessment and mitigation
+4. **Compliance Validation**: Regulatory and policy compliance checks
+5. **Governance Reporting**: Detailed progress and compliance reporting
+
+## Advanced Features
+
+### Task Hierarchy Management
+- **Epic Level**: Large-scale project objectives (weeks to months)
+- **Story Level**: Feature-specific implementations (days to weeks)
+- **Task Level**: Specific actionable items (hours to days)
+- **Subtask Level**: Granular implementation steps (minutes to hours)
+
+### Intelligent Task Orchestration
+- **Dependency Resolution**: Automatic dependency detection and sequencing
+- **Parallel Execution**: Independent task parallelization
+- **Resource Optimization**: Intelligent resource allocation and scheduling
+- **Context Sharing**: Cross-task context and knowledge sharing
+
+### Cross-Session Persistence
+- **Task State Management**: Persistent task states across sessions
+- **Context Continuity**: Preserved context and progress tracking
+- **Historical Analytics**: Task execution history and learning
+- **Recovery Mechanisms**: Automatic recovery from interruptions
+
+### Quality Gates and Validation
+- **Evidence Collection**: Systematic evidence gathering during execution
+- **Validation Criteria**: Customizable completion criteria
+- **Quality Metrics**: Comprehensive quality assessment
+- **Compliance Checks**: Automated compliance validation
+
+## Integration Points
+
+### Wave System Integration
+- **Wave Coordination**: Multi-wave task execution strategies
+- **Context Accumulation**: Progressive context building across waves
+- **Performance Monitoring**: Real-time performance tracking and optimization
+- **Error Recovery**: Graceful error handling and recovery mechanisms
+
+### MCP Server Coordination
+- **Context7**: Framework patterns and library documentation
+- **Sequential**: Complex analysis and multi-step reasoning
+- **Magic**: UI component generation and design systems
+- **Playwright**: End-to-end testing and performance validation
+
+### Persona Integration
+- **Architect**: System design and architectural decisions
+- **Analyzer**: Code analysis and quality assessment
+- **Project Manager**: Resource allocation and progress tracking
+- **Domain Experts**: Specialized expertise for specific task types
+
+## Performance Optimization
+
+### Execution Efficiency
+- **Batch Operations**: Grouped execution for related tasks
+- **Parallel Processing**: Independent task parallelization
+- **Context Caching**: Reusable context and analysis results
+- **Resource Pooling**: Shared resource utilization
+
+### Intelligence Features
+- **Predictive Planning**: AI-driven task estimation and planning
+- **Adaptive Execution**: Dynamic strategy adjustment based on progress
+- **Learning Systems**: Continuous improvement from execution patterns
+- **Optimization Recommendations**: Data-driven improvement suggestions
+
+## Usage Examples
+
+### Create Project-Level Task Hierarchy
+```
+/sc:task create "Implement user authentication system" --hierarchy --persist --strategy systematic
+```
+
+### Execute with Multi-Agent Delegation
+```
+/sc:task execute AUTH-001 --delegate --wave-mode --validate
+```
+
+### Analytics and Optimization
+```
+/sc:task analytics --project AUTH --optimization-recommendations
+```
+
+### Cross-Session Task Management
+```
+/sc:task status --all-sessions --detailed-breakdown
+```
+
+## Claude Code Integration
+- **TodoWrite Integration**: Seamless session-level task coordination
+- **Wave System**: Advanced multi-stage execution orchestration
+- **Hook System**: Real-time task monitoring and optimization
+- **MCP Coordination**: Intelligent server routing and resource utilization
+- **Performance Monitoring**: Sub-100ms execution targets with comprehensive metrics
+
+## Success Criteria
+- **Task Completion Rate**: >95% successful task completion
+- **Performance Targets**: <100ms hook execution, <5s task creation
+- **Quality Metrics**: >90% validation success rate
+- **Cross-Session Continuity**: 100% task state preservation
+- **Intelligence Effectiveness**: >80% accurate predictive planning

.claude/commands/sc/test.md

@@ -0,0 +1,34 @@
+---
+allowed-tools: [Read, Bash, Glob, TodoWrite, Edit, Write]
+description: "Execute tests, generate test reports, and maintain test coverage"
+---
+
+# /sc:test - Testing and Quality Assurance
+
+## Purpose
+Execute tests, generate comprehensive test reports, and maintain test coverage standards.
+
+## Usage
+```
+/sc:test [target] [--type unit|integration|e2e|all] [--coverage] [--watch]
+```
+
+## Arguments
+- `target` - Specific tests, files, or entire test suite
+- `--type` - Test type (unit, integration, e2e, all)
+- `--coverage` - Generate coverage reports
+- `--watch` - Run tests in watch mode
+- `--fix` - Automatically fix failing tests when possible
+
+## Execution
+1. Discover and categorize available tests
+2. Execute tests with appropriate configuration
+3. Monitor test results and collect metrics
+4. Generate comprehensive test reports
+5. Provide recommendations for test improvements
+
+## Claude Code Integration
+- Uses Bash for test execution and monitoring
+- Leverages Glob for test discovery
+- Applies TodoWrite for test result tracking
+- Maintains structured test reporting and coverage analysis

.claude/commands/sc/troubleshoot.md

@@ -0,0 +1,33 @@
+---
+allowed-tools: [Read, Grep, Glob, Bash, TodoWrite]
+description: "Diagnose and resolve issues in code, builds, or system behavior"
+---
+
+# /sc:troubleshoot - Issue Diagnosis and Resolution
+
+## Purpose
+Systematically diagnose and resolve issues in code, builds, deployments, or system behavior.
+
+## Usage
+```
+/sc:troubleshoot [issue] [--type bug|build|performance|deployment] [--trace]
+```
+
+## Arguments
+- `issue` - Description of the problem or error message
+- `--type` - Issue category (bug, build, performance, deployment)
+- `--trace` - Enable detailed tracing and logging
+- `--fix` - Automatically apply fixes when safe
+
+## Execution
+1. Analyze issue description and gather initial context
+2. Identify potential root causes and investigation paths
+3. Execute systematic debugging and diagnosis
+4. Propose and validate solution approaches
+5. Apply fixes and verify resolution
+
+## Claude Code Integration
+- Uses Read for error log analysis
+- Leverages Bash for runtime diagnostics
+- Applies Grep for pattern-based issue detection
+- Maintains structured troubleshooting documentation

.claude/commands/sc/workflow.md

@@ -0,0 +1,303 @@
+---
+allowed-tools: [Read, Write, Edit, Glob, Grep, TodoWrite, Task, mcp__sequential-thinking__sequentialthinking, mcp__context7__context7]
+description: "Generate structured implementation workflows from PRDs and feature requirements with expert guidance"
+wave-enabled: true
+complexity-threshold: 0.6
+performance-profile: complex
+personas: [architect, analyzer, frontend, backend, security, devops, project-manager]
+mcp-servers: [sequential, context7, magic]
+---
+
+# /sc:workflow - Implementation Workflow Generator
+
+## Purpose
+Analyze Product Requirements Documents (PRDs) and feature specifications to generate comprehensive, step-by-step implementation workflows with expert guidance, dependency mapping, and automated task orchestration.
+
+## Usage
+```
+/sc:workflow [prd-file|feature-description] [--persona expert] [--c7] [--sequential] [--strategy systematic|agile|mvp] [--output roadmap|tasks|detailed]
+```
+
+## Arguments
+- `prd-file|feature-description` - Path to PRD file or direct feature description
+- `--persona` - Force specific expert persona (architect, frontend, backend, security, devops, etc.)
+- `--strategy` - Workflow strategy (systematic, agile, mvp)
+- `--output` - Output format (roadmap, tasks, detailed)
+- `--estimate` - Include time and complexity estimates
+- `--dependencies` - Map external dependencies and integrations
+- `--risks` - Include risk assessment and mitigation strategies
+- `--parallel` - Identify parallelizable work streams
+- `--milestones` - Create milestone-based project phases
+
+## MCP Integration Flags
+- `--c7` / `--context7` - Enable Context7 for framework patterns and best practices
+- `--sequential` - Enable Sequential thinking for complex multi-step analysis
+- `--magic` - Enable Magic for UI component workflow planning
+- `--all-mcp` - Enable all MCP servers for comprehensive workflow generation
+
+## Workflow Strategies
+
+### Systematic Strategy (Default)
+1. **Requirements Analysis** - Deep dive into PRD structure and acceptance criteria
+2. **Architecture Planning** - System design and component architecture
+3. **Dependency Mapping** - Identify all internal and external dependencies
+4. **Implementation Phases** - Sequential phases with clear deliverables
+5. **Testing Strategy** - Comprehensive testing approach at each phase
+6. **Deployment Planning** - Production rollout and monitoring strategy
+
+### Agile Strategy
+1. **Epic Breakdown** - Convert PRD into user stories and epics
+2. **Sprint Planning** - Organize work into iterative sprints
+3. **MVP Definition** - Identify minimum viable product scope
+4. **Iterative Development** - Plan for continuous delivery and feedback
+5. **Stakeholder Engagement** - Regular review and adjustment cycles
+6. **Retrospective Planning** - Built-in improvement and learning cycles
+
+### MVP Strategy
+1. **Core Feature Identification** - Strip down to essential functionality
+2. **Rapid Prototyping** - Focus on quick validation and feedback
+3. **Technical Debt Planning** - Identify shortcuts and future improvements
+4. **Validation Metrics** - Define success criteria and measurement
+5. **Scaling Roadmap** - Plan for post-MVP feature expansion
+6. **User Feedback Integration** - Structured approach to user input
+
+## Expert Persona Auto-Activation
+
+### Frontend Workflow (`--persona frontend` or auto-detected)
+- **UI/UX Analysis** - Design system integration and component planning
+- **State Management** - Data flow and state architecture
+- **Performance Optimization** - Bundle optimization and lazy loading
+- **Accessibility Compliance** - WCAG guidelines and inclusive design
+- **Browser Compatibility** - Cross-browser testing strategy
+- **Mobile Responsiveness** - Responsive design implementation plan
+
+### Backend Workflow (`--persona backend` or auto-detected)
+- **API Design** - RESTful/GraphQL endpoint planning
+- **Database Schema** - Data modeling and migration strategy
+- **Security Implementation** - Authentication, authorization, and data protection
+- **Performance Scaling** - Caching, optimization, and load handling
+- **Service Integration** - Third-party APIs and microservices
+- **Monitoring & Logging** - Observability and debugging infrastructure
+
+### Architecture Workflow (`--persona architect` or auto-detected)
+- **System Design** - High-level architecture and service boundaries
+- **Technology Stack** - Framework and tool selection rationale
+- **Scalability Planning** - Growth considerations and bottleneck prevention
+- **Security Architecture** - Comprehensive security strategy
+- **Integration Patterns** - Service communication and data flow
+- **DevOps Strategy** - CI/CD pipeline and infrastructure as code
+
+### Security Workflow (`--persona security` or auto-detected)
+- **Threat Modeling** - Security risk assessment and attack vectors
+- **Data Protection** - Encryption, privacy, and compliance requirements
+- **Authentication Strategy** - User identity and access management
+- **Security Testing** - Penetration testing and vulnerability assessment
+- **Compliance Validation** - Regulatory requirements (GDPR, HIPAA, etc.)
+- **Incident Response** - Security monitoring and breach protocols
+
+### DevOps Workflow (`--persona devops` or auto-detected)
+- **Infrastructure Planning** - Cloud architecture and resource allocation
+- **CI/CD Pipeline** - Automated testing, building, and deployment
+- **Environment Management** - Development, staging, and production environments
+- **Monitoring Strategy** - Application and infrastructure monitoring
+- **Backup & Recovery** - Data protection and disaster recovery planning
+- **Performance Monitoring** - APM tools and performance optimization
+
+## Output Formats
+
+### Roadmap Format (`--output roadmap`)
+```
+# Feature Implementation Roadmap
+## Phase 1: Foundation (Week 1-2)
+- [ ] Architecture design and technology selection
+- [ ] Database schema design and setup
+- [ ] Basic project structure and CI/CD pipeline
+
+## Phase 2: Core Implementation (Week 3-6)
+- [ ] API development and authentication
+- [ ] Frontend components and user interface
+- [ ] Integration testing and security validation
+
+## Phase 3: Enhancement & Launch (Week 7-8)
+- [ ] Performance optimization and load testing
+- [ ] User acceptance testing and bug fixes
+- [ ] Production deployment and monitoring setup
+```
+
+### Tasks Format (`--output tasks`)
+```
+# Implementation Tasks
+## Epic: User Authentication System
+### Story: User Registration
+- [ ] Design registration form UI components
+- [ ] Implement backend registration API
+- [ ] Add email verification workflow
+- [ ] Create user onboarding flow
+
+### Story: User Login
+- [ ] Design login interface
+- [ ] Implement JWT authentication
+- [ ] Add password reset functionality
+- [ ] Set up session management
+```
+
+### Detailed Format (`--output detailed`)
+```
+# Detailed Implementation Workflow
+## Task: Implement User Registration API
+**Persona**: Backend Developer
+**Estimated Time**: 8 hours
+**Dependencies**: Database schema, authentication service
+**MCP Context**: Express.js patterns, security best practices
+
+### Implementation Steps:
+1. **Setup API endpoint** (1 hour)
+   - Create POST /api/register route
+   - Add input validation middleware
+   
+2. **Database integration** (2 hours)
+   - Implement user model
+   - Add password hashing
+   
+3. **Security measures** (3 hours)
+   - Rate limiting implementation
+   - Input sanitization
+   - SQL injection prevention
+   
+4. **Testing** (2 hours)
+   - Unit tests for registration logic
+   - Integration tests for API endpoint
+
+### Acceptance Criteria:
+- [ ] User can register with email and password
+- [ ] Passwords are properly hashed
+- [ ] Email validation is enforced
+- [ ] Rate limiting prevents abuse
+```
+
+## Advanced Features
+
+### Dependency Analysis
+- **Internal Dependencies** - Identify coupling between components and features
+- **External Dependencies** - Map third-party services and APIs
+- **Technical Dependencies** - Framework versions, database requirements
+- **Team Dependencies** - Cross-team coordination requirements
+- **Infrastructure Dependencies** - Cloud services, deployment requirements
+
+### Risk Assessment & Mitigation
+- **Technical Risks** - Complexity, performance, and scalability concerns
+- **Timeline Risks** - Dependency bottlenecks and resource constraints
+- **Security Risks** - Data protection and compliance vulnerabilities
+- **Business Risks** - Market changes and requirement evolution
+- **Mitigation Strategies** - Fallback plans and alternative approaches
+
+### Parallel Work Stream Identification
+- **Independent Components** - Features that can be developed simultaneously
+- **Shared Dependencies** - Common components requiring coordination
+- **Critical Path Analysis** - Bottlenecks that block other work
+- **Resource Allocation** - Team capacity and skill distribution
+- **Communication Protocols** - Coordination between parallel streams
+
+## Integration with SuperClaude Ecosystem
+
+### TodoWrite Integration
+- Automatically creates session tasks for immediate next steps
+- Provides progress tracking throughout workflow execution
+- Links workflow phases to actionable development tasks
+
+### Task Command Integration
+- Converts workflow into hierarchical project tasks (`/sc:task`)
+- Enables cross-session persistence and progress tracking
+- Supports complex orchestration with `/sc:spawn`
+
+### Implementation Command Integration
+- Seamlessly connects to `/sc:implement` for feature development
+- Provides context-aware implementation guidance
+- Auto-activates appropriate personas for each workflow phase
+
+### Analysis Command Integration
+- Leverages `/sc:analyze` for codebase assessment
+- Integrates existing code patterns into workflow planning
+- Identifies refactoring opportunities and technical debt
+
+## Usage Examples
+
+### Generate Workflow from PRD File
+```
+/sc:workflow docs/feature-100-prd.md --strategy systematic --c7 --sequential --estimate
+```
+
+### Create Frontend-Focused Workflow
+```
+/sc:workflow "User dashboard with real-time analytics" --persona frontend --magic --output detailed
+```
+
+### MVP Planning with Risk Assessment
+```
+/sc:workflow user-authentication-system --strategy mvp --risks --parallel --milestones
+```
+
+### Backend API Workflow with Dependencies
+```
+/sc:workflow payment-processing-api --persona backend --dependencies --c7 --output tasks
+```
+
+### Full-Stack Feature Workflow
+```
+/sc:workflow social-media-integration --all-mcp --sequential --parallel --estimate --output roadmap
+```
+
+## Quality Gates and Validation
+
+### Workflow Completeness Check
+- **Requirements Coverage** - Ensure all PRD requirements are addressed
+- **Acceptance Criteria** - Validate testable success criteria
+- **Technical Feasibility** - Assess implementation complexity and risks
+- **Resource Alignment** - Match workflow to team capabilities and timeline
+
+### Best Practices Validation
+- **Architecture Patterns** - Ensure adherence to established patterns
+- **Security Standards** - Validate security considerations at each phase
+- **Performance Requirements** - Include performance targets and monitoring
+- **Maintainability** - Plan for long-term code maintenance and updates
+
+### Stakeholder Alignment
+- **Business Requirements** - Ensure business value is clearly defined
+- **Technical Requirements** - Validate technical specifications and constraints
+- **Timeline Expectations** - Realistic estimation and milestone planning
+- **Success Metrics** - Define measurable outcomes and KPIs
+
+## Performance Optimization
+
+### Workflow Generation Speed
+- **PRD Parsing** - Efficient document analysis and requirement extraction
+- **Pattern Recognition** - Rapid identification of common implementation patterns
+- **Template Application** - Reusable workflow templates for common scenarios
+- **Incremental Generation** - Progressive workflow refinement and optimization
+
+### Context Management
+- **Memory Efficiency** - Optimal context usage for large PRDs
+- **Caching Strategy** - Reuse analysis results across similar workflows
+- **Progressive Loading** - Load workflow details on-demand
+- **Compression** - Efficient storage and retrieval of workflow data
+
+## Success Metrics
+
+### Workflow Quality
+- **Implementation Success Rate** - >90% successful feature completion following workflows
+- **Timeline Accuracy** - <20% variance from estimated timelines
+- **Requirement Coverage** - 100% PRD requirement mapping to workflow tasks
+- **Stakeholder Satisfaction** - >85% satisfaction with workflow clarity and completeness
+
+### Performance Targets
+- **Workflow Generation** - <30 seconds for standard PRDs
+- **Dependency Analysis** - <60 seconds for complex systems
+- **Risk Assessment** - <45 seconds for comprehensive evaluation
+- **Context Integration** - <10 seconds for MCP server coordination
+
+## Claude Code Integration
+- **Multi-Tool Orchestration** - Coordinates Read, Write, Edit, Glob, Grep for comprehensive analysis
+- **Progressive Task Creation** - Uses TodoWrite for immediate next steps and Task for long-term planning
+- **MCP Server Coordination** - Intelligent routing to Context7, Sequential, and Magic based on workflow needs
+- **Cross-Command Integration** - Seamless handoff to implement, analyze, design, and other SuperClaude commands
+- **Evidence-Based Planning** - Maintains audit trail of decisions and rationale throughout workflow generation