agentic-qe 2.5.10 → 2.6.1

package/dist/agents/pool/AgentPool.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Agent Pool Implementation
+ * Phase 3 D1: Memory Pooling for 16x Agent Spawn Speedup
+ *
+ * Target Performance:
+ * - Spawn time: <6ms (down from ~50-100ms)
+ * - Memory stable under load
+ * - Graceful degradation when exhausted
+ *
+ * Architecture:
+ * - Pre-allocated agent instances per type
+ * - Thread-safe acquire/release with mutex
+ * - Automatic pool expansion on demand
+ * - Health monitoring and recovery
+ */
+import { EventEmitter } from 'events';
+import { QEAgentType } from '../../types';
+import { AgentPoolConfig, PoolStats, AcquireOptions, ReleaseOptions, AcquireResult, IResettableAgent } from './types';
+/**
+ * Agent Pool - Pre-allocated agent instance management
+ *
+ * @example
+ * ```typescript
+ * const pool = new AgentPool(factory, config);
+ * await pool.warmup();
+ *
+ * // Fast acquisition (<6ms)
+ * const { agent, meta } = await pool.acquire('test-generator');
+ *
+ * // Use agent...
+ * await agent.executeTask(task);
+ *
+ * // Return to pool
+ * await pool.release(meta.poolId);
+ * ```
+ */
+export declare class AgentPool<T extends IResettableAgent> extends EventEmitter {
+    private readonly config;
+    private readonly factory;
+    private readonly pools;
+    private readonly agentsByPoolId;
+    private readonly waitingQueues;
+    private readonly mutexes;
+    private stats;
+    private healthCheckTimer;
+    private isShuttingDown;
+    constructor(factory: AgentFactory<T>, config?: Partial<AgentPoolConfig>);
+    /**
+     * Warm up the pool by pre-creating agents
+     * Should be called during application startup
+     */
+    warmup(types?: QEAgentType[]): Promise<void>;
+    /**
+     * Acquire an agent from the pool
+     * Returns immediately if available, otherwise waits or creates new
+     *
+     * @param type - Agent type to acquire
+     * @param options - Acquisition options
+     * @returns Acquired agent with metadata
+     */
+    acquire(type: QEAgentType, options?: AcquireOptions): Promise<AcquireResult<T>>;
+    /**
+     * Release an agent back to the pool
+     *
+     * @param poolId - Pool ID of the agent to release
+     * @param options - Release options
+     */
+    release(poolId: string, options?: ReleaseOptions): Promise<void>;
+    /**
+     * Get current pool statistics
+     */
+    getStats(): PoolStats;
+    /**
+     * Shutdown the pool and dispose all agents
+     */
+    shutdown(): Promise<void>;
+    private getPool;
+    private getTypeConfig;
+    private getConfiguredTypes;
+    private createPooledAgent;
+    private addToPool;
+    private tryAcquireFromPool;
+    private canCreateMore;
+    private getWaitingCount;
+    private waitForAgent;
+    private removeWaitingRequest;
+    private fulfillWaitingRequest;
+    private disposeAgent;
+    private replenishPool;
+    private recordAcquisition;
+    private startHealthCheck;
+    private performHealthCheck;
+    private log;
+}
+/**
+ * Factory interface for creating agents
+ */
+export interface AgentFactory<T extends IResettableAgent> {
+    /**
+     * Create a new agent instance
+     */
+    create(type: QEAgentType): Promise<T>;
+    /**
+     * Initialize an agent (heavy async operations)
+     */
+    initialize(agent: T): Promise<void>;
+    /**
+     * Dispose an agent (cleanup resources)
+     */
+    dispose(agent: T): Promise<void>;
+}
+//# sourceMappingURL=AgentPool.d.ts.map

