snow-flow 1.1.91 → 1.1.93

package/dist/agents/queen-agent.js

@@ -1,8 +1,9 @@
 "use strict";
 /**
- * Queen Agent Core
+ * 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
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -43,6 +44,8 @@ const eventemitter3_1 = require("eventemitter3");
 const queen_memory_1 = require("../queen/queen-memory");
 const coordinator_1 = require("./coordinator");
 const parallel_agent_engine_1 = require("../queen/parallel-agent-engine");
+const queen_403_handler_1 = require("./queen-403-handler");
+const logger_1 = require("../utils/logger");
 const crypto = __importStar(require("crypto"));
 class QueenAgent extends eventemitter3_1.EventEmitter {
     constructor(config = {}) {
@@ -52,20 +55,31 @@ class QueenAgent extends eventemitter3_1.EventEmitter {
             maxConcurrentAgents: config.maxConcurrentAgents || 8,
             debugMode: config.debugMode || false,
             autoSpawn: config.autoSpawn !== false,
-            claudeCodeInterface: config.claudeCodeInterface !== false
+            claudeCodeInterface: config.claudeCodeInterface !== false,
+            mcpTools: config.mcpTools || {}
         };
+        // Initialize logger first
+        this.logger = new logger_1.Logger('QueenAgent');
         // Initialize core systems
         this.memory = new queen_memory_1.QueenMemorySystem(this.config.memoryPath);
         this.coordinator = new coordinator_1.AgentCoordinator(this.memory);
         this.parallelEngine = new parallel_agent_engine_1.ParallelAgentEngine(this.memory);
+        this.handler403 = new queen_403_handler_1.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');
+            console.log('👑 Queen Agent initialized with Claude Code interface and 403 handling');
         }
     }
+    /**
+     * Update MCP tools configuration (useful when tools become available later)
+     */
+    updateMCPTools(mcpTools) {
+        this.config.mcpTools = mcpTools;
+        this.handler403 = new queen_403_handler_1.Queen403Handler(this.logger, mcpTools);
+    }
     /**
      * Analyze objective and create coordinated execution plan
      */
@@ -95,6 +109,94 @@ class QueenAgent extends eventemitter3_1.EventEmitter {
             throw error;
         }
     }
