claude-flow-novice 1.6.4 → 1.6.5

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/sdk/query-controller.js

@@ -0,0 +1,740 @@
+/**
+ * Agent Coordination V2 - QueryController
+ *
+ * Implements zero-cost agent pausing, resume-from-checkpoint, and dynamic resource allocation.
+ *
+ * @module coordination/v2/sdk/query-controller
+ */ import { EventEmitter } from 'node:events';
+import { Logger } from '../../../core/logger.js';
+import { generateId } from '../../../utils/helpers.js';
+import { HelpCoordinator } from '../help-system/help-coordinator.js';
+import { AgentState as AgentStateEnum } from '../../shared/core/agent-state.js';
+/**
+ * QueryController - Manages agent lifecycle with zero-cost pause/resume
+ *
+ * Features:
+ * - Pause agents mid-execution with zero token cost
+ * - Resume from exact message UUID checkpoint
+ * - Dynamic resource allocation (pause low-priority agents)
+ * - Event-driven resume triggers
+ * - Idle agent token consumption = 0
+ */ export class QueryController extends EventEmitter {
+    logger;
+    config;
+    sessions;
+    checkpoints;
+    resourceAllocations;
+    metrics;
+    agents;
+    coordinatorMetrics;
+    ready;
+    startTime;
+    /** Help coordinator for agent helper registration */ helpCoordinator;
+    constructor(config = {}){
+        super();
+        this.logger = new Logger({
+            level: 'info',
+            format: 'text',
+            destination: 'console'
+        });
+        this.config = {
+            maxConcurrentAgents: config.maxConcurrentAgents ?? 10,
+            defaultTokenBudget: config.defaultTokenBudget ?? 10000,
+            pauseTimeoutMs: config.pauseTimeoutMs ?? 5000,
+            resumeTimeoutMs: config.resumeTimeoutMs ?? 5000,
+            enableDynamicAllocation: config.enableDynamicAllocation ?? true
+        };
+        this.sessions = new Map();
+        this.checkpoints = new Map();
+        this.resourceAllocations = new Map();
+        this.metrics = this.initializeMetrics();
+        this.agents = new Map();
+        this.coordinatorMetrics = this.initializeCoordinatorMetrics();
+        this.ready = false;
+        this.startTime = Date.now();
+        // Initialize help coordinator for agent helper registration
+        this.helpCoordinator = new HelpCoordinator();
+        this.logger.info('QueryController initialized', {
+            maxConcurrentAgents: this.config.maxConcurrentAgents,
+            enableDynamicAllocation: this.config.enableDynamicAllocation
+        });
+    }
+    /**
+   * Register agent session for query control
+   */ registerSession(agentId, sessionId, priority = 5) {
+        const session = {
+            sessionId,
+            agentId,
+            state: 'idle',
+            isPaused: false,
+            checkpoints: [],
+            priority,
+            metadata: {}
+        };
+        this.sessions.set(sessionId, session);
+        this.checkpoints.set(sessionId, []);
+        this.resourceAllocations.set(agentId, {
+            agentId,
+            priority,
+            tokenBudget: this.config.defaultTokenBudget,
+            currentUsage: 0,
+            paused: false
+        });
+        // Also create agent entry for ICoordinator compatibility
+        const agent = {
+            agentId,
+            sessionId,
+            type: 'unknown',
+            state: 'idle',
+            isPaused: false,
+            priority,
+            session,
+            metadata: {}
+        };
+        this.agents.set(agentId, agent);
+        this.logger.debug('Session registered', {
+            agentId,
+            sessionId,
+            priority
+        });
+        return session;
+    }
+    /**
+   * Interrupt agent mid-execution (zero token cost)
+   * Pauses agent and creates checkpoint for resumption
+   */ async interrupt(sessionId, reason = 'Manual interrupt') {
+        const startTime = Date.now();
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        if (session.isPaused) {
+            this.logger.warn('Session already paused', {
+                sessionId
+            });
+            return {
+                success: false,
+                sessionId,
+                agentId: session.agentId,
+                pausedAt: new Date(),
+                checkpoint: session.checkpoints[session.checkpoints.length - 1],
+                latencyMs: Date.now() - startTime
+            };
+        }
+        // Create checkpoint at current message UUID
+        const checkpoint = {
+            id: generateId('checkpoint'),
+            sessionId,
+            agentId: session.agentId,
+            messageUUID: session.currentMessageUUID ?? generateId('msg'),
+            state: session.state,
+            timestamp: new Date(),
+            metadata: {
+                reason,
+                autoCheckpoint: false,
+                context: {
+                    ...session.metadata
+                }
+            }
+        };
+        // Update session state
+        session.isPaused = true;
+        session.checkpoints.push(checkpoint);
+        // Store checkpoint
+        const checkpointList = this.checkpoints.get(sessionId) ?? [];
+        checkpointList.push(checkpoint);
+        this.checkpoints.set(sessionId, checkpointList);
+        // Update resource allocation
+        const allocation = this.resourceAllocations.get(session.agentId);
+        if (allocation) {
+            allocation.paused = true;
+        }
+        // Update agent isPaused state for ICoordinator compatibility
+        const agent = this.agents.get(session.agentId);
+        if (agent) {
+            agent.isPaused = true;
+        }
+        const latencyMs = Math.max(Date.now() - startTime, 0.001); // Ensure non-zero for metrics
+        // Update metrics
+        this.metrics.totalPauses++;
+        this.metrics.averagePauseLatencyMs = (this.metrics.averagePauseLatencyMs * (this.metrics.totalPauses - 1) + latencyMs) / this.metrics.totalPauses;
+        this.metrics.idleAgents++;
+        const result = {
+            success: true,
+            sessionId,
+            agentId: session.agentId,
+            pausedAt: checkpoint.timestamp,
+            checkpoint,
+            latencyMs
+        };
+        this.logger.info('Agent paused', {
+            agentId: session.agentId,
+            sessionId,
+            latencyMs,
+            checkpointId: checkpoint.id
+        });
+        this.emit('agent:paused', result);
+        return result;
+    }
+    /**
+   * Resume agent from exact checkpoint
+   * Restores agent state from messageUUID with <50ms latency
+   */ async resumeSessionAt(sessionId, messageUUID, reason = 'Manual resume') {
+        const startTime = Date.now();
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        if (!session.isPaused) {
+            this.logger.warn('Session not paused', {
+                sessionId
+            });
+            return {
+                success: false,
+                sessionId,
+                agentId: session.agentId,
+                resumedAt: new Date(),
+                latencyMs: Date.now() - startTime
+            };
+        }
+        // Find checkpoint to resume from
+        let checkpoint;
+        if (messageUUID) {
+            checkpoint = session.checkpoints.find((cp)=>cp.messageUUID === messageUUID);
+            if (!checkpoint) {
+                throw new Error(`Checkpoint with messageUUID ${messageUUID} not found`);
+            }
+        } else {
+            // Use latest checkpoint
+            checkpoint = session.checkpoints[session.checkpoints.length - 1];
+        }
+        // Restore session state from checkpoint
+        session.isPaused = false;
+        session.state = checkpoint.state;
+        session.currentMessageUUID = checkpoint.messageUUID;
+        session.metadata = {
+            ...checkpoint.metadata.context
+        };
+        // Update resource allocation
+        const allocation = this.resourceAllocations.get(session.agentId);
+        if (allocation) {
+            allocation.paused = false;
+        }
+        // Update agent isPaused state for ICoordinator compatibility
+        const agent = this.agents.get(session.agentId);
+        if (agent) {
+            agent.isPaused = false;
+        }
+        const latencyMs = Math.max(Date.now() - startTime, 0.001); // Ensure non-zero for metrics
+        // Update metrics
+        this.metrics.totalResumes++;
+        this.metrics.averageResumeLatencyMs = (this.metrics.averageResumeLatencyMs * (this.metrics.totalResumes - 1) + latencyMs) / this.metrics.totalResumes;
+        this.metrics.idleAgents = Math.max(0, this.metrics.idleAgents - 1);
+        const result = {
+            success: true,
+            sessionId,
+            agentId: session.agentId,
+            resumedAt: new Date(),
+            resumedFromCheckpoint: checkpoint,
+            latencyMs
+        };
+        this.logger.info('Agent resumed', {
+            agentId: session.agentId,
+            sessionId,
+            latencyMs,
+            checkpointId: checkpoint.id,
+            messageUUID: checkpoint.messageUUID
+        });
+        this.emit('agent:resumed', result);
+        return result;
+    }
+    /**
+   * Dynamic resource allocation - pause low-priority agents
+   * Frees up resources for high-priority agents
+   */ async pauseLowPriorityAgents(priorityThreshold) {
+        const results = [];
+        for (const [sessionId, session] of this.sessions.entries()){
+            if (session.priority < priorityThreshold && !session.isPaused) {
+                try {
+                    const result = await this.interrupt(sessionId, `Dynamic allocation: priority ${session.priority} < threshold ${priorityThreshold}`);
+                    results.push(result);
+                    // Estimate token savings
+                    const allocation = this.resourceAllocations.get(session.agentId);
+                    if (allocation) {
+                        this.metrics.tokensSaved += allocation.tokenBudget - allocation.currentUsage;
+                    }
+                } catch (error) {
+                    this.logger.error('Failed to pause low-priority agent', {
+                        sessionId,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+        }
+        this.logger.info('Dynamic allocation completed', {
+            agentsPaused: results.length,
+            priorityThreshold,
+            tokensSaved: this.metrics.tokensSaved
+        });
+        return results;
+    }
+    /**
+   * Event-driven resume trigger
+   * Resumes agents based on external events (dependency resolution, help requests, etc.)
+   */ async handleResumeTrigger(trigger) {
+        this.logger.debug('Resume trigger received', trigger);
+        // Find paused agent by ID
+        let targetSession;
+        for (const session of this.sessions.values()){
+            if (session.agentId === trigger.agentId && session.isPaused) {
+                targetSession = session;
+                break;
+            }
+        }
+        if (!targetSession) {
+            this.logger.warn('No paused session found for trigger', {
+                agentId: trigger.agentId,
+                triggerType: trigger.type
+            });
+            return null;
+        }
+        const reason = `Event trigger: ${trigger.type}`;
+        const result = await this.resumeSessionAt(targetSession.sessionId, undefined, reason);
+        this.emit('resume:triggered', {
+            trigger,
+            result
+        });
+        return result;
+    }
+    /**
+   * Get query control metrics (legacy method)
+   */ getQueryControlMetrics() {
+        return {
+            ...this.metrics
+        };
+    }
+    /**
+   * Get all paused sessions (legacy method)
+   */ getPausedSessions() {
+        return Array.from(this.sessions.values()).filter((s)=>s.isPaused);
+    }
+    /**
+   * Get active sessions (legacy method)
+   */ getActiveSessions() {
+        return Array.from(this.sessions.values()).filter((s)=>!s.isPaused);
+    }
+    /**
+   * Check if agent is paused
+   */ isPaused(sessionId) {
+        const session = this.sessions.get(sessionId);
+        return session?.isPaused ?? false;
+    }
+    /**
+   * Get checkpoint history for session
+   */ getCheckpoints(sessionId) {
+        return this.checkpoints.get(sessionId) ?? [];
+    }
+    /**
+   * Get resource allocation for agent
+   */ getResourceAllocation(agentId) {
+        return this.resourceAllocations.get(agentId);
+    }
+    /**
+   * Update token usage for agent (internal synchronous method)
+   */ updateTokenUsageInternal(agentId, tokensUsed) {
+        const allocation = this.resourceAllocations.get(agentId);
+        if (allocation) {
+            allocation.currentUsage += tokensUsed;
+            // Auto-pause if exceeding budget
+            if (allocation.currentUsage > allocation.tokenBudget && !allocation.paused) {
+                this.logger.warn('Agent exceeding token budget', {
+                    agentId,
+                    current: allocation.currentUsage,
+                    budget: allocation.tokenBudget
+                });
+                // Find session and pause
+                for (const session of this.sessions.values()){
+                    if (session.agentId === agentId && !session.isPaused) {
+                        this.interrupt(session.sessionId, 'Token budget exceeded').catch((err)=>{
+                            this.logger.error('Auto-pause failed', {
+                                agentId,
+                                error: err
+                            });
+                        });
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    /**
+   * Get help coordinator instance for external access
+   */ getHelpCoordinator() {
+        return this.helpCoordinator;
+    }
+    /**
+   * Cleanup - terminate all sessions
+   */ async cleanup() {
+        this.logger.info('Cleaning up query controller', {
+            totalSessions: this.sessions.size,
+            pausedAgents: this.getPausedSessions().length
+        });
+        // Clear help coordinator
+        this.helpCoordinator.clear();
+        this.sessions.clear();
+        this.checkpoints.clear();
+        this.resourceAllocations.clear();
+        this.agents.clear();
+        this.removeAllListeners();
+        this.ready = false;
+    }
+    // ===========================
+    // ICoordinator Implementation
+    // ===========================
+    /**
+   * Initialize coordinator - ICoordinator interface
+   */ async initialize() {
+        this.logger.info('Initializing QueryController coordinator');
+        // Coordinator is ready after construction
+        this.ready = true;
+        this.startTime = Date.now();
+        this.emit('coordinator:initialized');
+    }
+    /**
+   * Check if coordinator is ready - ICoordinator interface
+   */ isReady() {
+        return this.ready;
+    }
+    /**
+   * Spawn agent - ICoordinator interface
+   */ async spawnAgent(config) {
+        if (!this.ready) {
+            throw new Error('Coordinator not initialized. Call initialize() first.');
+        }
+        if (this.agents.size >= this.config.maxConcurrentAgents) {
+            throw new Error(`Maximum concurrent agents (${this.config.maxConcurrentAgents}) reached`);
+        }
+        const sessionId = config.sessionId ?? generateId('session');
+        const agentId = config.agentId;
+        const priority = config.priority ?? 5;
+        const tokenBudget = config.tokenBudget ?? this.config.defaultTokenBudget;
+        // Register session
+        const session = this.registerSession(agentId, sessionId, priority);
+        // Create agent instance
+        const agent = {
+            agentId,
+            sessionId,
+            type: config.type,
+            state: config.initialState ?? 'idle',
+            isPaused: false,
+            priority,
+            session,
+            metadata: config.metadata ?? {}
+        };
+        // Store agent
+        this.agents.set(agentId, agent);
+        // Register as helper if capabilities provided
+        if (config.metadata?.capabilities && Array.isArray(config.metadata.capabilities)) {
+            const agentProfile = {
+                agentId,
+                type: config.type,
+                state: agent.state,
+                capabilities: config.metadata.capabilities,
+                priority,
+                workload: 0.0,
+                metadata: config.metadata
+            };
+            this.helpCoordinator.registerAgent(agentProfile);
+            this.logger.debug('Agent registered as helper', {
+                agentId,
+                capabilities: config.metadata.capabilities.map((c)=>c.name)
+            });
+        }
+        // Update coordinator metrics
+        this.coordinatorMetrics.totalAgentsSpawned++;
+        this.coordinatorMetrics.activeAgents++;
+        this.logger.info('Agent spawned', {
+            agentId,
+            type: config.type,
+            priority,
+            tokenBudget
+        });
+        this.emit('agent:spawned', agent);
+        return agent;
+    }
+    /**
+   * Pause agent - ICoordinator interface
+   */ async pauseAgent(agentId, reason) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        if (agent.isPaused) {
+            this.logger.warn('Agent already paused', {
+                agentId
+            });
+            return;
+        }
+        // Use existing interrupt method
+        await this.interrupt(agent.sessionId, reason ?? 'Manual pause');
+        // Update agent state
+        agent.isPaused = true;
+        // Update help coordinator state
+        this.helpCoordinator.updateAgentState(agentId, AgentStateEnum.PAUSED);
+        // Update coordinator metrics
+        this.coordinatorMetrics.activeAgents--;
+        this.coordinatorMetrics.pausedAgents++;
+    }
+    /**
+   * Resume agent - ICoordinator interface
+   */ async resumeAgent(agentId, checkpointId, messageUUID) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        if (!agent.isPaused) {
+            this.logger.warn('Agent not paused', {
+                agentId
+            });
+            return;
+        }
+        // Use existing resumeSessionAt method
+        await this.resumeSessionAt(agent.sessionId, messageUUID, 'Resume from coordinator');
+        // Update agent state
+        agent.isPaused = false;
+        // Update help coordinator state (resumed agents go to IDLE or WORKING)
+        this.helpCoordinator.updateAgentState(agentId, agent.state);
+        // Update coordinator metrics
+        this.coordinatorMetrics.pausedAgents--;
+        this.coordinatorMetrics.activeAgents++;
+    }
+    /**
+   * Terminate agent - ICoordinator interface
+   */ async terminateAgent(agentId, reason) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        // Create final checkpoint before termination
+        if (!agent.isPaused) {
+            await this.createCheckpoint(agentId, `Termination: ${reason ?? 'Manual termination'}`);
+        }
+        // Unregister helper if registered
+        this.helpCoordinator.unregisterAgent(agentId);
+        this.logger.debug('Agent unregistered from help coordinator', {
+            agentId
+        });
+        // Remove agent
+        this.agents.delete(agentId);
+        // Remove session
+        this.sessions.delete(agent.sessionId);
+        // Update coordinator metrics
+        if (agent.isPaused) {
+            this.coordinatorMetrics.pausedAgents--;
+        } else {
+            this.coordinatorMetrics.activeAgents--;
+        }
+        this.coordinatorMetrics.totalTerminations++;
+        this.logger.info('Agent terminated', {
+            agentId,
+            reason
+        });
+        this.emit('agent:terminated', {
+            agentId,
+            reason
+        });
+    }
+    /**
+   * Get agent state - ICoordinator interface
+   */ async getAgentState(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        return agent.state;
+    }
+    /**
+   * Get agent session - ICoordinator interface
+   */ async getAgentSession(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        const session = this.sessions.get(agent.sessionId);
+        if (!session) {
+            throw new Error(`Session ${agent.sessionId} not found`);
+        }
+        return session;
+    }
+    /**
+   * Create checkpoint - ICoordinator interface
+   */ async createCheckpoint(agentId, reason, metadata) {
+        const startTime = Date.now();
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        const session = this.sessions.get(agent.sessionId);
+        if (!session) {
+            throw new Error(`Session ${agent.sessionId} not found`);
+        }
+        const checkpoint = {
+            id: generateId('checkpoint'),
+            sessionId: agent.sessionId,
+            agentId,
+            messageUUID: session.currentMessageUUID ?? generateId('msg'),
+            state: agent.state,
+            timestamp: new Date(),
+            metadata: {
+                reason: reason ?? 'Manual checkpoint',
+                autoCheckpoint: false,
+                context: metadata
+            }
+        };
+        // Store checkpoint in session
+        session.checkpoints.push(checkpoint);
+        // Store in checkpoints map
+        const checkpointList = this.checkpoints.get(agent.sessionId) ?? [];
+        checkpointList.push(checkpoint);
+        this.checkpoints.set(agent.sessionId, checkpointList);
+        const latencyMs = Date.now() - startTime;
+        // Update coordinator metrics
+        this.coordinatorMetrics.totalCheckpoints++;
+        this.coordinatorMetrics.averageCheckpointTimeMs = (this.coordinatorMetrics.averageCheckpointTimeMs * (this.coordinatorMetrics.totalCheckpoints - 1) + latencyMs) / this.coordinatorMetrics.totalCheckpoints;
+        this.logger.debug('Checkpoint created', {
+            agentId,
+            checkpointId: checkpoint.id,
+            latencyMs
+        });
+        this.emit('checkpoint:created', checkpoint);
+        return checkpoint;
+    }
+    /**
+   * Restore checkpoint - ICoordinator interface
+   */ async restoreCheckpoint(checkpointId) {
+        const startTime = Date.now();
+        // Find checkpoint across all sessions
+        let foundCheckpoint;
+        let foundSessionId;
+        for (const [sessionId, checkpoints] of this.checkpoints.entries()){
+            const checkpoint = checkpoints.find((cp)=>cp.id === checkpointId);
+            if (checkpoint) {
+                foundCheckpoint = checkpoint;
+                foundSessionId = sessionId;
+                break;
+            }
+        }
+        if (!foundCheckpoint || !foundSessionId) {
+            throw new Error(`Checkpoint ${checkpointId} not found`);
+        }
+        const agent = this.agents.get(foundCheckpoint.agentId);
+        if (!agent) {
+            throw new Error(`Agent ${foundCheckpoint.agentId} not found for checkpoint`);
+        }
+        // Resume from checkpoint
+        await this.resumeSessionAt(foundSessionId, foundCheckpoint.messageUUID);
+        // Update agent state
+        agent.state = foundCheckpoint.state;
+        agent.isPaused = false;
+        const latencyMs = Date.now() - startTime;
+        // Update coordinator metrics
+        this.coordinatorMetrics.totalRestores++;
+        this.coordinatorMetrics.averageRestoreTimeMs = (this.coordinatorMetrics.averageRestoreTimeMs * (this.coordinatorMetrics.totalRestores - 1) + latencyMs) / this.coordinatorMetrics.totalRestores;
+        // Update p99 (simplified - use max of avg and current)
+        this.coordinatorMetrics.p99RestoreTimeMs = Math.max(this.coordinatorMetrics.p99RestoreTimeMs, latencyMs);
+        this.logger.info('Checkpoint restored', {
+            checkpointId,
+            agentId: agent.agentId,
+            latencyMs
+        });
+        this.emit('checkpoint:restored', {
+            checkpoint: foundCheckpoint,
+            agent
+        });
+        return agent;
+    }
+    /**
+   * List checkpoints - ICoordinator interface
+   */ async listCheckpoints(agentId, limit) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        const checkpoints = this.checkpoints.get(agent.sessionId) ?? [];
+        // Sort by timestamp descending (newest first)
+        const sorted = [
+            ...checkpoints
+        ].sort((a, b)=>b.timestamp.getTime() - a.timestamp.getTime());
+        // Apply limit if specified
+        return limit ? sorted.slice(0, limit) : sorted;
+    }
+    /**
+   * Get coordinator metrics - ICoordinator interface (overrides existing getMetrics)
+   * Includes both CoordinatorMetrics and legacy QueryControlMetrics fields
+   */ getMetrics() {
+        // Update uptime
+        this.coordinatorMetrics.uptimeMs = Date.now() - this.startTime;
+        // Sync metrics from QueryControlMetrics
+        this.coordinatorMetrics.tokensSaved = this.metrics.tokensSaved;
+        // Return merged metrics for backward compatibility
+        return {
+            ...this.coordinatorMetrics,
+            ...this.metrics
+        };
+    }
+    /**
+   * Get active agents - ICoordinator interface (overrides existing)
+   */ getActiveAgents() {
+        return Array.from(this.agents.values()).filter((agent)=>!agent.isPaused);
+    }
+    /**
+   * Get paused agents - ICoordinator interface (overrides existing)
+   */ getPausedAgents() {
+        return Array.from(this.agents.values()).filter((agent)=>agent.isPaused);
+    }
+    /**
+   * Update token usage - ICoordinator interface
+   */ async updateTokenUsage(agentId, tokensUsed) {
+        // Delegate to existing synchronous method
+        this.updateTokenUsageInternal(agentId, tokensUsed);
+        // Update coordinator metrics
+        this.coordinatorMetrics.totalTokensUsed += tokensUsed;
+        // Update help coordinator workload (tokens used / budget)
+        const allocation = this.resourceAllocations.get(agentId);
+        if (allocation) {
+            const workload = Math.min(1.0, allocation.currentUsage / allocation.tokenBudget);
+            this.helpCoordinator.updateAgentWorkload(agentId, workload);
+        }
+    }
+    // ===========================
+    // Private Helpers
+    // ===========================
+    initializeMetrics() {
+        return {
+            totalPauses: 0,
+            totalResumes: 0,
+            averagePauseLatencyMs: 0,
+            averageResumeLatencyMs: 0,
+            tokensSaved: 0,
+            idleAgents: 0
+        };
+    }
+    initializeCoordinatorMetrics() {
+        return {
+            totalAgentsSpawned: 0,
+            activeAgents: 0,
+            pausedAgents: 0,
+            totalTerminations: 0,
+            totalCheckpoints: 0,
+            totalRestores: 0,
+            averageCheckpointTimeMs: 0,
+            averageRestoreTimeMs: 0,
+            p99RestoreTimeMs: 0,
+            tokensSaved: 0,
+            totalTokensUsed: 0,
+            uptimeMs: 0
+        };
+    }
+}
+
+//# sourceMappingURL=query-controller.js.map