claude-flow 1.0.30 → 1.0.31

package/README.md

@@ -23,8 +23,9 @@
 
 - **🚀 10x Faster Development**: Parallel AI agent execution with intelligent task distribution
 - **🧠 Persistent Memory**: Agents learn and share knowledge across sessions
+- **⚡ SPARC Methodology**: Systematic development with Specification → Pseudocode → Architecture → Refinement → Completion
 - **🔄 Zero Configuration**: Works out-of-the-box with sensible defaults
-- **⚡ VSCode Native**: Seamless integration with your favorite IDE
+- **🤖 VSCode Native**: Seamless integration with your favorite IDE
 - **🔒 Enterprise Ready**: Production-grade security, monitoring, and scaling
 - **🌐 MCP Compatible**: Full Model Context Protocol support for tool integration
 
@@ -32,9 +33,14 @@
 
 ```bash
 # 🚀 Get started in 30 seconds
-npx claude-flow init
+npx claude-flow init --sparc
 npx claude-flow start
 
+# ⚡ SPARC Development Workflow
+npx claude-flow sparc modes              # List development modes
+npx claude-flow sparc tdd "user auth"    # Run TDD workflow
+npx claude-flow sparc run architect "design API"  # Architecture mode
+
 # 🤖 Spawn a research team
 npx claude-flow agent spawn researcher --name "Senior Researcher"
 npx claude-flow agent spawn analyst --name "Data Analyst"
@@ -67,8 +73,8 @@ Advanced CRDT-based memory system with SQLite performance and Markdown readabili
 </td>
 <td width="33%" align="center">
 
-### ⚡ **Enhanced Claude Integration**
-Spawn Claude instances with comprehensive Claude-Flow guidance, teaching them to use memory, coordination, and system commands effectively.
+### ⚡ **SPARC Development**
+Systematic AI-assisted development using Specification → Pseudocode → Architecture → Refinement → Completion methodology with 16+ specialized modes.
 
 </td>
 </tr>
@@ -145,12 +151,14 @@ Comprehensive documentation is available to help you get the most out of Claude-
 
 ### 1. **Initialize Claude Code Integration**
 ```bash
-npx claude-flow init
+npx claude-flow init --sparc
 ```
 This creates:
-- `CLAUDE.md` - Claude Code configuration
+- `CLAUDE.md` - SPARC-enhanced Claude Code configuration
 - `memory-bank.md` - Memory system documentation
 - `coordination.md` - Agent coordination documentation
+- `.roomodes` - SPARC development mode configurations
+- `.roo/` - SPARC templates and workflows
 - Memory folder structure with placeholders
 
 ### 2. **Start the Orchestrator**
@@ -237,6 +245,50 @@ npx claude-flow monitor
 npx claude-flow mcp tools
 ```
 
+## 🚀 **SPARC Development Methodology**
+
+Claude-Flow integrates the **SPARC** (Specification, Pseudocode, Architecture, Refinement, Completion) methodology for systematic AI-assisted development:
+
+### **Available SPARC Modes**
+```bash
+# List all development modes
+npx claude-flow sparc modes
+
+# Key modes include:
+# 🏗️ architect      - System design and architecture
+# 🧠 code           - Clean, modular implementation  
+# 🧪 tdd            - Test-driven development
+# 🛡️ security-review - Security analysis
+# 📚 docs-writer    - Documentation creation
+# 🔗 integration    - System integration
+```
+
+### **SPARC Workflow**
+```bash
+# 1. Specification - Define requirements
+npx claude-flow sparc run spec-pseudocode "user authentication system"
+
+# 2. Architecture - Design system structure  
+npx claude-flow sparc run architect "auth service architecture"
+
+# 3. Refinement - TDD implementation
+npx claude-flow sparc tdd "implement JWT authentication"
+
+# 4. Integration - Connect components
+npx claude-flow sparc run integration "auth with user management"
+
+# 5. Completion - Documentation and validation
+npx claude-flow sparc run docs-writer "authentication API docs"
+```
+
+### **SPARC Features**
+- **16+ Specialized AI Modes** for different development phases
+- **Memory Persistence** across SPARC sessions with namespaced storage
+- **TDD Enforcement** with Red-Green-Refactor cycle automation
+- **Modular Design** with <500 line file constraints
+- **Environment Safety** preventing credential exposure
+- **Quality Gates** with automated code analysis and security review
+
 ## Architecture
 
 Claude-Flow uses a modular architecture with the following components:
@@ -396,6 +448,18 @@ npx claude-flow monitor [options]
   -f, --focus <component>   Focus on specific component
 ```
 
+#### `sparc` - SPARC Development Methodology 🆕
+```bash
+npx claude-flow sparc <subcommand>
+  modes [--verbose]         List available SPARC development modes
+  info <mode>               Show detailed mode information
+  run <mode> "<task>"       Execute specific SPARC mode
+  tdd "<feature>"           Run full TDD workflow
+    --namespace <ns>        Use custom memory namespace
+    --dry-run               Show configuration without executing
+    --verbose               Show detailed output
+```
+
 #### `claude` - Spawn Claude Instances with Enhanced Guidance 🆕
 ```bash
 npx claude-flow claude <subcommand>
@@ -493,6 +557,27 @@ npx claude-flow agent spawn coordinator --name "Tech Lead"
 npx claude-flow workflow development-pipeline.json --watch
 ```
 
+**SPARC Development Workflow:**
+```bash
+# Initialize SPARC environment
+npx claude-flow init --sparc
+
+# Complete feature development using SPARC methodology
+npx claude-flow sparc run spec-pseudocode "user authentication system"
+npx claude-flow sparc run architect "JWT auth service design"
+npx claude-flow sparc tdd "implement secure authentication"
+npx claude-flow sparc run security-review "auth vulnerability scan"
+npx claude-flow sparc run integration "connect auth to user service"
+
+# TDD-focused development
+npx claude-flow sparc tdd "payment processing system"
+npx claude-flow sparc tdd "real-time notifications"
+
+# Architecture and design
+npx claude-flow sparc run architect "microservices architecture"
+npx claude-flow sparc run docs-writer "API documentation"
+```
+
 **Enhanced Claude Spawn Examples:**
 ```bash
 # Backend API development with high test coverage
@@ -627,7 +712,7 @@ Claude-Flow seamlessly integrates with Claude Code through the `CLAUDE.md` file
 - **Build Command Integration**: All build/test commands are available to Claude
 - **Memory Persistence**: Claude remembers context across sessions
 - **Enhanced Guidance**: Spawned Claude instances receive detailed Claude-Flow instructions