+    /**
+     * Handle deployment error with intelligent 403 detection and resolution
+     */
+    async handleDeploymentError(error, context) {
+        // 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
+     */
+    is403Error(error) {
+        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
+     */
+    async updateTodosWithPermissionFixes(objectiveId, permissionResult) {
+        const todoCoordination = this.todoCoordinations.get(objectiveId);
+        if (!todoCoordination)
+            return;
+        // Add new todos for permission fixes
+        const newTodos = [];
+        // 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) => {
+            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
      */
@@ -123,45 +225,19 @@ class QueenAgent extends eventemitter3_1.EventEmitter {
      * 🚀 NEW: Spawn parallel agents based on opportunities
      */
     async spawnParallelAgents(objectiveId, todoCoordination, opportunities) {
+        console.log('🚀 Queen Agent: Spawning parallel agent teams...');
         // Create execution plan
-        const plan = await this.parallelEngine.createExecutionPlan(opportunities, todoCoordination.todos, this.config.maxConcurrentAgents);
-        console.log(`🚀 Executing parallel plan with ${plan.agentTeam.length} specialized agents`);
-        // Execute parallel spawning
-        const result = await this.parallelEngine.executeParallelPlan(plan, async (type, specialization) => {
-            const agent = await this.spawnSpecializedAgent(type, objectiveId, specialization);
-            this.activeAgents.set(agent.id, agent);
-            return agent;
-        });
-        // Assign todos to parallel agents based on their workloads
-        for (const workload of plan.agentTeam) {
-            const agent = result.spawnedAgents.find(a => a.id === workload.agentId);
-            if (agent) {
-                // Advanced todo assignment based on workload specializations
-                this.assignTodosToParallelAgent(agent, todoCoordination, workload.assignedTodos, workload.specializations);
-            }
-        }
-        // Store parallel execution details
-        await this.memory.store(`parallel_agents_${objectiveId}`, {
-            planId: plan.planId,
-            agents: result.spawnedAgents.map(a => ({ id: a.id, type: a.type, capabilities: a.capabilities })),
-            executionDetails: result.executionDetails,
-            parallelizationOpportunities: opportunities.length,
-            estimatedSpeedup: result.executionDetails.estimatedSpeedup,
-            timestamp: new Date().toISOString()
+        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, specialization) => {
+            return await this.spawnSpecializedAgent(type, objectiveId, specialization);
         });
-        console.log(`✅ Spawned ${result.spawnedAgents.length} parallel agents`);
+        console.log(`✅ Spawned ${result.spawnedAgents.length} specialized agents in parallel`);
         console.log(`⚡ Estimated speedup: ${result.executionDetails.estimatedSpeedup}`);
-        console.log(`🔀 Parallel workflows: ${result.executionDetails.parallelWorkflows}`);
-        this.emit('agents:spawned', {
-            objectiveId,
-            agents: result.spawnedAgents,
-            parallel: true,
-            speedup: result.executionDetails.estimatedSpeedup
-        });
         return result.spawnedAgents;
     }
     /**
-     * Fallback: Spawn sequential agents (original behavior)
+     * Fallback to sequential agent spawning
      */
     async spawnSequentialAgents(objectiveId, todoCoordination, analysis) {
         const agents = [];
@@ -170,170 +246,228 @@ class QueenAgent extends eventemitter3_1.EventEmitter {
         for (const agentType of requiredAgentTypes) {
             const agent = await this.spawnSpecializedAgent(agentType, objectiveId);
             agents.push(agent);
-            this.activeAgents.set(agent.id, agent);
-            // Assign todos to agent based on capabilities
-            this.assignTodosToAgent(agent, todoCoordination);
         }
-        // Update memory with agent spawning information
-        await this.memory.store(`agents_${objectiveId}`, {
-            agents: agents.map(a => ({ id: a.id, type: a.type, capabilities: a.capabilities })),
-            timestamp: new Date().toISOString()
-        });
-        this.emit('agents:spawned', { objectiveId, agents, parallel: false });
         return agents;
     }
     /**
-     * Monitor and coordinate agent progress
-     */
-    async monitorProgress(objectiveId) {
-        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();
-        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
+     * Spawn a specialized agent with optional specialization
      */
-    async makeDecision(context) {
-        // Query memory for similar past decisions
-        const similarPatterns = await this.memory.findSimilarPatterns(context.objective);
-        // Analyze success rates of different approaches
-        const optionScores = new Map();
-        for (const option of context.options) {
-            const score = this.calculateOptionScore(option, similarPatterns, context);
-            optionScores.set(option, score);
-        }
-        // Select best option
-        const bestOption = Array.from(optionScores.entries())
-            .sort((a, b) => b[1] - a[1])[0];
-        const decision = {
-            decision: bestOption[0],
-            reasoning: this.generateDecisionReasoning(bestOption[0], similarPatterns, context),
-            confidence: bestOption[1] / 100
+    async spawnSpecializedAgent(type, objectiveId, specialization) {
+        const agentId = this.generateId('agent');
+        const agent = {
+            id: agentId,
+            type,
+            status: 'active',
+            objectiveId,
+            specialization,
+            startTime: Date.now()
         };
-        // Store decision for future learning
-        await this.memory.storeDecision({
-            context,
-            decision: decision.decision,
-            confidence: decision.confidence,
-            timestamp: new Date().toISOString()
+        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('decision:made', decision);
-        return decision;
+        this.emit('agent:spawned', agent);
+        // Assign todos to agent based on capabilities
+        await this.assignTodosToAgent(agent, objectiveId);
+        return agent;
     }
     /**
-     * Create TodoWrite coordination structure
+     * Analyze objective to determine requirements
      */
-    async createTodoCoordination(objective, analysis) {
-        const todos = [];
-        const dependencies = new Map();
-        // Create high-level todos based on task analysis
-        if (analysis.type === 'widget') {
-            todos.push(...this.createWidgetTodos(objective, analysis));
+    async performObjectiveAnalysis(objective) {
+        const description = objective.description.toLowerCase();
+        // Determine task type
+        let type = 'generic';
+        let requiredAgents = [];
+        let estimatedComplexity = 5;
+        let suggestedPattern = 'standard';
+        let dependencies = [];
+        // Widget development detection
+        if (description.includes('widget') || description.includes('portal') || 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');
+            }
         }
-        else if (analysis.type === 'flow') {
-            todos.push(...this.createFlowTodos(objective, analysis));
+        // 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 = 'modular';
         }
-        else if (analysis.type === 'script') {
-            todos.push(...this.createScriptTodos(objective, analysis));
+        // 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');
+            }
         }
-        else if (analysis.type === 'integration') {
-            todos.push(...this.createIntegrationTodos(objective, analysis));
+        // 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');
         }
-        else {
-            todos.push(...this.createGenericTodos(objective, analysis));
+        // Add security agent if mentioned
+        if (description.includes('secure') || description.includes('security') || description.includes('permission')) {
+            requiredAgents.push('security-specialist');
         }
-        // Set up dependencies based on logical flow
-        this.setupTodoDependencies(todos, dependencies);
         return {
-            taskId: objective.id,
+            type,
+            complexity: estimatedComplexity,
+            requiredAgents: [...new Set(requiredAgents)], // Remove duplicates
+            estimatedComplexity: Math.min(10, Math.max(1, estimatedComplexity)),
+            suggestedPattern,
+            dependencies
+        };
+    }
+    /**
+     * Create todo coordination structure for Claude Code interface
+     */
+    async createTodoCoordination(objective, analysis) {
+        const todos = this.generateTodosForObjective(objective, analysis);
+        const coordination = {
+            objectiveId: objective.id,
             todos,
             agentAssignments: new Map(),
-            dependencies
+            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
+     */
+    generateTodosForObjective(objective, analysis) {
+        const baseTodos = [
+            {
+                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 '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
      */
     createWidgetTodos(objective, analysis) {
+        // 🚀 ENHANCED: More specific todos to trigger parallel agent specialization
         const todos = [
             {
                 id: this.generateId('todo'),
-                content: `Analyze widget requirements: ${objective.description}`,
+                content: `Analyze portal requirements and user experience design: ${objective.description}`,
                 status: 'pending',
                 priority: 'high'
             },
             {
                 id: this.generateId('todo'),
-                content: 'Design widget HTML template structure',
+                content: 'Create widget HTML structure with responsive design and accessibility features',
                 status: 'pending',
                 priority: 'high'
             },
             {
                 id: this.generateId('todo'),
-                content: 'Implement server-side data processing logic',
+                content: 'Develop server-side script for backend data processing and API integration',
                 status: 'pending',
                 priority: 'high'
             },
             {
                 id: this.generateId('todo'),
-                content: 'Create client-side controller script',
+                content: 'Build client-side controller with interactive features and event handling',
                 status: 'pending',
-                priority: 'medium'
+                priority: 'high'
             },
             {
                 id: this.generateId('todo'),
-                content: 'Style widget with responsive CSS',
+                content: 'Style widget with CSS including responsive design and theme compliance',
                 status: 'pending',
-                priority: 'medium'
+                priority: 'high'
             },
             {
                 id: this.generateId('todo'),
-                content: 'Test widget functionality with mock data',
+                content: 'Implement performance optimization and caching strategies',
                 status: 'pending',
                 priority: 'medium'
             },
             {
                 id: this.generateId('todo'),
-                content: 'Deploy widget to ServiceNow instance',
+                content: 'Test widget functionality including cross-browser and mobile testing',
                 status: 'pending',
                 priority: 'high'
             },
             {
                 id: this.generateId('todo'),
-                content: 'Validate deployment and run integration tests',
+                content: 'Ensure security best practices and vulnerability scanning',
                 status: 'pending',
                 priority: 'high'
             }
@@ -383,13 +517,63 @@ class QueenAgent extends eventemitter3_1.EventEmitter {
             },
             {
                 id: this.generateId('todo'),
-                content: 'Test flow with mock scenarios',
+                content: 'Test flow with mock data scenarios',
+                status: 'pending',
+                priority: 'high'
+            }
+        ];
+        return todos;
+    }
+    /**
+     * Create application-specific todos
+     */
+    createApplicationTodos(objective, analysis) {
+        const todos = [
+            {
+                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: 'Deploy and activate flow',
+                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'
             }
@@ -407,12 +591,6 @@ class QueenAgent extends eventemitter3_1.EventEmitter {
                 status: 'pending',
                 priority: 'high'
             },
-            {
-                id: this.generateId('todo'),
-                content: 'Determine script type (Business Rule, Script Include, etc.)',
-                status: 'pending',
-                priority: 'high'
-            },
             {
                 id: this.generateId('todo'),
                 content: 'Design script logic and error handling',
@@ -421,7 +599,7 @@ class QueenAgent extends eventemitter3_1.EventEmitter {
             },
             {
                 id: this.generateId('todo'),
-                content: 'Implement core business logic',
+                content: 'Implement core functionality',
                 status: 'pending',
                 priority: 'high'
             },
@@ -433,19 +611,19 @@ class QueenAgent extends eventemitter3_1.EventEmitter {
             },
             {
                 id: this.generateId('todo'),
-                content: 'Create unit tests for script functions',
+                content: 'Optimize performance',
                 status: 'pending',
                 priority: 'medium'
             },
             {
                 id: this.generateId('todo'),
-                content: 'Deploy script to ServiceNow',
+                content: 'Create unit tests',
                 status: 'pending',
                 priority: 'high'
             },
             {
                 id: this.generateId('todo'),
-                content: 'Validate script execution and performance',
+                content: 'Deploy and validate in ServiceNow',
                 status: 'pending',
                 priority: 'high'
             }
@@ -557,7 +735,7 @@ class QueenAgent extends eventemitter3_1.EventEmitter {
             },
             {
                 id: this.generateId('todo'),
-                content: 'Validate and document solution',
+                content: 'Monitor and validate deployment',
                 status: 'pending',
                 priority: 'medium'
             }
@@ -565,432 +743,331 @@ class QueenAgent extends eventemitter3_1.EventEmitter {
         return todos;
     }
     /**
-     * Set up logical dependencies between todos
+     * Analyze todo dependencies
      */
-    setupTodoDependencies(todos, dependencies) {
-        // For sequential tasks, each depends on the previous
-        for (let i = 1; i < todos.length; i++) {
-            dependencies.set(todos[i].id, [todos[i - 1].id]);
-        }
-        // Some tasks can be parallelized
-        // For example, styling and client script can happen in parallel after template is done
-        const templateTodo = todos.find(t => t.content.includes('template') || t.content.includes('structure'));
-        const stylingTodo = todos.find(t => t.content.includes('CSS') || t.content.includes('style'));
-        const clientTodo = todos.find(t => t.content.includes('client') || t.content.includes('controller'));
-        if (templateTodo && stylingTodo && clientTodo) {
-            // Both styling and client script depend only on template, not on each other
-            dependencies.set(stylingTodo.id, [templateTodo.id]);
-            dependencies.set(clientTodo.id, [templateTodo.id]);
-        }
-    }
-    /**
-     * 🚀 NEW: Assign todos to parallel agent with specializations
-     */
-    assignTodosToParallelAgent(agent, todoCoordination, assignedTodoIds, specializations) {
-        // Assign specific todos based on parallel workload planning
-        for (const todoId of assignedTodoIds) {
-            todoCoordination.agentAssignments.set(todoId, agent.id);
-            // Update agent task with first assigned todo
-            if (!agent.task) {
-                agent.task = todoId;
+    analyzeTodoDependencies(todos) {
+        const dependencies = new Map();
+        // 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);
             }
-        }
-        // Store specialization context in memory for agent coordination
-        this.memory.store(`agent_specializations_${agent.id}`, {
-            agentId: agent.id,
-            specializations,
-            assignedTodos: assignedTodoIds,
-            parallelMode: true,
-            timestamp: new Date().toISOString()
         });
-        console.log(`👤 Agent ${agent.type} (${agent.id}) specialized for: ${specializations.join(', ')}`);
-        console.log(`📝 Assigned ${assignedTodoIds.length} todos for parallel execution`);
+        return dependencies;
     }
     /**
      * Assign todos to agent based on capabilities
      */
-    assignTodosToAgent(agent, todoCoordination) {
-        const agentCapabilityMap = {
-            'widget-creator': ['widget', 'template', 'HTML', 'server', 'client', 'deploy widget'],
-            'flow-builder': ['flow', 'trigger', 'decision', 'action', 'workflow'],
-            'script-writer': ['script', 'business rule', 'logic', 'function'],
-            'app-architect': ['architecture', 'design', 'structure', 'solution'],
-            'integration-specialist': ['integration', 'REST', 'SOAP', 'API', 'external'],
-            'catalog-manager': ['catalog', 'item', 'category', 'variable'],
-            'researcher': ['analyze', 'research', 'requirements', 'existing'],
-            'tester': ['test', 'validate', 'mock', 'scenario', 'integration test']
-        };
-        const agentKeywords = agentCapabilityMap[agent.type] || [];
-        // Assign todos that match agent capabilities
-        for (const todo of todoCoordination.todos) {
-            if (!todoCoordination.agentAssignments.has(todo.id)) {
-                const todoLower = todo.content.toLowerCase();
-                const matches = agentKeywords.some(keyword => todoLower.includes(keyword.toLowerCase()));
-                if (matches) {
-                    todoCoordination.agentAssignments.set(todo.id, agent.id);
-                    // Update agent task list
-                    if (!agent.task) {
-                        agent.task = todo.id;
-                    }
-                }
+    async assignTodosToAgent(agent, objectiveId) {
+        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}`);
+            if (agentData) {
+                agentData.assignedTodos.push(todo.id);
+                await this.memory.store(`agent_${agent.id}`, agentData);
             }
         }
+        this.emit('todos:assigned', { agent, todos: assignableTodos });
     }
     /**
-     * Perform deep analysis of objective
+     * Check if agent can handle specific todo
      */
-    async performObjectiveAnalysis(objective) {
-        const description = objective.description.toLowerCase();
-        // Determine task type
-        let type = 'unknown';
-        if (description.includes('widget'))
-            type = 'widget';
-        else if (description.includes('flow') || description.includes('workflow'))
-            type = 'flow';
-        else if (description.includes('script') || description.includes('business rule'))
-            type = 'script';
-        else if (description.includes('app') || description.includes('application'))
-            type = 'application';
-        else if (description.includes('integration') || description.includes('api'))
-            type = 'integration';
-        // Determine required agents
-        const requiredAgents = [];
-        // Always include researcher for analysis
-        requiredAgents.push('researcher');
-        // Add type-specific agents
-        switch (type) {
-            case 'widget':
-                requiredAgents.push('widget-creator');
-                if (description.includes('test'))
-                    requiredAgents.push('tester');
-                break;
-            case 'flow':
-                requiredAgents.push('flow-builder');
-                if (description.includes('catalog'))
-                    requiredAgents.push('catalog-manager');
-                if (description.includes('test'))
-                    requiredAgents.push('tester');
-                break;
-            case 'script':
-                requiredAgents.push('script-writer');
-                if (description.includes('test'))
-                    requiredAgents.push('tester');
-                break;
-            case 'integration':
-                requiredAgents.push('integration-specialist');
-                requiredAgents.push('tester');
-                break;
-            case 'application':
-                requiredAgents.push('app-architect');
-                requiredAgents.push('widget-creator');
-                requiredAgents.push('flow-builder');
-                requiredAgents.push('tester');
-                break;
+    canAgentHandleTodo(agent, todo) {
+        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');
             default:
-                // For unknown types, spawn a balanced team
-                requiredAgents.push('app-architect');
-                requiredAgents.push('script-writer');
-                break;
+                // Generic agents can handle setup and coordination tasks
+                return todoContent.includes('initialize') ||
+                    todoContent.includes('validate') ||
+                    todoContent.includes('create update set') ||
+                    todoContent.includes('documentation');
         }
-        // Estimate complexity based on description
-        const complexityFactors = {
-            words: description.split(' ').length,
-            hasIntegration: description.includes('integration') || description.includes('api'),
-            hasMultipleComponents: description.includes('and') || description.includes('with'),
-            hasComplexLogic: description.includes('complex') || description.includes('advanced'),
-            hasPerformanceReqs: description.includes('performance') || description.includes('optimize')
-        };
-        const estimatedComplexity = complexityFactors.words / 10 +
-            (complexityFactors.hasIntegration ? 2 : 0) +
-            (complexityFactors.hasMultipleComponents ? 1 : 0) +
-            (complexityFactors.hasComplexLogic ? 2 : 0) +
-            (complexityFactors.hasPerformanceReqs ? 1 : 0);
-        // Look for successful patterns in memory
-        const suggestedPattern = await this.memory.findBestPattern(type);
-        // Extract dependencies
-        const dependencies = [];
-        if (description.includes('table'))
-            dependencies.push('table_creation');
-        if (description.includes('user'))
-            dependencies.push('user_management');
-        if (description.includes('approval'))
-            dependencies.push('approval_framework');
-        if (description.includes('notification'))
-            dependencies.push('notification_system');
-        return {
-            type,
-            requiredAgents: [...new Set(requiredAgents)], // Remove duplicates
-            estimatedComplexity: Math.min(10, Math.max(1, estimatedComplexity)),
-            suggestedPattern,
-            dependencies
-        };
     }
     /**
-     * Spawn a specialized agent with optional specialization
+     * Monitor agent progress through todo updates
      */
-    async spawnSpecializedAgent(type, objectiveId, specialization) {
-        const agentId = this.generateId(`agent_${type}`);
-        const agent = {
-            id: agentId,
-            type,
-            status: 'idle',
-            capabilities: this.getAgentCapabilities(type),
-            mcpTools: this.getAgentMcpTools(type)
-        };
-        // Store agent in memory for coordination
-        await this.memory.store(`agent_${agentId}`, {
-            agent,
-            objectiveId,
-            specialization: specialization || 'general',
-            parallelMode: !!specialization,
-            spawnedAt: new Date().toISOString()
-        });
-        if (specialization) {
-            console.log(`👤 Spawned specialized ${type} agent: ${specialization}`);
-        }
-        // Notify coordinator of new agent
-        await this.coordinator.registerAgent(agent);
-        this.emit('agent:spawned', agent);
-        return agent;
-    }
-    /**
-     * Get agent capabilities based on type
-     */
-    getAgentCapabilities(type) {
-        const capabilityMap = {
-            'widget-creator': ['html_generation', 'css_styling', 'javascript_development', 'servicenow_api', 'widget_deployment'],
-            'flow-builder': ['flow_design', 'trigger_configuration', 'action_creation', 'decision_logic', 'flow_testing'],
-            'script-writer': ['glide_scripting', 'business_logic', 'error_handling', 'performance_optimization', 'script_deployment'],
-            'app-architect': ['system_design', 'architecture_planning', 'component_integration', 'best_practices', 'documentation'],
-            'integration-specialist': ['rest_api', 'soap_services', 'data_transformation', 'authentication', 'error_recovery'],
-            'catalog-manager': ['catalog_creation', 'variable_management', 'workflow_linking', 'approval_setup', 'ui_design'],
-            'researcher': ['requirement_analysis', 'feasibility_study', 'solution_research', 'best_practice_identification'],
-            'tester': ['test_planning', 'test_execution', 'mock_data_creation', 'integration_testing', 'performance_testing']
-        };
-        return capabilityMap[type] || ['general_servicenow_development'];
-    }
-    /**
-     * Get MCP tools available to agent type
-     */
-    getAgentMcpTools(type) {
-        const toolMap = {
-            'widget-creator': ['snow_deploy', 'snow_preview_widget', 'snow_widget_test'],
-            'flow-builder': ['snow_create_flow', 'snow_test_flow_with_mock', 'snow_validate_flow_definition'],
-            'script-writer': ['snow_create_script_include', 'snow_create_business_rule', 'snow_create_client_script'],
-            'app-architect': ['snow_analyze_requirements', 'snow_create_application', 'snow_intelligent_flow_analysis'],
-            'integration-specialist': ['snow_create_rest_message', 'snow_create_transform_map', 'snow_test_integration'],
-            'catalog-manager': ['snow_catalog_item_search', 'snow_catalog_item_manager', 'snow_link_catalog_to_flow'],
-            'researcher': ['snow_find_artifact', 'snow_comprehensive_search', 'snow_discover_existing_flows'],
-            'tester': ['snow_test_flow_with_mock', 'snow_widget_test', 'snow_comprehensive_flow_test']
-        };
-        return toolMap[type] || ['snow_find_artifact'];
-    }
-    /**
-     * Identify blocking issues in todo coordination
-     */
-    async identifyBlockingIssues(todoCoordination) {
-        const issues = [];
-        // Check for todos with unmet dependencies
-        for (const [todoId, deps] of todoCoordination.dependencies) {
-            const todo = todoCoordination.todos.find(t => t.id === todoId);
-            if (todo && todo.status === 'pending') {
-                const unmetDeps = deps.filter(depId => {
-                    const depTodo = todoCoordination.todos.find(t => t.id === depId);
-                    return depTodo && depTodo.status !== 'completed';
-                });
-                if (unmetDeps.length > 0) {
-                    issues.push(`Todo "${todo.content}" blocked by ${unmetDeps.length} dependencies`);
-                }
-            }
-        }
-        // Check for todos with no assigned agent
-        const unassignedTodos = todoCoordination.todos.filter(todo => !todoCoordination.agentAssignments.has(todo.id) && todo.status === 'pending');
-        if (unassignedTodos.length > 0) {
-            issues.push(`${unassignedTodos.length} todos have no assigned agent`);
+    async monitorProgress(objectiveId) {
+        const todoCoordination = this.todoCoordinations.get(objectiveId);
+        if (!todoCoordination) {
+            throw new Error(`No todo coordination found for objective: ${objectiveId}`);
         }
-        // Check for failed todos
-        const failedTodos = todoCoordination.todos.filter(t => t.status === 'cancelled');
-        if (failedTodos.length > 0) {
-            issues.push(`${failedTodos.length} todos have failed`);
+        // 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();
+        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);
         }
-        return issues;
+        // 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
+        };
     }
     /**
-     * Estimate completion time based on progress
+     * Make memory-driven decisions based on past patterns
      */
-    estimateCompletion(todoCoordination, currentProgress) {
-        const startTime = new Date(todoCoordination.taskId.split('_')[1]); // Extract timestamp from ID
-        const elapsedMs = Date.now() - startTime.getTime();
-        if (currentProgress === 0) {
-            // Default estimate if no progress yet
-            return new Date(Date.now() + 3600000); // 1 hour
+    async makeDecision(context) {
+        // Query memory for similar past decisions
+        const similarPatterns = await this.memory.findSimilarPatterns(context.objective);
+        // Analyze success rates of past decisions
+        const successRates = new Map();
+        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);
         }
-        const estimatedTotalMs = (elapsedMs / currentProgress) * 100;
-        const remainingMs = estimatedTotalMs - elapsedMs;
-        return new Date(Date.now() + remainingMs);
-    }
-    /**
-     * Calculate score for decision option
-     */
-    calculateOptionScore(option, patterns, context) {
-        let score = 50; // Base score
-        // Adjust based on historical success with similar patterns
-        for (const pattern of patterns) {
-            if (pattern.agentSequence.some(agent => option.toLowerCase().includes(agent))) {
-                score += pattern.successRate * 20;
+        // 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;
             }
         }
-        // Adjust based on context constraints
-        if (context.currentState?.failedAttempts?.includes(option)) {
-            score -= 30; // Penalize previously failed options
-        }
-        // Boost score if option matches objective keywords
-        const objectiveWords = context.objective.toLowerCase().split(' ');
-        const optionWords = option.toLowerCase().split(' ');
-        const matches = objectiveWords.filter(word => optionWords.includes(word)).length;
-        score += matches * 5;
-        return Math.min(100, Math.max(0, score));
-    }
-    /**
-     * Generate reasoning for decision
-     */
-    generateDecisionReasoning(decision, patterns, context) {
-        const reasons = [];
-        // Check historical patterns
-        const relevantPatterns = patterns.filter(p => p.agentSequence.some(agent => decision.toLowerCase().includes(agent)));
-        if (relevantPatterns.length > 0) {
-            const avgSuccess = relevantPatterns.reduce((sum, p) => sum + p.successRate, 0) / relevantPatterns.length;
-            reasons.push(`Historical success rate: ${Math.round(avgSuccess)}%`);
-        }
-        // Check objective alignment
-        const objectiveWords = context.objective.toLowerCase().split(' ');
-        const decisionWords = decision.toLowerCase().split(' ');
-        const alignment = objectiveWords.filter(word => decisionWords.includes(word)).length;
-        if (alignment > 0) {
-            reasons.push(`Strong alignment with objective (${alignment} matching concepts)`);
-        }
-        // Default reasoning if no specific reasons
-        if (reasons.length === 0) {
-            reasons.push('Best option based on current context and available capabilities');
-        }
-        return reasons.join('; ');
+        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({
+            context,
+            decision: decision.decision,
+            confidence: decision.confidence,
+            timestamp: new Date().toISOString()
+        });
+        this.emit('decision:made', decision);
+        return decision;
     }
     /**
-     * Set up event handlers for coordination
+     * Setup event handlers for coordination
      */
     setupEventHandlers() {
-        // Listen to coordinator events
-        this.coordinator.on('agent:handoff', async (data) => {
-            await this.handleAgentHandoff(data);
+        // 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:blocked', async (data) => {
-            await this.handleAgentBlocked(data);
+        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('coordination:error', async (error) => {
-            await this.handleCoordinationError(error);
+        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);
+                }
+            }
         });
     }
     /**
-     * Handle agent handoff events
+     * Check if more agents need to be spawned
      */
-    async handleAgentHandoff(data) {
-        this.emit('coordination:handoff', data);
-        // Update todo status if handoff includes completed work
-        if (data.completedTodoId) {
-            await this.updateTodoStatus(data.objectiveId, data.completedTodoId, 'completed');
+    async checkAndSpawnAgents(objectiveId) {
+        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 agent blocked events
+     * Handle coordination errors
      */
-    async handleAgentBlocked(data) {
-        this.emit('coordination:blocked', data);
-        // Attempt to resolve blockage
-        const resolution = await this.makeDecision({
-            objective: `Resolve blockage for ${data.agentId}`,
-            currentState: data,
-            options: ['spawn_helper_agent', 'reassign_task', 'provide_fallback', 'wait_for_dependency']
+    async handleCoordinationError(error, context) {
+        console.error('❌ Coordination error:', error);
+        // Store error in memory for learning
+        await this.memory.storeError({
+            error: error.message || error,
+            context,
+            timestamp: new Date().toISOString(),
+            recovery: null
         });
-        if (resolution.decision === 'spawn_helper_agent') {
-            // Spawn additional agent to help
-            await this.spawnAgents(data.objectiveId);
-        }
+        this.emit('coordination:error', { error, context });
     }
     /**
-     * Handle coordination errors
+     * Identify blocking issues from todos
      */
-    async handleCoordinationError(error) {
-        this.emit('coordination:error', error);
-        // Log error to memory for learning
-        await this.memory.store(`error_${Date.now()}`, {
-            error: error.message,
-            stack: error.stack,
-            context: error.context,
-            timestamp: new Date().toISOString()
+    async identifyBlockingIssues(todoCoordination) {
+        const issues = [];
+        // Check for failed todos
+        const failedTodos = todoCoordination.todos.filter(t => t.status === 'failed');
+        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}`);
+            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;
     }
     /**
-     * Update todo status
+     * Estimate completion time based on current progress
      */
-    async updateTodoStatus(objectiveId, todoId, status) {
-        const todoCoordination = this.todoCoordinations.get(objectiveId);
-        if (!todoCoordination)
-            return;
-        const todo = todoCoordination.todos.find(t => t.id === todoId);
-        if (todo) {
-            todo.status = status;
-            // Store update in memory
-            await this.memory.store(`todo_update_${todoId}`, {
-                todoId,
-                newStatus: status,
-                timestamp: new Date().toISOString()
-            });
-            this.emit('todo:updated', { objectiveId, todoId, status });
+    estimateCompletion(todoCoordination, currentProgress) {
+        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
+     * Generate unique ID for entities
      */
     generateId(prefix) {
         return `${prefix}_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
     }
     /**
-     * Get queen status
-     */
-    async getStatus() {
-        let totalTodos = 0;
-        let completedTodos = 0;
-        for (const coordination of this.todoCoordinations.values()) {
-            totalTodos += coordination.todos.length;
-            completedTodos += coordination.todos.filter(t => t.status === 'completed').length;
-        }
-        return {
-            activeObjectives: this.activeObjectives.size,
-            activeAgents: this.activeAgents.size,
-            totalTodos,
-            completedTodos,
-            memoryStats: await this.memory.getStats()
-        };
-    }
-    /**
-     * Shutdown queen agent
+     * Shutdown queen agent gracefully
      */
     async shutdown() {
-        if (this.config.debugMode) {
-            console.log('👑 Shutting down Queen Agent');
+        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()
+            });
         }
-        // Terminate all active agents
+        // Notify all active agents
         for (const agent of this.activeAgents.values()) {
-            await this.coordinator.terminateAgent(agent.id);
+            this.emit('agent:shutdown', agent);
         }
-        // Close memory system
-        this.memory.close();
-        // Clear all maps
-        this.activeObjectives.clear();
-        this.todoCoordinations.clear();
-        this.activeAgents.clear();
-        this.emit('shutdown');
+        await this.memory.close();
+        this.removeAllListeners();
+        console.log('✅ Queen Agent shutdown complete');
     }
 }
 exports.QueenAgent = QueenAgent;
-//# sourceMappingURL=queen-agent.js.map