aios-core 2.1.5 → 2.2.0

package/.aios-core/development/tasks/dev-optimize-performance.md

@@ -1,1034 +1,1034 @@
----
-
-## Execution Modes
-
-**Choose your execution mode:**
-
-### 1. YOLO Mode - Fast, Autonomous (0-1 prompts)
-- Autonomous decision making with logging
-- Minimal user interaction
-- **Best for:** Simple, deterministic tasks
-
-### 2. Interactive Mode - Balanced, Educational (5-10 prompts) **[DEFAULT]**
-- Explicit decision checkpoints
-- Educational explanations
-- **Best for:** Learning, complex decisions
-
-### 3. Pre-Flight Planning - Comprehensive Upfront Planning
-- Task analysis phase (identify all ambiguities)
-- Zero ambiguity execution
-- **Best for:** Ambiguous requirements, critical work
-
-**Parameter:** `mode` (optional, default: `interactive`)
-
----
-
-## Task Definition (AIOS Task Format V1.0)
-
-```yaml
-task: devOptimizePerformance()
-responsável: Dex (Builder)
-responsavel_type: Agente
-atomic_layer: Strategy
-
-**Entrada:**
-- campo: task
-  tipo: string
-  origem: User Input
-  obrigatório: true
-  validação: Must be registered task
-
-- campo: parameters
-  tipo: object
-  origem: User Input
-  obrigatório: false
-  validação: Valid task parameters
-
-- campo: mode
-  tipo: string
-  origem: User Input
-  obrigatório: false
-  validação: yolo|interactive|pre-flight
-
-**Saída:**
-- campo: execution_result
-  tipo: object
-  destino: Memory
-  persistido: false
-
-- campo: logs
-  tipo: array
-  destino: File (.ai/logs/*)
-  persistido: true
-
-- campo: state
-  tipo: object
-  destino: State management
-  persistido: true
-```
-
----
-
-## Pre-Conditions
-
-**Purpose:** Validate prerequisites BEFORE task execution (blocking)
-
-**Checklist:**
-
-```yaml
-pre-conditions:
-  - [ ] Task is registered; required parameters provided; dependencies met
-    tipo: pre-condition
-    blocker: true
-    validação: |
-      Check task is registered; required parameters provided; dependencies met
-    error_message: "Pre-condition failed: Task is registered; required parameters provided; dependencies met"
-```
-
----
-
-## Post-Conditions
-
-**Purpose:** Validate execution success AFTER task completes
-
-**Checklist:**
-
-```yaml
-post-conditions:
-  - [ ] Task completed; exit code 0; expected outputs created
-    tipo: post-condition
-    blocker: true
-    validação: |
-      Verify task completed; exit code 0; expected outputs created
-    error_message: "Post-condition failed: Task completed; exit code 0; expected outputs created"
-```
-
----
-
-## Acceptance Criteria
-
-**Purpose:** Definitive pass/fail criteria for task completion
-
-**Checklist:**
-
-```yaml
-acceptance-criteria:
-  - [ ] Task completed as expected; side effects documented
-    tipo: acceptance-criterion
-    blocker: true
-    validação: |
-      Assert task completed as expected; side effects documented
-    error_message: "Acceptance criterion not met: Task completed as expected; side effects documented"
-```
-
----
-
-## Tools
-
-**External/shared resources used by this task:**
-
-- **Tool:** task-runner
-  - **Purpose:** Task execution and orchestration
-  - **Source:** .aios-core/core/task-runner.js
-
-- **Tool:** logger
-  - **Purpose:** Execution logging and error tracking
-  - **Source:** .aios-core/utils/logger.js
-
----
-
-## Scripts
-
-**Agent-specific code for this task:**
-
-- **Script:** execute-task.js
-  - **Purpose:** Generic task execution wrapper
-  - **Language:** JavaScript
-  - **Location:** .aios-core/scripts/execute-task.js
-
----
-
-## Error Handling
-
-**Strategy:** retry
-
-**Common Errors:**
-
-1. **Error:** Task Not Found
-   - **Cause:** Specified task not registered in system
-   - **Resolution:** Verify task name and registration
-   - **Recovery:** List available tasks, suggest similar
-
-2. **Error:** Invalid Parameters
-   - **Cause:** Task parameters do not match expected schema
-   - **Resolution:** Validate parameters against task definition
-   - **Recovery:** Provide parameter template, reject execution
-
-3. **Error:** Execution Timeout
-   - **Cause:** Task exceeds maximum execution time
-   - **Resolution:** Optimize task or increase timeout
-   - **Recovery:** Kill task, cleanup resources, log state
-
----
-
-## Performance
-
-**Expected Metrics:**
-
-```yaml
-duration_expected: 5-20 min (estimated)
-cost_estimated: $0.003-0.015
-token_usage: ~2,000-8,000 tokens
-```
-
-**Optimization Notes:**
-- Iterative analysis with depth limits; cache intermediate results; batch similar operations
-
----
-
-## Metadata
-
-```yaml
-story: N/A
-version: 1.0.0
-dependencies:
-  - N/A
-tags:
-  - development
-  - code
-updated_at: 2025-11-17
-```
-
----
-
-checklists:
-  - dev-master-checklist.md
----
-
-# Optimize Performance - AIOS Developer Task
-
-## Purpose
-Analyze code for performance bottlenecks and suggest optimizations to improve runtime performance, memory usage, and scalability.
-
-## Command Pattern
-```
-*optimize-performance <path> [options]
-```
-
-## Parameters
-- `path`: File or directory path to analyze
-- `options`: Performance analysis configuration
-
-### Options
-- `--patterns <types>`: Comma-separated optimization patterns to check
-- `--profile`: Enable runtime profiling (if applicable)
-- `--threshold <level>`: Minimum impact threshold for suggestions (low/medium/high)
-- `--report <file>`: Generate performance report
-- `--apply <optimization-id>`: Apply specific optimization
-- `--recursive`: Analyze directories recursively
-- `--exclude <patterns>`: Exclude file patterns
-- `--focus <category>`: Focus on specific category (algorithm/memory/async/database/bundle/react)
-
-## Optimization Patterns
-- `algorithm_complexity`: High time complexity algorithms
-- `loop_optimization`: Nested loops and iterations
-- `memory_usage`: Memory consumption and leaks
-- `async_operations`: Async/await patterns
-- `caching`: Memoization opportunities
-- `database_queries`: N+1 and query optimization
-- `bundle_size`: JavaScript bundle optimization
-- `react_performance`: React-specific optimizations
-- `string_operations`: String manipulation
-- `object_operations`: Object creation and access
-
-## Examples
-```bash
-# Analyze single file
-*optimize-performance aios-core/scripts/data-processor.js
-
-# Analyze directory with specific patterns
-*optimize-performance aios-core/agents --patterns algorithm_complexity,async_operations --recursive
-
-# Generate performance report
-*optimize-performance . --recursive --report performance-report.json
-
-# Focus on database optimizations
-*optimize-performance aios-core/services --focus database --recursive
-
-# Apply specific optimization
-*optimize-performance aios-core/scripts/calculator.js --apply opt-001
-```
-
-## Implementation
-
-```javascript
-const fs = require('fs').promises;
-const path = require('path');
-const chalk = require('chalk');
-const inquirer = require('inquirer');
-const glob = require('glob').promises;
-
-class OptimizePerformanceTask {
-  constructor() {
-    this.taskName = 'optimize-performance';
-    this.description = 'Analyze and optimize code performance';
-    this.rootPath = process.cwd();
-    this.performanceOptimizer = null;
-    this.analysisResults = [];
-    this.appliedOptimizations = [];
-  }
-
-  async execute(params) {
-    try {
-      console.log(chalk.blue('⚡ AIOS Performance Optimization'));
-      console.log(chalk.gray('Analyzing code for performance improvements\n'));
-
-      // Parse parameters
-      const config = await this.parseParameters(params);
-      
-      // Initialize dependencies
-      await this.initializeDependencies();
-
-      // Get files to analyze
-      const files = await this.getFilesToAnalyze(config);
-      
-      if (files.length === 0) {
-        console.log(chalk.yellow('No files found to analyze'));
-        return { success: true, results: [] };
-      }
-
-      console.log(chalk.gray(`Found ${files.length} files to analyze\n`));
-
-      // Execute based on mode
-      if (config.apply) {
-        // Apply specific optimization
-        await this.applyOptimization(config.apply, config);
-      } else {
-        // Analyze files
-        await this.analyzeFiles(files, config);
-        
-        // Display results
-        await this.displayResults(config);
-        
-        // Generate report if requested
-        if (config.report) {
-          await this.generateReport(config.report);
-        }
-      }
-
-      return {
-        success: true,
-        filesAnalyzed: files.length,
-        totalIssues: this.getTotalIssues(),
-        criticalIssues: this.getCriticalIssues()
-      };
-
-    } catch (error) {
-      console.error(chalk.red(`\n❌ Performance optimization failed: ${error.message}`));
-      throw error;
-    }
-  }
-
-  async parseParameters(params) {
-    if (params.length < 1) {
-      throw new Error('Usage: *optimize-performance <path> [options]');
-    }
-
-    const config = {
-      targetPath: params[0],
-      patterns: null,
-      profile: false,
-      threshold: 'low',
-      report: null,
-      apply: null,
-      recursive: false,
-      exclude: [],
-      focus: null
-    };
-
-    // Parse options
-    for (let i = 1; i < params.length; i++) {
-      const param = params[i];
-      
-      if (param === '--profile') {
-        config.profile = true;
-      } else if (param === '--recursive') {
-        config.recursive = true;
-      } else if (param.startsWith('--patterns') && params[i + 1]) {
-        config.patterns = params[++i].split(',').map(p => p.trim());
-      } else if (param.startsWith('--threshold') && params[i + 1]) {
-        config.threshold = params[++i];
-      } else if (param.startsWith('--report') && params[i + 1]) {
-        config.report = params[++i];
-      } else if (param.startsWith('--apply') && params[i + 1]) {
-        config.apply = params[++i];
-      } else if (param.startsWith('--exclude') && params[i + 1]) {
-        config.exclude = params[++i].split(',').map(e => e.trim());
-      } else if (param.startsWith('--focus') && params[i + 1]) {
-        config.focus = params[++i];
-      }
-    }
-
-    // Validate threshold
-    if (!['low', 'medium', 'high'].includes(config.threshold)) {
-      throw new Error('Threshold must be: low, medium, or high');
-    }
-
-    return config;
-  }
-
-  async initializeDependencies() {
-    try {
-      const PerformanceOptimizer = require('../scripts/performance-optimizer');
-      this.performanceOptimizer = new PerformanceOptimizer({ 
-        rootPath: this.rootPath,
-        enableProfiling: true
-      });
-
-      // Listen to events
-      this.performanceOptimizer.on('analyzed', (analysis) => {
-        this.analysisResults.push(analysis);
-      });
-
-    } catch (error) {
-      throw new Error(`Failed to initialize dependencies: ${error.message}`);
-    }
-  }
-
-  async getFilesToAnalyze(config) {
-    const targetPath = path.resolve(this.rootPath, config.targetPath);
-    const files = [];
-
-    try {
-      const stats = await fs.stat(targetPath);
-      
-      if (stats.isFile()) {
-        // Single file
-        if (this.shouldAnalyzeFile(targetPath, config)) {
-          files.push(targetPath);
-        }
-      } else if (stats.isDirectory()) {
-        // Directory
-        const pattern = config.recursive ? '**/*.{js,jsx,ts,tsx}' : '*.{js,jsx,ts,tsx}';
-        const globPattern = path.join(targetPath, pattern);
-        
-        const matches = await glob(globPattern, {
-          ignore: config.exclude.map(e => path.join(targetPath, '**', e)),
-          nodir: true
-        });
-        
-        for (const match of matches) {
-          if (this.shouldAnalyzeFile(match, config)) {
-            files.push(match);
-          }
-        }
-      }
-    } catch (error) {
-      console.warn(chalk.yellow(`Cannot access ${targetPath}: ${error.message}`));
-    }
-
-    return files;
-  }
-
-  shouldAnalyzeFile(filePath, config) {
-    // Skip test files unless analyzing tests
-    if (filePath.includes('.test.') || filePath.includes('.spec.')) {
-      return false;
-    }
-    
-    // Skip minified files
-    if (filePath.includes('.min.')) {
-      return false;
-    }
-    
-    // Skip build artifacts
-    if (filePath.includes('/dist/') || filePath.includes('/build/')) {
-      return false;
-    }
-    
-    // Skip node_modules
-    if (filePath.includes('node_modules')) {
-      return false;
-    }
-    
-    return true;
-  }
-
-  async analyzeFiles(files, config) {
-    console.log(chalk.blue('🔍 Analyzing performance...'));
-    
-    const progressInterval = Math.max(1, Math.floor(files.length / 20));
-    
-    for (let i = 0; i < files.length; i++) {
-      const file = files[i];
-      
-      try {
-        const analysis = await this.performanceOptimizer.analyzePerformance(file, {
-          patterns: config.patterns,
-          enableProfiling: config.profile
-        });
-        
-        // Filter by threshold
-        if (analysis.issues && analysis.issues.length > 0) {
-          analysis.issues = this.filterByThreshold(analysis.issues, config.threshold);
-        }
-        
-        // Filter by focus category
-        if (config.focus && analysis.issues) {
-          analysis.issues = analysis.issues.filter(issue => 
-            issue.category === config.focus
-          );
-        }
-        
-        // Show progress
-        if (i % progressInterval === 0) {
-          const progress = Math.floor((i / files.length) * 100);
-          process.stdout.write(`\rProgress: ${progress}%`);
-        }
-        
-      } catch (error) {
-        console.warn(chalk.yellow(`\nFailed to analyze ${file}: ${error.message}`));
-      }
-    }
-    
-    console.log('\rProgress: 100%\n');
-  }
-
-  filterByThreshold(issues, threshold) {
-    const thresholdMap = {
-      low: ['low', 'medium', 'high', 'critical'],
-      medium: ['medium', 'high', 'critical'],
-      high: ['high', 'critical']
-    };
-    
-    const allowedImpacts = thresholdMap[threshold];
-    
-    return issues.filter(issue => 
-      allowedImpacts.includes(issue.impact) || 
-      allowedImpacts.includes(issue.severity)
-    );
-  }
-
-  async displayResults(config) {
-    const totalIssues = this.getTotalIssues();
-    
-    if (totalIssues === 0) {
-      console.log(chalk.green('✅ No performance issues found!'));
-      console.log(chalk.gray('Your code is already well optimized.'));
-      return;
-    }
-
-    console.log(chalk.blue(`\n📊 Performance Analysis Results\n`));
-    console.log(chalk.gray('Found ') + chalk.yellow(totalIssues) + chalk.gray(' optimization opportunities\n'));
-
-    // Group by category
-    const byCategory = this.groupByCategory();
-    
-    // Display by category
-    for (const [category, results] of Object.entries(byCategory)) {
-      console.log(chalk.blue(`\n${this.getCategoryIcon(category)} ${this.getCategoryName(category)}`));
-      console.log(chalk.gray('─'.repeat(50)));
-      
-      for (const result of results) {
-        this.displayFileResults(result);
-      }
-    }
-
-    // Show performance scores
-    this.displayPerformanceScores();
-
-    // Show top recommendations
-    this.displayTopRecommendations();
-
-    // Show next steps
-    console.log(chalk.blue('\n📌 Next Steps:'));
-    console.log('1. Review critical issues first');
-    console.log('2. Apply optimizations incrementally');
-    console.log('3. Test after each optimization');
-    console.log('4. Monitor performance improvements');
-    if (config.report) {
-      console.log(`5. View detailed report: ${config.report}`);
-    }
-  }
-
-  displayFileResults(result) {
-    const relativePath = path.relative(this.rootPath, result.filePath);
-    
-    console.log(`\n📄 ${chalk.blue(relativePath)}`);
-    
-    if (result.metrics?.performanceScore !== undefined) {
-      const score = result.metrics.performanceScore;
-      const scoreColor = score >= 80 ? chalk.green : score >= 60 ? chalk.yellow : chalk.red;
-      console.log(`   Performance Score: ${scoreColor(score + '/100')}`);
-    }
-    
-    // Display issues
-    for (const issue of result.issues) {
-      this.displayIssue(issue);
-      
-      // Display suggestions for this issue
-      const suggestion = result.suggestions?.find(s => 
-        s.issueId === issue.id || s.pattern === issue.pattern
-      );
-      
-      if (suggestion) {
-        this.displaySuggestion(suggestion);
-      }
-    }
-  }
-
-  displayIssue(issue) {
-    const impactColors = {
-      critical: chalk.red,
-      high: chalk.red,
-      medium: chalk.yellow,
-      low: chalk.gray
-    };
-    
-    const impactColor = impactColors[issue.impact || issue.severity] || chalk.gray;
-    
-    console.log(`\n   ${impactColor(`[${(issue.impact || issue.severity || 'info').toUpperCase()}]`)} ${issue.description}`);
-    
-    if (issue.location) {
-      console.log(chalk.gray(`   Location: Line ${issue.location.start?.line || '?'}`));
-    }
-    
-    if (issue.type) {
-      console.log(chalk.gray(`   Type: ${issue.type}`));
-    }
-  }
-
-  displaySuggestion(suggestion) {
-    console.log(chalk.green('   💡 Suggestion:'));
-    
-    if (suggestion.optimizations) {
-      for (const opt of suggestion.optimizations) {
-        console.log(`      - ${opt.description}`);
-        
-        if (opt.code) {
-          console.log(chalk.gray('        Example:'));
-          const codeLines = opt.code.split('\n');
-          for (const line of codeLines) {
-            console.log(chalk.gray(`          ${line}`));
-          }
-        }
-        
-        if (opt.improvement) {
-          console.log(chalk.green(`        → ${opt.improvement}`));
-        }
-      }
-    }
-    
-    if (suggestion.estimatedImprovement) {
-      console.log(chalk.green(`      Estimated improvement: ${suggestion.estimatedImprovement}`));
-    }
-  }
-
-  groupByCategory() {
-    const grouped = {};
-    
-    for (const result of this.analysisResults) {
-      if (!result.issues || result.issues.length === 0) continue;
-      
-      for (const issue of result.issues) {
-        const category = issue.category || 'other';
-        
-        if (!grouped[category]) {
-          grouped[category] = [];
-        }
-        
-        // Find or create file entry
-        let fileEntry = grouped[category].find(r => r.filePath === result.filePath);
-        if (!fileEntry) {
-          fileEntry = {
-            filePath: result.filePath,
-            issues: [],
-            suggestions: result.suggestions || [],
-            metrics: result.metrics
-          };
-          grouped[category].push(fileEntry);
-        }
-        
-        fileEntry.issues.push(issue);
-      }
-    }
-    
-    return grouped;
-  }
-
-  getCategoryIcon(category) {
-    const icons = {
-      algorithm: '🔄',
-      memory: '💾',
-      async: '⚡',
-      database: '🗄️',
-      bundle: '📦',
-      react: '⚛️',
-      caching: '💰',
-      framework: '🏗️',
-      other: '🔧'
-    };
-    
-    return icons[category] || icons.other;
-  }
-
-  getCategoryName(category) {
-    const names = {
-      algorithm: 'Algorithm Optimization',
-      memory: 'Memory Usage',
-      async: 'Async Operations',
-      database: 'Database Queries',
-      bundle: 'Bundle Size',
-      react: 'React Performance',
-      caching: 'Caching Opportunities',
-      framework: 'Framework-Specific',
-      other: 'Other Optimizations'
-    };
-    
-    return names[category] || category;
-  }
-
-  displayPerformanceScores() {
-    console.log(chalk.blue('\n📈 Performance Summary'));
-    console.log(chalk.gray('─'.repeat(50)));
-    
-    let totalScore = 0;
-    let fileCount = 0;
-    
-    for (const result of this.analysisResults) {
-      if (result.metrics?.performanceScore !== undefined) {
-        totalScore += result.metrics.performanceScore;
-        fileCount++;
-      }
-    }
-    
-    if (fileCount > 0) {
-      const avgScore = Math.round(totalScore / fileCount);
-      const scoreColor = avgScore >= 80 ? chalk.green : avgScore >= 60 ? chalk.yellow : chalk.red;
-      
-      console.log(`Average Performance Score: ${scoreColor(avgScore + '/100')}`);
-      console.log(`Files Analyzed: ${fileCount}`);
-    }
-    
-    // Issue breakdown
-    const criticalCount = this.getCriticalIssues();
-    const highCount = this.getIssuesByImpact('high');
-    const mediumCount = this.getIssuesByImpact('medium');
-    const lowCount = this.getIssuesByImpact('low');
-    
-    console.log('\nIssue Breakdown:');
-    if (criticalCount > 0) console.log(chalk.red(`  Critical: ${criticalCount}`));
-    if (highCount > 0) console.log(chalk.red(`  High: ${highCount}`));
-    if (mediumCount > 0) console.log(chalk.yellow(`  Medium: ${mediumCount}`));
-    if (lowCount > 0) console.log(chalk.gray(`  Low: ${lowCount}`));
-  }
-
-  displayTopRecommendations() {
-    console.log(chalk.blue('\n🎯 Top Recommendations'));
-    console.log(chalk.gray('─'.repeat(50)));
-    
-    const recommendations = this.getTopRecommendations();
-    
-    if (recommendations.length === 0) {
-      console.log(chalk.gray('No specific recommendations'));
-      return;
-    }
-    
-    for (let i = 0; i < Math.min(5, recommendations.length); i++) {
-      const rec = recommendations[i];
-      console.log(`\n${i + 1}. ${rec.title}`);
-      console.log(chalk.gray(`   ${rec.description}`));
-      if (rec.files) {
-        console.log(chalk.gray(`   Files affected: ${rec.files.length}`));
-      }
-    }
-  }
-
-  getTopRecommendations() {
-    const recommendations = [];
-    const byCategory = this.groupByCategory();
-    
-    // Algorithm complexity issues
-    if (byCategory.algorithm?.length > 0) {
-      const highComplexity = byCategory.algorithm.filter(r => 
-        r.issues.some(i => i.type === 'high_complexity' && i.severity === 'critical')
-      );
-      
-      if (highComplexity.length > 0) {
-        recommendations.push({
-          title: 'Optimize High-Complexity Algorithms',
-          description: 'Several functions have O(n²) or worse complexity. Consider using more efficient algorithms.',
-          priority: 'critical',
-          files: highComplexity
-        });
-      }
-    }
-    
-    // Async issues
-    if (byCategory.async?.length > 0) {
-      const sequentialAwaits = byCategory.async.filter(r => 
-        r.issues.some(i => i.type === 'sequential_awaits')
-      );
-      
-      if (sequentialAwaits.length > 0) {
-        recommendations.push({
-          title: 'Parallelize Async Operations',
-          description: 'Use Promise.all to run independent async operations in parallel.',
-          priority: 'high',
-          files: sequentialAwaits
-        });
-      }
-    }
-    
-    // Database issues
-    if (byCategory.database?.length > 0) {
-      const nPlusOne = byCategory.database.filter(r => 
-        r.issues.some(i => i.type === 'n_plus_one')
-      );
-      
-      if (nPlusOne.length > 0) {
-        recommendations.push({
-          title: 'Fix N+1 Query Problems',
-          description: 'Database queries in loops cause performance degradation. Use JOINs or batch loading.',
-          priority: 'critical',
-          files: nPlusOne
-        });
-      }
-    }
-    
-    // Memory issues
-    if (byCategory.memory?.length > 0) {
-      recommendations.push({
-        title: 'Optimize Memory Usage',
-        description: 'Review memory allocations and potential leaks. Consider using more efficient data structures.',
-        priority: 'medium',
-        files: byCategory.memory
-      });
-    }
-    
-    // Caching opportunities
-    if (byCategory.caching?.length > 0) {
-      recommendations.push({
-        title: 'Implement Caching',
-        description: 'Add memoization or caching for expensive repeated operations.',
-        priority: 'medium',
-        files: byCategory.caching
-      });
-    }
-    
-    // Sort by priority
-    const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
-    recommendations.sort((a, b) => 
-      priorityOrder[a.priority] - priorityOrder[b.priority]
-    );
-    
-    return recommendations;
-  }
-
-  async applyOptimization(optimizationId, config) {
-    console.log(chalk.blue(`\n🔧 Applying optimization: ${optimizationId}`));
-    
-    // Find the optimization in results
-    let targetOptimization = null;
-    let targetFile = null;
-    
-    for (const result of this.analysisResults) {
-      const suggestion = result.suggestions?.find(s => 
-        s.issueId === optimizationId || s.id === optimizationId
-      );
-      
-      if (suggestion) {
-        targetOptimization = suggestion;
-        targetFile = result.filePath;
-        break;
-      }
-    }
-    
-    if (!targetOptimization) {
-      throw new Error(`Optimization not found: ${optimizationId}`);
-    }
-    
-    console.log(chalk.gray(`File: ${path.relative(this.rootPath, targetFile)}`));
-    console.log(chalk.gray(`Type: ${targetOptimization.type || 'General optimization'}`));
-    
-    // Show optimization details
-    if (targetOptimization.optimizations) {
-      console.log(chalk.blue('\nOptimizations to apply:'));
-      for (const opt of targetOptimization.optimizations) {
-        console.log(`  - ${opt.description}`);
-      }
-    }
-    
-    // Confirm application
-    const { confirm } = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'confirm',
-      message: 'Apply this optimization?',
-      default: true
-    }]);
-    
-    if (!confirm) {
-      console.log(chalk.gray('Optimization cancelled'));
-      return;
-    }
-    
-    // Apply the optimization
-    try {
-      const result = await this.performanceOptimizer.applyOptimization(
-        targetFile,
-        targetOptimization
-      );
-      
-      if (result.success) {
-        console.log(chalk.green('✅ Optimization applied successfully'));
-        
-        // Show changes
-        for (const change of result.changes) {
-          console.log(chalk.gray(`  - ${change.description}`));
-        }
-        
-        this.appliedOptimizations.push({
-          file: targetFile,
-          optimization: targetOptimization,
-          result,
-          timestamp: new Date().toISOString()
-        });
-      } else {
-        console.error(chalk.red(`Failed to apply optimization: ${result.error}`));
-      }
-    } catch (error) {
-      console.error(chalk.red(`Error applying optimization: ${error.message}`));
-    }
-  }
-
-  async generateReport(reportPath) {
-    console.log(chalk.blue('\n📤 Generating performance report...'));
-    
-    const report = await this.performanceOptimizer.generateOptimizationReport();
-    
-    // Add analysis results
-    report.analysisResults = this.analysisResults.map(r => ({
-      file: path.relative(this.rootPath, r.filePath),
-      performanceScore: r.metrics?.performanceScore,
-      issues: r.issues.length,
-      criticalIssues: r.issues.filter(i => 
-        i.impact === 'critical' || i.severity === 'critical'
-      ).length,
-      suggestions: r.suggestions?.length || 0
-    }));
-    
-    // Add applied optimizations
-    report.appliedOptimizations = this.appliedOptimizations;
-    
-    await fs.writeFile(reportPath, JSON.stringify(report, null, 2));
-    console.log(chalk.green(`✅ Report generated: ${reportPath}`));
-    
-    // Show report summary
-    console.log(chalk.blue('\n📊 Report Summary:'));
-    console.log(`  Files analyzed: ${report.summary.filesAnalyzed}`);
-    console.log(`  Total issues: ${report.summary.totalIssues}`);
-    console.log(`  Critical issues: ${report.summary.criticalIssues}`);
-    console.log(`  Optimizations applied: ${report.summary.optimizationsApplied}`);
-  }
-
-  getTotalIssues() {
-    return this.analysisResults.reduce((total, result) => 
-      total + (result.issues?.length || 0), 0
-    );
-  }
-
-  getCriticalIssues() {
-    return this.analysisResults.reduce((total, result) => 
-      total + (result.issues?.filter(i => 
-        i.impact === 'critical' || i.severity === 'critical'
-      ).length || 0), 0
-    );
-  }
-
-  getIssuesByImpact(impact) {
-    return this.analysisResults.reduce((total, result) => 
-      total + (result.issues?.filter(i => 
-        i.impact === impact || i.severity === impact
-      ).length || 0), 0
-    );
-  }
-}
-
-module.exports = OptimizePerformanceTask;
-```
-
-## Integration Points
-
-### Performance Optimizer
-- Core analysis engine
-- Pattern detection system
-- Optimization suggestion generator
-- Runtime profiling capability
-
-### Analysis Categories
-- **Algorithm**: Time complexity, nested loops
-- **Memory**: Allocations, leaks, data structures
-- **Async**: Promise patterns, parallelization
-- **Database**: Query optimization, N+1 problems
-- **Bundle**: Import optimization, tree-shaking
-- **React**: Component rendering, memoization
-- **Caching**: Memoization opportunities
-
-### Metrics Collection
-- Static code analysis
-- Complexity calculations
-- Performance scoring
-- Impact assessment
-
-## Performance Analysis Workflow
-
-### Detection Phase
-1. Parse source code into AST
-2. Run pattern detectors
-3. Calculate complexity metrics
-4. Identify bottlenecks
-5. Score performance impact
-
-### Analysis Phase
-1. Evaluate issue severity
-2. Group related issues
-3. Generate optimization suggestions
-4. Estimate improvements
-5. Prioritize recommendations
-
-### Optimization Phase
-1. Review suggestions
-2. Validate safety
-3. Apply transformations
-4. Test results
-5. Measure improvements
-
-## Best Practices
-
-### Performance Analysis
-- Start with critical issues
-- Focus on hot paths
-- Measure before and after
-- Test optimizations thoroughly
-- Consider trade-offs
-
-### Optimization Strategy
-- Profile first, optimize second
-- Target biggest bottlenecks
-- Preserve code readability
-- Document optimizations
-- Monitor regression
-
-### Continuous Improvement
-- Regular performance audits
-- Automated performance tests
-- Track metrics over time
-- Share optimization patterns
-- Build performance culture
-
-## Security Considerations
-- Validate optimization safety
-- Preserve functionality
-- Avoid premature optimization
-- Test edge cases
+---
+
+## Execution Modes
+
+**Choose your execution mode:**
+
+### 1. YOLO Mode - Fast, Autonomous (0-1 prompts)
+- Autonomous decision making with logging
+- Minimal user interaction
+- **Best for:** Simple, deterministic tasks
+
+### 2. Interactive Mode - Balanced, Educational (5-10 prompts) **[DEFAULT]**
+- Explicit decision checkpoints
+- Educational explanations
+- **Best for:** Learning, complex decisions
+
+### 3. Pre-Flight Planning - Comprehensive Upfront Planning
+- Task analysis phase (identify all ambiguities)
+- Zero ambiguity execution
+- **Best for:** Ambiguous requirements, critical work
+
+**Parameter:** `mode` (optional, default: `interactive`)
+
+---
+
+## Task Definition (AIOS Task Format V1.0)
+
+```yaml
+task: devOptimizePerformance()
+responsável: Dex (Builder)
+responsavel_type: Agente
+atomic_layer: Strategy
+
+**Entrada:**
+- campo: task
+  tipo: string
+  origem: User Input
+  obrigatório: true
+  validação: Must be registered task
+
+- campo: parameters
+  tipo: object
+  origem: User Input
+  obrigatório: false
+  validação: Valid task parameters
+
+- campo: mode
+  tipo: string
+  origem: User Input
+  obrigatório: false
+  validação: yolo|interactive|pre-flight
+
+**Saída:**
+- campo: execution_result
+  tipo: object
+  destino: Memory
+  persistido: false
+
+- campo: logs
+  tipo: array
+  destino: File (.ai/logs/*)
+  persistido: true
+
+- campo: state
+  tipo: object
+  destino: State management
+  persistido: true
+```
+
+---
+
+## Pre-Conditions
+
+**Purpose:** Validate prerequisites BEFORE task execution (blocking)
+
+**Checklist:**
+
+```yaml
+pre-conditions:
+  - [ ] Task is registered; required parameters provided; dependencies met
+    tipo: pre-condition
+    blocker: true
+    validação: |
+      Check task is registered; required parameters provided; dependencies met
+    error_message: "Pre-condition failed: Task is registered; required parameters provided; dependencies met"
+```
+
+---
+
+## Post-Conditions
+
+**Purpose:** Validate execution success AFTER task completes
+
+**Checklist:**
+
+```yaml
+post-conditions:
+  - [ ] Task completed; exit code 0; expected outputs created
+    tipo: post-condition
+    blocker: true
+    validação: |
+      Verify task completed; exit code 0; expected outputs created
+    error_message: "Post-condition failed: Task completed; exit code 0; expected outputs created"
+```
+
+---
+
+## Acceptance Criteria
+
+**Purpose:** Definitive pass/fail criteria for task completion
+
+**Checklist:**
+
+```yaml
+acceptance-criteria:
+  - [ ] Task completed as expected; side effects documented
+    tipo: acceptance-criterion
+    blocker: true
+    validação: |
+      Assert task completed as expected; side effects documented
+    error_message: "Acceptance criterion not met: Task completed as expected; side effects documented"
+```
+
+---
+
+## Tools
+
+**External/shared resources used by this task:**
+
+- **Tool:** task-runner
+  - **Purpose:** Task execution and orchestration
+  - **Source:** .aios-core/core/task-runner.js
+
+- **Tool:** logger
+  - **Purpose:** Execution logging and error tracking
+  - **Source:** .aios-core/utils/logger.js
+
+---
+
+## Scripts
+
+**Agent-specific code for this task:**
+
+- **Script:** execute-task.js
+  - **Purpose:** Generic task execution wrapper
+  - **Language:** JavaScript
+  - **Location:** .aios-core/scripts/execute-task.js
+
+---
+
+## Error Handling
+
+**Strategy:** retry
+
+**Common Errors:**
+
+1. **Error:** Task Not Found
+   - **Cause:** Specified task not registered in system
+   - **Resolution:** Verify task name and registration
+   - **Recovery:** List available tasks, suggest similar
+
+2. **Error:** Invalid Parameters
+   - **Cause:** Task parameters do not match expected schema
+   - **Resolution:** Validate parameters against task definition
+   - **Recovery:** Provide parameter template, reject execution
+
+3. **Error:** Execution Timeout
+   - **Cause:** Task exceeds maximum execution time
+   - **Resolution:** Optimize task or increase timeout
+   - **Recovery:** Kill task, cleanup resources, log state
+
+---
+
+## Performance
+
+**Expected Metrics:**
+
+```yaml
+duration_expected: 5-20 min (estimated)
+cost_estimated: $0.003-0.015
+token_usage: ~2,000-8,000 tokens
+```
+
+**Optimization Notes:**
+- Iterative analysis with depth limits; cache intermediate results; batch similar operations
+
+---
+
+## Metadata
+
+```yaml
+story: N/A
+version: 1.0.0
+dependencies:
+  - N/A
+tags:
+  - development
+  - code
+updated_at: 2025-11-17
+```
+
+---
+
+checklists:
+  - dev-master-checklist.md
+---
+
+# Optimize Performance - AIOS Developer Task
+
+## Purpose
+Analyze code for performance bottlenecks and suggest optimizations to improve runtime performance, memory usage, and scalability.
+
+## Command Pattern
+```
+*optimize-performance <path> [options]
+```
+
+## Parameters
+- `path`: File or directory path to analyze
+- `options`: Performance analysis configuration
+
+### Options
+- `--patterns <types>`: Comma-separated optimization patterns to check
+- `--profile`: Enable runtime profiling (if applicable)
+- `--threshold <level>`: Minimum impact threshold for suggestions (low/medium/high)
+- `--report <file>`: Generate performance report
+- `--apply <optimization-id>`: Apply specific optimization
+- `--recursive`: Analyze directories recursively
+- `--exclude <patterns>`: Exclude file patterns
+- `--focus <category>`: Focus on specific category (algorithm/memory/async/database/bundle/react)
+
+## Optimization Patterns
+- `algorithm_complexity`: High time complexity algorithms
+- `loop_optimization`: Nested loops and iterations
+- `memory_usage`: Memory consumption and leaks
+- `async_operations`: Async/await patterns
+- `caching`: Memoization opportunities
+- `database_queries`: N+1 and query optimization
+- `bundle_size`: JavaScript bundle optimization
+- `react_performance`: React-specific optimizations
+- `string_operations`: String manipulation
+- `object_operations`: Object creation and access
+
+## Examples
+```bash
+# Analyze single file
+*optimize-performance aios-core/scripts/data-processor.js
+
+# Analyze directory with specific patterns
+*optimize-performance aios-core/agents --patterns algorithm_complexity,async_operations --recursive
+
+# Generate performance report
+*optimize-performance . --recursive --report performance-report.json
+
+# Focus on database optimizations
+*optimize-performance aios-core/services --focus database --recursive
+
+# Apply specific optimization
+*optimize-performance aios-core/scripts/calculator.js --apply opt-001
+```
+
+## Implementation
+
+```javascript
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const glob = require('glob').promises;
+
+class OptimizePerformanceTask {
+  constructor() {
+    this.taskName = 'optimize-performance';
+    this.description = 'Analyze and optimize code performance';
+    this.rootPath = process.cwd();
+    this.performanceOptimizer = null;
+    this.analysisResults = [];
+    this.appliedOptimizations = [];
+  }
+
+  async execute(params) {
+    try {
+      console.log(chalk.blue('⚡ AIOS Performance Optimization'));
+      console.log(chalk.gray('Analyzing code for performance improvements\n'));
+
+      // Parse parameters
+      const config = await this.parseParameters(params);
+      
+      // Initialize dependencies
+      await this.initializeDependencies();
+
+      // Get files to analyze
+      const files = await this.getFilesToAnalyze(config);
+      
+      if (files.length === 0) {
+        console.log(chalk.yellow('No files found to analyze'));
+        return { success: true, results: [] };
+      }
+
+      console.log(chalk.gray(`Found ${files.length} files to analyze\n`));
+
+      // Execute based on mode
+      if (config.apply) {
+        // Apply specific optimization
+        await this.applyOptimization(config.apply, config);
+      } else {
+        // Analyze files
+        await this.analyzeFiles(files, config);
+        
+        // Display results
+        await this.displayResults(config);
+        
+        // Generate report if requested
+        if (config.report) {
+          await this.generateReport(config.report);
+        }
+      }
+
+      return {
+        success: true,
+        filesAnalyzed: files.length,
+        totalIssues: this.getTotalIssues(),
+        criticalIssues: this.getCriticalIssues()
+      };
+
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Performance optimization failed: ${error.message}`));
+      throw error;
+    }
+  }
+
+  async parseParameters(params) {
+    if (params.length < 1) {
+      throw new Error('Usage: *optimize-performance <path> [options]');
+    }
+
+    const config = {
+      targetPath: params[0],
+      patterns: null,
+      profile: false,
+      threshold: 'low',
+      report: null,
+      apply: null,
+      recursive: false,
+      exclude: [],
+      focus: null
+    };
+
+    // Parse options
+    for (let i = 1; i < params.length; i++) {
+      const param = params[i];
+      
+      if (param === '--profile') {
+        config.profile = true;
+      } else if (param === '--recursive') {
+        config.recursive = true;
+      } else if (param.startsWith('--patterns') && params[i + 1]) {
+        config.patterns = params[++i].split(',').map(p => p.trim());
+      } else if (param.startsWith('--threshold') && params[i + 1]) {
+        config.threshold = params[++i];
+      } else if (param.startsWith('--report') && params[i + 1]) {
+        config.report = params[++i];
+      } else if (param.startsWith('--apply') && params[i + 1]) {
+        config.apply = params[++i];
+      } else if (param.startsWith('--exclude') && params[i + 1]) {
+        config.exclude = params[++i].split(',').map(e => e.trim());
+      } else if (param.startsWith('--focus') && params[i + 1]) {
+        config.focus = params[++i];
+      }
+    }
+
+    // Validate threshold
+    if (!['low', 'medium', 'high'].includes(config.threshold)) {
+      throw new Error('Threshold must be: low, medium, or high');
+    }
+
+    return config;
+  }
+
+  async initializeDependencies() {
+    try {
+      const PerformanceOptimizer = require('../scripts/performance-optimizer');
+      this.performanceOptimizer = new PerformanceOptimizer({ 
+        rootPath: this.rootPath,
+        enableProfiling: true
+      });
+
+      // Listen to events
+      this.performanceOptimizer.on('analyzed', (analysis) => {
+        this.analysisResults.push(analysis);
+      });
+
+    } catch (error) {
+      throw new Error(`Failed to initialize dependencies: ${error.message}`);
+    }
+  }
+
+  async getFilesToAnalyze(config) {
+    const targetPath = path.resolve(this.rootPath, config.targetPath);
+    const files = [];
+
+    try {
+      const stats = await fs.stat(targetPath);
+      
+      if (stats.isFile()) {
+        // Single file
+        if (this.shouldAnalyzeFile(targetPath, config)) {
+          files.push(targetPath);
+        }
+      } else if (stats.isDirectory()) {
+        // Directory
+        const pattern = config.recursive ? '**/*.{js,jsx,ts,tsx}' : '*.{js,jsx,ts,tsx}';
+        const globPattern = path.join(targetPath, pattern);
+        
+        const matches = await glob(globPattern, {
+          ignore: config.exclude.map(e => path.join(targetPath, '**', e)),
+          nodir: true
+        });
+        
+        for (const match of matches) {
+          if (this.shouldAnalyzeFile(match, config)) {
+            files.push(match);
+          }
+        }
+      }
+    } catch (error) {
+      console.warn(chalk.yellow(`Cannot access ${targetPath}: ${error.message}`));
+    }
+
+    return files;
+  }
+
+  shouldAnalyzeFile(filePath, config) {
+    // Skip test files unless analyzing tests
+    if (filePath.includes('.test.') || filePath.includes('.spec.')) {
+      return false;
+    }
+    
+    // Skip minified files
+    if (filePath.includes('.min.')) {
+      return false;
+    }
+    
+    // Skip build artifacts
+    if (filePath.includes('/dist/') || filePath.includes('/build/')) {
+      return false;
+    }
+    
+    // Skip node_modules
+    if (filePath.includes('node_modules')) {
+      return false;
+    }
+    
+    return true;
+  }
+
+  async analyzeFiles(files, config) {
+    console.log(chalk.blue('🔍 Analyzing performance...'));
+    
+    const progressInterval = Math.max(1, Math.floor(files.length / 20));
+    
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      
+      try {
+        const analysis = await this.performanceOptimizer.analyzePerformance(file, {
+          patterns: config.patterns,
+          enableProfiling: config.profile
+        });
+        
+        // Filter by threshold
+        if (analysis.issues && analysis.issues.length > 0) {
+          analysis.issues = this.filterByThreshold(analysis.issues, config.threshold);
+        }
+        
+        // Filter by focus category
+        if (config.focus && analysis.issues) {
+          analysis.issues = analysis.issues.filter(issue => 
+            issue.category === config.focus
+          );
+        }
+        
+        // Show progress
+        if (i % progressInterval === 0) {
+          const progress = Math.floor((i / files.length) * 100);
+          process.stdout.write(`\rProgress: ${progress}%`);
+        }
+        
+      } catch (error) {
+        console.warn(chalk.yellow(`\nFailed to analyze ${file}: ${error.message}`));
+      }
+    }
+    
+    console.log('\rProgress: 100%\n');
+  }
+
+  filterByThreshold(issues, threshold) {
+    const thresholdMap = {
+      low: ['low', 'medium', 'high', 'critical'],
+      medium: ['medium', 'high', 'critical'],
+      high: ['high', 'critical']
+    };
+    
+    const allowedImpacts = thresholdMap[threshold];
+    
+    return issues.filter(issue => 
+      allowedImpacts.includes(issue.impact) || 
+      allowedImpacts.includes(issue.severity)
+    );
+  }
+
+  async displayResults(config) {
+    const totalIssues = this.getTotalIssues();
+    
+    if (totalIssues === 0) {
+      console.log(chalk.green('✅ No performance issues found!'));
+      console.log(chalk.gray('Your code is already well optimized.'));
+      return;
+    }
+
+    console.log(chalk.blue(`\n📊 Performance Analysis Results\n`));
+    console.log(chalk.gray('Found ') + chalk.yellow(totalIssues) + chalk.gray(' optimization opportunities\n'));
+
+    // Group by category
+    const byCategory = this.groupByCategory();
+    
+    // Display by category
+    for (const [category, results] of Object.entries(byCategory)) {
+      console.log(chalk.blue(`\n${this.getCategoryIcon(category)} ${this.getCategoryName(category)}`));
+      console.log(chalk.gray('─'.repeat(50)));
+      
+      for (const result of results) {
+        this.displayFileResults(result);
+      }
+    }
+
+    // Show performance scores
+    this.displayPerformanceScores();
+
+    // Show top recommendations
+    this.displayTopRecommendations();
+
+    // Show next steps
+    console.log(chalk.blue('\n📌 Next Steps:'));
+    console.log('1. Review critical issues first');
+    console.log('2. Apply optimizations incrementally');
+    console.log('3. Test after each optimization');
+    console.log('4. Monitor performance improvements');
+    if (config.report) {
+      console.log(`5. View detailed report: ${config.report}`);
+    }
+  }
+
+  displayFileResults(result) {
+    const relativePath = path.relative(this.rootPath, result.filePath);
+    
+    console.log(`\n📄 ${chalk.blue(relativePath)}`);
+    
+    if (result.metrics?.performanceScore !== undefined) {
+      const score = result.metrics.performanceScore;
+      const scoreColor = score >= 80 ? chalk.green : score >= 60 ? chalk.yellow : chalk.red;
+      console.log(`   Performance Score: ${scoreColor(score + '/100')}`);
+    }
+    
+    // Display issues
+    for (const issue of result.issues) {
+      this.displayIssue(issue);
+      
+      // Display suggestions for this issue
+      const suggestion = result.suggestions?.find(s => 
+        s.issueId === issue.id || s.pattern === issue.pattern
+      );
+      
+      if (suggestion) {
+        this.displaySuggestion(suggestion);
+      }
+    }
+  }
+
+  displayIssue(issue) {
+    const impactColors = {
+      critical: chalk.red,
+      high: chalk.red,
+      medium: chalk.yellow,
+      low: chalk.gray
+    };
+    
+    const impactColor = impactColors[issue.impact || issue.severity] || chalk.gray;
+    
+    console.log(`\n   ${impactColor(`[${(issue.impact || issue.severity || 'info').toUpperCase()}]`)} ${issue.description}`);
+    
+    if (issue.location) {
+      console.log(chalk.gray(`   Location: Line ${issue.location.start?.line || '?'}`));
+    }
+    
+    if (issue.type) {
+      console.log(chalk.gray(`   Type: ${issue.type}`));
+    }
+  }
+
+  displaySuggestion(suggestion) {
+    console.log(chalk.green('   💡 Suggestion:'));
+    
+    if (suggestion.optimizations) {
+      for (const opt of suggestion.optimizations) {
+        console.log(`      - ${opt.description}`);
+        
+        if (opt.code) {
+          console.log(chalk.gray('        Example:'));
+          const codeLines = opt.code.split('\n');
+          for (const line of codeLines) {
+            console.log(chalk.gray(`          ${line}`));
+          }
+        }
+        
+        if (opt.improvement) {
+          console.log(chalk.green(`        → ${opt.improvement}`));
+        }
+      }
+    }
+    
+    if (suggestion.estimatedImprovement) {
+      console.log(chalk.green(`      Estimated improvement: ${suggestion.estimatedImprovement}`));
+    }
+  }
+
+  groupByCategory() {
+    const grouped = {};
+    
+    for (const result of this.analysisResults) {
+      if (!result.issues || result.issues.length === 0) continue;
+      
+      for (const issue of result.issues) {
+        const category = issue.category || 'other';
+        
+        if (!grouped[category]) {
+          grouped[category] = [];
+        }
+        
+        // Find or create file entry
+        let fileEntry = grouped[category].find(r => r.filePath === result.filePath);
+        if (!fileEntry) {
+          fileEntry = {
+            filePath: result.filePath,
+            issues: [],
+            suggestions: result.suggestions || [],
+            metrics: result.metrics
+          };
+          grouped[category].push(fileEntry);
+        }
+        
+        fileEntry.issues.push(issue);
+      }
+    }
+    
+    return grouped;
+  }
+
+  getCategoryIcon(category) {
+    const icons = {
+      algorithm: '🔄',
+      memory: '💾',
+      async: '⚡',
+      database: '🗄️',
+      bundle: '📦',
+      react: '⚛️',
+      caching: '💰',
+      framework: '🏗️',
+      other: '🔧'
+    };
+    
+    return icons[category] || icons.other;
+  }
+
+  getCategoryName(category) {
+    const names = {
+      algorithm: 'Algorithm Optimization',
+      memory: 'Memory Usage',
+      async: 'Async Operations',
+      database: 'Database Queries',
+      bundle: 'Bundle Size',
+      react: 'React Performance',
+      caching: 'Caching Opportunities',
+      framework: 'Framework-Specific',
+      other: 'Other Optimizations'
+    };
+    
+    return names[category] || category;
+  }
+
+  displayPerformanceScores() {
+    console.log(chalk.blue('\n📈 Performance Summary'));
+    console.log(chalk.gray('─'.repeat(50)));
+    
+    let totalScore = 0;
+    let fileCount = 0;
+    
+    for (const result of this.analysisResults) {
+      if (result.metrics?.performanceScore !== undefined) {
+        totalScore += result.metrics.performanceScore;
+        fileCount++;
+      }
+    }
+    
+    if (fileCount > 0) {
+      const avgScore = Math.round(totalScore / fileCount);
+      const scoreColor = avgScore >= 80 ? chalk.green : avgScore >= 60 ? chalk.yellow : chalk.red;
+      
+      console.log(`Average Performance Score: ${scoreColor(avgScore + '/100')}`);
+      console.log(`Files Analyzed: ${fileCount}`);
+    }
+    
+    // Issue breakdown
+    const criticalCount = this.getCriticalIssues();
+    const highCount = this.getIssuesByImpact('high');
+    const mediumCount = this.getIssuesByImpact('medium');
+    const lowCount = this.getIssuesByImpact('low');
+    
+    console.log('\nIssue Breakdown:');
+    if (criticalCount > 0) console.log(chalk.red(`  Critical: ${criticalCount}`));
+    if (highCount > 0) console.log(chalk.red(`  High: ${highCount}`));
+    if (mediumCount > 0) console.log(chalk.yellow(`  Medium: ${mediumCount}`));
+    if (lowCount > 0) console.log(chalk.gray(`  Low: ${lowCount}`));
+  }
+
+  displayTopRecommendations() {
+    console.log(chalk.blue('\n🎯 Top Recommendations'));
+    console.log(chalk.gray('─'.repeat(50)));
+    
+    const recommendations = this.getTopRecommendations();
+    
+    if (recommendations.length === 0) {
+      console.log(chalk.gray('No specific recommendations'));
+      return;
+    }
+    
+    for (let i = 0; i < Math.min(5, recommendations.length); i++) {
+      const rec = recommendations[i];
+      console.log(`\n${i + 1}. ${rec.title}`);
+      console.log(chalk.gray(`   ${rec.description}`));
+      if (rec.files) {
+        console.log(chalk.gray(`   Files affected: ${rec.files.length}`));
+      }
+    }
+  }
+
+  getTopRecommendations() {
+    const recommendations = [];
+    const byCategory = this.groupByCategory();
+    
+    // Algorithm complexity issues
+    if (byCategory.algorithm?.length > 0) {
+      const highComplexity = byCategory.algorithm.filter(r => 
+        r.issues.some(i => i.type === 'high_complexity' && i.severity === 'critical')
+      );
+      
+      if (highComplexity.length > 0) {
+        recommendations.push({
+          title: 'Optimize High-Complexity Algorithms',
+          description: 'Several functions have O(n²) or worse complexity. Consider using more efficient algorithms.',
+          priority: 'critical',
+          files: highComplexity
+        });
+      }
+    }
+    
+    // Async issues
+    if (byCategory.async?.length > 0) {
+      const sequentialAwaits = byCategory.async.filter(r => 
+        r.issues.some(i => i.type === 'sequential_awaits')
+      );
+      
+      if (sequentialAwaits.length > 0) {
+        recommendations.push({
+          title: 'Parallelize Async Operations',
+          description: 'Use Promise.all to run independent async operations in parallel.',
+          priority: 'high',
+          files: sequentialAwaits
+        });
+      }
+    }
+    
+    // Database issues
+    if (byCategory.database?.length > 0) {
+      const nPlusOne = byCategory.database.filter(r => 
+        r.issues.some(i => i.type === 'n_plus_one')
+      );
+      
+      if (nPlusOne.length > 0) {
+        recommendations.push({
+          title: 'Fix N+1 Query Problems',
+          description: 'Database queries in loops cause performance degradation. Use JOINs or batch loading.',
+          priority: 'critical',
+          files: nPlusOne
+        });
+      }
+    }
+    
+    // Memory issues
+    if (byCategory.memory?.length > 0) {
+      recommendations.push({
+        title: 'Optimize Memory Usage',
+        description: 'Review memory allocations and potential leaks. Consider using more efficient data structures.',
+        priority: 'medium',
+        files: byCategory.memory
+      });
+    }
+    
+    // Caching opportunities
+    if (byCategory.caching?.length > 0) {
+      recommendations.push({
+        title: 'Implement Caching',
+        description: 'Add memoization or caching for expensive repeated operations.',
+        priority: 'medium',
+        files: byCategory.caching
+      });
+    }
+    
+    // Sort by priority
+    const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    recommendations.sort((a, b) => 
+      priorityOrder[a.priority] - priorityOrder[b.priority]
+    );
+    
+    return recommendations;
+  }
+
+  async applyOptimization(optimizationId, config) {
+    console.log(chalk.blue(`\n🔧 Applying optimization: ${optimizationId}`));
+    
+    // Find the optimization in results
+    let targetOptimization = null;
+    let targetFile = null;
+    
+    for (const result of this.analysisResults) {
+      const suggestion = result.suggestions?.find(s => 
+        s.issueId === optimizationId || s.id === optimizationId
+      );
+      
+      if (suggestion) {
+        targetOptimization = suggestion;
+        targetFile = result.filePath;
+        break;
+      }
+    }
+    
+    if (!targetOptimization) {
+      throw new Error(`Optimization not found: ${optimizationId}`);
+    }
+    
+    console.log(chalk.gray(`File: ${path.relative(this.rootPath, targetFile)}`));
+    console.log(chalk.gray(`Type: ${targetOptimization.type || 'General optimization'}`));
+    
+    // Show optimization details
+    if (targetOptimization.optimizations) {
+      console.log(chalk.blue('\nOptimizations to apply:'));
+      for (const opt of targetOptimization.optimizations) {
+        console.log(`  - ${opt.description}`);
+      }
+    }
+    
+    // Confirm application
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: 'Apply this optimization?',
+      default: true
+    }]);
+    
+    if (!confirm) {
+      console.log(chalk.gray('Optimization cancelled'));
+      return;
+    }
+    
+    // Apply the optimization
+    try {
+      const result = await this.performanceOptimizer.applyOptimization(
+        targetFile,
+        targetOptimization
+      );
+      
+      if (result.success) {
+        console.log(chalk.green('✅ Optimization applied successfully'));
+        
+        // Show changes
+        for (const change of result.changes) {
+          console.log(chalk.gray(`  - ${change.description}`));
+        }
+        
+        this.appliedOptimizations.push({
+          file: targetFile,
+          optimization: targetOptimization,
+          result,
+          timestamp: new Date().toISOString()
+        });
+      } else {
+        console.error(chalk.red(`Failed to apply optimization: ${result.error}`));
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error applying optimization: ${error.message}`));
+    }
+  }
+
+  async generateReport(reportPath) {
+    console.log(chalk.blue('\n📤 Generating performance report...'));
+    
+    const report = await this.performanceOptimizer.generateOptimizationReport();
+    
+    // Add analysis results
+    report.analysisResults = this.analysisResults.map(r => ({
+      file: path.relative(this.rootPath, r.filePath),
+      performanceScore: r.metrics?.performanceScore,
+      issues: r.issues.length,
+      criticalIssues: r.issues.filter(i => 
+        i.impact === 'critical' || i.severity === 'critical'
+      ).length,
+      suggestions: r.suggestions?.length || 0
+    }));
+    
+    // Add applied optimizations
+    report.appliedOptimizations = this.appliedOptimizations;
+    
+    await fs.writeFile(reportPath, JSON.stringify(report, null, 2));
+    console.log(chalk.green(`✅ Report generated: ${reportPath}`));
+    
+    // Show report summary
+    console.log(chalk.blue('\n📊 Report Summary:'));
+    console.log(`  Files analyzed: ${report.summary.filesAnalyzed}`);
+    console.log(`  Total issues: ${report.summary.totalIssues}`);
+    console.log(`  Critical issues: ${report.summary.criticalIssues}`);
+    console.log(`  Optimizations applied: ${report.summary.optimizationsApplied}`);
+  }
+
+  getTotalIssues() {
+    return this.analysisResults.reduce((total, result) => 
+      total + (result.issues?.length || 0), 0
+    );
+  }
+
+  getCriticalIssues() {
+    return this.analysisResults.reduce((total, result) => 
+      total + (result.issues?.filter(i => 
+        i.impact === 'critical' || i.severity === 'critical'
+      ).length || 0), 0
+    );
+  }
+
+  getIssuesByImpact(impact) {
+    return this.analysisResults.reduce((total, result) => 
+      total + (result.issues?.filter(i => 
+        i.impact === impact || i.severity === impact
+      ).length || 0), 0
+    );
+  }
+}
+
+module.exports = OptimizePerformanceTask;
+```
+
+## Integration Points
+
+### Performance Optimizer
+- Core analysis engine
+- Pattern detection system
+- Optimization suggestion generator
+- Runtime profiling capability
+
+### Analysis Categories
+- **Algorithm**: Time complexity, nested loops
+- **Memory**: Allocations, leaks, data structures
+- **Async**: Promise patterns, parallelization
+- **Database**: Query optimization, N+1 problems
+- **Bundle**: Import optimization, tree-shaking
+- **React**: Component rendering, memoization
+- **Caching**: Memoization opportunities
+
+### Metrics Collection
+- Static code analysis
+- Complexity calculations
+- Performance scoring
+- Impact assessment
+
+## Performance Analysis Workflow
+
+### Detection Phase
+1. Parse source code into AST
+2. Run pattern detectors
+3. Calculate complexity metrics
+4. Identify bottlenecks
+5. Score performance impact
+
+### Analysis Phase
+1. Evaluate issue severity
+2. Group related issues
+3. Generate optimization suggestions
+4. Estimate improvements
+5. Prioritize recommendations
+
+### Optimization Phase
+1. Review suggestions
+2. Validate safety
+3. Apply transformations
+4. Test results
+5. Measure improvements
+
+## Best Practices
+
+### Performance Analysis
+- Start with critical issues
+- Focus on hot paths
+- Measure before and after
+- Test optimizations thoroughly
+- Consider trade-offs
+
+### Optimization Strategy
+- Profile first, optimize second
+- Target biggest bottlenecks
+- Preserve code readability
+- Document optimizations
+- Monitor regression
+
+### Continuous Improvement
+- Regular performance audits
+- Automated performance tests
+- Track metrics over time
+- Share optimization patterns
+- Build performance culture
+
+## Security Considerations
+- Validate optimization safety
+- Preserve functionality
+- Avoid premature optimization
+- Test edge cases
 - Monitor side effects