claude-flow 2.0.0-alpha.61 → 2.0.0-alpha.62

package/src/cli/simple-commands/hive-mind/queen.js

@@ -13,20 +13,20 @@ const QUEEN_TYPES = {
     name: 'Strategic Queen',
     traits: ['long-term planning', 'resource optimization', 'goal alignment'],
     decisionWeight: 3,
-    consensusThreshold: 0.6
+    consensusThreshold: 0.6,
   },
   tactical: {
     name: 'Tactical Queen',
     traits: ['task prioritization', 'workflow optimization', 'rapid response'],
     decisionWeight: 2,
-    consensusThreshold: 0.5
+    consensusThreshold: 0.5,
   },
   adaptive: {
     name: 'Adaptive Queen',
     traits: ['learning', 'pattern recognition', 'strategy evolution'],
     decisionWeight: 2.5,
-    consensusThreshold: 0.55
-  }
+    consensusThreshold: 0.55,
+  },
 };
 
 /**
@@ -35,14 +35,14 @@ const QUEEN_TYPES = {
 export class QueenCoordinator extends EventEmitter {
   constructor(config = {}) {
     super();
-    
+
     this.config = {
       swarmId: config.swarmId,
       type: config.type || 'strategic',
       objective: config.objective || '',
-      ...QUEEN_TYPES[config.type || 'strategic']
+      ...QUEEN_TYPES[config.type || 'strategic'],
     };
-    
+
     this.state = {
       status: 'initializing',
       decisionsCount: 0,
@@ -50,20 +50,20 @@ export class QueenCoordinator extends EventEmitter {
       learningData: new Map(),
       currentStrategy: null,
       taskQueue: [],
-      workerAssignments: new Map()
+      workerAssignments: new Map(),
     };
-    
+
     this.strategies = {
       divide_and_conquer: this._divideAndConquerStrategy.bind(this),
       parallel_execution: this._parallelExecutionStrategy.bind(this),
       sequential_refinement: this._sequentialRefinementStrategy.bind(this),
       consensus_driven: this._consensusDrivenStrategy.bind(this),
-      adaptive_learning: this._adaptiveLearningStrategy.bind(this)
+      adaptive_learning: this._adaptiveLearningStrategy.bind(this),
     };
-    
+
     this._initialize();
   }
-  
+
   /**
    * Initialize queen coordinator
    */
@@ -71,10 +71,10 @@ export class QueenCoordinator extends EventEmitter {
     this.state.status = 'active';
     this.emit('queen:initialized', {
       type: this.config.type,
-      traits: this.config.traits
+      traits: this.config.traits,
     });
   }
-  
+
   /**
    * Analyze objective and create strategic plan
    */
@@ -85,16 +85,16 @@ export class QueenCoordinator extends EventEmitter {
       requiredCapabilities: this._identifyRequiredCapabilities(objective),
       estimatedTasks: this._estimateTaskCount(objective),
       recommendedStrategy: this._selectStrategy(objective),
-      resourceRequirements: this._estimateResources(objective)
+      resourceRequirements: this._estimateResources(objective),
     };
-    
+
     // Store analysis for learning
     this.state.learningData.set('objective_analysis', analysis);
-    
+
     this.emit('objective:analyzed', analysis);
     return analysis;
   }
-  
+
   /**
    * Assess complexity of objective
    */
@@ -102,31 +102,41 @@ export class QueenCoordinator extends EventEmitter {
     const complexityFactors = {
       length: objective.length > 100 ? 2 : 1,
       keywords: this._countComplexityKeywords(objective),
-      components: this._identifyComponents(objective).length
+      components: this._identifyComponents(objective).length,
     };
-    
+
     const score = Object.values(complexityFactors).reduce((a, b) => a + b, 0);
-    
+
     if (score <= 3) return 'low';
     if (score <= 6) return 'medium';
     if (score <= 9) return 'high';
     return 'very_high';
   }
-  
+
   /**
    * Count complexity keywords
    */
   _countComplexityKeywords(text) {
     const complexKeywords = [
-      'complex', 'advanced', 'enterprise', 'distributed', 'scalable',
-      'microservices', 'architecture', 'integration', 'optimization',
-      'security', 'performance', 'concurrent', 'real-time'
+      'complex',
+      'advanced',
+      'enterprise',
+      'distributed',
+      'scalable',
+      'microservices',
+      'architecture',
+      'integration',
+      'optimization',
+      'security',
+      'performance',
+      'concurrent',
+      'real-time',
     ];
-    
+
     const lowerText = text.toLowerCase();
-    return complexKeywords.filter(keyword => lowerText.includes(keyword)).length;
+    return complexKeywords.filter((keyword) => lowerText.includes(keyword)).length;
   }
