snow-flow 1.4.49 → 2.0.0

package/src/agents/queen-agent.ts

@@ -0,0 +1,1399 @@
+/**
+ * Queen Agent Core with Enhanced 403 Error Handling
+ * Master coordinator that analyzes objectives and spawns specialized agents
+ * Works through Claude Code interface using TodoWrite for task coordination
+ * Now with intelligent 403 error handling using Gap Analysis Engine
+ */
+
+import { EventEmitter } from 'eventemitter3';
+import { TodoItem, TodoStatus } from '../types/todo.types';
+import { ServiceNowTask, Agent, AgentType, TaskAnalysis, DeploymentPattern } from '../queen/types';
+import { QueenMemorySystem } from '../queen/queen-memory';
+import { AgentCoordinator } from './coordinator';
+import { ParallelAgentEngine, ParallelizationOpportunity } from '../queen/parallel-agent-engine';
+import { Queen403Handler } from './queen-403-handler';
+import { Logger } from '../utils/logger';
+import * as crypto from 'crypto';
+
+export interface QueenAgentConfig {
+  memoryPath?: string;
+  maxConcurrentAgents?: number;
+  debugMode?: boolean;
+  autoSpawn?: boolean;
+  claudeCodeInterface?: boolean;
+  mcpTools?: any; // MCP tools for Gap Analysis
+}
+
+export interface QueenObjective {
+  id: string;
+  description: string;
+  priority?: 'low' | 'medium' | 'high' | 'critical';
+  constraints?: string[];
+  metadata?: Record<string, any>;
+}
+
+export interface TodoCoordination {
+  objectiveId: string;
+  todos: TodoItem[];
+  agentAssignments: Map<string, string>; // todoId -> agentId
+  dependencies: Map<string, string[]>; // todoId -> [dependencyIds]
+}
+
+export class QueenAgent extends EventEmitter {
+  private memory: QueenMemorySystem;
+  private coordinator: AgentCoordinator;
+  private parallelEngine: ParallelAgentEngine;
+  private handler403: Queen403Handler;
+  private config: Required<QueenAgentConfig>;
+  private activeObjectives: Map<string, QueenObjective>;
+  private todoCoordinations: Map<string, TodoCoordination>;
+  private activeAgents: Map<string, Agent>;
+  private logger: Logger;
+
+  constructor(config: QueenAgentConfig = {}) {
+    super();
+    
+    this.config = {
+      memoryPath: config.memoryPath,
+      maxConcurrentAgents: config.maxConcurrentAgents || 8,
+      debugMode: config.debugMode || false,
+      autoSpawn: config.autoSpawn !== false,
+      claudeCodeInterface: config.claudeCodeInterface !== false,
+      mcpTools: config.mcpTools || {}
+    };
+
+    // Initialize logger first
+    this.logger = new Logger('QueenAgent');
+
+    // Initialize core systems
+    this.memory = new QueenMemorySystem(this.config.memoryPath);
+    this.coordinator = new AgentCoordinator(this.memory);
+    this.parallelEngine = new ParallelAgentEngine(this.memory);
+    this.handler403 = new Queen403Handler(this.logger, this.config.mcpTools);
+    this.activeObjectives = new Map();
+    this.todoCoordinations = new Map();
+    this.activeAgents = new Map();
+
+    this.setupEventHandlers();
+    
+    if (this.config.debugMode) {
+      console.log('👑 Queen Agent initialized with Claude Code interface and 403 handling');
+    }
+  }
+
+  /**
+   * Update MCP tools configuration (useful when tools become available later)
+   */
+  updateMCPTools(mcpTools: any): void {
+    this.config.mcpTools = mcpTools;
+    this.handler403 = new Queen403Handler(this.logger, mcpTools);
+  }
+
+  /**
+   * Analyze objective and create coordinated execution plan
+   */
+  async analyzeObjective(objective: string | QueenObjective): Promise<TaskAnalysis> {
+    const queenObjective = typeof objective === 'string' 
+      ? { id: this.generateId('obj'), description: objective } 
+      : objective;
+
+    this.activeObjectives.set(queenObjective.id, queenObjective);
+    this.emit('objective:analyzing', queenObjective);
+
+    try {
+      // Analyze objective using memory patterns and neural learning
+      const _analysis = await this.performObjectiveAnalysis(queenObjective);
+      
+      // Store _analysis in memory for coordination
+      await this.memory.store(`analysis_${queenObjective.id}`, {
+        objective: queenObjective,
+        _analysis,
+        timestamp: new Date().toISOString()
+      });
+
+      // Create TodoWrite coordination structure
+      const todoCoordination = await this.createTodoCoordination(queenObjective, _analysis);
+      this.todoCoordinations.set(queenObjective.id, todoCoordination);
+
+      this.emit('objective:analyzed', { objective: queenObjective, _analysis, todos: todoCoordination.todos });
+      
+      return _analysis;
+
+    } catch (error) {
+      this.emit('objective:error', { objective: queenObjective, error });
+      throw error;
+    }
+  }
+
+  /**
+   * Handle deployment error with intelligent 403 detection and resolution
+   */
+  async handleDeploymentError(error: any, context: {
+    objectiveId: string;
+    agentId?: string;
+    operation: string;
+    artifactType?: string;
+    tableName?: string;
+  }): Promise<boolean> {
+    // Check if it's a 403 permission error
+    if (this.is403Error(error)) {
+      console.log('🚨 Queen Agent: Detected 403 permission error - activating intelligent _analysis');
+      
+      const objective = this.activeObjectives.get(context.objectiveId);
+      if (!objective) {
+        console.error('No objective found for error context');
+        return false;
+      }
+
+      // Use 403 handler with Gap Analysis
+      const result = await this.handler403.handle403Error({
+        error,
+        operation: context.operation,
+        tableName: context.tableName,
+        artifactType: context.artifactType,
+        objective: objective.description
+      });
+
+      // Update todos based on analysis
+      if (result.nextSteps.length > 0) {
+        await this.updateTodosWithPermissionFixes(context.objectiveId, result);
+      }
+
+      // If automatic fixes were applied, return true to retry
+      if (result.resolved) {
+        console.log('✅ Queen Agent: Automatic fixes applied - suggesting retry');
+        this.emit('permission:auto-fixed', { context, result });
+        return true;
+      }
+
+      // Emit event for manual intervention needed
+      this.emit('permission:manual-required', { context, result });
+      return false;
+    }
+
+    return false;
+  }
+
+  /**
+   * Check if error is a 403 permission error
+   */
+  private is403Error(error: any): boolean {
+    const errorStr = error?.toString() || '';
+    const errorMsg = error?.message || '';
+    const statusCode = error?.status || error?.statusCode || error?.response?.status;
+    
+    return statusCode === 403 || 
+           errorStr.includes('403') || 
+           errorMsg.includes('403') ||
+           errorMsg.includes('permission') ||
+           errorMsg.includes('access denied') ||
+           errorMsg.includes('insufficient privileges');
+  }
+
+  /**
+   * Update todos with permission fix steps
+   */
+  private async updateTodosWithPermissionFixes(
+    objectiveId: string, 
+    permissionResult: any
+  ): Promise<void> {
+    const todoCoordination = this.todoCoordinations.get(objectiveId);
+    if (!todoCoordination) return;
+
+    // Add new todos for permission fixes
+    const newTodos: TodoItem[] = [];
+
+    // Add retry todo if automatic fixes were applied
+    if (permissionResult.resolved) {
+      newTodos.push({
+        id: this.generateId('todo'),
+        content: '🔄 Retry deployment after automatic permission fixes',
+        status: 'pending',
+        priority: 'high'
+      });
+    }
+
+    // Add manual action todos
+    permissionResult.nextSteps.forEach((step: string) => {
+      newTodos.push({
+        id: this.generateId('todo'),
+        content: step,
+        status: 'pending',
+        priority: 'high'
+      });
+    });
+
+    // Insert new todos at the beginning of pending todos
+    const pendingIndex = todoCoordination.todos.findIndex(t => t.status === 'pending');
+    if (pendingIndex >= 0) {
+      todoCoordination.todos.splice(pendingIndex, 0, ...newTodos);
+    } else {
+      todoCoordination.todos.push(...newTodos);
+    }
+
+    // Emit update event
+    this.emit('todos:updated', { objectiveId, todos: todoCoordination.todos });
+  }
+
+  /**
+   * Spawn agents based on objective requirements with intelligent parallelization
+   */
+  async spawnAgents(objectiveId: string): Promise<Agent[]> {
+    const todoCoordination = this.todoCoordinations.get(objectiveId);
+    if (!todoCoordination) {
+      throw new Error(`No todo coordination found for objective: ${objectiveId}`);
+    }
+
+    const _analysis = await this.memory.get(`analysis_${objectiveId}`) as { _analysis: TaskAnalysis };
+    if (!_analysis) {
+      throw new Error(`No _analysis found for objective: ${objectiveId}`);
+    }
+
+    console.log('🧠 Queen Agent: Analyzing parallelization opportunities...');
+    
+    // 🚀 NEW: Detect parallelization opportunities
+    const opportunities = await this.parallelEngine.detectParallelizationOpportunities(
+      todoCoordination.todos,
+      _analysis._analysis.type,
+      Array.from(this.activeAgents.values())
+    );
+
+    if (opportunities.length > 0) {
+      console.log(`🎯 Found ${opportunities.length} parallelization opportunities!`);
+      return await this.spawnParallelAgents(objectiveId, todoCoordination, opportunities);
+    } else {
+      console.log('📋 No parallelization opportunities found, using sequential approach');
+      return await this.spawnSequentialAgents(objectiveId, todoCoordination, _analysis._analysis);
+    }
+  }
+
+  /**
+   * 🚀 NEW: Spawn parallel agents based on opportunities
+   */
+  private async spawnParallelAgents(
+    objectiveId: string,
+    todoCoordination: TodoCoordination,
+    opportunities: ParallelizationOpportunity[]
+  ): Promise<Agent[]> {
+    console.log('🚀 Queen Agent: Spawning parallel agent teams...');
+    
+    // Create execution plan
+    const executionPlan = await this.parallelEngine.createExecutionPlan(
+      opportunities,
+      todoCoordination.todos,
+      this.config.maxConcurrentAgents
+    );
+
+    // Execute the plan and get spawned agents
+    const result = await this.parallelEngine.executeParallelPlan(
+      executionPlan,
+      async (type: AgentType, specialization?: string) => {
+        return await this.spawnSpecializedAgent(type, objectiveId, specialization);
+      }
+    );
+
+    console.log(`✅ Spawned ${result.spawnedAgents.length} specialized agents in parallel`);
+    console.log(`⚡ Estimated speedup: ${result.executionDetails.estimatedSpeedup}`);
+
+    return result.spawnedAgents;
+  }
+
+  /**
+   * Fallback to sequential agent spawning
+   */
+  private async spawnSequentialAgents(
+    objectiveId: string,
+    todoCoordination: TodoCoordination,
+    _analysis: TaskAnalysis
+  ): Promise<Agent[]> {
+    const agents: Agent[] = [];
+    const requiredAgentTypes = new Set(_analysis.requiredAgents);
+
+    // Spawn agents for each required type
+    for (const agentType of requiredAgentTypes) {
+      const agent = await this.spawnSpecializedAgent(agentType, objectiveId);
+      agents.push(agent);
+    }
+
+    return agents;
+  }
+
+  /**
+   * Spawn a specialized agent with optional specialization
+   */
+  private async spawnSpecializedAgent(
+    type: AgentType, 
+    objectiveId: string,
+    specialization?: string
+  ): Promise<Agent> {
+    const agentId = this.generateId('agent');
+    
+    const agent: Agent = {
+      id: agentId,
+      type,
+      status: 'active',
+      objectiveId,
+      specialization,
+      startTime: Date.now(),
+      capabilities: [],
+      mcpTools: []
+    };
+
+    this.activeAgents.set(agentId, agent);
+    
+    // Store agent info in memory for coordination
+    await this.memory.store(`agent_${agentId}`, {
+      agent,
+      objective: this.activeObjectives.get(objectiveId),
+      assignedTodos: [],
+      status: 'initializing'
+    });
+
+    this.emit('agent:spawned', agent);
+    
+    // Assign todos to agent based on capabilities
+    await this.assignTodosToAgent(agent, objectiveId);
+
+    return agent;
+  }
+
+  /**
+   * Analyze objective to determine requirements
+   */
+  private async performObjectiveAnalysis(objective: QueenObjective): Promise<TaskAnalysis> {
+    const description = objective.description.toLowerCase();
+    
+    // Determine task type
+    let type: ServiceNowTask['type'] = 'unknown';
+    let requiredAgents: AgentType[] = [];
+    let estimatedComplexity = 5;
+    let suggestedPattern: DeploymentPattern = {
+      taskType: 'standard',
+      successRate: 0.8,
+      agentSequence: [],
+      mcpSequence: [],
+      avgDuration: 300,
+      lastUsed: new Date()
+    };
+    const dependencies: string[] = [];
+
+    // Portal page detection - check for specific page keywords
+    if ((description.includes('portal') && description.includes('page')) || 
+        description.includes('portal page') || 
+        (description.includes('widget') && description.includes('page')) ||
+        (description.includes('widget') && description.includes('plaats')) ||
+        (description.includes('widget') && description.includes('add')) ||
+        description.includes('service portal page')) {
+      type = 'portal_page';
+      requiredAgents = ['widget-creator', 'page-designer', 'script-writer', 'tester'];
+      if (description.includes('dashboard') || description.includes('multi')) {
+        estimatedComplexity = 8;
+        requiredAgents.push('ui-ux-specialist');
+      }
+    }
+    // Widget development detection (only if not portal page)
+    else if (description.includes('widget') || description.includes('ui component')) {
+      type = 'widget';
+      requiredAgents = ['widget-creator', 'script-writer', 'tester'];
+      if (description.includes('complex') || description.includes('interactive')) {
+        estimatedComplexity = 8;
+        requiredAgents.push('ui-ux-specialist');
+      }
+    }
+    
+    // Flow development detection
+    else if (description.includes('flow') || description.includes('workflow') || description.includes('automation')) {
+      type = 'flow';
+      requiredAgents = ['flow-builder', 'integration-specialist', 'tester'];
+      if (description.includes('approval')) {
+        requiredAgents.push('approval-specialist');
+        dependencies.push('user_management', 'notification_system');
+      }
+    }
+    
+    // Application development
+    else if (description.includes('application') || description.includes('app') || description.includes('complete solution')) {
+      type = 'application';
+      requiredAgents = ['app-architect', 'widget-creator', 'flow-builder', 'script-writer', 'tester'];
+      estimatedComplexity = 10;
+      suggestedPattern = {
+        taskType: 'modular',
+        successRate: 0.8,
+        agentSequence: requiredAgents,
+        mcpSequence: [],
+        avgDuration: 900,
+        lastUsed: new Date()
+      };
+    }
+    
+    // Script development
+    else if (description.includes('script') || description.includes('business rule') || description.includes('api')) {
+      type = 'script';
+      requiredAgents = ['script-writer', 'tester'];
+      if (description.includes('integration')) {
+        requiredAgents.push('integration-specialist');
+      }
+    }
+    
+    // Integration development
+    else if (description.includes('integration') || description.includes('connect') || description.includes('external')) {
+      type = 'integration';
+      requiredAgents = ['integration-specialist', 'script-writer', 'tester'];
+      dependencies.push('authentication', 'data_transformation');
+    }
+
+    // Add security agent if mentioned
+    if (description.includes('secure') || description.includes('security') || description.includes('permission')) {
+      requiredAgents.push('security-specialist');
+    }
+
+    return {
+      type,
+      complexity: estimatedComplexity.toString(),
+      requiredAgents: [...new Set(requiredAgents)], // Remove duplicates
+      estimatedComplexity: Math.min(10, Math.max(1, estimatedComplexity)),
+      suggestedPattern,
+      dependencies
+    };
+  }
+
+  /**
+   * Create todo coordination structure for Claude Code interface
+   */
+  private async createTodoCoordination(
+    objective: QueenObjective, 
+    _analysis: TaskAnalysis
+  ): Promise<TodoCoordination> {
+    const todos = this.generateTodosForObjective(objective, _analysis);
+    
+    const coordination: TodoCoordination = {
+      objectiveId: objective.id,
+      todos,
+      agentAssignments: new Map(),
+      dependencies: this.analyzeTodoDependencies(todos)
+    };
+
+    // Store coordination info in memory
+    await this.memory.store(`coordination_${objective.id}`, coordination);
+
+    return coordination;
+  }
+
+  /**
+   * Generate todos based on objective type
+   */
+  private generateTodosForObjective(objective: QueenObjective, _analysis: TaskAnalysis): TodoItem[] {
+    const baseTodos: TodoItem[] = [
+      {
+        id: this.generateId('todo'),
+        content: `Initialize swarm memory session for: ${objective.description}`,
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Validate ServiceNow authentication and permissions',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Check for existing similar artifacts',
+        status: 'pending',
+        priority: 'medium'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Create Update Set for tracking changes',
+        status: 'pending',
+        priority: 'high'
+      }
+    ];
+
+    // Add type-specific todos
+    switch (_analysis.type) {
+      case 'widget':
+        baseTodos.push(...this.createWidgetTodos(objective, _analysis));
+        break;
+      case 'portal_page':
+        baseTodos.push(...this.createPortalPageTodos(objective, _analysis));
+        break;
+      case 'flow':
+        baseTodos.push(...this.createFlowTodos(objective, _analysis));
+        break;
+      case 'application':
+        baseTodos.push(...this.createApplicationTodos(objective, _analysis));
+        break;
+      case 'script':
+        baseTodos.push(...this.createScriptTodos(objective, _analysis));
+        break;
+      case 'integration':
+        baseTodos.push(...this.createIntegrationTodos(objective, _analysis));
+        break;
+      default:
+        baseTodos.push(...this.createGenericTodos(objective, _analysis));
+    }
+
+    // Add final todos
+    baseTodos.push(
+      {
+        id: this.generateId('todo'),
+        content: 'Validate solution completeness',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Generate documentation and handoff materials',
+        status: 'pending',
+        priority: 'medium'
+      }
+    );
+
+    return baseTodos;
+  }
+
+  /**
+   * Create widget-specific todos
+   */
+  private createWidgetTodos(objective: QueenObjective, _analysis: TaskAnalysis): TodoItem[] {
+    // 🚀 ENHANCED: More specific todos to trigger parallel agent specialization
+    const todos: TodoItem[] = [
+      {
+        id: this.generateId('todo'),
+        content: `Analyze portal requirements and user experience design: ${objective.description}`,
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Create widget HTML structure with responsive design and accessibility features',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Develop server-side script for backend data processing and API integration',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Build client-side controller with interactive features and event handling',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Style widget with CSS including responsive design and theme compliance',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Implement performance optimization and caching strategies',
+        status: 'pending',
+        priority: 'medium'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Test widget functionality including cross-browser and mobile testing',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Ensure security best practices and vulnerability scanning',
+        status: 'pending',
+        priority: 'high'
+      }
+    ];
+
+    return todos;
+  }
+
+  /**
+   * Create portal page-specific todos
+   */
+  private createPortalPageTodos(objective: QueenObjective, _analysis: TaskAnalysis): TodoItem[] {
+    const todos: TodoItem[] = [
+      {
+        id: this.generateId('todo'),
+        content: `Analyze portal page requirements: ${objective.description}`,
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Create or identify widget to be placed on the page',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Design portal page layout (single column, multi-column, or with sidebar)',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Determine target portal (Service Portal or Employee Service Center)',
+        status: 'pending',
+        priority: 'medium'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Create portal page with proper page ID and title',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Configure page structure (containers, rows, columns)',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Place widget instance on the portal page with proper sizing',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Apply custom CSS styling for page layout and responsiveness',
+        status: 'pending',
+        priority: 'medium'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Configure page permissions and accessibility settings',
+        status: 'pending',
+        priority: 'medium'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Test portal page across different devices and browsers',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Add page to portal navigation menu if needed',
+        status: 'pending',
+        priority: 'low'
+      }
+    ];
+
+    return todos;
+  }
+
+  /**
+   * Create flow-specific todos
+   */
+  private createFlowTodos(objective: QueenObjective, _analysis: TaskAnalysis): TodoItem[] {
+    const todos: TodoItem[] = [
+      {
+        id: this.generateId('todo'),
+        content: `Analyze flow requirements: ${objective.description}`,
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Design flow trigger conditions and events',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Map out flow steps and decision points',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Configure flow actions and integrations',
+        status: 'pending',
+        priority: 'medium'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Set up data transformations and variables',
+        status: 'pending',
+        priority: 'medium'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Create flow using natural language API',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Test flow with mock data scenarios',
+        status: 'pending',
+        priority: 'high'
+      }
+    ];
+
+    return todos;
+  }
+
+  /**
+   * Create application-specific todos
+   */
+  private createApplicationTodos(objective: QueenObjective, _analysis: TaskAnalysis): TodoItem[] {
+    const todos: TodoItem[] = [
+      {
+        id: this.generateId('todo'),
+        content: `Design application architecture: ${objective.description}`,
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Create application scope and structure',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Design data model and tables',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Create UI components and widgets',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Implement business logic and workflows',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Configure security and access controls',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Create integration points',
+        status: 'pending',
+        priority: 'medium'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Test application end-to-end',
+        status: 'pending',
+        priority: 'high'
+      }
+    ];
+
+    return todos;
+  }
+
+  /**
+   * Create script-specific todos
+   */
+  private createScriptTodos(objective: QueenObjective, _analysis: TaskAnalysis): TodoItem[] {
+    const todos: TodoItem[] = [
+      {
+        id: this.generateId('todo'),
+        content: `Analyze script requirements: ${objective.description}`,
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Design script logic and error handling',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Implement core functionality',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Add logging and debugging capabilities',
+        status: 'pending',
+        priority: 'medium'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Optimize performance',
+        status: 'pending',
+        priority: 'medium'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Create unit tests',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Deploy and validate in ServiceNow',
+        status: 'pending',
+        priority: 'high'
+      }
+    ];
+
+    return todos;
+  }
+
+  /**
+   * Create integration-specific todos
+   */
+  private createIntegrationTodos(objective: QueenObjective, _analysis: TaskAnalysis): TodoItem[] {
+    const todos: TodoItem[] = [
+      {
+        id: this.generateId('todo'),
+        content: `Analyze integration requirements: ${objective.description}`,
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Identify external systems and APIs',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Design data mapping and transformation',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Configure authentication and security',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Create REST/SOAP message configurations',
+        status: 'pending',
+        priority: 'medium'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Implement error handling and retry logic',
+        status: 'pending',
+        priority: 'medium'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Test integration with mock endpoints',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Deploy and monitor integration',
+        status: 'pending',
+        priority: 'high'
+      }
+    ];
+
+    return todos;
+  }
+
+  /**
+   * Create generic todos for unknown task types
+   */
+  private createGenericTodos(objective: QueenObjective, _analysis: TaskAnalysis): TodoItem[] {
+    const todos: TodoItem[] = [
+      {
+        id: this.generateId('todo'),
+        content: `Analyze requirements: ${objective.description}`,
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Research existing ServiceNow capabilities',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Design solution architecture',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Implement core functionality',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Create necessary configurations',
+        status: 'pending',
+        priority: 'medium'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Test solution thoroughly',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Deploy to ServiceNow',
+        status: 'pending',
+        priority: 'high'
+      },
+      {
+        id: this.generateId('todo'),
+        content: 'Monitor and validate deployment',
+        status: 'pending',
+        priority: 'medium'
+      }
+    ];
+
+    return todos;
+  }
+
+  /**
+   * Analyze todo dependencies
+   */
+  private analyzeTodoDependencies(todos: TodoItem[]): Map<string, string[]> {
+    const dependencies = new Map<string, string[]>();
+    
+    // Simple dependency _analysis - each todo depends on all previous high priority todos
+    const highPriorityTodos = todos.filter(t => t.priority === 'high');
+    
+    highPriorityTodos.forEach((todo, index) => {
+      if (index > 0) {
+        const prevHighPriorityIds = highPriorityTodos
+          .slice(0, index)
+          .map(t => t.id);
+        dependencies.set(todo.id, prevHighPriorityIds);
+      }
+    });
+
+    return dependencies;
+  }
+
+  /**
+   * Assign todos to agent based on capabilities
+   */
+  private async assignTodosToAgent(agent: Agent, objectiveId: string): Promise<void> {
+    const todoCoordination = this.todoCoordinations.get(objectiveId);
+    if (!todoCoordination) return;
+
+    const unassignedTodos = todoCoordination.todos.filter(todo => 
+      !Array.from(todoCoordination.agentAssignments.values()).includes(todo.id) &&
+      todo.status === 'pending'
+    );
+
+    // Assign todos based on agent type and specialization
+    const assignableTodos = unassignedTodos.filter(todo => 
+      this.canAgentHandleTodo(agent, todo)
+    );
+
+    for (const todo of assignableTodos) {
+      todoCoordination.agentAssignments.set(todo.id, agent.id);
+      
+      // Update agent's assigned todos in memory
+      const agentData = await this.memory.get(`agent_${agent.id}`) as any;
+      if (agentData) {
+        agentData.assignedTodos.push(todo.id);
+        await this.memory.store(`agent_${agent.id}`, agentData);
+      }
+    }
+
+    this.emit('todos:assigned', { agent, todos: assignableTodos });
+  }
+
+  /**
+   * Check if agent can handle specific todo
+   */
+  private canAgentHandleTodo(agent: Agent, todo: TodoItem): boolean {
+    const todoContent = todo.content.toLowerCase();
+    
+    switch (agent.type) {
+      case 'widget-creator':
+        return todoContent.includes('widget') || 
+               todoContent.includes('html') || 
+               todoContent.includes('portal') ||
+               todoContent.includes('ui');
+               
+      case 'css-specialist':
+        return todoContent.includes('style') || 
+               todoContent.includes('css') || 
+               todoContent.includes('responsive') ||
+               todoContent.includes('theme');
+               
+      case 'backend-specialist':
+        return todoContent.includes('server') || 
+               todoContent.includes('backend') || 
+               todoContent.includes('data') ||
+               todoContent.includes('api');
+               
+      case 'frontend-specialist':
+        return todoContent.includes('client') || 
+               todoContent.includes('controller') || 
+               todoContent.includes('interactive') ||
+               todoContent.includes('event');
+               
+      case 'flow-builder':
+        return todoContent.includes('flow') || 
+               todoContent.includes('workflow') ||
+               todoContent.includes('trigger') ||
+               todoContent.includes('action');
+               
+      case 'script-writer':
+        return todoContent.includes('script') || 
+               todoContent.includes('logic') ||
+               todoContent.includes('function');
+               
+      case 'integration-specialist':
+        return todoContent.includes('integration') || 
+               todoContent.includes('external') ||
+               todoContent.includes('api') ||
+               todoContent.includes('rest');
+               
+      case 'tester':
+        return todoContent.includes('test') || 
+               todoContent.includes('validate') ||
+               todoContent.includes('verify');
+               
+      case 'security-specialist':
+        return todoContent.includes('security') || 
+               todoContent.includes('permission') ||
+               todoContent.includes('access') ||
+               todoContent.includes('vulnerability');
+               
+      case 'performance-specialist':
+        return todoContent.includes('performance') || 
+               todoContent.includes('optimization') ||
+               todoContent.includes('caching');
+               
+      case 'ui-ux-specialist':
+        return todoContent.includes('user experience') || 
+               todoContent.includes('design') ||
+               todoContent.includes('ux');
+               
+      case 'page-designer':
+        return todoContent.includes('portal page') || 
+               todoContent.includes('page layout') ||
+               todoContent.includes('page structure') ||
+               todoContent.includes('place widget') ||
+               todoContent.includes('configure page') ||
+               todoContent.includes('containers') ||
+               todoContent.includes('rows') ||
+               todoContent.includes('columns') ||
+               todoContent.includes('page permissions') ||
+               todoContent.includes('portal navigation');
+               
+      default:
+        // Generic agents can handle setup and coordination tasks
+        return todoContent.includes('initialize') || 
+               todoContent.includes('validate') ||
+               todoContent.includes('create update set') ||
+               todoContent.includes('documentation');
+    }
+  }
+
+  /**
+   * Monitor agent progress through todo updates
+   */
+  async monitorProgress(objectiveId: string): Promise<{
+    overall: number;
+    byAgent: Map<string, number>;
+    blockingIssues: string[];
+    estimatedCompletion: Date;
+  }> {
+    const todoCoordination = this.todoCoordinations.get(objectiveId);
+    if (!todoCoordination) {
+      throw new Error(`No todo coordination found for objective: ${objectiveId}`);
+    }
+
+    // Calculate progress from todos
+    const completedTodos = todoCoordination.todos.filter(t => t.status === 'completed').length;
+    const totalTodos = todoCoordination.todos.length;
+    const overallProgress = totalTodos > 0 ? (completedTodos / totalTodos) * 100 : 0;
+
+    // Calculate per-agent progress
+    const byAgent = new Map<string, number>();
+    for (const [todoId, agentId] of todoCoordination.agentAssignments) {
+      const agentTodos = Array.from(todoCoordination.agentAssignments.entries())
+        .filter(([_, aid]) => aid === agentId);
+      const agentCompleted = agentTodos.filter(([tid, _]) => 
+        todoCoordination.todos.find(t => t.id === tid)?.status === 'completed'
+      ).length;
+      const agentProgress = agentTodos.length > 0 ? (agentCompleted / agentTodos.length) * 100 : 0;
+      byAgent.set(agentId, agentProgress);
+    }
+
+    // Identify blocking issues
+    const blockingIssues = await this.identifyBlockingIssues(todoCoordination);
+
+    // Estimate completion based on current velocity
+    const estimatedCompletion = this.estimateCompletion(todoCoordination, overallProgress);
+
+    // Store progress in memory
+    await this.memory.store(`progress_${objectiveId}`, {
+      overall: overallProgress,
+      byAgent: Object.fromEntries(byAgent),
+      blockingIssues,
+      estimatedCompletion: estimatedCompletion.toISOString(),
+      timestamp: new Date().toISOString()
+    });
+
+    this.emit('progress:updated', { objectiveId, overall: overallProgress, byAgent, blockingIssues });
+
+    return {
+      overall: overallProgress,
+      byAgent,
+      blockingIssues,
+      estimatedCompletion
+    };
+  }
+
+  /**
+   * Make memory-driven decisions based on past patterns
+   */
+  async makeDecision(context: {
+    objective: string;
+    currentState: any;
+    options: string[];
+  }): Promise<{
+    decision: string;
+    confidence: number;
+    reasoning: string;
+  }> {
+    // Query memory for similar past decisions
+    const similarPatterns = await this.memory.findSimilarPatterns(context.objective);
+    
+    // Analyze success rates of past decisions
+    const successRates = new Map<string, number>();
+    for (const option of context.options) {
+      const pastOutcomes = similarPatterns.filter(p => p.decision === option);
+      const successRate = pastOutcomes.length > 0 
+        ? pastOutcomes.filter(p => p.outcome === 'success').length / pastOutcomes.length
+        : 0.5; // Default to 50% if no history
+      successRates.set(option, successRate);
+    }
+
+    // Choose option with highest success rate
+    let bestOption = context.options[0];
+    let highestRate = 0;
+    
+    for (const [option, rate] of successRates) {
+      if (rate > highestRate) {
+        highestRate = rate;
+        bestOption = option;
+      }
+    }
+
+    const confidence = highestRate > 0.7 ? 0.9 : highestRate > 0.5 ? 0.7 : 0.5;
+    
+    const decision = {
+      decision: bestOption,
+      confidence,
+      reasoning: `Based on ${similarPatterns.length} similar past scenarios, "${bestOption}" has a ${(highestRate * 100).toFixed(0)}% success rate.`
+    };
+
+    // Store decision for future learning
+    await this.memory.storeDecision('decision', {
+      context,
+      decision: decision.decision,
+      confidence: decision.confidence,
+      timestamp: new Date().toISOString()
+    });
+
+    this.emit('decision:made', decision);
+    
+    return decision;
+  }
+
+  /**
+   * Setup event handlers for coordination
+   */
+  private setupEventHandlers(): void {
+    // Handle agent lifecycle events
+    this.coordinator.on('agent:ready', async (data) => {
+      console.log(`✅ Agent ${data.agentId} ready for tasks`);
+      await this.assignTodosToAgent(
+        this.activeAgents.get(data.agentId)!,
+        data.objectiveId
+      );
+    });
+
+    this.coordinator.on('agent:completed', async (data) => {
+      console.log(`✅ Agent ${data.agentId} completed all tasks`);
+      this.activeAgents.delete(data.agentId);
+      
+      // Check if we need to spawn more agents
+      if (this.config.autoSpawn) {
+        await this.checkAndSpawnAgents(data.objectiveId);
+      }
+    });
+
+    this.coordinator.on('agent:error', async (data) => {
+      console.error(`❌ Agent ${data.agentId} encountered error:`, data.error);
+      
+      // Handle 403 errors specifically
+      if (this.is403Error(data.error)) {
+        const handled = await this.handleDeploymentError(data.error, {
+          objectiveId: data.objectiveId,
+          agentId: data.agentId,
+          operation: 'deployment',
+          artifactType: data.artifactType
+        });
+
+        if (handled) {
+          // Retry the agent's task
+          this.emit('agent:retry', data);
+        }
+      }
+    });
+  }
+
+  /**
+   * Check if more agents need to be spawned
+   */
+  private async checkAndSpawnAgents(objectiveId: string): Promise<void> {
+    const todoCoordination = this.todoCoordinations.get(objectiveId);
+    if (!todoCoordination) return;
+
+    const unassignedTodos = todoCoordination.todos.filter(todo => 
+      !Array.from(todoCoordination.agentAssignments.values()).includes(todo.id) &&
+      todo.status === 'pending'
+    );
+
+    if (unassignedTodos.length > 0 && this.activeAgents.size < this.config.maxConcurrentAgents) {
+      // Spawn additional agents if needed
+      await this.spawnAgents(objectiveId);
+    }
+  }
+
+  /**
+   * Handle coordination errors
+   */
+  private async handleCoordinationError(error: any, context: any): Promise<void> {
+    console.error('❌ Coordination error:', error);
+    
+    // Store error in memory for learning - using store method
+    await this.memory.store('error', {
+      error: error.message || error,
+      context,
+      timestamp: new Date().toISOString(),
+      recovery: null
+    });
+
+    this.emit('coordination:error', { error, context });
+  }
+
+  /**
+   * Identify blocking issues from todos
+   */
+  private async identifyBlockingIssues(todoCoordination: TodoCoordination): Promise<string[]> {
+    const issues: string[] = [];
+    
+    // Check for failed todos
+    const failedTodos = todoCoordination.todos.filter(t => t.status === 'failed' as TodoStatus);
+    if (failedTodos.length > 0) {
+      issues.push(`${failedTodos.length} failed tasks blocking progress`);
+    }
+
+    // Check for stuck in-progress todos (older than 10 minutes)
+    const stuckTodos = todoCoordination.todos.filter(t => {
+      if (t.status !== 'in_progress') return false;
+      const todoData = this.memory.get(`todo_${t.id}`) as any;
+      if (!todoData || !todoData.startTime) return false;
+      return Date.now() - todoData.startTime > 10 * 60 * 1000; // 10 minutes
+    });
+    
+    if (stuckTodos.length > 0) {
+      issues.push(`${stuckTodos.length} tasks stuck in progress`);
+    }
+
+    // Check for dependency bottlenecks
+    const pendingWithDeps = todoCoordination.todos.filter(t => 
+      t.status === 'pending' &&
+      todoCoordination.dependencies.has(t.id)
+    );
+    
+    for (const todo of pendingWithDeps) {
+      const deps = todoCoordination.dependencies.get(todo.id) || [];
+      const incompleteDeps = deps.filter(depId => {
+        const depTodo = todoCoordination.todos.find(t => t.id === depId);
+        return depTodo && depTodo.status !== 'completed';
+      });
+      
+      if (incompleteDeps.length === deps.length) {
+        issues.push(`Task "${todo.content}" blocked by dependencies`);
+      }
+    }
+
+    return issues;
+  }
+
+  /**
+   * Estimate completion time based on current progress
+   */
+  private estimateCompletion(todoCoordination: TodoCoordination, currentProgress: number): Date {
+    if (currentProgress === 0) {
+      return new Date(Date.now() + 24 * 60 * 60 * 1000); // 24 hours if no progress
+    }
+
+    const completedTodos = todoCoordination.todos.filter(t => t.status === 'completed').length;
+    const startTime = this.activeObjectives.get(todoCoordination.objectiveId)?.metadata?.startTime || Date.now();
+    const elapsedTime = Date.now() - startTime;
+    
+    const averageTimePerTodo = elapsedTime / completedTodos;
+    const remainingTodos = todoCoordination.todos.filter(t => t.status !== 'completed').length;
+    const estimatedRemainingTime = averageTimePerTodo * remainingTodos;
+
+    return new Date(Date.now() + estimatedRemainingTime);
+  }
+
+  /**
+   * Generate unique ID for entities
+   */
+  private generateId(prefix: string): string {
+    return `${prefix}_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
+  }
+
+  /**
+   * Shutdown queen agent gracefully
+   */
+  async shutdown(): Promise<void> {
+    console.log('👑 Queen Agent shutting down...');
+    
+    // Save current state
+    for (const [objectiveId, objective] of this.activeObjectives) {
+      await this.memory.store(`objective_state_${objectiveId}`, {
+        objective,
+        todoCoordination: this.todoCoordinations.get(objectiveId),
+        activeAgents: Array.from(this.activeAgents.values()).filter(a => a.objectiveId === objectiveId),
+        timestamp: new Date().toISOString()
+      });
+    }
+
+    // Notify all active agents
+    for (const agent of this.activeAgents.values()) {
+      this.emit('agent:shutdown', agent);
+    }
+
+    await this.memory.close();
+    this.removeAllListeners();
+    
+    console.log('✅ Queen Agent shutdown complete');
+  }
+}