package/dist/agents/pool/AgentPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentPool.d.ts","sourceRoot":"","sources":["../../../src/agents/pool/AgentPool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EACL,eAAe,EAIf,SAAS,EAET,cAAc,EACd,cAAc,EACd,aAAa,EAEb,gBAAgB,EACjB,MAAM,SAAS,CAAC;AA2CjB;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,SAAS,CAAC,CAAC,SAAS,gBAAgB,CAAE,SAAQ,YAAY;IACrE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkB;IACzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkB;IAG1C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAsD;IAG5E,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA+C;IAG9E,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAoD;IAGlF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8C;IAGtE,OAAO,CAAC,KAAK,CAIX;IAGF,OAAO,CAAC,gBAAgB,CAA+B;IAGvD,OAAO,CAAC,cAAc,CAAS;gBAG7B,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,EACxB,MAAM,GAAE,OAAO,CAAC,eAAe,CAAM;IAavC;;;OAGG;IACG,MAAM,CAAC,KAAK,CAAC,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAoClD;;;;;;;OAOG;IACG,OAAO,CACX,IAAI,EAAE,WAAW,EACjB,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;IAgF5B;;;;;OAKG;IACG,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAmD1E;;OAEG;IACH,QAAQ,IAAI,SAAS;IA8DrB;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAoC/B,OAAO,CAAC,OAAO;IASf,OAAO,CAAC,aAAa;IAMrB,OAAO,CAAC,kBAAkB;YAeZ,iBAAiB;IAqC/B,OAAO,CAAC,SAAS;YAMH,kBAAkB;IA0ChC,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,eAAe;YAKT,YAAY;IA6C1B,OAAO,CAAC,oBAAoB;YAUd,qBAAqB;YAkBrB,YAAY;YAkCZ,aAAa;IAmB3B,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,gBAAgB;YAMV,kBAAkB;IAsBhC,OAAO,CAAC,GAAG;CAKZ;AAED;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,gBAAgB;IACtD;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAEtC;;OAEG;IACH,UAAU,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEpC;;OAEG;IACH,OAAO,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAClC"}

package/dist/agents/pool/AgentPool.js