-  
+
   /**
    * Identify components in objective
    */
@@ -139,27 +149,27 @@ export class QueenCoordinator extends EventEmitter {
       auth: ['auth', 'security', 'login', 'permission', 'access'],
       testing: ['test', 'quality', 'validation', 'verify'],
       deployment: ['deploy', 'ci/cd', 'docker', 'kubernetes'],
-      monitoring: ['monitor', 'logging', 'metrics', 'observability']
+      monitoring: ['monitor', 'logging', 'metrics', 'observability'],
     };
-    
+
     const lowerObjective = objective.toLowerCase();
-    
+
     Object.entries(componentKeywords).forEach(([component, keywords]) => {
-      if (keywords.some(keyword => lowerObjective.includes(keyword))) {
+      if (keywords.some((keyword) => lowerObjective.includes(keyword))) {
         components.push(component);
       }
     });
-    
+
     return components;
   }
-  
+
   /**
    * Identify required capabilities
    */
   _identifyRequiredCapabilities(objective) {
     const capabilities = new Set();
     const components = this._identifyComponents(objective);
-    
+
     // Map components to capabilities
     const capabilityMap = {
       backend: ['coder', 'architect', 'tester'],
@@ -168,79 +178,82 @@ export class QueenCoordinator extends EventEmitter {
       auth: ['architect', 'coder', 'tester'],
       testing: ['tester', 'reviewer'],
       deployment: ['architect', 'optimizer'],
-      monitoring: ['analyst', 'optimizer']
+      monitoring: ['analyst', 'optimizer'],
     };
-    
-    components.forEach(component => {
+
+    components.forEach((component) => {
       const caps = capabilityMap[component] || [];
-      caps.forEach(cap => capabilities.add(cap));
+      caps.forEach((cap) => capabilities.add(cap));
     });
-    
+
     // Always include researcher for initial analysis
     capabilities.add('researcher');
-    
+
     return Array.from(capabilities);
   }
-  
+
   /**
    * Estimate number of tasks
    */
   _estimateTaskCount(objective) {
     const complexity = this._assessComplexity(objective);
     const components = this._identifyComponents(objective).length;
-    
+
     const baseTaskCount = {
       low: 5,
       medium: 10,
       high: 20,
-      very_high: 30
+      very_high: 30,
     };
-    
-    return baseTaskCount[complexity] + (components * 3);
+
+    return baseTaskCount[complexity] + components * 3;
   }
-  
+
   /**
    * Select optimal strategy
    */
   _selectStrategy(objective) {
     const complexity = this._assessComplexity(objective);
     const components = this._identifyComponents(objective);
-    
+
     // Strategy selection heuristics
     if (components.length > 3 && complexity !== 'low') {
       return 'divide_and_conquer';
     }
-    
+
     if (objective.toLowerCase().includes('parallel') || components.length > 5) {
       return 'parallel_execution';
     }
-    
-    if (objective.toLowerCase().includes('iterative') || objective.toLowerCase().includes('refine')) {
+
+    if (
+      objective.toLowerCase().includes('iterative') ||
+      objective.toLowerCase().includes('refine')
+    ) {
       return 'sequential_refinement';
     }
-    
+
     if (this.config.type === 'adaptive') {
       return 'adaptive_learning';
     }
-    
+
     return 'consensus_driven'; // Default
   }
-  
+
   /**
    * Estimate resource requirements
    */
   _estimateResources(objective) {
     const complexity = this._assessComplexity(objective);
     const taskCount = this._estimateTaskCount(objective);
-    
+
     return {
       minWorkers: Math.min(3, Math.ceil(taskCount / 10)),
       optimalWorkers: Math.min(8, Math.ceil(taskCount / 5)),
       estimatedTime: taskCount * 5, // minutes
-      memoryRequirement: complexity === 'very_high' ? 'high' : 'medium'
+      memoryRequirement: complexity === 'very_high' ? 'high' : 'medium',
     };
   }
-  
+
   /**
    * Create execution plan
    */
@@ -249,45 +262,45 @@ export class QueenCoordinator extends EventEmitter {
     if (!strategy) {
       throw new Error(`Unknown strategy: ${analysis.recommendedStrategy}`);
     }
-    
+
     const plan = await strategy(analysis, workers);
-    
+
     this.state.currentStrategy = analysis.recommendedStrategy;
     this.state.strategiesExecuted++;
-    
+
     this.emit('plan:created', plan);
     return plan;
   }
-  
+
   /**
    * Divide and conquer strategy
    */
   async _divideAndConquerStrategy(analysis, workers) {
     const components = this._identifyComponents(analysis.objective);
     const phases = [];
-    
+
     // Phase 1: Research and planning
     phases.push({
       name: 'Research and Planning',
       tasks: [
         'Research best practices and patterns',
         'Analyze requirements and constraints',
-        'Create high-level architecture design'
+        'Create high-level architecture design',
       ],
-      workers: workers.filter(w => ['researcher', 'architect'].includes(w.type)),
-      parallel: true
+      workers: workers.filter((w) => ['researcher', 'architect'].includes(w.type)),
+      parallel: true,
     });
-    
+
     // Phase 2: Component development
-    components.forEach(component => {
+    components.forEach((component) => {
       phases.push({
         name: `Develop ${component}`,
         tasks: this._generateComponentTasks(component),
-        workers: workers.filter(w => ['coder', 'architect'].includes(w.type)),
-        parallel: true
+        workers: workers.filter((w) => ['coder', 'architect'].includes(w.type)),
+        parallel: true,
       });
     });
-    
+
     // Phase 3: Integration and testing
     phases.push({
       name: 'Integration and Testing',
@@ -295,12 +308,12 @@ export class QueenCoordinator extends EventEmitter {
         'Integrate components',
         'Write integration tests',
         'Perform end-to-end testing',
-        'Fix integration issues'
+        'Fix integration issues',
       ],
-      workers: workers.filter(w => ['coder', 'tester'].includes(w.type)),
-      parallel: false
+      workers: workers.filter((w) => ['coder', 'tester'].includes(w.type)),
+      parallel: false,
     });
-    
+
     // Phase 4: Optimization and documentation
     phases.push({
       name: 'Optimization and Documentation',
@@ -308,48 +321,50 @@ export class QueenCoordinator extends EventEmitter {
         'Optimize performance',
         'Document architecture',
         'Create user documentation',
-        'Prepare deployment guide'
+        'Prepare deployment guide',
       ],
-      workers: workers.filter(w => ['optimizer', 'documenter'].includes(w.type)),
-      parallel: true
+      workers: workers.filter((w) => ['optimizer', 'documenter'].includes(w.type)),
+      parallel: true,
     });
-    
+
     return {
       strategy: 'divide_and_conquer',
       phases,
       estimatedDuration: phases.length * 15, // minutes
-      parallelism: 'high'
+      parallelism: 'high',
     };
   }
-  
+
   /**
    * Parallel execution strategy
    */
   async _parallelExecutionStrategy(analysis, workers) {
     const tasks = this._generateAllTasks(analysis);
     const workerGroups = this._groupWorkersByType(workers);
-    
+
     return {
       strategy: 'parallel_execution',
-      phases: [{
-        name: 'Parallel Execution',
-        tasks: tasks,
-        workers: workers,
-        parallel: true,
-        workerAssignment: this._optimizeWorkerAssignment(tasks, workerGroups)
-      }],
+      phases: [
+        {
+          name: 'Parallel Execution',
+          tasks: tasks,
+          workers: workers,
+          parallel: true,
+          workerAssignment: this._optimizeWorkerAssignment(tasks, workerGroups),
+        },
+      ],
       estimatedDuration: Math.ceil(tasks.length / workers.length) * 10,
-      parallelism: 'maximum'
+      parallelism: 'maximum',
     };
   }
-  
+
   /**
    * Sequential refinement strategy
    */
   async _sequentialRefinementStrategy(analysis, workers) {
     const iterations = 3;
     const phases = [];
-    
+
     for (let i = 0; i < iterations; i++) {
       phases.push({
         name: `Iteration ${i + 1}`,
@@ -357,30 +372,30 @@ export class QueenCoordinator extends EventEmitter {
           `Design iteration ${i + 1}`,
           `Implement features for iteration ${i + 1}`,
           `Test iteration ${i + 1}`,
-          `Review and refine iteration ${i + 1}`
+          `Review and refine iteration ${i + 1}`,
         ],
         workers: workers,
         parallel: false,
-        requiresConsensus: true
+        requiresConsensus: true,
       });
     }
-    
+
     return {
       strategy: 'sequential_refinement',
       phases,
       estimatedDuration: phases.length * 20,
       parallelism: 'low',
-      iterative: true
+      iterative: true,
     };
   }
-  
+
   /**
    * Consensus-driven strategy
    */
   async _consensusDrivenStrategy(analysis, workers) {
     const decisionPoints = this._identifyDecisionPoints(analysis);
     const phases = [];
-    
+
     decisionPoints.forEach((decision, index) => {
       phases.push({
         name: `Decision Phase ${index + 1}: ${decision}`,
@@ -388,24 +403,24 @@ export class QueenCoordinator extends EventEmitter {
           `Research options for ${decision}`,
           `Analyze trade-offs`,
           `Build consensus on approach`,
-          `Implement chosen solution`
+          `Implement chosen solution`,
         ],
         workers: workers,
         parallel: index === 0, // Only first phase in parallel
         requiresConsensus: true,
-        consensusThreshold: this.config.consensusThreshold
+        consensusThreshold: this.config.consensusThreshold,
       });
     });
-    
+
     return {
       strategy: 'consensus_driven',
       phases,
       estimatedDuration: phases.length * 25,
       parallelism: 'medium',
-      consensusRequired: true
+      consensusRequired: true,
     };
   }
-  
+
   /**
    * Adaptive learning strategy
    */
@@ -416,45 +431,37 @@ export class QueenCoordinator extends EventEmitter {
         tasks: [
           'Explore multiple approaches',
           'Experiment with different solutions',
-          'Collect performance metrics'
+          'Collect performance metrics',
         ],
         workers: workers,
         parallel: true,
-        learning: true
+        learning: true,
       },
       {
         name: 'Analysis Phase',
-        tasks: [
-          'Analyze results',
-          'Identify patterns',
-          'Select best approaches'
-        ],
-        workers: workers.filter(w => ['analyst', 'researcher'].includes(w.type)),
+        tasks: ['Analyze results', 'Identify patterns', 'Select best approaches'],
+        workers: workers.filter((w) => ['analyst', 'researcher'].includes(w.type)),
         parallel: false,
-        learning: true
+        learning: true,
       },
       {
         name: 'Implementation Phase',
-        tasks: [
-          'Implement optimized solution',
-          'Apply learned patterns',
-          'Validate improvements'
-        ],
+        tasks: ['Implement optimized solution', 'Apply learned patterns', 'Validate improvements'],
         workers: workers,
         parallel: true,
-        applyLearning: true
-      }
+        applyLearning: true,
+      },
     ];
-    
+
     return {
       strategy: 'adaptive_learning',
       phases: learningPhases,
       estimatedDuration: 45,
       parallelism: 'adaptive',
-      learningEnabled: true
+      learningEnabled: true,
     };
   }
-  
+
   /**
    * Generate component-specific tasks
    */
@@ -464,109 +471,103 @@ export class QueenCoordinator extends EventEmitter {
         'Design API endpoints',
         'Implement business logic',
         'Set up database models',
-        'Create API tests'
+        'Create API tests',
       ],
       frontend: [
         'Design UI components',
         'Implement user interface',
         'Add interactivity',
-        'Create UI tests'
+        'Create UI tests',
       ],
       data: [
         'Design data schema',
         'Implement data access layer',
         'Set up caching',
-        'Optimize queries'
+        'Optimize queries',
       ],
       auth: [
         'Design authentication flow',
         'Implement auth middleware',
         'Add authorization checks',
-        'Test security'
-      ]
+        'Test security',
+      ],
     };
-    
-    return taskTemplates[component] || [
-      `Design ${component}`,
-      `Implement ${component}`,
-      `Test ${component}`
-    ];
+
+    return (
+      taskTemplates[component] || [
+        `Design ${component}`,
+        `Implement ${component}`,
+        `Test ${component}`,
+      ]
+    );
   }
