ruvnet · June 9, 2025 20:28 · hassan-alnator · Jun 9, 2025 · Hulupeep · Jun 9, 2025
diff --git a/*claude.md b/*claude.md
diff --git a/claude-sparc.sh b/claude-sparc.sh
 #!/bin/bash

 # SPARC Automated Development System
 # Generic workflow for comprehensive software development using SPARC methodology

 set -e  # Exit on any error

 # Default configuration
 PROJECT_NAME="sparc-project"
 README_PATH="README.md"
 MCP_CONFIG=".roo/mcp.json"
 VERBOSE=false
 DRY_RUN=false
 SKIP_RESEARCH=false
 SKIP_TESTS=false
 TEST_COVERAGE_TARGET=100
 PARALLEL_EXECUTION=true
 COMMIT_FREQUENCY="phase"  # phase, feature, or manual
 OUTPUT_FORMAT="text"
 DEVELOPMENT_MODE="full"   # full, backend-only, frontend-only, api-only

 # Help function
 show_help() {
    cat << EOF
 SPARC Automated Development System
 ==================================

 A comprehensive, automated software development workflow using SPARC methodology
 (Specification, Pseudocode, Architecture, Refinement, Completion)

 USAGE:
    ./claude-sparc.sh [OPTIONS] [PROJECT_NAME] [README_PATH]

 ARGUMENTS:
    PROJECT_NAME    Name of the project to develop (default: sparc-project)
    README_PATH     Path to initial requirements/readme file (default: readme.md)

 OPTIONS:
    -h, --help                  Show this help message
    -v, --verbose              Enable verbose output
    -d, --dry-run              Show what would be done without executing
    -c, --config FILE          MCP configuration file (default: .roo/mcp.json)
    
    # Research Options
    --skip-research            Skip the web research phase
    --research-depth LEVEL     Research depth: basic, standard, comprehensive (default: standard)
    
    # Development Options
    --mode MODE                Development mode: full, backend-only, frontend-only, api-only (default: full)
    --skip-tests               Skip test development (not recommended)
    --coverage TARGET          Test coverage target percentage (default: 100)
    --no-parallel              Disable parallel execution
    
    # Commit Options
    --commit-freq FREQ         Commit frequency: phase, feature, manual (default: phase)
    --no-commits               Disable automatic commits
    
    # Output Options
    --output FORMAT            Output format: text, json, markdown (default: text)
    --quiet                    Suppress non-essential output

 EXAMPLES:
    # Basic usage
    ./claude-sparc.sh my-app docs/requirements.md
    
    # Backend API development with verbose output
    ./claude-sparc.sh --mode api-only --verbose user-service api-spec.md
    
    # Quick prototype without research
    ./claude-sparc.sh --skip-research --coverage 80 prototype-app readme.md
    
    # Dry run to see what would be executed
    ./claude-sparc.sh --dry-run --verbose my-project requirements.md

 DEVELOPMENT MODES:
    full            Complete full-stack development (default)
    backend-only    Backend services and APIs only
    frontend-only   Frontend application only
    api-only        REST/GraphQL API development only

 RESEARCH DEPTHS:
    basic           Quick domain overview and technology stack research
    standard        Comprehensive research including competitive analysis (default)
    comprehensive   Extensive research with academic papers and detailed analysis

 COMMIT FREQUENCIES:
    phase           Commit after each SPARC phase completion (default)
    feature         Commit after each feature implementation
    manual          No automatic commits (manual git operations only)

 For more information, see SPARC-DEVELOPMENT-GUIDE.md
 EOF
 }

 # Parse command line arguments
 parse_args() {
    while [[ $# -gt 0 ]]; do
        case $1 in
            -h|--help)
                show_help
                exit 0
                ;;
            -v|--verbose)
                VERBOSE=true
                shift
                ;;
            -d|--dry-run)
                DRY_RUN=true
                shift
                ;;
            -c|--config)
                MCP_CONFIG="$2"
                shift 2
                ;;
            --skip-research)
                SKIP_RESEARCH=true
                shift
                ;;
            --research-depth)
                RESEARCH_DEPTH="$2"
                shift 2
                ;;
            --mode)
                DEVELOPMENT_MODE="$2"
                shift 2
                ;;
            --skip-tests)
                SKIP_TESTS=true
                shift
                ;;
            --coverage)
                TEST_COVERAGE_TARGET="$2"
                shift 2
                ;;
            --no-parallel)
                PARALLEL_EXECUTION=false
                shift
                ;;
            --commit-freq)
                COMMIT_FREQUENCY="$2"
                shift 2
                ;;
            --no-commits)
                COMMIT_FREQUENCY="manual"
                shift
                ;;
            --output)
                OUTPUT_FORMAT="$2"
                shift 2
                ;;
            --quiet)
                VERBOSE=false
                shift
                ;;
            -*)
                echo "Unknown option: $1" >&2
                echo "Use --help for usage information" >&2
                exit 1
                ;;
            *)
                if [[ "$PROJECT_NAME" == "sparc-project" ]]; then
                    PROJECT_NAME="$1"
                elif [[ "$README_PATH" == "README.md" ]]; then
                    README_PATH="$1"
                else
                    echo "Too many arguments: $1" >&2
                    echo "Use --help for usage information" >&2
                    exit 1
                fi
                shift
                ;;
        esac
    done
 }

 # Validate configuration
 validate_config() {
    # Check if MCP config exists
    if [[ ! -f "$MCP_CONFIG" ]]; then
        echo "Warning: MCP config file not found: $MCP_CONFIG" >&2
        echo "Using default MCP configuration" >&2
    fi
    
    # Check if README exists, try to find alternatives if default doesn't exist
    if [[ ! -f "$README_PATH" ]]; then
        # Try common README file variations
        local readme_alternatives=("README.md" "readme.md" "Readme.md" "README.txt" "readme.txt")
        local found_readme=""
        
        for alt in "${readme_alternatives[@]}"; do
            if [[ -f "$alt" ]]; then
                found_readme="$alt"
                break
            fi
        done
        
        if [[ -n "$found_readme" ]]; then
            echo "README file '$README_PATH' not found, using '$found_readme' instead" >&2
            README_PATH="$found_readme"
        else
            echo "Error: No README file found. Tried: ${readme_alternatives[*]}" >&2
            echo "Please specify a valid README file path or create one of the above files." >&2
            exit 1
        fi
    fi
    
    # Validate development mode
    case $DEVELOPMENT_MODE in
        full|backend-only|frontend-only|api-only) ;;
        *) echo "Error: Invalid development mode: $DEVELOPMENT_MODE" >&2; exit 1 ;;
    esac
    
    # Validate commit frequency
    case $COMMIT_FREQUENCY in
        phase|feature|manual) ;;
        *) echo "Error: Invalid commit frequency: $COMMIT_FREQUENCY" >&2; exit 1 ;;
    esac
    
    # Validate output format
    case $OUTPUT_FORMAT in
        text|json|markdown) ;;
        *) echo "Error: Invalid output format: $OUTPUT_FORMAT" >&2; exit 1 ;;
    esac
    
    # Validate coverage target
    if [[ ! "$TEST_COVERAGE_TARGET" =~ ^[0-9]+$ ]] || [[ "$TEST_COVERAGE_TARGET" -lt 0 ]] || [[ "$TEST_COVERAGE_TARGET" -gt 100 ]]; then
        echo "Error: Invalid coverage target: $TEST_COVERAGE_TARGET (must be 0-100)" >&2
        exit 1
    fi
 }

 # Show configuration
 show_config() {
    if [[ "$VERBOSE" == true ]]; then
        cat << EOF
 SPARC Configuration:
 ===================
 Project Name: $PROJECT_NAME
 README Path: $README_PATH
 MCP Config: $MCP_CONFIG
 Development Mode: $DEVELOPMENT_MODE
 Research Depth: ${RESEARCH_DEPTH:-standard}
 Test Coverage Target: $TEST_COVERAGE_TARGET%
 Parallel Execution: $PARALLEL_EXECUTION
 Commit Frequency: $COMMIT_FREQUENCY
 Output Format: $OUTPUT_FORMAT
 Skip Research: $SKIP_RESEARCH
 Skip Tests: $SKIP_TESTS
 Dry Run: $DRY_RUN
 ===================
 EOF
    fi
 }

 # Build allowed tools based on configuration
 build_allowed_tools() {
    local tools="View,Edit,Replace,GlobTool,GrepTool,LS,Bash"
    
    if [[ "$SKIP_RESEARCH" != true ]]; then
        tools="$tools,WebFetchTool"
    fi
    
    if [[ "$PARALLEL_EXECUTION" == true ]]; then
        tools="$tools,BatchTool,dispatch_agent"
    fi
    
    echo "$tools"
 }

 # Build Claude command flags
 build_claude_flags() {
    local flags="--mcp-config $MCP_CONFIG --dangerously-skip-permissions"
    
    if [[ "$VERBOSE" == true ]]; then
        flags="$flags --verbose"
    fi
    
    if [[ "$OUTPUT_FORMAT" != "text" ]]; then
        flags="$flags --output-format $OUTPUT_FORMAT"
    fi
    
    echo "$flags"
 }

 # Main execution
 main() {
    parse_args "$@"
    validate_config
    show_config
    
    if [[ "$DRY_RUN" == true ]]; then
        echo "DRY RUN - Would execute the following:"
        echo "Project: $PROJECT_NAME"
        echo "README: $README_PATH"
        echo "Allowed Tools: $(build_allowed_tools)"
        echo "Claude Flags: $(build_claude_flags)"
        exit 0
    fi
    
    # Execute the SPARC development process
    execute_sparc_development
 }

 # Execute SPARC development process
 execute_sparc_development() {
    local allowed_tools=$(build_allowed_tools)
    local claude_flags=$(build_claude_flags)

 claude "
 # SPARC Automated Development System
 # Project: ${PROJECT_NAME}
 # Initial Research Document: ${README_PATH}
 # Configuration: Mode=${DEVELOPMENT_MODE}, Coverage=${TEST_COVERAGE_TARGET}%, Parallel=${PARALLEL_EXECUTION}

 $(if [[ "$SKIP_RESEARCH" != true ]]; then cat << 'RESEARCH_BLOCK'
 ## PHASE 0: COMPREHENSIVE RESEARCH & DISCOVERY
 ### Research Depth: ${RESEARCH_DEPTH:-standard}
 ### Parallel Web Research Phase ($(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo "BatchTool execution"; else echo "Sequential execution"; fi)):

 1. **Domain Research**:
   - WebFetchTool: Extract key concepts from ${README_PATH}
   - WebFetchTool: Search for latest industry trends and technologies
   - WebFetchTool: Research competitive landscape and existing solutions
   $(if [[ "${RESEARCH_DEPTH:-standard}" == "comprehensive" ]]; then echo "   - WebFetchTool: Gather academic papers and technical documentation"; fi)

 2. **Technology Stack Research**:
   - WebFetchTool: Research best practices for identified technology domains
   - WebFetchTool: Search for framework comparisons and recommendations
   - WebFetchTool: Investigate security considerations and compliance requirements
   $(if [[ "${RESEARCH_DEPTH:-standard}" != "basic" ]]; then echo "   - WebFetchTool: Research scalability patterns and architecture approaches"; fi)

 3. **Implementation Research**:
   - WebFetchTool: Search for code examples and implementation patterns
   $(if [[ "$SKIP_TESTS" != true ]]; then echo "   - WebFetchTool: Research testing frameworks and methodologies"; fi)
   - WebFetchTool: Investigate deployment and DevOps best practices
   $(if [[ "${RESEARCH_DEPTH:-standard}" == "comprehensive" ]]; then echo "   - WebFetchTool: Research monitoring and observability solutions"; fi)

 ### Research Processing:
 $(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo "Use BatchTool to execute all research queries in parallel for maximum efficiency."; else echo "Execute research queries sequentially for thorough analysis."; fi)

 $(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo "**Commit**: 'feat: complete comprehensive research phase - gathered domain knowledge, technology insights, and implementation patterns'"; fi)
 RESEARCH_BLOCK
 fi)

 ## SPECIFICATION PHASE
 ### Requirements Analysis for ${DEVELOPMENT_MODE} development:
 1. **Functional Requirements**:
   - Analyze ${README_PATH} to extract core functionality
   - Define user stories and acceptance criteria
   - Identify system boundaries and interfaces
   $(if [[ "$DEVELOPMENT_MODE" == "full" || "$DEVELOPMENT_MODE" == "backend-only" || "$DEVELOPMENT_MODE" == "api-only" ]]; then echo "   - Specify API endpoints and data models"; fi)
   $(if [[ "$DEVELOPMENT_MODE" == "full" || "$DEVELOPMENT_MODE" == "frontend-only" ]]; then echo "   - Define user interface requirements and user experience flows"; fi)

 2. **Non-Functional Requirements**:
   - Security and compliance requirements
   - Performance benchmarks and SLAs
   - Scalability and availability targets
   - Maintainability and extensibility goals

 3. **Technical Constraints**:
   - Technology stack decisions based on research
   - Integration requirements and dependencies
   - Deployment and infrastructure constraints
   - Budget and timeline considerations

 $(if [[ "$COMMIT_FREQUENCY" == "phase" ]]; then echo "**Commit**: 'docs: complete specification phase - defined functional/non-functional requirements and technical constraints for ${DEVELOPMENT_MODE} development'"; fi)

 ## PSEUDOCODE PHASE
 ### High-Level Architecture Design for ${DEVELOPMENT_MODE}:
 1. **System Architecture**:
   $(if [[ "$DEVELOPMENT_MODE" == "full" || "$DEVELOPMENT_MODE" == "backend-only" ]]; then echo "   - Define backend components and their responsibilities"; fi)
   $(if [[ "$DEVELOPMENT_MODE" == "full" || "$DEVELOPMENT_MODE" == "frontend-only" ]]; then echo "   - Design frontend architecture and component hierarchy"; fi)
   $(if [[ "$DEVELOPMENT_MODE" == "api-only" ]]; then echo "   - Define API architecture and endpoint structure"; fi)
   - Design data flow and communication patterns
   - Specify APIs and integration points
   - Plan error handling and recovery strategies

 2. **Algorithm Design**:
   - Core business logic algorithms
   - Data processing and transformation logic
   - Optimization strategies and performance considerations
   - Security and validation algorithms

 $(if [[ "$SKIP_TESTS" != true ]]; then cat << 'TEST_BLOCK'
 3. **Test Strategy**:
   - Unit testing approach (TDD London School)
   - Integration testing strategy
   - End-to-end testing scenarios
   - Target: ${TEST_COVERAGE_TARGET}% test coverage
   $(if [[ "$DEVELOPMENT_MODE" == "full" ]]; then echo "   - Frontend and backend testing coordination"; fi)
 TEST_BLOCK
 fi)

 $(if [[ "$COMMIT_FREQUENCY" == "phase" ]]; then echo "**Commit**: 'design: complete pseudocode phase - defined system architecture, algorithms, and test strategy for ${DEVELOPMENT_MODE}'"; fi)

 ## ARCHITECTURE PHASE
 ### Detailed System Design for ${DEVELOPMENT_MODE}:
 1. **Component Architecture**:
   - Detailed component specifications
   - Interface definitions and contracts
   - Dependency injection and inversion of control
   - Configuration management strategy

 $(if [[ "$DEVELOPMENT_MODE" == "full" || "$DEVELOPMENT_MODE" == "backend-only" || "$DEVELOPMENT_MODE" == "api-only" ]]; then cat << 'DATA_BLOCK'
 2. **Data Architecture**:
   - Database schema design
   - Data access patterns and repositories
   - Caching strategies and data flow
   - Backup and recovery procedures
 DATA_BLOCK
 fi)

 3. **Infrastructure Architecture**:
   - Deployment architecture and environments
   - CI/CD pipeline design
   - Monitoring and logging architecture
   - Security architecture and access controls

 $(if [[ "$COMMIT_FREQUENCY" == "phase" ]]; then echo "**Commit**: 'arch: complete architecture phase - detailed component, data, and infrastructure design for ${DEVELOPMENT_MODE}'"; fi)

 ## REFINEMENT PHASE (TDD Implementation)
 ### $(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo "Parallel"; else echo "Sequential"; fi) Development Tracks for ${DEVELOPMENT_MODE}:

 $(if [[ "$DEVELOPMENT_MODE" == "full" || "$DEVELOPMENT_MODE" == "backend-only" || "$DEVELOPMENT_MODE" == "api-only" ]]; then cat << 'BACKEND_BLOCK'
 #### Track 1: Backend Development
 1. **Setup & Infrastructure**:
   - Bash: Initialize project structure
   - Bash: Setup development environment
   - Bash: Configure CI/CD pipeline
   $(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo "   - **Commit**: 'feat: initialize backend infrastructure and development environment'"; fi)

 $(if [[ "$SKIP_TESTS" != true ]]; then cat << 'BACKEND_TDD_BLOCK'
 2. **TDD Core Components** (London School):
   - Red: Write failing tests for core business logic
   - Green: Implement minimal code to pass tests
   - Refactor: Optimize while maintaining green tests
   - Target: ${TEST_COVERAGE_TARGET}% coverage
   $(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo "   - **Commit**: 'feat: implement core business logic with TDD - ${TEST_COVERAGE_TARGET}% test coverage'"; fi)
 BACKEND_TDD_BLOCK
 fi)

 3. **API Layer Development**:
   - $(if [[ "$SKIP_TESTS" != true ]]; then echo "Red: Write API contract tests"; else echo "Implement API endpoints"; fi)
   - $(if [[ "$SKIP_TESTS" != true ]]; then echo "Green: Implement API endpoints"; else echo "Add input validation and error handling"; fi)
   - $(if [[ "$SKIP_TESTS" != true ]]; then echo "Refactor: Optimize API performance"; else echo "Optimize API performance"; fi)
   $(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo "   - **Commit**: 'feat: complete API layer with $(if [[ "$SKIP_TESTS" != true ]]; then echo "comprehensive test coverage"; else echo "validation and error handling"; fi)'"; fi)
 BACKEND_BLOCK
 fi)

 $(if [[ "$DEVELOPMENT_MODE" == "full" || "$DEVELOPMENT_MODE" == "frontend-only" ]]; then cat << 'FRONTEND_BLOCK'
 #### Track 2: Frontend Development
 1. **UI Component Library**:
   - $(if [[ "$SKIP_TESTS" != true ]]; then echo "Red: Write component tests"; else echo "Implement UI components"; fi)
   - $(if [[ "$SKIP_TESTS" != true ]]; then echo "Green: Implement UI components"; else echo "Add component styling and interactions"; fi)
   - $(if [[ "$SKIP_TESTS" != true ]]; then echo "Refactor: Optimize for reusability"; else echo "Optimize for reusability and performance"; fi)
   $(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo "   - **Commit**: 'feat: complete UI component library with $(if [[ "$SKIP_TESTS" != true ]]; then echo "full test coverage"; else echo "optimized components"; fi)'"; fi)

 2. **Application Logic**:
   - $(if [[ "$SKIP_TESTS" != true ]]; then echo "Red: Write application flow tests"; else echo "Implement user interactions"; fi)
   - $(if [[ "$SKIP_TESTS" != true ]]; then echo "Green: Implement user interactions"; else echo "Add state management and routing"; fi)
   - $(if [[ "$SKIP_TESTS" != true ]]; then echo "Refactor: Optimize user experience"; else echo "Optimize user experience and performance"; fi)
   $(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo "   - **Commit**: 'feat: complete frontend application logic with $(if [[ "$SKIP_TESTS" != true ]]; then echo "end-to-end tests"; else echo "optimized user experience"; fi)'"; fi)
 FRONTEND_BLOCK
 fi)

 #### Track 3: Integration & Quality Assurance
 1. **Integration Testing**:
   $(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo "   - BatchTool: Run parallel integration test suites"; else echo "   - Bash: Run integration test suites"; fi)
   - Bash: Execute performance benchmarks
   - Bash: Run security scans and audits
   $(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo "   - **Commit**: 'test: complete integration testing with performance and security validation'"; fi)

 2. **Quality Gates**:
   $(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo "   - BatchTool: Run parallel quality checks (linting, analysis, documentation)"; else echo "   - Bash: Run comprehensive linting and code quality analysis"; fi)
   - Bash: Validate documentation completeness
   $(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo "   - **Commit**: 'quality: pass all quality gates - linting, analysis, and documentation'"; fi)

 ### $(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo "Parallel"; else echo "Sequential"; fi) Subtask Orchestration:
 $(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo "Use BatchTool to execute independent development tracks in parallel where possible."; else echo "Execute development tracks sequentially for thorough validation."; fi)

 ## COMPLETION PHASE
 ### Final Integration & Deployment for ${DEVELOPMENT_MODE}:
 1. **System Integration**:
   - Integrate all development tracks
   $(if [[ "$SKIP_TESTS" != true ]]; then echo "   - Run comprehensive end-to-end tests"; fi)
   - Validate against original requirements
   $(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo "   - **Commit**: 'feat: complete system integration with full validation'"; fi)

 2. **Documentation & Deployment**:
   $(if [[ "$DEVELOPMENT_MODE" == "api-only" || "$DEVELOPMENT_MODE" == "backend-only" || "$DEVELOPMENT_MODE" == "full" ]]; then echo "   - Generate comprehensive API documentation"; fi)
   - Create deployment guides and runbooks
   - Setup monitoring and alerting
   $(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo "   - **Commit**: 'docs: complete documentation and deployment preparation'"; fi)

 3. **Production Readiness**:
   - Execute production deployment checklist
   - Validate monitoring and observability
   - Conduct final security review
   $(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo "   - **Commit**: 'deploy: production-ready release with full monitoring and security validation'"; fi)

 ## SPARC METHODOLOGY ENFORCEMENT
 ### Quality Standards:
 - **Modularity**: All files ≤ 500 lines, functions ≤ 50 lines
 - **Security**: No hardcoded secrets, comprehensive input validation
 $(if [[ "$SKIP_TESTS" != true ]]; then echo "- **Testing**: ${TEST_COVERAGE_TARGET}% test coverage with TDD London School approach"; fi)
 - **Documentation**: Self-documenting code with strategic comments
 - **Performance**: Optimized critical paths with benchmarking

 ### Tool Utilization Strategy:
 $(if [[ "$SKIP_RESEARCH" != true ]]; then echo "- **WebFetchTool**: Comprehensive research and documentation gathering"; fi)
 $(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo "- **BatchTool**: Parallel research, testing, and quality checks"; fi)
 - **Bash**: Git operations, CI/CD, testing, and deployment
 - **Edit/Replace**: Code implementation and refactoring
 - **GlobTool/GrepTool**: Code analysis and pattern detection
 $(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo "- **dispatch_agent**: Complex subtask delegation"; fi)

 ### Commit Standards (Frequency: ${COMMIT_FREQUENCY}):
 - **feat**: New features and major functionality
 $(if [[ "$SKIP_TESTS" != true ]]; then echo "- **test**: Test implementation and coverage improvements"; fi)
 - **fix**: Bug fixes and issue resolution
 - **docs**: Documentation updates and improvements
 - **arch**: Architectural changes and design updates
 - **quality**: Code quality improvements and refactoring
 - **deploy**: Deployment and infrastructure changes

 ### $(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo "Parallel"; else echo "Sequential"; fi) Execution Strategy:
 $(if [[ "$PARALLEL_EXECUTION" == true ]]; then cat << 'PARALLEL_BLOCK'
 1. Use BatchTool for independent operations
 2. Leverage dispatch_agent for complex subtasks
 3. Implement concurrent development tracks
 4. Optimize for maximum development velocity
 PARALLEL_BLOCK
 else cat << 'SEQUENTIAL_BLOCK'
 1. Execute operations sequentially for thorough validation
 2. Focus on quality over speed
 3. Ensure each step is fully validated before proceeding
 4. Maintain clear development progression
 SEQUENTIAL_BLOCK
 fi)

 ### Continuous Integration:
 $(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo "- Commit after each $(if [[ "$COMMIT_FREQUENCY" == "phase" ]]; then echo "major phase"; else echo "feature"; fi) completion"; fi)
 $(if [[ "$SKIP_TESTS" != true ]]; then echo "- Run automated tests on every commit"; fi)
 - Validate quality gates continuously
 - Monitor performance and security metrics

 ## SUCCESS CRITERIA:
 $(if [[ "$SKIP_TESTS" != true ]]; then echo "- ✅ ${TEST_COVERAGE_TARGET}% test coverage achieved"; fi)
 - ✅ All quality gates passed
 - ✅ Production deployment successful
 - ✅ Comprehensive documentation complete
 - ✅ Security and performance validated
 - ✅ Monitoring and observability operational

 Continue development until all success criteria are met. $(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo "Use parallel execution and subtask orchestration for maximum efficiency."; fi) $(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo "Commit after each $(if [[ "$COMMIT_FREQUENCY" == "phase" ]]; then echo "phase"; else echo "feature"; fi) with detailed messages."; fi) Display '<SPARC-COMPLETE>' when the entire development lifecycle is finished.
 " \
  --allowedTools "$allowed_tools" \
  $claude_flags
 }

 # Execute main function with all arguments
 main "$@"

diff --git a/memory-bank.md b/memory-bank.md
diff --git a/optional-coordination-system.md b/optional-coordination-system.md