@@ -0,0 +1,573 @@
+"use strict";
+/**
+ * Agent Pool Implementation
+ * Phase 3 D1: Memory Pooling for 16x Agent Spawn Speedup
+ *
+ * Target Performance:
+ * - Spawn time: <6ms (down from ~50-100ms)
+ * - Memory stable under load
+ * - Graceful degradation when exhausted
+ *
+ * Architecture:
+ * - Pre-allocated agent instances per type
+ * - Thread-safe acquire/release with mutex
+ * - Automatic pool expansion on demand
+ * - Health monitoring and recovery
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentPool = void 0;
+const events_1 = require("events");
+const crypto_1 = require("crypto");
+const types_1 = require("./types");
+/**
+ * Default pool configuration
+ */
+const DEFAULT_TYPE_CONFIG = {
+    minSize: 2,
+    maxSize: 10,
+    warmupCount: 2,
+    preInitialize: false, // Lazy init by default for faster startup
+    idleTtlMs: 300000, // 5 minutes
+    growthIncrement: 2,
+};
+const DEFAULT_POOL_CONFIG = {
+    typeConfigs: new Map(),
+    defaultConfig: DEFAULT_TYPE_CONFIG,
+    debug: false,
+    globalMaxAgents: 100,
+    warmupStrategy: 'lazy',
+    healthCheckIntervalMs: 60000, // 1 minute
+};
+/**
+ * Agent Pool - Pre-allocated agent instance management
+ *
+ * @example
+ * ```typescript
+ * const pool = new AgentPool(factory, config);
+ * await pool.warmup();
+ *
+ * // Fast acquisition (<6ms)
+ * const { agent, meta } = await pool.acquire('test-generator');
+ *
+ * // Use agent...
+ * await agent.executeTask(task);
+ *
+ * // Return to pool
+ * await pool.release(meta.poolId);
+ * ```
+ */
+class AgentPool extends events_1.EventEmitter {
+    constructor(factory, config = {}) {
+        super();
+        // Pool storage: type -> array of pooled agents
+        this.pools = new Map();
+        // Quick lookup by poolId
+        this.agentsByPoolId = new Map();
+        // Waiting queue for each type
+        this.waitingQueues = new Map();
+        // Mutex for thread-safe operations
+        this.mutexes = new Map();
+        // Statistics
+        this.stats = {
+            totalAcquisitions: 0,
+            totalMisses: 0,
+            totalAcquisitionTimeMs: 0,
+        };
+        // Health check timer
+        this.healthCheckTimer = null;
+        // Shutdown flag
+        this.isShuttingDown = false;
+        this.factory = factory;
+        this.config = { ...DEFAULT_POOL_CONFIG, ...config };
+        if (config.typeConfigs) {
+            this.config.typeConfigs = new Map(config.typeConfigs);
+        }
+        this.log('AgentPool initialized', { globalMax: this.config.globalMaxAgents });
+    }
+    /**
+     * Warm up the pool by pre-creating agents
+     * Should be called during application startup
+     */
+    async warmup(types) {
+        const typesToWarm = types || this.getConfiguredTypes();
+        this.log('Starting pool warmup', { types: typesToWarm });
+        const warmupPromises = typesToWarm.map(async (type) => {
+            const typeConfig = this.getTypeConfig(type);
+            const count = typeConfig.warmupCount;
+            if (count <= 0)
+                return;
+            this.log(`Warming ${count} agents of type ${type}`);
+            const startTime = Date.now();
+            // Create agents in parallel for faster warmup
+            const createPromises = Array(count)
+                .fill(null)
+                .map(() => this.createPooledAgent(type, typeConfig.preInitialize));
+            const agents = await Promise.all(createPromises);
+            agents.forEach((entry) => this.addToPool(type, entry));
+            const elapsed = Date.now() - startTime;
+            this.log(`Warmed ${count} ${type} agents in ${elapsed}ms`);
+            this.emit('pool:warmed', { type, count });
+        });
+        await Promise.all(warmupPromises);
+        // Start health check if configured
+        if (this.config.healthCheckIntervalMs > 0) {
+            this.startHealthCheck();
+        }
+        this.log('Pool warmup complete', this.getStats());
+    }
+    /**
+     * Acquire an agent from the pool
+     * Returns immediately if available, otherwise waits or creates new
+     *
+     * @param type - Agent type to acquire
+     * @param options - Acquisition options
+     * @returns Acquired agent with metadata
+     */
+    async acquire(type, options = {}) {
+        const startTime = Date.now();
+        const { timeoutMs = 5000, waitIfUnavailable = true, priority = 0, requiredCapabilities = [], } = options;
+        if (this.isShuttingDown) {
+            throw new Error('Pool is shutting down');
+        }
+        // Try to get from pool first (fast path)
+        const fromPool = await this.tryAcquireFromPool(type, requiredCapabilities);
+        if (fromPool) {
+            const acquisitionTimeMs = Date.now() - startTime;
+            this.recordAcquisition(acquisitionTimeMs, true);
+            this.emit('agent:acquired', {
+                poolId: fromPool.meta.poolId,
+                type,
+                fromPool: true,
+            });
+            return {
+                agent: fromPool.agent,
+                meta: fromPool.meta,
+                fromPool: true,
+                acquisitionTimeMs,
+            };
+        }
+        // Pool miss - try to create new agent
+        const typeConfig = this.getTypeConfig(type);
+        const pool = this.getPool(type);
+        const currentSize = pool.length;
+        if (currentSize < typeConfig.maxSize && this.canCreateMore()) {
+            // Create new agent
+            const entry = await this.createPooledAgent(type, true);
+            entry.meta.state = types_1.PooledAgentState.IN_USE;
+            entry.meta.lastAcquiredAt = Date.now();
+            this.agentsByPoolId.set(entry.meta.poolId, entry);
+            const acquisitionTimeMs = Date.now() - startTime;
+            this.recordAcquisition(acquisitionTimeMs, false);
+            this.emit('agent:created', { poolId: entry.meta.poolId, type });
+            this.emit('agent:acquired', {
+                poolId: entry.meta.poolId,
+                type,
+                fromPool: false,
+            });
+            // Add to pool for tracking
+            pool.push(entry);
+            return {
+                agent: entry.agent,
+                meta: entry.meta,
+                fromPool: false,
+                acquisitionTimeMs,
+            };
+        }
+        // Pool exhausted
+        if (!waitIfUnavailable) {
+            throw new Error(`No agents available for type ${type} and waitIfUnavailable=false`);
+        }
+        // Queue the request
+        this.emit('pool:exhausted', {
+            type,
+            waitingCount: this.getWaitingCount(type) + 1,
+        });
+        return this.waitForAgent(type, priority, timeoutMs, startTime);
+    }
+    /**
+     * Release an agent back to the pool
+     *
+     * @param poolId - Pool ID of the agent to release
+     * @param options - Release options
+     */
+    async release(poolId, options = {}) {
+        const { reset = true, hasError = false, dispose = false } = options;
+        const entry = this.agentsByPoolId.get(poolId);
+        if (!entry) {
+            this.log(`Warning: Attempted to release unknown agent ${poolId}`);
+            return;
+        }
+        if (entry.meta.state !== types_1.PooledAgentState.IN_USE) {
+            this.log(`Warning: Attempted to release agent not in use ${poolId}`);
+            return;
+        }
+        const useTime = Date.now() - (entry.meta.lastAcquiredAt || Date.now());
+        entry.meta.totalUseTimeMs += useTime;
+        entry.meta.lastReleasedAt = Date.now();
+        if (dispose || hasError) {
+            await this.disposeAgent(entry, hasError ? 'error' : 'explicit');
+            return;
+        }
+        // Reset agent for reuse
+        if (reset) {
+            entry.meta.state = types_1.PooledAgentState.RESETTING;
+            try {
+                await entry.agent.reset();
+                entry.meta.reuseCount++;
+                entry.meta.state = types_1.PooledAgentState.AVAILABLE;
+                entry.meta.lastError = null;
+            }
+            catch (error) {
+                entry.meta.lastError = error;
+                this.emit('agent:error', {
+                    poolId,
+                    type: entry.meta.type,
+                    error: error,
+                });
+                await this.disposeAgent(entry, 'reset-failed');
+                return;
+            }
+        }
+        else {
+            entry.meta.state = types_1.PooledAgentState.AVAILABLE;
+        }
+        this.emit('agent:released', { poolId, type: entry.meta.type });
+        // Check if anyone is waiting
+        await this.fulfillWaitingRequest(entry.meta.type);
+    }
+    /**
+     * Get current pool statistics
+     */
+    getStats() {
+        const byType = new Map();
+        let totalAgents = 0;
+        let availableAgents = 0;
+        let inUseAgents = 0;
+        let initializingAgents = 0;
+        for (const [type, pool] of this.pools) {
+            const typeConfig = this.getTypeConfig(type);
+            let available = 0;
+            let inUse = 0;
+            let totalReuse = 0;
+            for (const entry of pool) {
+                switch (entry.meta.state) {
+                    case types_1.PooledAgentState.AVAILABLE:
+                        available++;
+                        availableAgents++;
+                        break;
+                    case types_1.PooledAgentState.IN_USE:
+                        inUse++;
+                        inUseAgents++;
+                        break;
+                    case types_1.PooledAgentState.INITIALIZING:
+                        initializingAgents++;
+                        break;
+                }
+                totalReuse += entry.meta.reuseCount;
+            }
+            byType.set(type, {
+                type,
+                total: pool.length,
+                available,
+                inUse,
+                minSize: typeConfig.minSize,
+                maxSize: typeConfig.maxSize,
+                avgReuseCount: pool.length > 0 ? totalReuse / pool.length : 0,
+            });
+            totalAgents += pool.length;
+        }
+        const totalAcq = this.stats.totalAcquisitions;
+        const avgAcquisitionTimeMs = totalAcq > 0 ? this.stats.totalAcquisitionTimeMs / totalAcq : 0;
+        const hitRate = totalAcq > 0 ? (totalAcq - this.stats.totalMisses) / totalAcq : 0;
+        return {
+            totalAgents,
+            availableAgents,
+            inUseAgents,
+            initializingAgents,
+            byType,
+            avgAcquisitionTimeMs,
+            hitRate,
+            totalAcquisitions: totalAcq,
+            totalMisses: this.stats.totalMisses,
+        };
+    }
+    /**
+     * Shutdown the pool and dispose all agents
+     */
+    async shutdown() {
+        this.isShuttingDown = true;
+        this.log('Shutting down pool');
+        // Stop health check
+        if (this.healthCheckTimer) {
+            clearInterval(this.healthCheckTimer);
+            this.healthCheckTimer = null;
+        }
+        // Reject all waiting requests
+        for (const [type, queue] of this.waitingQueues) {
+            for (const request of queue) {
+                clearTimeout(request.timeoutId);
+                request.reject(new Error('Pool is shutting down'));
+            }
+            queue.length = 0;
+        }
+        // Dispose all agents
+        const disposePromises = [];
+        for (const [, pool] of this.pools) {
+            for (const entry of pool) {
+                disposePromises.push(this.disposeAgent(entry, 'shutdown'));
+            }
+        }
+        await Promise.all(disposePromises);
+        this.pools.clear();
+        this.agentsByPoolId.clear();
+        this.log('Pool shutdown complete');
+    }
+    // === Private Methods ===
+    getPool(type) {
+        let pool = this.pools.get(type);
+        if (!pool) {
+            pool = [];
+            this.pools.set(type, pool);
+        }
+        return pool;
+    }
+    getTypeConfig(type) {
+        const specific = this.config.typeConfigs.get(type);
+        if (specific)
+            return specific;
+        return { ...this.config.defaultConfig, type };
+    }
+    getConfiguredTypes() {
+        // Return all configured types plus common defaults
+        const types = new Set(this.config.typeConfigs.keys());
+        // Add default agent types that should always be warmed
+        const defaultTypes = [
+            'test-generator',
+            'coverage-analyzer',
+            'quality-gate',
+        ];
+        defaultTypes.forEach((t) => types.add(t));
+        return Array.from(types);
+    }
+    async createPooledAgent(type, initialize) {
+        const poolId = `pool-${type}-${(0, crypto_1.randomUUID)().slice(0, 8)}`;
+        const now = Date.now();
+        const meta = {
+            poolId,
+            type,
+            state: types_1.PooledAgentState.INITIALIZING,
+            createdAt: now,
+            lastAcquiredAt: null,
+            lastReleasedAt: null,
+            reuseCount: 0,
+            totalUseTimeMs: 0,
+            isInitialized: false,
+            lastError: null,
+        };
+        const agent = await this.factory.create(type);
+        meta.state = types_1.PooledAgentState.AVAILABLE;
+        if (initialize) {
+            try {
+                await this.factory.initialize(agent);
+                meta.isInitialized = true;
+            }
+            catch (error) {
+                meta.lastError = error;
+                meta.state = types_1.PooledAgentState.ERROR;
+                this.log(`Failed to initialize agent ${poolId}`, error);
+            }
+        }
+        return { agent, meta };
+    }
+    addToPool(type, entry) {
+        const pool = this.getPool(type);
+        pool.push(entry);
+        this.agentsByPoolId.set(entry.meta.poolId, entry);
+    }
+    async tryAcquireFromPool(type, requiredCapabilities) {
+        const pool = this.getPool(type);
+        // Find first available agent
+        for (const entry of pool) {
+            if (entry.meta.state === types_1.PooledAgentState.AVAILABLE) {
+                // Check health
+                if (!entry.agent.isHealthy()) {
+                    this.log(`Agent ${entry.meta.poolId} unhealthy, disposing`);
+                    await this.disposeAgent(entry, 'unhealthy');
+                    continue;
+                }
+                // Check capabilities if required
+                // Note: Capability filtering available when agents expose capabilities
+                // Acquire
+                entry.meta.state = types_1.PooledAgentState.IN_USE;
+                entry.meta.lastAcquiredAt = Date.now();
+                // Ensure initialized
+                if (!entry.meta.isInitialized) {
+                    try {
+                        await this.factory.initialize(entry.agent);
+                        entry.meta.isInitialized = true;
+                    }
+                    catch (error) {
+                        entry.meta.lastError = error;
+                        await this.disposeAgent(entry, 'init-failed');
+                        continue;
+                    }
+                }
+                return entry;
+            }
+        }
+        return null;
+    }
+    canCreateMore() {
+        let total = 0;
+        for (const pool of this.pools.values()) {
+            total += pool.length;
+        }
+        return total < this.config.globalMaxAgents;
+    }
+    getWaitingCount(type) {
+        const queue = this.waitingQueues.get(type);
+        return queue?.length || 0;
+    }
+    async waitForAgent(type, priority, timeoutMs, startTime) {
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                this.removeWaitingRequest(type, request);
+                reject(new Error(`Timeout waiting for agent of type ${type}`));
+            }, timeoutMs);
+            const request = {
+                type,
+                priority,
+                resolve: (result) => {
+                    clearTimeout(timeoutId);
+                    result.acquisitionTimeMs = Date.now() - startTime;
+                    this.recordAcquisition(result.acquisitionTimeMs, result.fromPool);
+                    resolve(result);
+                },
+                reject: (error) => {
+                    clearTimeout(timeoutId);
+                    reject(error);
+                },
+                timeoutId,
+                requestedAt: startTime,
+            };
+            let queue = this.waitingQueues.get(type);
+            if (!queue) {
+                queue = [];
+                this.waitingQueues.set(type, queue);
+            }
+            // Insert by priority (higher first)
+            const insertIdx = queue.findIndex((r) => r.priority < priority);
+            if (insertIdx === -1) {
+                queue.push(request);
+            }
+            else {
+                queue.splice(insertIdx, 0, request);
+            }
+        });
+    }
+    removeWaitingRequest(type, request) {
+        const queue = this.waitingQueues.get(type);
+        if (queue) {
+            const idx = queue.indexOf(request);
+            if (idx !== -1) {
+                queue.splice(idx, 1);
+            }
+        }
+    }
+    async fulfillWaitingRequest(type) {
+        const queue = this.waitingQueues.get(type);
+        if (!queue || queue.length === 0)
+            return;
+        const request = queue.shift();
+        try {
+            const result = await this.acquire(type, {
+                waitIfUnavailable: false,
+                priority: request.priority,
+            });
+            request.resolve(result);
+        }
+        catch (error) {
+            // Put back in queue for retry
+            queue.unshift(request);
+        }
+    }
+    async disposeAgent(entry, reason) {
+        entry.meta.state = types_1.PooledAgentState.DISPOSING;
+        // Remove from pool
+        const pool = this.getPool(entry.meta.type);
+        const idx = pool.indexOf(entry);
+        if (idx !== -1) {
+            pool.splice(idx, 1);
+        }
+        this.agentsByPoolId.delete(entry.meta.poolId);
+        // Dispose via factory
+        try {
+            await this.factory.dispose(entry.agent);
+        }
+        catch (error) {
+            this.log(`Error disposing agent ${entry.meta.poolId}`, error);
+        }
+        this.emit('agent:disposed', {
+            poolId: entry.meta.poolId,
+            type: entry.meta.type,
+            reason,
+        });
+        // Ensure minimum pool size
+        const typeConfig = this.getTypeConfig(entry.meta.type);
+        if (pool.length < typeConfig.minSize && !this.isShuttingDown) {
+            this.replenishPool(entry.meta.type, 1);
+        }
+    }
+    async replenishPool(type, count) {
+        const typeConfig = this.getTypeConfig(type);
+        const pool = this.getPool(type);
+        const toCreate = Math.min(count, typeConfig.maxSize - pool.length);
+        if (toCreate <= 0)
+            return;
+        this.log(`Replenishing ${toCreate} agents for type ${type}`);
+        const createPromises = Array(toCreate)
+            .fill(null)
+            .map(() => this.createPooledAgent(type, typeConfig.preInitialize));
+        const entries = await Promise.all(createPromises);
+        entries.forEach((entry) => this.addToPool(type, entry));
+        this.emit('pool:expanded', { type, newSize: pool.length });
+    }
+    recordAcquisition(timeMs, fromPool) {
+        this.stats.totalAcquisitions++;
+        this.stats.totalAcquisitionTimeMs += timeMs;
+        if (!fromPool) {
+            this.stats.totalMisses++;
+        }
+    }
+    startHealthCheck() {
+        this.healthCheckTimer = setInterval(() => {
+            this.performHealthCheck();
+        }, this.config.healthCheckIntervalMs);
+    }
+    async performHealthCheck() {
+        const stats = this.getStats();
+        this.emit('pool:healthCheck', { stats });
+        // Check for expired idle agents
+        const now = Date.now();
+        for (const [type, pool] of this.pools) {
+            const typeConfig = this.getTypeConfig(type);
+            if (typeConfig.idleTtlMs <= 0)
+                continue;
+            for (const entry of [...pool]) {
+                if (entry.meta.state !== types_1.PooledAgentState.AVAILABLE)
+                    continue;
+                const idleTime = now - (entry.meta.lastReleasedAt || entry.meta.createdAt);
+                if (idleTime > typeConfig.idleTtlMs && pool.length > typeConfig.minSize) {
+                    await this.disposeAgent(entry, 'idle-timeout');
+                }
+            }
+        }
+    }
+    log(message, data) {
+        if (this.config.debug) {
+            console.log(`[AgentPool] ${message}`, data ?? '');
+        }
+    }
+}
+exports.AgentPool = AgentPool;
+//# sourceMappingURL=AgentPool.js.map