-- **SPARC Methodology**: Built-in support for structured AI development
+- **SPARC Methodology**: Built-in support for systematic development with 16+ specialized AI modes
 
 Use with Claude Code:
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "1.0.30",
+  "version": "1.0.31",
   "description": "Advanced AI agent orchestration system for Claude Code",
   "main": "src/cli/main.ts",
   "bin": {

package/src/cli/simple-cli.js

@@ -13,7 +13,7 @@ import {
 } from './command-registry.js';
 import { parseFlags } from './utils.js';
 
-const VERSION = '1.0.30';
+const VERSION = '1.0.31';
 
 function printHelp() {
   console.log(`
@@ -25,7 +25,7 @@ USAGE:
 KEY COMMANDS:
   init [--sparc]                       Initialize project with Claude integration
   agent spawn <type> [--name <name>]   Create AI agent (researcher, coder, analyst)
-  sparc <subcommand>                   SPARC-based TDD development
+  sparc <subcommand>                   SPARC-based development modes
   memory <subcommand>                  Manage persistent memory
   start                                Start orchestration system
   status                               Show system status

package/src/cli/simple-commands/sparc-modes/architect.js

@@ -0,0 +1,53 @@
+// architect.js - Architect mode orchestration template
+export function getArchitectOrchestration(taskDescription, memoryNamespace) {
+  return `
+## Task Orchestration Steps
+
+1. **Requirements Analysis** (10 mins)
+   - Analyze the user's request: "${taskDescription}"
+   - Query existing project context: \`npx claude-flow memory query ${memoryNamespace}\`
+   - Identify core components, services, and modular boundaries
+   - List external dependencies and integration points
+   - Document scalability and security requirements
+   - Store findings: \`npx claude-flow memory store ${memoryNamespace}_requirements "Core components: X, Y, Z. External deps: API-A, Service-B. Security: OAuth2, RLS policies needed."\`
+
+2. **System Architecture Design** (20 mins)
+   - Create modular architecture diagram using Mermaid syntax
+   - Define clear service boundaries and responsibilities
+   - Design API contracts between components
+   - Plan data flow and state management patterns
+   - Ensure NO hardcoded secrets or env values in design
+   - Create extensible integration points
+   - Store architecture: \`npx claude-flow memory store ${memoryNamespace}_architecture "Microservices: auth-service, user-service, data-processor. APIs: REST for external, gRPC for internal. State: Event-sourced with CQRS."\`
+
+3. **Technical Specifications** (15 mins)
+   - Define detailed interface contracts (OpenAPI/AsyncAPI)
+   - Specify data models and database schemas
+   - Plan security boundaries and authentication flows
+   - Document performance and scaling considerations
+   - Define configuration management strategy
+   - Store specs: \`npx claude-flow memory store ${memoryNamespace}_tech_specs "Auth: JWT with refresh tokens. DB: PostgreSQL with read replicas. Cache: Redis. Config: Environment-based with secrets manager."\`
+
+4. **Modular Implementation Plan** (10 mins)
+   - Break system into modules < 500 lines each
+   - Create development phases with clear milestones
+   - Define testing strategy (unit, integration, e2e)
+   - Plan deployment and rollback procedures
+   - Identify tasks for other SPARC modes
+   - Store plan: \`npx claude-flow memory store ${memoryNamespace}_implementation_plan "Phase 1: Core auth (tdd mode). Phase 2: User management (code mode). Phase 3: Integration (integration mode)."\`
+
+5. **Deliverables**
+   - architecture/
+     - system-overview.md (with Mermaid diagrams)
+     - api-specifications.md (OpenAPI/AsyncAPI specs)
+     - data-models.md (schemas with relationships)
+     - security-architecture.md (auth flows, boundaries)
+     - deployment-architecture.md (infrastructure design)
+   - implementation-plan.md (phased approach with SPARC mode assignments)
+
+## Next Steps
+After completing architecture, delegate to appropriate modes:
+- \`npx claude-flow sparc run spec-pseudocode "Create detailed pseudocode for ${taskDescription}" --non-interactive\`
+- \`npx claude-flow sparc run tdd "Implement core authentication module" --non-interactive\`
+- \`npx claude-flow sparc run security-review "Review architecture for vulnerabilities" --non-interactive\``;
+}

package/src/cli/simple-commands/sparc-modes/ask.js

@@ -0,0 +1,126 @@
+// ask.js - Ask mode orchestration template
+export function getAskOrchestration(taskDescription, memoryNamespace) {
+  return `
+## ❓ Ask Mode - SPARC Navigation Guide
+
+I'll help you navigate the SPARC methodology and determine the best approach for: "${taskDescription}"
+
+## Understanding Your Request
+
+Let me analyze your needs and guide you to the right SPARC mode:
+
+### 1. **Project Phase Analysis** (5 mins)
+   - What stage is your project in?
+   - What type of help do you need?
+   - What's your end goal?
+
+### 2. **SPARC Mode Recommendations**
+
+Based on your request, here are the relevant SPARC modes:
+
+#### 📋 Planning & Design Modes:
+- **\`spec-pseudocode\`** - For creating detailed specifications, requirements, and high-level logic
+  - Use when: Starting a new feature, defining requirements, planning algorithms
+  - Example: \`npx claude-flow sparc run spec-pseudocode "Create user authentication flow" --non-interactive\`
+
+- **\`architect\`** - For system design, API boundaries, and service architecture
+  - Use when: Designing system structure, defining APIs, planning microservices
+  - Example: \`npx claude-flow sparc run architect "Design e-commerce platform architecture" --non-interactive\`
+
+#### 🧠 Implementation Modes:
+- **\`code\`** - For implementing features with clean architecture
+  - Use when: Building new features, writing production code
+  - Example: \`npx claude-flow sparc run code "Implement payment processing service" --non-interactive\`
+
+- **\`tdd\`** - For test-first development with comprehensive coverage
+  - Use when: Want high quality code, need test coverage, following TDD practices
+  - Example: \`npx claude-flow sparc run tdd "Build shopping cart with TDD" --non-interactive\`
+
+#### 🔧 Quality & Maintenance Modes:
+- **\`debug\`** - For troubleshooting issues and fixing bugs
+  - Use when: Something's broken, need to trace errors, fix runtime issues
+  - Example: \`npx claude-flow sparc run debug "Fix memory leak in data processor" --non-interactive\`
+
+- **\`security-review\`** - For security audits and vulnerability checks
+  - Use when: Need security audit, checking for exposed secrets, compliance review
+  - Example: \`npx claude-flow sparc run security-review "Audit user data handling" --non-interactive\`
+
+- **\`refinement-optimization-mode\`** - For performance optimization and refactoring
+  - Use when: Code needs optimization, files too large, performance issues
+  - Example: \`npx claude-flow sparc run refinement-optimization-mode "Optimize database queries" --non-interactive\`
+
+#### 📚 Documentation & Integration:
+- **\`docs-writer\`** - For creating documentation and guides
+  - Use when: Need README, API docs, user guides
+  - Example: \`npx claude-flow sparc run docs-writer "Create API documentation" --non-interactive\`
+
+- **\`integration\`** - For connecting services and ensuring system cohesion
+  - Use when: Integrating components, connecting APIs, system integration
+  - Example: \`npx claude-flow sparc run integration "Connect auth service to user service" --non-interactive\`
+
+#### 🚀 Deployment & Operations:
+- **\`devops\`** - For deployment, CI/CD, and infrastructure
+  - Use when: Setting up deployment, configuring CI/CD, provisioning infrastructure
+  - Example: \`npx claude-flow sparc run devops "Deploy to AWS with auto-scaling" --non-interactive\`
+
+- **\`post-deployment-monitoring-mode\`** - For production monitoring
+  - Use when: Setting up monitoring, configuring alerts, tracking metrics
+  - Example: \`npx claude-flow sparc run post-deployment-monitoring-mode "Setup DataDog monitoring" --non-interactive\`
+
+#### 🔐 Specialized Modes:
+- **\`supabase-admin\`** - For Supabase database and auth management
+  - Use when: Working with Supabase, setting up database, configuring auth
+  - Example: \`npx claude-flow sparc run supabase-admin "Setup user authentication database" --non-interactive\`
+
+- **\`mcp\`** - For MCP (Model Context Protocol) integrations
+  - Use when: Integrating external tools via MCP, API connections
+  - Example: \`npx claude-flow sparc run mcp "Integrate Stripe payment API" --non-interactive\`
+
+### 3. **Workflow Recommendations**
+
+For "${taskDescription}", I recommend this workflow:
+
+\`\`\`bash
+# Step 1: Define requirements
+npx claude-flow sparc run spec-pseudocode "${taskDescription} - requirements and pseudocode" --non-interactive
+
+# Step 2: Design architecture (if needed)
+npx claude-flow sparc run architect "${taskDescription} - system design" --non-interactive
+
+# Step 3: Implement with TDD
+npx claude-flow sparc run tdd "${taskDescription} - implementation" --non-interactive
+
+# Step 4: Security review
+npx claude-flow sparc run security-review "${taskDescription} - security audit" --non-interactive
+
+# Step 5: Documentation
+npx claude-flow sparc run docs-writer "${taskDescription} - documentation" --non-interactive
+\`\`\`
+
+### 4. **Best Practices Reminder**
+When using any SPARC mode, remember:
+✅ Keep files modular (< 500 lines)
+✅ Never hardcode environment variables
+✅ Use configuration files for env-specific values
+✅ Write tests for critical functionality
+✅ Document your decisions in memory
+
+### 5. **Memory Management**
+Track your progress across modes:
+\`\`\`bash
+# Store project context
+npx claude-flow memory store ${memoryNamespace}_context "Working on: ${taskDescription}"
+
+# Query previous work
+npx claude-flow memory query ${memoryNamespace}
+
+# List all memory entries
+npx claude-flow memory list
+\`\`\`
+
+## Next Steps
+
+Based on your request "${taskDescription}", which SPARC mode would you like to use? Or would you like me to help you break down your task into smaller, mode-specific subtasks?
+
+Remember: The SPARC methodology ensures systematic, high-quality development. Each mode has a specific purpose - use them in combination for best results!`;
+}

package/src/cli/simple-commands/sparc-modes/code.js

@@ -0,0 +1,85 @@
+// code.js - Auto-Coder mode orchestration template
+export function getCodeOrchestration(taskDescription, memoryNamespace) {
+  return `
+## Task Orchestration Steps
+
+1. **Context & Architecture Review** (5 mins)
+   - Review implementation task: "${taskDescription}"
+   - Query architecture and pseudocode: 
+     \`\`\`bash
+     npx claude-flow memory query ${memoryNamespace}_architecture
+     npx claude-flow memory query ${memoryNamespace}_pseudocode
+     npx claude-flow memory query ${memoryNamespace}_tech_specs
+     \`\`\`
+   - Identify modules to implement and their boundaries
+   - Review configuration requirements
+   - Check for any blocking dependencies
+
+2. **Project Setup & Configuration** (10 mins)
+   - Initialize project structure following clean architecture
+   - Set up environment configuration (NO hardcoded values):
+     - Create .env.example with all required variables
+     - Set up config/ directory with environment loaders
+     - Implement secrets management abstraction
+   - Install dependencies based on tech specs
+   - Create module structure (each file < 500 lines)
+   - Store setup: \`npx claude-flow memory store ${memoryNamespace}_setup "Project structure: src/{domain,application,infrastructure}. Config: dotenv + vault integration. Dependencies: express, joi, winston."\`
+
+3. **Modular Implementation** (30 mins)
+   - Implement features using clean architecture principles:
+     - Domain layer: Business entities and rules
+     - Application layer: Use cases and workflows
+     - Infrastructure layer: External integrations
+   - Follow SOLID principles and dependency injection
+   - Keep each module/file under 500 lines
+   - Use configuration for ALL environment-specific values
+   - Implement comprehensive error handling
+   - Add structured logging with context
+   - Store progress: \`npx claude-flow memory store ${memoryNamespace}_implementation "Completed: auth-service (3 modules), user-repository (2 modules). Remaining: notification-service."\`
+
+4. **Integration & Basic Testing** (15 mins)
+   - Wire up dependency injection container
+   - Connect modules following architecture design
+   - Implement health checks and monitoring endpoints
+   - Add input validation and sanitization
+   - Create smoke tests for critical paths
+   - Verify configuration loading works correctly
+   - Test error scenarios and graceful degradation
+   - Store results: \`npx claude-flow memory store ${memoryNamespace}_tests "Smoke tests passing. Health checks operational. Error handling verified. Ready for TDD mode deep testing."\`
+
+5. **Code Quality & Documentation** (10 mins)
+   - Run linters and formatters
+   - Add inline documentation for complex logic
+   - Create API documentation (if applicable)
+   - Generate dependency graphs
+   - Update README with setup instructions
+   - Store completion: \`npx claude-flow memory store ${memoryNamespace}_code_complete "Implementation complete. All modules < 500 lines. No hardcoded secrets. Ready for testing and integration."\`
+
+## Deliverables
+- src/
+  - domain/ (business logic, < 500 lines per file)
+  - application/ (use cases, < 500 lines per file)
+  - infrastructure/ (external integrations)
+  - config/ (environment management)
+- tests/
+  - smoke/ (basic functionality tests)
+  - fixtures/ (test data)
+- config/
+  - .env.example (all required variables)
+  - config.js (environment loader)
+- docs/
+  - API.md (if applicable)
+  - SETUP.md (detailed setup guide)
+
+## Tool Usage Reminders
+- Use \`insert_content\` for new files or empty targets
+- Use \`apply_diff\` for modifying existing code with complete search/replace blocks
+- Avoid \`search_and_replace\` unless absolutely necessary
+- Always verify all tool parameters before execution
+
+## Next Steps
+After implementation, delegate to:
+- \`npx claude-flow sparc run tdd "Write comprehensive tests for ${taskDescription}" --non-interactive\`
+- \`npx claude-flow sparc run integration "Integrate ${taskDescription} with existing systems" --non-interactive\`
+- \`npx claude-flow sparc run security-review "Security audit for ${taskDescription}" --non-interactive\``;
+}

package/src/cli/simple-commands/sparc-modes/debug.js

@@ -0,0 +1,112 @@
+// debug.js - Debugger mode orchestration template
+export function getDebugOrchestration(taskDescription, memoryNamespace) {
+  return `
+## Task Orchestration Steps
+
+1. **Issue Analysis & Reproduction** (10 mins)
+   - Understand the reported issue: "${taskDescription}"
+   - Query relevant context and previous issues:
+     \`\`\`bash
+     npx claude-flow memory query ${memoryNamespace}_bugs
+     npx claude-flow memory query ${memoryNamespace}_implementation
+     npx claude-flow memory query ${memoryNamespace}_tests
+     \`\`\`
+   - Set up debugging environment:
+     - Enable verbose logging
+     - Configure debugging tools
+     - Prepare monitoring setup
+   - Reproduce the issue consistently
+   - Collect error messages, stack traces, and logs
+   - Identify affected components and dependencies
+   - Store findings: \`npx claude-flow memory store ${memoryNamespace}_issue_analysis "Issue: ${taskDescription}. Reproduction: Steps 1-3. Error: Stack trace at line X. Affected: auth-service, user-repository."\`
+
+2. **Root Cause Investigation** (20 mins)
+   - Add strategic debug logging:
+     - Entry/exit points of suspect functions
+     - State before/after transformations
+     - External service call results
+   - Use debugging tools:
+     - Debugger breakpoints
+     - Memory profilers (if memory issue)
+     - Network analyzers (if API issue)
+   - Trace execution flow systematically:
+     - Follow data through the system
+     - Check assumptions at each step
+     - Verify external dependencies
+   - Analyze patterns:
+     - When does it fail? (timing, load, specific data)
+     - What changed recently? (code, config, dependencies)
+   - Avoid changing env configuration directly
+   - Store investigation: \`npx claude-flow memory store ${memoryNamespace}_root_cause "Root cause: Race condition in auth token refresh. Occurs under high load when token expires during request processing. Fix approach: Implement token refresh mutex."\`
+
+3. **Solution Development** (15 mins)
+   - Develop targeted fix approach:
+     - Minimal change to resolve issue
+     - Maintain backward compatibility
+     - Consider edge cases
+   - Implement the solution:
+     - Keep changes modular
+     - Don't exceed 500 lines per file
+     - Add inline comments explaining the fix
+   - Add regression tests:
+     - Test the specific failure scenario
+     - Test related edge cases
+     - Ensure fix doesn't break existing tests
+   - Implement defensive coding:
+     - Add validation where missing
+     - Improve error messages
+     - Add circuit breakers if needed
+   - Store solution: \`npx claude-flow memory store ${memoryNamespace}_solution "Fix: Added mutex lock for token refresh. Tests: 3 regression tests added. Validation: Added token expiry check. No breaking changes."\`
+
+4. **Validation & Performance Check** (10 mins)
+   - Run comprehensive test suite:
+     \`\`\`bash
+     npm test
+     npm run test:integration
+     npm run test:e2e
+     \`\`\`
+   - Verify original issue is resolved
+   - Check performance impact:
+     - Run performance benchmarks
+     - Monitor memory usage
+     - Check response times
+   - Test in conditions that triggered the bug
+   - Verify no new issues introduced
+   - Document the fix with context
+   - Store validation: \`npx claude-flow memory store ${memoryNamespace}_debug_validation "All tests passing. Performance impact: <5ms latency increase. Memory usage unchanged. Original issue resolved."\`
+
+5. **Documentation & Cleanup** (5 mins)
+   - Create detailed fix documentation
+   - Remove debug logging (keep useful ones)
+   - Update error handling guides
+   - Create runbook for similar issues
+   - Submit for code review
+
+## Deliverables
+- Fixed code with:
+  - Inline comments explaining the fix
+  - Improved error messages
+  - Defensive coding additions
+- tests/regression/
+  - Test cases for the specific bug
+  - Edge case coverage
+- docs/
+  - DEBUG_REPORT.md (root cause analysis)
+  - FIX_DOCUMENTATION.md (what was changed and why)
+  - RUNBOOK.md (guide for similar issues)
+- Performance comparison report
+
+## Debugging Best Practices
+- Use structured logging with correlation IDs
+- Avoid changing production env during debugging
+- Keep debug changes isolated and reversible
+- Test fixes under same conditions as bug
+- Document investigation process for future reference
+- Consider using feature flags for gradual rollout
+
+## Next Steps
+After debugging completes:
+- \`npx claude-flow sparc run security-review "Review security impact of ${taskDescription} fix" --non-interactive\`
+- \`npx claude-flow sparc run refinement-optimization-mode "Refactor affected modules for better maintainability" --non-interactive\`
+- \`npx claude-flow sparc run post-deployment-monitoring-mode "Monitor ${taskDescription} fix in production" --non-interactive\``;
+}