@loxia-labs/loxia-autopilot-one 1.0.1

package/src/core/agentPool.js

@@ -0,0 +1,1474 @@
+/**
+ * AgentPool - Manages the lifecycle, state, and communication of all active agents
+ * 
+ * Purpose:
+ * - Agent creation and destruction
+ * - Agent notification and routing
+ * - Multi-agent conversation coordination
+ * - Agent state persistence and recovery
+ * - Agent activity management
+ */
+
+import {
+  AGENT_TYPES,
+  AGENT_STATUS,
+  AGENT_MODES,
+  AGENT_MODE_STATES,
+  MESSAGE_ROLES,
+  MESSAGE_TYPES,
+  INTER_AGENT_MESSAGE,
+  MODEL_FORMAT_VERSIONS,
+  SYSTEM_DEFAULTS
+} from '../utilities/constants.js';
+import DirectoryAccessManager from '../utilities/directoryAccessManager.js';
+
+class AgentPool {
+  constructor(config, logger, stateManager, contextManager, toolsRegistry = null) {
+    this.config = config;
+    this.logger = logger;
+    this.stateManager = stateManager;
+    this.contextManager = contextManager;
+    this.toolsRegistry = toolsRegistry;
+    
+    // Agent registry - maps agent ID to agent object
+    this.agents = new Map();
+    
+    // Agent directory for discovery
+    this.agentDirectory = new Map();
+    
+    // Paused agents tracking
+    this.pausedAgents = new Map();
+    
+    // Agent notification queue
+    this.notificationQueue = new Map();
+    
+    this.maxAgentsPerProject = config.system?.maxAgentsPerProject || SYSTEM_DEFAULTS.MAX_AGENTS_PER_PROJECT;
+    
+    // MessageProcessor reference for triggering responses (set via setMessageProcessor)
+    this.messageProcessor = null;
+      
+    // Initialize directory access manager
+    this.directoryAccessManager = new DirectoryAccessManager(config, logger);
+  }
+
+  /**
+   * Create a new agent with specified configuration
+   * @param {Object} config - Agent configuration
+   * @param {string} config.name - Agent name
+   * @param {string} config.type - Agent type ('user-created', 'system-agent', 'agent-engineer')
+   * @param {string} config.systemPrompt - Agent's system prompt
+   * @param {string} config.preferredModel - Preferred LLM model
+   * @param {Array} config.capabilities - Available tools/capabilities
+   * @param {Object} config.directoryAccess - Directory access configuration
+   * @param {string} config.projectDir - Project directory for default access setup
+   * @returns {Promise<Object>} Created agent object
+   */
+  async createAgent(config) {
+    // Check agent limit
+    if (this.agents.size >= this.maxAgentsPerProject) {
+      throw new Error(`Maximum agents per project exceeded (${this.maxAgentsPerProject})`);
+    }
+    
+    const agentId = this._generateAgentId(config.name);
+    const now = new Date().toISOString();
+    
+    // Enhance system prompt with tool descriptions if available
+    let enhancedSystemPrompt = config.systemPrompt;
+    if (this.toolsRegistry && config.capabilities && config.capabilities.length > 0) {
+      try {
+        enhancedSystemPrompt = this.toolsRegistry.enhanceSystemPrompt(
+          config.systemPrompt, 
+          config.capabilities,
+          {
+            compact: config.compactToolDescriptions || false,
+            includeExamples: config.includeToolExamples !== false,
+            includeUsageGuidelines: config.includeUsageGuidelines !== false,
+            includeSecurityNotes: config.includeSecurityNotes !== false
+          }
+        );
+        
+        this.logger?.info(`System prompt enhanced with tool descriptions`, {
+          agentId,
+          capabilities: config.capabilities,
+          originalLength: config.systemPrompt?.length || 0,
+          enhancedLength: enhancedSystemPrompt?.length || 0
+        });
+      } catch (error) {
+        this.logger?.error(`Failed to enhance system prompt with tools`, {
+          agentId,
+          error: error.message,
+          capabilities: config.capabilities
+        });
+        // Fall back to original prompt
+        enhancedSystemPrompt = config.systemPrompt;
+      }
+    }
+
+    // Setup directory access configuration
+    let directoryAccess;
+    
+    console.log('AgentPool DEBUG: createAgent - config.directoryAccess:', config.directoryAccess ? 'EXISTS' : 'NULL/UNDEFINED');
+    if (config.directoryAccess) {
+      console.log('AgentPool DEBUG: createAgent - directoryAccess from config:', JSON.stringify(config.directoryAccess, null, 2));
+    }
+    console.log('AgentPool DEBUG: createAgent - config.projectDir:', config.projectDir);
+    
+    if (config.directoryAccess) {
+      // Validate provided directory access configuration
+      const validation = this.directoryAccessManager.validateAccessConfiguration(config.directoryAccess);
+      console.log('AgentPool DEBUG: createAgent - validation result:', validation);
+      if (!validation.valid) {
+        throw new Error(`Invalid directory access configuration: ${validation.errors.join(', ')}`);
+      }
+      directoryAccess = config.directoryAccess;
+      console.log('AgentPool DEBUG: createAgent - Using provided directoryAccess');
+    } else {
+      // Create default directory access based on project directory
+      const projectDir = config.projectDir || process.cwd();
+      directoryAccess = DirectoryAccessManager.createProjectDefaults(projectDir);
+      console.log('AgentPool DEBUG: createAgent - Created default directoryAccess for projectDir:', projectDir);
+      console.log('AgentPool DEBUG: createAgent - Default directoryAccess:', JSON.stringify(directoryAccess, null, 2));
+    }
+
+    const agent = {
+      id: agentId,
+      type: config.type || AGENT_TYPES.USER_CREATED,
+      name: config.name || `Agent-${Date.now()}`,
+      systemPrompt: enhancedSystemPrompt,
+      originalSystemPrompt: config.systemPrompt, // Store original for reference
+      preferredModel: config.preferredModel,
+      status: AGENT_STATUS.ACTIVE,
+      capabilities: config.capabilities || [],
+      directoryAccess: directoryAccess, // Directory access configuration
+      conversations: {
+        full: {
+          messages: [],
+          lastUpdated: now
+        }
+      },
+      currentModel: config.preferredModel,
+      dynamicModelRouting: config.dynamicModelRouting || false, // New field for routing
+      platformProvided: config.platformProvided || false, // Platform vs direct access
+      
+      // Agent Mode Configuration
+      mode: config.mode || AGENT_MODES.CHAT,
+      modeState: AGENT_MODE_STATES.IDLE,
+      currentTask: null, // Current autonomous task being executed
+      taskStartTime: null,
+      maxIterations: config.maxIterations || 10, // Safety limit for autonomous loops
+      iterationCount: 0,
+      stopRequested: false,
+      delayEndTime: null, // When agent delay expires (for agentDelay tool)
+      
+      // Message Queues for scheduler processing
+      messageQueues: {
+        toolResults: [],      // Tool execution results waiting to be processed
+        interAgentMessages: [], // Messages from other agents
+        userMessages: []      // Messages from users
+      },
+      
+      createdAt: now,
+      lastActivity: now,
+      pausedUntil: null,
+      metadata: config.metadata || {},
+      
+      // CRITICAL: Store sessionId for API key resolution
+      sessionId: config.sessionId,
+      
+      // Inter-agent conversation tracking to prevent spam
+      interAgentTracking: new Map(), // recipientId -> { lastSent, lastReceived, lastType }
+      
+      // Task Management System for agent-mode autonomous operation
+      taskList: {
+        tasks: [],  // Array of task objects
+        lastUpdated: now
+      },
+      
+      // Incoming messages tracking (for unprocessed messages)
+      incomingMessages: []
+    };
+
+    this.logger.info(`Agent created with routing config`, {
+      agentId,
+      dynamicModelRouting: agent.dynamicModelRouting,
+      platformProvided: agent.platformProvided,
+      preferredModel: agent.preferredModel
+    });
+    
+    // Initialize model-specific conversation with dual storage structure
+    if (config.preferredModel) {
+      agent.conversations[config.preferredModel] = {
+        // Dual storage for compactization support
+        messages: [],                    // Original messages - never modified
+        compactizedMessages: null,       // Working copy - null until first compaction
+
+        // Compactization metadata
+        lastCompactization: null,        // Timestamp of last compaction
+        compactizationCount: 0,          // Number of times compacted
+        compactizationStrategy: null,    // 'summarization', 'truncation', 'aggressive'
+        originalTokenCount: 0,           // Token count before last compaction
+        compactedTokenCount: 0,          // Token count after last compaction
+
+        // Backward compatibility
+        tokenCount: 0,                   // Current effective token count
+        lastUpdated: now,
+        formatVersion: this._getModelFormatVersion(config.preferredModel)
+      };
+    }
+    
+    // Add to registry and directory
+    this.agents.set(agentId, agent);
+    this._updateAgentDirectory(agent);
+    
+    // Persist agent state
+    await this.stateManager.persistAgentState(agentId);
+    
+    this.logger.info(`Agent created: ${agentId}`, {
+      agentId,
+      name: agent.name,
+      type: agent.type,
+      model: agent.preferredModel
+    });
+    
+    return agent;
+  }
+
+  /**
+   * Retrieve agent instance by ID
+   * @param {string} agentId - Agent identifier
+   * @returns {Promise<Object|null>} Agent object or null if not found
+   */
+  async getAgent(agentId, enrichWithSchedulerStatus = false) {
+    const agent = this.agents.get(agentId);
+    if (!agent) return null;
+
+    // Optionally enrich with scheduler status for UI
+    if (enrichWithSchedulerStatus && this.scheduler) {
+      agent.inScheduler = this.scheduler.isAgentInScheduler(agentId);
+    }
+
+    return agent;
+  }
+
+  /**
+   * Update an existing agent's configuration
+   * @param {string} agentId - Agent identifier
+   * @param {Object} updates - Updates to apply to the agent
+   * @returns {Promise<Object>} Updated agent object
+   */
+  async updateAgent(agentId, updates) {
+    const agent = await this.getAgent(agentId);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+
+    this.logger.info(`Updating agent: ${agentId}`, {
+      updates,
+      currentName: agent.name
+    });
+
+    // Validate directory access configuration if being updated
+    if (updates.directoryAccess) {
+      const validation = this.directoryAccessManager.validateAccessConfiguration(updates.directoryAccess);
+      if (!validation.valid) {
+        throw new Error(`Invalid directory access configuration: ${validation.errors.join(', ')}`);
+      }
+
+      this.logger.info(`Directory access validation passed for agent: ${agentId}`, {
+        workingDirectory: updates.directoryAccess.workingDirectory,
+        readOnlyDirs: updates.directoryAccess.readOnlyDirectories?.length || 0,
+        writeEnabledDirs: updates.directoryAccess.writeEnabledDirectories?.length || 0
+      });
+    }
+
+    // If capabilities are being updated, regenerate the enhanced system prompt
+    if (updates.capabilities && this.toolsRegistry) {
+      try {
+        const baseSystemPrompt = agent.originalSystemPrompt || agent.systemPrompt;
+        const enhancedSystemPrompt = this.toolsRegistry.enhanceSystemPrompt(
+          baseSystemPrompt,
+          updates.capabilities,
+          {
+            compact: agent.compactToolDescriptions || false,
+            includeExamples: agent.includeToolExamples !== false,
+            includeUsageGuidelines: agent.includeUsageGuidelines !== false,
+            includeSecurityNotes: agent.includeSecurityNotes !== false
+          }
+        );
+
+        updates.systemPrompt = enhancedSystemPrompt;
+
+        this.logger.info(`System prompt regenerated with updated capabilities`, {
+          agentId,
+          oldCapabilities: agent.capabilities,
+          newCapabilities: updates.capabilities,
+          originalLength: baseSystemPrompt?.length || 0,
+          enhancedLength: enhancedSystemPrompt?.length || 0
+        });
+      } catch (error) {
+        this.logger.error(`Failed to regenerate system prompt with updated capabilities`, {
+          agentId,
+          error: error.message,
+          capabilities: updates.capabilities
+        });
+        // Continue with update even if enhancement fails
+      }
+    }
+
+    // Create updated agent object with new values
+    const updatedAgent = {
+      ...agent,
+      ...updates,
+      id: agentId, // Ensure ID cannot be changed
+      lastModified: new Date().toISOString(),
+      lastActivity: new Date().toISOString()
+    };
+
+    // CRITICAL FIX: When preferredModel changes, also update currentModel
+    // This ensures the UI immediately reflects the model change
+    if (updates.preferredModel && updates.preferredModel !== agent.preferredModel) {
+      const oldModel = agent.preferredModel;
+      const newModel = updates.preferredModel;
+
+      updatedAgent.currentModel = newModel;
+
+      // CRITICAL FIX: Initialize conversation for new model if it doesn't exist
+      if (!updatedAgent.conversations[newModel]) {
+        updatedAgent.conversations[newModel] = this._createEmptyConversation(newModel);
+        this.logger.info(`Created conversation for new model: ${newModel}`, { agentId });
+      }
+
+      // Copy conversation history from old model to new model
+      // This preserves context when switching models
+      if (oldModel && updatedAgent.conversations[oldModel]) {
+        const oldConversation = updatedAgent.conversations[oldModel];
+        const newConversation = updatedAgent.conversations[newModel];
+
+        // Copy messages if new conversation is empty
+        if (newConversation.messages.length === 0 && oldConversation.messages.length > 0) {
+          // Copy original messages
+          newConversation.messages = [...oldConversation.messages];
+
+          // Copy compacted messages if they exist
+          if (oldConversation.compactizedMessages) {
+            newConversation.compactizedMessages = [...oldConversation.compactizedMessages];
+            newConversation.lastCompactization = oldConversation.lastCompactization;
+            newConversation.compactizationCount = oldConversation.compactizationCount;
+            newConversation.compactizationStrategy = oldConversation.compactizationStrategy;
+            newConversation.originalTokenCount = oldConversation.originalTokenCount;
+            newConversation.compactedTokenCount = oldConversation.compactedTokenCount;
+          }
+
+          newConversation.lastUpdated = new Date().toISOString();
+
+          this.logger.info(`Copied conversation history from ${oldModel} to ${newModel}`, {
+            agentId,
+            messageCount: newConversation.messages.length,
+            hasCompacted: !!newConversation.compactizedMessages
+          });
+        }
+      }
+
+      this.logger.info(`Model changed via UI - updating both preferredModel and currentModel`, {
+        agentId,
+        oldModel,
+        newModel,
+        conversationCopied: oldModel && updatedAgent.conversations[oldModel]?.messages.length > 0
+      });
+    }
+
+    // Update agent in registry
+    this.agents.set(agentId, updatedAgent);
+    
+    // Log the actual update for debugging
+    this.logger.info(`Agent updated in registry with mode: ${updatedAgent.mode}`, {
+      agentId,
+      beforeMode: agent.mode,
+      afterMode: updatedAgent.mode,
+      allUpdates: Object.keys(updates)
+    });
+
+    // Update agent directory
+    this._updateAgentDirectory(updatedAgent);
+
+    // Persist the updated agent state
+    await this.stateManager.persistAgentState(updatedAgent);
+
+    // CRITICAL: If agent was switched to AGENT mode, add it to scheduler
+    if (updates.mode === AGENT_MODES.AGENT && this.scheduler) {
+      // CRITICAL FIX: Use the session ID from updates first, then agent's sessionId
+      const sessionId = updates.sessionId || updatedAgent.sessionId;
+      
+      if (!sessionId) {
+        this.logger.warn(`Agent ${agentId} switching to AGENT mode but has no sessionId - this will cause API key resolution issues`);
+      }
+      
+      this.logger.info(`Adding agent to scheduler (switched to AGENT mode): ${agentId}`, {
+        agentName: updatedAgent.name,
+        sessionId: sessionId,
+        hasSessionId: !!sessionId
+      });
+      
+      await this.scheduler.addAgent(agentId, {
+        sessionId: sessionId, // NO FALLBACK - let scheduler handle missing session ID appropriately
+        triggeredBy: 'mode-change',
+        reason: 'Agent switched to AGENT mode'
+      });
+    }
+    
+    // If agent was switched from AGENT to CHAT mode, remove from scheduler
+    if (agent.mode === AGENT_MODES.AGENT && updates.mode === AGENT_MODES.CHAT && this.scheduler) {
+      this.logger.info(`Removing agent from scheduler (switched to CHAT mode): ${agentId}`);
+      this.scheduler.removeAgent(agentId, 'mode-change-to-chat');
+    }
+
+    this.logger.info(`Agent updated successfully: ${agentId}`, {
+      newName: updatedAgent.name,
+      changes: Object.keys(updates)
+    });
+
+    return updatedAgent;
+  }
+
+  /**
+   * Agent notification from Message Processor for inter-agent communication
+   * @param {string} agentId - Target agent ID
+   * @param {Object} message - Message object with agent redirect
+   * @returns {Promise<boolean>} Success status
+   */
+  async notifyAgent(agentId, message) {
+    const agent = await this.getAgent(agentId);
+    if (!agent) {
+      this.logger.warn(`Agent notification failed - agent not found: ${agentId}`);
+      return false;
+    }
+    
+    // Check if agent is paused
+    if (this._isAgentPaused(agent)) {
+      this.logger.info(`Agent notification queued - agent is paused: ${agentId}`);
+      this._queueNotification(agentId, message);
+      return true;
+    }
+    
+    // Add notification to agent's conversation
+    const notificationMessage = {
+      id: `msg-${Date.now()}`,
+      conversationId: message.conversationId,
+      agentId: message.from, // sender agent ID
+      content: message.content,
+      role: MESSAGE_ROLES.SYSTEM,
+      timestamp: new Date().toISOString(),
+      type: MESSAGE_TYPES.AGENT_NOTIFICATION,
+      fromAgent: message.from,
+      context: message.context,
+      urgent: message.urgent || false,
+      requiresResponse: message.requiresResponse || false
+    };
+    
+    // Add to full conversation
+    agent.conversations.full.messages.push(notificationMessage);
+    agent.conversations.full.lastUpdated = new Date().toISOString();
+    
+    // Add to current model conversation
+    if (agent.currentModel && agent.conversations[agent.currentModel]) {
+      const formattedMessage = this._formatMessageForModel(notificationMessage, agent.currentModel);
+      agent.conversations[agent.currentModel].messages.push(formattedMessage);
+      agent.conversations[agent.currentModel].lastUpdated = new Date().toISOString();
+    }
+    
+    // Update agent activity
+    agent.lastActivity = new Date().toISOString();
+    await this.persistAgentState(agentId);
+    
+    this.logger.info(`Agent notified: ${agentId}`, {
+      fromAgent: message.from,
+      urgent: message.urgent,
+      requiresResponse: message.requiresResponse
+    });
+    
+    return true;
+  }
+
+  /**
+   * Get all agents (returns full agent objects)
+   * @returns {Promise<Array>} List of all agent objects
+   */
+  async getAllAgents() {
+    const agents = Array.from(this.agents.values());
+    
+    // Update pause status for all agents
+    for (const agent of agents) {
+      this._updateAgentPauseStatus(agent);
+    }
+    
+    return agents;
+  }
+
+  /**
+   * List all active agents with their current status
+   * @returns {Promise<Array>} Array of agent objects
+   */
+  async listActiveAgents() {
+    const agents = Array.from(this.agents.values());
+    
+    // Update pause status for all agents
+    for (const agent of agents) {
+      this._updateAgentPauseStatus(agent);
+    }
+    
+    return agents.map(agent => ({
+      id: agent.id,
+      name: agent.name,
+      type: agent.type,
+      status: agent.status,
+      systemPrompt: agent.systemPrompt,
+      preferredModel: agent.preferredModel,
+      currentModel: agent.currentModel,
+      dynamicModelRouting: agent.dynamicModelRouting,
+      platformProvided: agent.platformProvided,
+      capabilities: agent.capabilities,
+      lastActivity: agent.lastActivity,
+      isPaused: this._isAgentPaused(agent),
+      pausedUntil: agent.pausedUntil,
+      messageCount: agent.conversations.full.messages.length,
+      createdAt: agent.createdAt
+    }));
+  }
+
+  /**
+   * Persist agent state to storage
+   * @param {string} agentId - Agent identifier
+   * @returns {Promise<void>}
+   */
+  async persistAgentState(agentId) {
+    const agent = await this.getAgent(agentId);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+    
+    await this.stateManager.persistAgentState(agent);
+  }
+
+  /**
+   * Resume agent from persisted state
+   * @param {Object} agentData - Persisted agent data
+   * @returns {Promise<Object>} Restored agent object
+   */
+  async resumeAgent(agentData) {
+    const agent = {
+      ...agentData,
+      status: agentData.status === 'paused' && this._isPauseExpired(agentData) ? 'active' : agentData.status
+    };
+    
+    // Validate conversations structure
+    if (!agent.conversations || !agent.conversations.full) {
+      agent.conversations = {
+        full: {
+          messages: [],
+          lastUpdated: new Date().toISOString()
+        }
+      };
+    }
+    
+    // Add to registry and directory
+    this.agents.set(agent.id, agent);
+    this._updateAgentDirectory(agent);
+    
+    // Process any queued notifications
+    await this._processQueuedNotifications(agent.id);
+    
+    this.logger.info(`Agent resumed: ${agent.id}`, {
+      name: agent.name,
+      status: agent.status,
+      messageCount: agent.conversations.full.messages.length
+    });
+    
+    return agent;
+  }
+
+  /**
+   * Pause agent for specified duration
+   * @param {string} agentId - Agent identifier
+   * @param {number|Date} duration - Pause duration in seconds or Date object
+   * @param {string} reason - Reason for pause
+   * @returns {Promise<Object>} Pause confirmation
+   */
+  async pauseAgent(agentId, duration, reason = 'Agent pause requested') {
+    const agent = await this.getAgent(agentId);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+    
+    let pauseUntil;
+    if (duration instanceof Date) {
+      pauseUntil = duration;
+    } else {
+      // Duration in seconds
+      const maxPauseDuration = this.config.system?.maxPauseDuration || 300;
+      const pauseSeconds = Math.min(duration, maxPauseDuration);
+      pauseUntil = new Date(Date.now() + pauseSeconds * 1000);
+    }
+    
+    agent.status = AGENT_STATUS.PAUSED;
+    agent.pausedUntil = pauseUntil.toISOString();
+    agent.lastActivity = new Date().toISOString();
+    
+    // Add to paused agents tracking
+    this.pausedAgents.set(agentId, {
+      agentId,
+      pausedAt: new Date().toISOString(),
+      pausedUntil: pauseUntil.toISOString(),
+      reason,
+      originalStatus: AGENT_STATUS.ACTIVE
+    });
+    
+    await this.persistAgentState(agentId);
+    
+    this.logger.info(`Agent paused: ${agentId}`, {
+      pausedUntil: pauseUntil.toISOString(),
+      reason,
+      durationSeconds: Math.round((pauseUntil.getTime() - Date.now()) / 1000)
+    });
+    
+    return {
+      success: true,
+      agentId,
+      pausedUntil: pauseUntil.toISOString(),
+      reason,
+      message: `Agent paused until ${pauseUntil.toISOString()}`
+    };
+  }
+
+  /**
+   * Resume paused agent
+   * @param {string} agentId - Agent identifier
+   * @returns {Promise<Object>} Resume confirmation
+   */
+  async resumeAgent(agentId) {
+    const agent = await this.getAgent(agentId);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+    
+    if (agent.status !== AGENT_STATUS.PAUSED) {
+      return {
+        success: true,
+        message: `Agent ${agentId} is not paused`
+      };
+    }
+    
+    agent.status = AGENT_STATUS.ACTIVE;
+    agent.pausedUntil = null;
+    agent.lastActivity = new Date().toISOString();
+    
+    // Remove from paused agents tracking
+    this.pausedAgents.delete(agentId);
+    
+    // Process any queued notifications
+    await this._processQueuedNotifications(agentId);
+    
+    await this.persistAgentState(agentId);
+    
+    this.logger.info(`Agent resumed: ${agentId}`);
+    
+    return {
+      success: true,
+      agentId,
+      message: `Agent ${agentId} resumed successfully`
+    };
+  }
+
+  /**
+   * Restore agent from saved state
+   * @param {Object} agentState - Saved agent state
+   * @returns {Promise<Object>} Restored agent
+   */
+  async restoreAgent(agentState) {
+    return await this.resumeAgent(agentState);
+  }
+
+  /**
+   * Get agent discovery directory
+   * @returns {Array} Array of agent info for discovery
+   */
+  getAgentDirectory() {
+    return Array.from(this.agentDirectory.values());
+  }
+
+  /**
+   * List all active agents
+   * @returns {Array} Array of active agents
+   */
+
+  /**
+   * Delete an agent and clean up its resources
+   * @param {string} agentId - Agent identifier
+   * @returns {Promise<Object>} Deletion result
+   */
+  async deleteAgent(agentId) {
+    const agent = await this.getAgent(agentId);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+
+    // Clean up file attachments with reference counting
+    if (this.fileAttachmentService) {
+      try {
+        await this.fileAttachmentService.deleteAgentAttachments(agentId);
+        this.logger.info(`File attachments cleaned up for agent: ${agentId}`);
+      } catch (error) {
+        this.logger.warn(`Failed to clean up file attachments for agent: ${error.message}`, { agentId });
+        // Continue with agent deletion even if attachment cleanup fails
+      }
+    }
+
+    // Clean up agent resources
+    this.agents.delete(agentId);
+    this.agentDirectory.delete(agentId);
+    this.pausedAgents.delete(agentId);
+    this.notificationQueue.delete(agentId);
+    
+    // Clean up persistent state
+    try {
+      await this.stateManager.deleteAgentState(agentId);
+    } catch (error) {
+      this.logger.warn(`Failed to delete agent persistent state: ${error.message}`, { agentId });
+    }
+    
+    this.logger.info(`Agent deleted: ${agentId}`, {
+      agentName: agent.name,
+      totalAgents: this.agents.size
+    });
+    
+    return {
+      success: true,
+      agentId,
+      remainingAgents: this.agents.size
+    };
+  }
+
+  /**
+   * Generate unique agent ID
+   * @private
+   */
+  _generateAgentId(name) {
+    const sanitizedName = name.toLowerCase().replace(/[^a-z0-9]/g, '-');
+    const timestamp = Date.now();
+    return `agent-${sanitizedName}-${timestamp}`;
+  }
+
+  /**
+   * Update agent directory for discovery
+   * @private
+   */
+  _updateAgentDirectory(agent) {
+    this.agentDirectory.set(agent.id, {
+      id: agent.id,
+      name: agent.name,
+      type: agent.type,
+      capabilities: agent.capabilities,
+      status: agent.status,
+      description: this._generateAgentDescription(agent)
+    });
+  }
+
+  /**
+   * Generate agent description for directory
+   * @private
+   */
+  _generateAgentDescription(agent) {
+    let description = `${agent.name} (${agent.type})`;
+    
+    if (agent.capabilities.length > 0) {
+      description += ` - Capabilities: ${agent.capabilities.join(', ')}`;
+    }
+    
+    return description;
+  }
+
+  /**
+   * Check if agent is currently paused
+   * @private
+   */
+  _isAgentPaused(agent) {
+    if (agent.status !== AGENT_STATUS.PAUSED || !agent.pausedUntil) {
+      return false;
+    }
+    
+    return new Date() < new Date(agent.pausedUntil);
+  }
+
+  /**
+   * Check if pause duration has expired
+   * @private
+   */
+  _isPauseExpired(agent) {
+    if (!agent.pausedUntil) return true;
+    return new Date() >= new Date(agent.pausedUntil);
+  }
+
+  /**
+   * Update agent pause status
+   * @private
+   */
+  _updateAgentPauseStatus(agent) {
+    if (agent.status === AGENT_STATUS.PAUSED && this._isPauseExpired(agent)) {
+      agent.status = AGENT_STATUS.ACTIVE;
+      agent.pausedUntil = null;
+      this.pausedAgents.delete(agent.id);
+    }
+  }
+
+  /**
+   * Queue notification for paused agent
+   * @private
+   */
+  _queueNotification(agentId, message) {
+    if (!this.notificationQueue.has(agentId)) {
+      this.notificationQueue.set(agentId, []);
+    }
+    
+    this.notificationQueue.get(agentId).push({
+      ...message,
+      queuedAt: new Date().toISOString()
+    });
+  }
+
+  /**
+   * Process queued notifications for agent
+   * @private
+   */
+  async _processQueuedNotifications(agentId) {
+    const notifications = this.notificationQueue.get(agentId);
+    if (!notifications || notifications.length === 0) {
+      return;
+    }
+    
+    this.logger.info(`Processing ${notifications.length} queued notifications for agent: ${agentId}`);
+    
+    for (const notification of notifications) {
+      await this.notifyAgent(agentId, notification);
+    }
+    
+    // Clear queue
+    this.notificationQueue.delete(agentId);
+  }
+
+  /**
+   * Format message for specific model
+   * @private
+   */
+  _formatMessageForModel(message, targetModel) {
+    // This would be implemented with model-specific formatting logic
+    // For now, return the message as-is
+    return { ...message };
+  }
+
+  /**
+   * Get model format version
+   * @private
+   */
+  _getModelFormatVersion(model) {
+    return MODEL_FORMAT_VERSIONS[model] || MODEL_FORMAT_VERSIONS.DEFAULT;
+  }
+
+  /**
+   * Refresh tool descriptions for an existing agent
+   * @param {string} agentId - Agent identifier
+   * @param {Object} options - Refresh options
+   * @returns {Promise<boolean>} Success status
+   */
+  async refreshAgentToolDescriptions(agentId, options = {}) {
+    const agent = await this.getAgent(agentId);
+    if (!agent || !this.toolsRegistry) {
+      return false;
+    }
+
+    try {
+      // Use original prompt if available, otherwise current prompt
+      const basePrompt = agent.originalSystemPrompt || agent.systemPrompt;
+      
+      // Enhance with current tool capabilities
+      const enhancedPrompt = this.toolsRegistry.enhanceSystemPrompt(
+        basePrompt,
+        agent.capabilities,
+        {
+          compact: options.compact || false,
+          includeExamples: options.includeExamples !== false,
+          includeUsageGuidelines: options.includeUsageGuidelines !== false,
+          includeSecurityNotes: options.includeSecurityNotes !== false
+        }
+      );
+
+      // Update agent's system prompt
+      agent.systemPrompt = enhancedPrompt;
+      agent.lastActivity = new Date().toISOString();
+
+      // Persist changes
+      await this.stateManager.persistAgentState(agentId);
+
+      this.logger?.info(`Agent tool descriptions refreshed: ${agentId}`, {
+        capabilities: agent.capabilities,
+        promptLength: enhancedPrompt.length
+      });
+
+      return true;
+
+    } catch (error) {
+      this.logger?.error(`Failed to refresh tool descriptions for agent: ${agentId}`, {
+        error: error.message
+      });
+      return false;
+    }
+  }
+
+  /**
+   * Set or update tools registry for the agent pool
+   * @param {ToolsRegistry} toolsRegistry - Tools registry instance
+   */
+  setToolsRegistry(toolsRegistry) {
+    this.toolsRegistry = toolsRegistry;
+    
+    this.logger?.info('Tools registry updated for agent pool', {
+      hasRegistry: !!toolsRegistry
+    });
+  }
+
+  /**
+   * Bulk refresh tool descriptions for all agents
+   * @param {Object} options - Refresh options
+   * @returns {Promise<Object>} Results summary
+   */
+  async bulkRefreshToolDescriptions(options = {}) {
+    const results = {
+      total: this.agents.size,
+      successful: 0,
+      failed: 0,
+      skipped: 0
+    };
+
+    for (const [agentId, agent] of this.agents.entries()) {
+      if (!agent.capabilities || agent.capabilities.length === 0) {
+        results.skipped++;
+        continue;
+      }
+
+      const success = await this.refreshAgentToolDescriptions(agentId, options);
+      if (success) {
+        results.successful++;
+      } else {
+        results.failed++;
+      }
+    }
+
+    this.logger?.info('Bulk tool descriptions refresh completed', results);
+    return results;
+  }
+
+  /**
+   * Set MessageProcessor reference for triggering responses
+   * @param {MessageProcessor} messageProcessor - MessageProcessor instance
+   */
+  setMessageProcessor(messageProcessor) {
+    this.messageProcessor = messageProcessor;
+  }
+
+  /**
+   * Set AgentScheduler reference for managing agent modes
+   * @param {AgentScheduler} scheduler - AgentScheduler instance
+   */
+  setScheduler(scheduler) {
+    this.scheduler = scheduler;
+
+    this.logger?.info('AgentScheduler reference set for agent pool', {
+      hasScheduler: !!scheduler
+    });
+  }
+
+  /**
+   * Set FileAttachmentService reference for cleaning up attachments
+   * @param {FileAttachmentService} fileAttachmentService - FileAttachmentService instance
+   */
+  setFileAttachmentService(fileAttachmentService) {
+    this.fileAttachmentService = fileAttachmentService;
+
+    this.logger?.info('FileAttachmentService reference set for agent pool', {
+      hasService: !!fileAttachmentService
+    });
+  }
+
+  // OLD INTER-AGENT MESSAGE QUEUE SYSTEM REMOVED
+  // Now using the new messageQueues system with AgentScheduler
+  // Inter-agent messages are queued via addInterAgentMessage() method
+
+  /**
+   * Add message to agent's user message queue
+   * @param {string} agentId - Agent ID
+   * @param {Object} message - User message to queue
+   * @returns {Promise<void>}
+   */
+  async addUserMessage(agentId, message) {
+    const agent = await this.getAgent(agentId);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+
+    const queuedMessage = {
+      ...message,
+      id: message.id || `user-msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      queuedAt: new Date().toISOString(),
+      timestamp: message.timestamp || new Date().toISOString()
+    };
+
+    agent.messageQueues.userMessages.push(queuedMessage);
+    await this.persistAgentState(agentId);
+
+    this.logger.info(`User message queued for agent: ${agentId}`, {
+      messageId: queuedMessage.id,
+      queueSize: agent.messageQueues.userMessages.length
+    });
+  }
+
+  /**
+   * Add message to agent's inter-agent message queue
+   * @param {string} agentId - Agent ID
+   * @param {Object} message - Inter-agent message to queue
+   * @returns {Promise<void>}
+   */
+  async addInterAgentMessage(agentId, message) {
+    const agent = await this.getAgent(agentId);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+
+    const queuedMessage = {
+      ...message,
+      id: message.id || message.messageId || `inter-agent-msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      queuedAt: new Date().toISOString(),
+      timestamp: message.timestamp || new Date().toISOString()
+    };
+
+    agent.messageQueues.interAgentMessages.push(queuedMessage);
+    await this.persistAgentState(agentId);
+
+    this.logger.info(`Inter-agent message queued for agent: ${agentId}`, {
+      messageId: queuedMessage.id,
+      sender: message.sender || message.senderName,
+      queueSize: agent.messageQueues.interAgentMessages.length
+    });
+  }
+
+  /**
+   * Add tool result to agent's tool results queue
+   * @param {string} agentId - Agent ID
+   * @param {Object} toolResult - Tool result to queue
+   * @returns {Promise<void>}
+   */
+  async addToolResult(agentId, toolResult) {
+    const agent = await this.getAgent(agentId);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+
+    const queuedResult = {
+      ...toolResult,
+      id: toolResult.id || `tool-result-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      queuedAt: new Date().toISOString(),
+      timestamp: toolResult.timestamp || new Date().toISOString()
+    };
+
+    agent.messageQueues.toolResults.push(queuedResult);
+    await this.persistAgentState(agentId);
+
+    this.logger.debug(`Tool result queued for agent: ${agentId}`, {
+      toolId: toolResult.toolId,
+      status: toolResult.status,
+      queueSize: agent.messageQueues.toolResults.length
+    });
+  }
+
+  /**
+   * Clear all message queues for an agent
+   * @param {string} agentId - Agent ID
+   * @returns {Promise<void>}
+   */
+  async clearAgentQueues(agentId) {
+    const agent = await this.getAgent(agentId);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+
+    agent.messageQueues.toolResults = [];
+    agent.messageQueues.interAgentMessages = [];
+    agent.messageQueues.userMessages = [];
+
+    await this.persistAgentState(agentId);
+
+    this.logger.info(`Message queues cleared for agent: ${agentId}`);
+  }
+
+  /**
+   * Get total queued messages count for an agent
+   * @param {string} agentId - Agent ID
+   * @returns {Promise<Object>} Queue counts by type
+   */
+  async getQueueCounts(agentId) {
+    const agent = await this.getAgent(agentId);
+    if (!agent) {
+      return { toolResults: 0, interAgentMessages: 0, userMessages: 0, total: 0 };
+    }
+
+    const counts = {
+      toolResults: agent.messageQueues.toolResults.length,
+      interAgentMessages: agent.messageQueues.interAgentMessages.length,
+      userMessages: agent.messageQueues.userMessages.length
+    };
+
+    counts.total = counts.toolResults + counts.interAgentMessages + counts.userMessages;
+
+    return counts;
+  }
+
+  /**
+   * Get messages for AI request - returns compacted if available, otherwise original
+   * CRITICAL FIX: Ensures compacted messages stay in sync with new messages after compaction
+   * This is the primary method that should be used when preparing messages for AI service
+   * @param {string} agentId - Agent ID
+   * @param {string} modelId - Model ID
+   * @returns {Promise<Array>} Messages array to send to AI
+   */
+  async getMessagesForAI(agentId, modelId) {
+    const ENABLE_COMPACT_DEBUG = process.env.COMPACT_DEBUG === 'true';
+
+    const agent = await this.getAgent(agentId);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+
+    const conversation = agent.conversations[modelId];
+    if (!conversation) {
+      this.logger.warn(`No conversation found for model: ${modelId}`, { agentId });
+      return [];
+    }
+
+    // If no compacted messages exist, return original
+    if (!conversation.compactizedMessages) {
+      this.logger.debug('Retrieved messages for AI (no compaction)', {
+        agentId,
+        modelId,
+        messageCount: conversation.messages.length
+      });
+
+      if (ENABLE_COMPACT_DEBUG) {
+        console.log('[GET-MESSAGES-FOR-AI]', {
+          agentId,
+          modelId,
+          returnedArray: 'originalMessages',
+          messageCount: conversation.messages.length,
+          reason: 'No compacted messages exist'
+        });
+      }
+
+      return conversation.messages;
+    }
+
+    // CRITICAL FIX: Check if new messages were added after compaction
+    // This fixes the bug where user input was ignored after compaction
+    const compactedLength = conversation.compactizedMessages.length;
+    const originalLength = conversation.messages.length;
+
+    if (originalLength > compactedLength) {
+      // New messages exist in original that aren't in compacted
+      const missingMessages = conversation.messages.slice(compactedLength);
+
+      this.logger.info('Syncing compacted messages with new messages', {
+        agentId,
+        modelId,
+        compactedLength,
+        originalLength,
+        missingCount: missingMessages.length
+      });
+
+      // Append missing messages to compacted array
+      conversation.compactizedMessages.push(...missingMessages);
+
+      // Persist the update
+      await this.persistAgentState(agentId);
+    }
+
+    this.logger.debug('Retrieved messages for AI (compacted + synced)', {
+      agentId,
+      modelId,
+      messageCount: conversation.compactizedMessages.length,
+      wasResynced: originalLength > compactedLength
+    });
+
+    if (ENABLE_COMPACT_DEBUG) {
+      console.log('[GET-MESSAGES-FOR-AI]', {
+        agentId,
+        modelId,
+        returnedArray: 'compactizedMessages',
+        messageCount: conversation.compactizedMessages.length,
+        originalMessageCount: conversation.messages.length,
+        wasSynced: originalLength > compactedLength,
+        syncedMessageCount: originalLength > compactedLength ? originalLength - compactedLength : 0,
+        reason: 'Compacted messages exist, returning compacted version'
+      });
+    }
+
+    return conversation.compactizedMessages;
+  }
+
+  /**
+   * Add message to conversation (stores in original messages array)
+   * @param {string} agentId - Agent ID
+   * @param {string} modelId - Model ID
+   * @param {Object} message - Message object to add
+   * @returns {Promise<void>}
+   */
+  async addMessageToConversation(agentId, modelId, message) {
+    const ENABLE_COMPACT_DEBUG = process.env.COMPACT_DEBUG === 'true';
+
+    const agent = await this.getAgent(agentId);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+
+    // Ensure model conversation exists
+    if (!agent.conversations[modelId]) {
+      agent.conversations[modelId] = this._createEmptyConversation(modelId);
+    }
+
+    const conversation = agent.conversations[modelId];
+
+    const originalLengthBefore = conversation.messages.length;
+    const compactedLengthBefore = conversation.compactizedMessages?.length || 0;
+
+    // Always add to original messages (never modify original)
+    conversation.messages.push({
+      ...message,
+      timestamp: message.timestamp || new Date().toISOString()
+    });
+
+    // If compacted version exists, also add to it (append new messages after compaction)
+    if (conversation.compactizedMessages) {
+      conversation.compactizedMessages.push({
+        ...message,
+        timestamp: message.timestamp || new Date().toISOString()
+      });
+    }
+
+    conversation.lastUpdated = new Date().toISOString();
+
+    if (ENABLE_COMPACT_DEBUG) {
+      console.log('[ADD-MESSAGE-TO-CONVERSATION]', {
+        agentId,
+        modelId,
+        role: message.role,
+        hasCompactedVersion: !!conversation.compactizedMessages,
+        originalMessages: {
+          before: originalLengthBefore,
+          after: conversation.messages.length,
+          added: 1
+        },
+        compactizedMessages: conversation.compactizedMessages ? {
+          before: compactedLengthBefore,
+          after: conversation.compactizedMessages.length,
+          added: 1
+        } : null,
+        behavior: conversation.compactizedMessages ? 'Added to BOTH arrays' : 'Added to original only'
+      });
+    }
+
+    await this.persistAgentState(agentId);
+
+    this.logger.debug('Message added to conversation', {
+      agentId,
+      modelId,
+      role: message.role,
+      hasCompacted: !!conversation.compactizedMessages
+    });
+  }
+
+  /**
+   * Update compacted messages after compactization
+   * @param {string} agentId - Agent ID
+   * @param {string} modelId - Model ID
+   * @param {Object} compactionResult - Compaction result with messages and metadata
+   * @returns {Promise<void>}
+   */
+  async updateCompactedMessages(agentId, modelId, compactionResult) {
+    const agent = await this.getAgent(agentId);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+
+    // Ensure model conversation exists (important for model switching scenarios)
+    if (!agent.conversations[modelId]) {
+      agent.conversations[modelId] = this._createEmptyConversation(modelId);
+      this.logger.debug(`Created conversation for model switching: ${modelId}`);
+    }
+
+    const conversation = agent.conversations[modelId];
+
+    // Update compacted messages
+    conversation.compactizedMessages = compactionResult.compactedMessages;
+
+    // Update metadata
+    conversation.lastCompactization = new Date().toISOString();
+    conversation.compactizationCount += 1;
+    conversation.compactizationStrategy = compactionResult.strategy;
+    conversation.originalTokenCount = compactionResult.originalTokenCount;
+    conversation.compactedTokenCount = compactionResult.compactedTokenCount;
+    conversation.tokenCount = compactionResult.compactedTokenCount;
+    conversation.lastUpdated = new Date().toISOString();
+
+    await this.persistAgentState(agentId);
+
+    this.logger.info('Compacted messages updated', {
+      agentId,
+      modelId,
+      strategy: compactionResult.strategy,
+      originalTokens: compactionResult.originalTokenCount,
+      compactedTokens: compactionResult.compactedTokenCount,
+      reductionPercent: compactionResult.reductionPercent,
+      compactizationCount: conversation.compactizationCount
+    });
+  }
+
+  /**
+   * Clear compacted messages and revert to original
+   * Useful for debugging or if compaction needs to be redone
+   * @param {string} agentId - Agent ID
+   * @param {string} modelId - Model ID
+   * @returns {Promise<void>}
+   */
+  async clearCompactedMessages(agentId, modelId) {
+    const agent = await this.getAgent(agentId);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+
+    const conversation = agent.conversations[modelId];
+    if (!conversation) {
+      return;
+    }
+
+    conversation.compactizedMessages = null;
+    conversation.lastCompactization = null;
+    conversation.compactizationCount = 0;
+    conversation.compactizationStrategy = null;
+    conversation.originalTokenCount = 0;
+    conversation.compactedTokenCount = 0;
+    conversation.tokenCount = 0;
+
+    await this.persistAgentState(agentId);
+
+    this.logger.info('Compacted messages cleared', { agentId, modelId });
+  }
+
+  /**
+   * Get compaction metadata for a conversation
+   * @param {string} agentId - Agent ID
+   * @param {string} modelId - Model ID
+   * @returns {Promise<Object|null>} Compaction metadata or null if no compaction
+   */
+  async getCompactionMetadata(agentId, modelId) {
+    const agent = await this.getAgent(agentId);
+    if (!agent) {
+      return null;
+    }
+
+    const conversation = agent.conversations[modelId];
+    if (!conversation) {
+      return null;
+    }
+
+    // Return metadata whether compacted or not
+    const isCompacted = !!conversation.compactizedMessages;
+
+    return {
+      isCompacted,
+      lastCompactization: conversation.lastCompactization || null,
+      compactizationCount: conversation.compactizationCount || 0,
+      strategy: conversation.compactizationStrategy || null,
+      originalTokenCount: conversation.originalTokenCount || 0,
+      compactedTokenCount: conversation.compactedTokenCount || 0,
+      reductionPercent: conversation.originalTokenCount > 0
+        ? ((conversation.originalTokenCount - conversation.compactedTokenCount) / conversation.originalTokenCount) * 100
+        : 0,
+      originalMessages: conversation.messages || [],
+      compactedMessages: conversation.compactizedMessages || null,
+      originalMessageCount: conversation.messages?.length || 0,
+      compactedMessageCount: conversation.compactizedMessages?.length || 0
+    };
+  }
+
+  /**
+   * Migrate existing agent conversations to dual storage structure
+   * Ensures backward compatibility with existing agents
+   * @param {string} agentId - Agent ID
+   * @returns {Promise<boolean>} True if migration was needed and performed
+   */
+  async migrateConversationStructure(agentId) {
+    const agent = await this.getAgent(agentId);
+    if (!agent) {
+      return false;
+    }
+
+    let migrated = false;
+
+    // Check each conversation for migration needs
+    for (const [modelId, conversation] of Object.entries(agent.conversations)) {
+      if (modelId === 'full') continue; // Skip full conversation
+
+      // Check if conversation needs migration (missing new fields)
+      if (conversation.compactizedMessages === undefined) {
+        // Add new fields
+        conversation.compactizedMessages = null;
+        conversation.lastCompactization = null;
+        conversation.compactizationCount = 0;
+        conversation.compactizationStrategy = null;
+        conversation.originalTokenCount = 0;
+        conversation.compactedTokenCount = 0;
+
+        migrated = true;
+
+        this.logger.info('Migrated conversation structure', {
+          agentId,
+          modelId,
+          messageCount: conversation.messages?.length || 0
+        });
+      }
+    }
+
+    if (migrated) {
+      await this.persistAgentState(agentId);
+    }
+
+    return migrated;
+  }
+
+  /**
+   * Create empty conversation structure with all required fields
+   * @private
+   * @param {string} modelId - Model ID
+   * @returns {Object} Empty conversation structure
+   */
+  _createEmptyConversation(modelId) {
+    return {
+      messages: [],
+      compactizedMessages: null,
+      lastCompactization: null,
+      compactizationCount: 0,
+      compactizationStrategy: null,
+      originalTokenCount: 0,
+      compactedTokenCount: 0,
+      tokenCount: 0,
+      lastUpdated: new Date().toISOString(),
+      formatVersion: this._getModelFormatVersion(modelId)
+    };
+  }
+}
+
+export default AgentPool;