-  
+
   /**
    * Generate all tasks based on analysis
    */
   _generateAllTasks(analysis) {
     const tasks = [];
     const components = this._identifyComponents(analysis.objective);
-    
+
     // Add general tasks
-    tasks.push(
-      'Analyze requirements',
-      'Design architecture',
-      'Set up project structure'
-    );
-    
+    tasks.push('Analyze requirements', 'Design architecture', 'Set up project structure');
+
     // Add component tasks
-    components.forEach(component => {
+    components.forEach((component) => {
       tasks.push(...this._generateComponentTasks(component));
     });
-    
+
     // Add integration tasks
-    tasks.push(
-      'Integrate components',
-      'Write tests',
-      'Document solution'
-    );
-    
+    tasks.push('Integrate components', 'Write tests', 'Document solution');
+
     return tasks;
   }
-  
+
   /**
    * Group workers by type
    */
   _groupWorkersByType(workers) {
     const groups = {};
-    
-    workers.forEach(worker => {
+
+    workers.forEach((worker) => {
       if (!groups[worker.type]) {
         groups[worker.type] = [];
       }
       groups[worker.type].push(worker);
     });
-    
+
     return groups;
   }
-  
+
   /**
    * Optimize worker assignment for tasks
    */
   _optimizeWorkerAssignment(tasks, workerGroups) {
     const assignments = {};
-    
-    tasks.forEach(task => {
+
+    tasks.forEach((task) => {
       const bestWorkerType = this._findBestWorkerType(task);
       const availableWorkers = workerGroups[bestWorkerType] || [];
-      
+
       if (availableWorkers.length > 0) {
         // Round-robin assignment within type
-        const workerIndex = Object.keys(assignments).filter(
-          t => assignments[t].type === bestWorkerType
-        ).length % availableWorkers.length;
-        
+        const workerIndex =
+          Object.keys(assignments).filter((t) => assignments[t].type === bestWorkerType).length %
+          availableWorkers.length;
+
         assignments[task] = availableWorkers[workerIndex];
       }
     });
-    
+
     return assignments;
   }
-  
+
   /**
    * Find best worker type for task
    */
   _findBestWorkerType(task) {
     const taskLower = task.toLowerCase();
-    
+
     if (taskLower.includes('research') || taskLower.includes('analyze')) {
       return 'researcher';
     }
@@ -585,40 +586,47 @@ export class QueenCoordinator extends EventEmitter {
     if (taskLower.includes('document') || taskLower.includes('write')) {
       return 'documenter';
     }
-    
+
     return 'coder'; // Default
   }
-  
+
   /**
    * Identify decision points in objective
    */
   _identifyDecisionPoints(analysis) {
     const decisionKeywords = [
-      'choose', 'select', 'decide', 'option', 'approach',
-      'strategy', 'method', 'solution', 'alternative'
+      'choose',
+      'select',
+      'decide',
+      'option',
+      'approach',
+      'strategy',
+      'method',
+      'solution',
+      'alternative',
     ];
-    
+
     const decisions = [];
     const components = this._identifyComponents(analysis.objective);
-    
+
     // Architecture decisions
     if (components.length > 2) {
       decisions.push('Architecture pattern selection');
     }
-    
+
     // Technology decisions
-    components.forEach(component => {
+    components.forEach((component) => {
       decisions.push(`Technology stack for ${component}`);
     });
-    
+
     // Implementation decisions
     if (analysis.complexity !== 'low') {
       decisions.push('Implementation approach');
     }
-    
+
     return decisions;
   }
-  
+
   /**
    * Make strategic decision
    */
@@ -628,24 +636,24 @@ export class QueenCoordinator extends EventEmitter {
       options,
       workerVotes,
       queenVote: this._calculateQueenVote(topic, options, workerVotes),
-      timestamp: Date.now()
+      timestamp: Date.now(),
     };
-    
+
     // Calculate final decision with queen's weighted vote
     const finalDecision = this._calculateFinalDecision(decision);
-    
+
     decision.result = finalDecision;
     this.state.decisionsCount++;
-    
+
     // Learn from decision
     if (this.config.type === 'adaptive') {
       this._learnFromDecision(decision);
     }
-    
+
     this.emit('decision:made', decision);
     return decision;
   }
-  
+
   /**
    * Calculate queen's vote
    */
@@ -654,109 +662,111 @@ export class QueenCoordinator extends EventEmitter {
     if (this.config.type === 'strategic') {
       return this._strategicVote(topic, options);
     }
-    
+
     // Tactical queen focuses on immediate efficiency
     if (this.config.type === 'tactical') {
       return this._tacticalVote(topic, options, workerVotes);
     }
-    
+
     // Adaptive queen learns from past decisions
     if (this.config.type === 'adaptive') {
       return this._adaptiveVote(topic, options, workerVotes);
     }
-    
+
     return options[0]; // Default
   }
-  
+
   /**
    * Strategic voting logic
    */
   _strategicVote(topic, options) {
     // Prefer options that mention long-term benefits
     const strategicKeywords = ['scalable', 'maintainable', 'extensible', 'future'];
-    
+
     for (const option of options) {
       const optionLower = option.toLowerCase();
-      if (strategicKeywords.some(keyword => optionLower.includes(keyword))) {
+      if (strategicKeywords.some((keyword) => optionLower.includes(keyword))) {
         return option;
       }
     }
-    
+
     return options[0];
   }
-  
+
   /**
    * Tactical voting logic
    */
   _tacticalVote(topic, options, workerVotes) {
     // Follow majority if consensus is strong
     const voteCounts = {};
-    Object.values(workerVotes).forEach(vote => {
+    Object.values(workerVotes).forEach((vote) => {
       voteCounts[vote] = (voteCounts[vote] || 0) + 1;
     });
-    
+
     const sorted = Object.entries(voteCounts).sort((a, b) => b[1] - a[1]);
     if (sorted.length > 0 && sorted[0][1] > Object.keys(workerVotes).length * 0.6) {
       return sorted[0][0];
     }
-    
+
     // Otherwise, prefer quick implementation
     const tacticalKeywords = ['simple', 'quick', 'fast', 'efficient'];
-    
+
     for (const option of options) {
       const optionLower = option.toLowerCase();
-      if (tacticalKeywords.some(keyword => optionLower.includes(keyword))) {
+      if (tacticalKeywords.some((keyword) => optionLower.includes(keyword))) {
         return option;
       }
     }
-    
+
     return options[0];
   }
-  
+
   /**
    * Adaptive voting logic
    */
   _adaptiveVote(topic, options, workerVotes) {
     // Check if we've seen similar decisions before
-    const similarDecisions = Array.from(this.state.learningData.entries())
-      .filter(([key, value]) => key.includes('decision') && value.topic.includes(topic));
-    
+    const similarDecisions = Array.from(this.state.learningData.entries()).filter(
+      ([key, value]) => key.includes('decision') && value.topic.includes(topic),
+    );
+
     if (similarDecisions.length > 0) {
       // Use learned preferences
       const successfulOptions = similarDecisions
         .filter(([_, decision]) => decision.success)
         .map(([_, decision]) => decision.result);
-      
+
       for (const option of options) {
         if (successfulOptions.includes(option)) {
           return option;
         }
       }
     }
-    
+
     // Otherwise, explore new option
     return options[Math.floor(Math.random() * options.length)];
   }
-  
+
   /**
    * Calculate final decision with weighted votes
    */
   _calculateFinalDecision(decision) {
     const voteCounts = {};
-    
+
     // Count worker votes
-    Object.values(decision.workerVotes).forEach(vote => {
+    Object.values(decision.workerVotes).forEach((vote) => {
       voteCounts[vote] = (voteCounts[vote] || 0) + 1;
     });
-    
+
     // Add queen's weighted vote
-    voteCounts[decision.queenVote] = (voteCounts[decision.queenVote] || 0) + this.config.decisionWeight;
-    
+    voteCounts[decision.queenVote] =
+      (voteCounts[decision.queenVote] || 0) + this.config.decisionWeight;
+
     // Find winner
     const sorted = Object.entries(voteCounts).sort((a, b) => b[1] - a[1]);
     return sorted[0][0];
   }
-  
+
   /**
    * Learn from decision outcomes
    */
@@ -764,24 +774,24 @@ export class QueenCoordinator extends EventEmitter {
     const key = `decision-${this.state.decisionsCount}`;
     this.state.learningData.set(key, {
       ...decision,
-      success: true // Will be updated based on outcome
+      success: true, // Will be updated based on outcome
     });
   }
-  
+
   /**
    * Update decision outcome
    */
   updateDecisionOutcome(decisionId, success, metrics = {}) {
     const key = `decision-${decisionId}`;
     const decision = this.state.learningData.get(key);
-    
+
     if (decision) {
       decision.success = success;
       decision.metrics = metrics;
       this.emit('learning:updated', { decisionId, success, metrics });
     }
   }
-  
+
   /**
    * Get queen status
    */
@@ -793,7 +803,7 @@ export class QueenCoordinator extends EventEmitter {
       decisionsCount: this.state.decisionsCount,
       strategiesExecuted: this.state.strategiesExecuted,
       currentStrategy: this.state.currentStrategy,
-      learningDataSize: this.state.learningData.size
+      learningDataSize: this.state.learningData.size,
     };
   }
-}
+}